cacalabs
/
neercs
镜像自地址 https://github.com/cacalabs/neercs.git
1
0
派生 0
代码 工单 0 版本发布 0 百科 动态
您最多选择25个主题 主题必须以字母或数字开头，可以包含连字符 (-)，并且长度不得超过35个字符
245 提交
1 分支
432 KiB
 
 
 
 
 
目录树: f1b532c412
分支列表 标签列表
${ item.name }
创建分支 ${ searchTerm }
从 'f1b532c412'
${ noResults }
neercs/neercs/term/ansi.cpp

1146 行
39 KiB
原始文件 Blame 文件历史 

  1. /*

  2.  *  neercs — console-based window manager

  3.  *

  4.  *  Copyright © 2006—2015 Sam Hocevar <sam@hocevar.net>

  5.  *            © 2008—2010 Jean-Yves Lamoureux <jylam@lnxscene.org>

  6.  *            © 2008—2010 Pascal Terjan <pterjan@linuxfr.org>

  7.  *

  8.  *  This program is free software. It comes without any warranty, to

  9.  *  the extent permitted by applicable law. You can redistribute it

  10.  *  and/or modify it under the terms of the Do What the Fuck You Want

  11.  *  to Public License, Version 2, as published by the WTFPL Task Force.

  12.  *  See http://www.wtfpl.net/ for more details.

  13.  */

  14. 

  15. #if HAVE_CONFIG_H

  16. #   include "config.h"

  17. #endif

  18. 

  19. #include <string.h>

  20. 

  21. #include <lol/engine.h>

  22. 

  23. using namespace lol;

  24. 

  25. #include "../neercs.h"

  26. #include "term.h"

  27. 

  28. /* DEC ACS with common extensions */

  29. static uint32_t dec_acs(uint32_t uc)

  30. {

  31.     switch (uc)

  32.     {

  33.     case '+':

  34.         return 0x2192;          /* RIGHTWARDS ARROW */

  35.     case ',':

  36.         return 0x2190;          /* LEFTWARDS ARROW */

  37.     case '-':

  38.         return 0x2191;          /* UPWARDS ARROW */

  39.     case '.':

  40.         return 0x2193;          /* DOWNWARDS ARROW */

  41.     case '0':

  42.         return 0x25AE;          /* BLACK VERTICAL RECTANGLE */

  43.     case '_':

  44.         return 0x25AE;          /* BLACK VERTICAL RECTANGLE */

  45.     case '`':

  46.         return 0x25C6;          /* BLACK DIAMOND */

  47.     case 'a':

  48.         return 0x2592;          /* MEDIUM SHADE */

  49.     case 'b':

  50.         return 0x2409;          /* SYMBOL FOR HORIZONTAL TABULATION */

  51.     case 'c':

  52.         return 0x240C;          /* SYMBOL FOR FORM FEED */

  53.     case 'd':

  54.         return 0x240D;          /* SYMBOL FOR CARRIAGE RETURN */

  55.     case 'e':

  56.         return 0x240A;          /* SYMBOL FOR LINE FEED */

  57.     case 'f':

  58.         return 0x00B0;          /* DEGREE SIGN */

  59.     case 'g':

  60.         return 0x00B1;          /* PLUS-MINUS SIGN */

  61.     case 'h':

  62.         return 0x2424;          /* SYMBOL FOR NEWLINE */

  63.     case 'i':

  64.         return 0x240B;          /* SYMBOL FOR VERTICAL TABULATION */

  65.     case 'j':

  66.         return 0x2518;          /* BOX DRAWINGS LIGHT UP AND LEFT */

  67.     case 'k':

  68.         return 0x2510;          /* BOX DRAWINGS LIGHT DOWN AND LEFT */

  69.     case 'l':

  70.         return 0x250C;          /* BOX DRAWINGS LIGHT DOWN AND RIGHT */

  71.     case 'm':

  72.         return 0x2514;          /* BOX DRAWINGS LIGHT UP AND RIGHT */

  73.     case 'n':

  74.         return 0x253C;          /* BOX DRAWINGS LIGHT VERTICAL AND HORIZONTAL */

  75.     case 'o':

  76.         return 0x23BA;          /* HORIZONTAL SCAN LINE-1 */

  77.     case 'p':

  78.         return 0x23BB;          /* HORIZONTAL SCAN LINE-3 */

  79.     case 'q':

  80.         return 0x2500;          /* BOX DRAWINGS LIGHT HORIZONTAL */

  81.     case 'r':

  82.         return 0x23BC;          /* HORIZONTAL SCAN LINE-7 */

  83.     case 's':

  84.         return 0x23BD;          /* HORIZONTAL SCAN LINE-9 */

  85.     case 't':

  86.         return 0x251C;          /* BOX DRAWINGS LIGHT VERTICAL AND RIGHT */

  87.     case 'u':

  88.         return 0x2524;          /* BOX DRAWINGS LIGHT VERTICAL AND LEFT */

  89.     case 'v':

  90.         return 0x2534;          /* BOX DRAWINGS LIGHT UP AND HORIZONTAL */

  91.     case 'w':

  92.         return 0x252C;          /* BOX DRAWINGS LIGHT DOWN AND HORIZONTAL */

  93.     case 'x':

  94.         return 0x2502;          /* BOX DRAWINGS LIGHT VERTICAL */

  95.     case 'y':

  96.         return 0x2264;          /* LESS-THAN OR EQUAL TO */

  97.     case 'z':

  98.         return 0x2265;          /* GREATER-THAN OR EQUAL TO */

  99.     case '{':

  100.         return 0x03C0;          /* GREEK SMALL LETTER PI */

  101.     case '|':

  102.         return 0x2260;          /* NOT EQUAL TO */

  103.     case '}':

  104.         return 0x00A3;          /* POUND SIGN */

  105.     case '~':

  106.         return 0x00B7;          /* MIDDLE DOT */

  107.     default:

  108.         return uc;

  109.     }

  110. };

  111. 

  112. #define LITERAL2CHAR(i0,i1) (((i0) << 8) | (i1))

  113. 

  114. #define LITERAL3CHAR(i0,i1,i2) LITERAL2CHAR(LITERAL2CHAR(i0, i1), i2)

  115. 

  116. inline int Term::ReadChar(unsigned char c, int *x, int *y)

  117. {

  118.     if (c == '\r')

  119.     {

  120.         *x = 0;

  121.     }

  122. 

  123.     else if (c == '\n')

  124.     {

  125.         *x = 0;

  126.         *y = *y + 1;

  127.     }

  128.     else if (c == '\a')

  129.     {

  130.         /* FIXME TODO: in_bell ? */

  131. //        if (!m_bell)

  132. //            screen_list->in_bell = 10;

  133.         m_bell = 1;

  134.     }

  135. 

  136.     else if (c == '\t')

  137.     {

  138.         *x = (*x + 7) & ~7;

  139.     }

  140. 

  141.     else if (c == '\x08')

  142.     {

  143.         if (*x > 0)

  144.             *x = *x - 1;

  145.     }

  146.     else if (c == '\x0b')

  147.     {

  148.         /* Vertical tab */

  149.         /* Not sure about the real meaning of it, just y++ for now */

  150.         if (*y < caca_get_canvas_height(m_caca))

  151.             *y = *y + 1;

  152.     }

  153.     else if (c == '\x0e')

  154.     {

  155.         /* Shift Out (Ctrl-N) -> Switch to Alternate Character Set: invokes

  156.            the G1 character set. */

  157.         m_conv_state.glr[0] = 1;

  158.     }

  159. 

  160.     else if (c == '\x0f')

  161.     {

  162.         /* Shift In (Ctrl-O) -> Switch to Standard Character Set: invokes the

  163.            G0 character set. */

  164.         m_conv_state.glr[0] = 0;

  165.     }

  166.     else

  167.     {

  168.         return 1;

  169.     }

  170.     return 0;

  171. }

  172. 

  173. inline int Term::ReadDuplet(unsigned char const *buffer, unsigned int *skip,

  174.                           int top, int bottom, int width, int height)

  175. {

  176.     int i = 0, j, k;

  177.     unsigned int dummy = 0;

  178. 

  179.     /* Single Shift Select of G2 Character Set (SS2: 0x8e): affects next

  180.        character only */

  181.     if (buffer[i] == '\033' && buffer[i + 1] == 'N')

  182.     {

  183.         m_conv_state.ss = 2;

  184.         *skip += 1;

  185.     }

  186.     /* Reverse Index (RI) go up one line, reverse scroll if necessary */

  187.     else if (buffer[i] == '\033' && buffer[i + 1] == 'M')

  188.     {

  189.         /* FIXME : not sure about the meaning of 'go up one line' and 'if

  190.            necessary' words. Implemented as a scroller only. */

  191.         for (j = bottom - 1; j > top; j--)

  192.         {

  193.             for (k = 0; k < width; k++)

  194.             {

  195.                 caca_put_char(m_caca, k, j, caca_get_char(m_caca, k, j - 1));

  196.                 caca_put_attr(m_caca, k, j, caca_get_attr(m_caca, k, j - 1));

  197.             }

  198.         }

  199.         caca_draw_line(m_caca, 0, top - 1, width - 1, top - 1, ' ');

  200.         *skip += 1;

  201.     }

  202. 

  203.     /* Single Shift Select of G3 Character Set (SS2: 0x8f): affects next

  204.        character only */

  205.     else if (buffer[i] == '\033' && buffer[i + 1] == 'O')

  206.     {

  207.         m_conv_state.ss = 3;

  208.         *skip += 1;

  209.     }

  210. 

  211.     /* LOCKING-SHIFT TWO (LS2), ISO 2022, ECMA-48 (1986), ISO 6429 : 1988 */

  212.     else if (buffer[i] == '\033' && buffer[i + 1] == 'n')

  213.     {

  214.         m_conv_state.glr[0] = 2;

  215.         *skip += 1;

  216.     }

  217. 

  218.     /* LOCKING-SHIFT THREE (LS3) ISO 2022, ECMA-48 (1986), ISO 6429 : 1988 */

  219.     else if (buffer[i] == '\033' && buffer[i + 1] == 'o')

  220.     {

  221.         m_conv_state.glr[0] = 3;

  222.         *skip += 1;

  223.     }

  224. 

  225.     /* RESET TO INITIAL STATE (RIS), ECMA-48 (1986), ISO 6429 : 1988 */

  226.     else if (buffer[i] == '\033' && buffer[i + 1] == 'c')

  227.     {

  228.         m_dfg = CACA_DEFAULT;

  229.         m_dbg = CACA_DEFAULT;

  230. 

  231.         caca_set_color_ansi(m_caca, m_dfg, m_dbg);

  232.         m_clearattr = caca_get_attr(m_caca, -1, -1);

  233.         ReadGrcm(1, &dummy);

  234. 

  235.         m_conv_state.Reset();

  236.         *skip += 1;

  237.     }

  238. 

  239.     /* Coding Method Delimiter (CMD), ECMA-48 (1991), ISO/IEC 6429:1992 (ISO

  240.        IR 189) */

  241.     else if (buffer[i] == '\033' && buffer[i + 1] == 'd')

  242.     {

  243.         m_conv_state.Reset();

  244.         *skip += 1;

  245.     }

  246.     else

  247.     {

  248.         return 1;

  249.     }

  250. 

  251.     return 0;

  252. }

  253. 

  254. size_t Term::ReadAnsi(void const *data, size_t size)

  255. {

  256.     unsigned char const *buffer = (unsigned char const *)data;

  257.     unsigned int i, j, k, skip, dummy = 0;

  258.     unsigned int width, height, top, bottom;

  259.     uint32_t savedattr;

  260.     int x = 0, y = 0, save_x = 0, save_y = 0;

  261.     char b[100];

  262. 

  263.     msg::debug("ansi : import_term\n");

  264. 

  265.     width = caca_get_canvas_width(m_caca);

  266.     height = caca_get_canvas_height(m_caca);

  267.     x = caca_get_cursor_x(m_caca);

  268.     y = caca_get_cursor_y(m_caca);

  269.     top = 1;

  270.     bottom = height;

  271. 

  272.     if (!m_init)

  273.     {

  274.         m_fg = m_dfg = CACA_LIGHTGRAY;

  275.         m_bg = m_dbg = CACA_BLACK;

  276. 

  277.         m_bold = m_blink = m_italics = m_negative = m_concealed

  278.          = m_underline = m_faint = m_strike = m_proportional = 0;

  279. 

  280.         caca_set_color_ansi(m_caca, m_dfg, m_dbg);

  281.         m_clearattr = caca_get_attr(m_caca, -1, -1);

  282. 

  283.         ReadGrcm(1, &dummy);

  284. 

  285.         m_conv_state.Reset();

  286. 

  287.         m_init = 1;

  288.     }

  289. 

  290.     for (i = 0; i < size; i += skip)

  291.     {

  292.         uint32_t ch = 0;

  293.         int wch = 0;

  294. 

  295.         skip = 1;

  296. 

  297.         /* Control codes (ASCII < \x20) */

  298.         if (!ReadChar(buffer[i], &x, &y))

  299.         {

  300.         }

  301. 

  302.         /* If there are not enough characters to parse the escape sequence,

  303.            wait until the next try. We require 3. */

  304. 

  305.         else if (buffer[i] == '\033' && i + 2 >= size)

  306.             break;

  307. 

  308. 

  309.         else if (!ReadDuplet(&buffer[i], &skip, top, bottom, width, height))

  310.         {

  311. 

  312.         }

  313. 

  314. 

  315.         /* GZDM4, G0-Designators, multi, 94^n chars [grandfathered short form

  316.            from ISO 2022:1986] */

  317.         else if (buffer[i] == '\033' && buffer[i + 1] == '$'

  318.                  && (buffer[i + 2] >= '@') && (buffer[i + 2] <= 'C'))

  319.         {

  320.             m_conv_state.gn[0] = LITERAL2CHAR('$', buffer[i + 2]);

  321.             skip += 2;

  322.         }

  323. 

  324.         /* GnDMx Gn-Designators, 9x^n chars; need one more char to distinguish

  325.            these */

  326.         else if (buffer[i] == '\033' && buffer[i + 1] == '$'

  327.                  && (i + 3 >= size))

  328.             break;

  329. 

  330.         /* GZD4 G0-Designator, 94 chars */

  331.         else if (buffer[i] == '\033' && buffer[i + 1] == '(')

  332.         {

  333.             m_conv_state.gn[0] = buffer[i + 2];

  334.             skip += 2;

  335.         }

  336. 

  337.         /* G1D4 G1-Designator, 94 chars */

  338.         else if (buffer[i] == '\033' && buffer[i + 1] == ')')

  339.         {

  340.             m_conv_state.gn[1] = buffer[i + 2];

  341.             skip += 2;

  342.         }

  343. 

  344.         /* G2D4 G2-Designator, 94 chars */

  345.         else if (buffer[i] == '\033' && buffer[i + 1] == '*')

  346.         {

  347.             m_conv_state.gn[2] = buffer[i + 2];

  348.             skip += 2;

  349.         }

  350. 

  351.         /* G3D4 G3-Designator, 94 chars */

  352.         else if (buffer[i] == '\033' && buffer[i + 1] == '+')

  353.         {

  354.             m_conv_state.gn[3] = buffer[i + 2];

  355.             skip += 2;

  356.         }

  357. 

  358.         /* G2D6 G2-Designator, 96 chars */

  359.         else if (buffer[i] == '\033' && buffer[i + 1] == '.')

  360.         {

  361.             m_conv_state.gn[2] = LITERAL2CHAR('.', buffer[i + 2]);

  362.             skip += 2;

  363.         }

  364. 

  365.         /* G3D6 G3-Designator, 96 chars */

  366.         else if (buffer[i] == '\033' && buffer[i + 1] == '/')

  367.         {

  368.             m_conv_state.gn[3] = LITERAL2CHAR('.', buffer[i + 2]);

  369.             skip += 2;

  370.         }

  371. 

  372.         /* GZDM4 G0-Designator, 94^n chars */

  373.         else if (buffer[i] == '\033' && buffer[i + 1] == '$'

  374.                  && buffer[i + 2] == '(')

  375.         {

  376.             m_conv_state.gn[0] = LITERAL2CHAR('$', buffer[i + 3]);

  377.             skip += 3;

  378.         }

  379. 

  380.         /* G1DM4 G1-Designator, 94^n chars */

  381.         else if (buffer[i] == '\033' && buffer[i + 1] == '$'

  382.                  && buffer[i + 2] == ')')

  383.         {

  384.             m_conv_state.gn[1] = LITERAL2CHAR('$', buffer[i + 3]);

  385.             skip += 3;

  386.         }

  387. 

  388.         /* G2DM4 G2-Designator, 94^n chars */

  389.         else if (buffer[i] == '\033' && buffer[i + 1] == '$'

  390.                  && buffer[i + 2] == '*')

  391.         {

  392.             m_conv_state.gn[2] = LITERAL2CHAR('$', buffer[i + 3]);

  393.             skip += 3;

  394.         }

  395. 

  396.         /* G3DM4 G3-Designator, 94^n chars */

  397.         else if (buffer[i] == '\033' && buffer[i + 1] == '$'

  398.                  && buffer[i + 2] == '+')

  399.         {

  400.             m_conv_state.gn[3] = LITERAL2CHAR('$', buffer[i + 3]);

  401.             skip += 3;

  402.         }

  403. 

  404.         /* G2DM6 G2-Designator, 96^n chars */

  405.         else if (buffer[i] == '\033' && buffer[i + 1] == '$'

  406.                  && buffer[i + 2] == '.')

  407.         {

  408.             m_conv_state.gn[2] = LITERAL3CHAR('$', '.', buffer[i + 3]);

  409.             skip += 3;

  410.         }

  411. 

  412.         /* G3DM6 G3-Designator, 96^n chars */

  413.         else if (buffer[i] == '\033' && buffer[i + 1] == '$'

  414.                  && buffer[i + 2] == '/')

  415.         {

  416.             m_conv_state.gn[3] = LITERAL3CHAR('$', '.', buffer[i + 3]);

  417.             skip += 3;

  418.         }

  419.         else if (buffer[i] == '\033' && buffer[i + 1] == '#')

  420.         {

  421.             msg::debug("ansi private '#' sequence\n");

  422. 

  423.             switch (buffer[i + 2])

  424.             {

  425.             case '8':          /* DECALN Fills the entire screen area with

  426.                                    uppercase Es for screen focus and

  427.                                    alignment. */

  428.                 for (j = 0; j < height; j++)

  429.                 {

  430.                     for (k = 0; k < width; k++)

  431.                     {

  432.                         caca_put_char(m_caca, k, j, 'E');

  433.                     }

  434.                 }

  435.                 x = 0;

  436.                 y = 0;

  437.                 skip += 2;

  438.                 break;

  439. 

  440.             default:

  441.                 msg::debug("Unknow private sequence 'ESC#%c'\n", buffer[i + 2]);

  442.                 continue;

  443.             }

  444. 

  445.         }

  446.         /* Interpret escape commands, as per Standard ECMA-48 "Control

  447.            Functions for Coded Character Sets", 5.4. Control sequences. */

  448.         else if (buffer[i] == '\033' && buffer[i + 1] == '[')

  449.         {

  450.             unsigned int argc = 0, argv[101];

  451.             unsigned int param, inter, junk, final;

  452. 

  453.             if (buffer[i + 2] == '?')

  454.             {

  455.                 msg::debug("CSI? %c%c%c%c%c\n",

  456.                            buffer[i + 3], buffer[i + 4], buffer[i + 5],

  457.                            buffer[i + 6], buffer[i + 7]);

  458.             }

  459. 

  460.             /* Compute offsets to parameter bytes, intermediate bytes and to

  461.                the final byte. Only the final byte is mandatory, there can be

  462.                zero of the others. 0 param=2 inter final final+1

  463.                +-----+------------------+---------------------+-----------------+

  464.                | CSI | parameter bytes | intermediate bytes | final byte | | |

  465.                0x30 - 0x3f | 0x20 - 0x2f | 0x40 - 0x7e | | ^[[ | 0123456789:;<=>?

  466.                | SPC !"#$%&'()*+,-./ | azAZ@[\]^_`{|}~ |

  467.                +-----+------------------+---------------------+-----------------+ */

  468.             param = 2;

  469. 

  470.             /* vttest use to interleave control characters (\014 CR or \010

  471.                BS) into CSI sequences, either directly after ESC[ or after

  472.                param. Can't find anything related to this in any documentation

  473.                nor XTerm sources, thought. */

  474. 

  475.             for (junk = param; i + junk < size; junk++)

  476.                 if (buffer[i + junk] < 0x20)

  477.                 {

  478.                     ReadChar(buffer[i + junk], &x, &y);

  479.                 }

  480.                 else

  481.                 {

  482.                     break;

  483.                 }

  484. 

  485.             /* Intermediate offset */

  486.             for (inter = junk; i + inter < size; inter++)

  487.                 if (buffer[i + inter] < 0x30 || buffer[i + inter] > 0x3f)

  488.                 {

  489.                     break;

  490.                 }

  491.             /* Interleaved character */

  492.             for (junk = inter; i + junk < size; junk++)

  493.                 if (buffer[i + junk] < 0x20)

  494.                 {

  495.                     ReadChar(buffer[i + junk], &x, &y);

  496.                 }

  497.                 else

  498.                 {

  499.                     break;

  500.                 }

  501. 

  502.             /* Final Byte offset */

  503.             for (final = junk; i + final < size; final++)

  504.                 if (buffer[i + final] < 0x20 || buffer[i + final] > 0x2f)

  505.                 {

  506.                     break;

  507.                 }

  508.             if (i + final >= size

  509.                 || buffer[i + final] < 0x40 || buffer[i + final] > 0x7e)

  510.             {

  511.                 msg::debug("ansi Invalid Final Byte (%d %c)\n",

  512.                            buffer[i + final], buffer[i + final]);

  513.                 break;          /* Invalid Final Byte */

  514.             }

  515. 

  516.             skip += final;

  517. 

  518.             /* Sanity checks */

  519.             if (param < inter && buffer[i + param] >= 0x3c)

  520.             {

  521.                 /* Private sequence, only parse what we know */

  522.                 msg::debug("ansi import: private sequence \"^[[%.*s\"\n",

  523.                            final - param + 1, buffer + i + param);

  524.                 /* FIXME better parsing */

  525.                 if (buffer[i + 2] == '?')

  526.                 {

  527.                     char arg[5], *end;

  528.                     int a = 0;

  529.                     int c, p, Pm;

  530.                     for (p = 0; p < 4; p++)

  531.                     {

  532.                         if (buffer[i + 3 + p] >= '0'

  533.                             && buffer[i + 3 + p] <= '9')

  534.                         {

  535.                             arg[a] = buffer[i + 3 + p];

  536.                             arg[a + 1] = 0;

  537.                             a++;

  538.                             msg::debug("private a now '%s'\n", arg);

  539.                         }

  540.                         else

  541.                         {

  542.                             break;

  543.                         }

  544.                     }

  545.                     Pm = strtol(arg, &end, 10);

  546. 

  547.                     c = buffer[i + 3 + (end - arg)];

  548. 

  549.                     msg::debug("ansi private mouse: command %c arg %d\n", c, Pm);

  550.                     if (c == 'h')       /* DECSET DEC Private Mode Set */

  551.                     {

  552. 

  553.                         switch (Pm)

  554.                         {

  555.                             /* FIXME Handle different modes */

  556.                         case 9:

  557.                             msg::debug("mouse : X10 mode\n");

  558.                             m_report_mouse = MOUSE_X10;

  559.                             break;

  560.                         case 1000:     /* Send Mouse X & Y on button press

  561.                                            and release.  */

  562.                                 msg::debug("mouse : VT200 mode\n");

  563.                             m_report_mouse = MOUSE_VT200;

  564.                             break;

  565.                         case 1001:     /* Use Hilite Mouse Tracking.  */

  566.                                 msg::debug("mouse : VT200_HIGHLIGHT mode\n");

  567.                             m_report_mouse = MOUSE_VT200_HIGHLIGHT;

  568.                             break;

  569.                         case 1002:     /* Use Cell Motion Mouse Tracking. */

  570.                                 msg::debug("mouse : BTN mode\n");

  571.                             m_report_mouse = MOUSE_BTN_EVENT;

  572.                             break;

  573.                         case 1003:     /* Use All Motion Mouse Tracking.  */

  574.                                 msg::debug("mouse : ANY mode\n");

  575.                             m_report_mouse = MOUSE_ANY_EVENT;

  576.                             break;

  577.                         default:

  578.                             break;

  579.                         }

  580.                     }

  581.                     else if (c == 'l')  /* DECRST DEC Private Mode Reset */

  582.                     {

  583.                         Pm = atoi(arg);

  584.                         switch (Pm)

  585.                         {

  586.                             /* FIXME Handle different modes */

  587.                         case 9:

  588.                         case 1000:     /* Send Mouse X & Y on button press

  589.                                            and release.  */

  590.                         case 1001:     /* Use Hilite Mouse Tracking.  */

  591.                         case 1002:     /* Use Cell Motion Mouse Tracking. */

  592.                         case 1003:     /* Use All Motion Mouse Tracking.  */

  593.                             m_report_mouse = MOUSE_NONE;

  594.                             msg::debug("ansi private mouse : NOT reporting mouse\n");

  595.                             break;

  596.                         default:

  597.                             break;

  598.                         }

  599.                     }

  600.                 }

  601.                 continue;       /* Private sequence, skip it entirely */

  602.             }

  603. 

  604.             if (final - param > 100)

  605.                 continue;       /* Suspiciously long sequence, skip it */

  606. 

  607.             /* Parse parameter bytes as per ECMA-48 5.4.2: Parameter string

  608.                format */

  609.             if (param < inter)

  610.             {

  611.                 argv[0] = 0;

  612.                 for (j = param; j < inter; j++)

  613.                 {

  614.                     if (buffer[i + j] == ';')

  615.                         argv[++argc] = 0;

  616.                     else if (buffer[i + j] >= '0' && buffer[i + j] <= '9')

  617.                         argv[argc] = 10 * argv[argc] + (buffer[i + j] - '0');

  618.                 }

  619.                 argc++;

  620.             }

  621. 

  622.             /* Interpret final byte. The code representations are given in

  623.                ECMA-48 5.4: Control sequences, and the code definitions are

  624.                given in ECMA-48 8.3: Definition of control functions. */

  625.             msg::debug("ansi import: command '%c'\n", buffer[i + final]);

  626.             switch (buffer[i + final])

  627.             {

  628.             case 'A':          /* CUU (0x41) - Cursor Up */

  629.                 y -= argc ? argv[0] : 1;

  630.                 if (y < 0)

  631.                     y = 0;

  632.                 break;

  633.             case 'B':          /* CUD (0x42) - Cursor Down */

  634.                 y += argc ? argv[0] : 1;

  635.                 break;

  636.             case 'C':          /* CUF (0x43) - Cursor Right */

  637.                 x += argc ? argv[0] : 1;

  638.                 break;

  639.             case 'D':          /* CUB (0x44) - Cursor Left */

  640.                 x -= argc ? argv[0] : 1;

  641.                 if (x < 0)

  642.                     x = 0;

  643.                 break;

  644.             case 'G':          /* CHA (0x47) - Cursor Character Absolute */

  645.                 x = (argc && argv[0] > 0) ? argv[0] - 1 : 0;

  646.                 break;

  647.             case 'H':          /* CUP (0x48) - Cursor Position */

  648.                 x = (argc > 1 && argv[1] > 0) ? argv[1] - 1 : 0;

  649.                 y = (argc > 0 && argv[0] > 0) ? argv[0] - 1 : 0;

  650.                 msg::debug("ansi CUP : Cursor at %dx%d\n", x, y);

  651.                 break;

  652.             case 'J':          /* ED (0x4a) - Erase In Page */

  653.                 savedattr = caca_get_attr(m_caca, -1, -1);

  654.                 caca_set_attr(m_caca, m_clearattr);

  655.                 if (!argc || argv[0] == 0)

  656.                 {

  657.                     caca_draw_line(m_caca, x, y, width, y, ' ');

  658.                     caca_fill_box(m_caca, 0, y + 1, width, height - 1, ' ');

  659.                 }

  660.                 else if (argv[0] == 1)

  661.                 {

  662.                     caca_fill_box(m_caca, 0, 0, width, y, ' ');

  663.                     caca_draw_line(m_caca, 0, y, x, y, ' ');

  664.                 }

  665.                 else if (argv[0] == 2)

  666.                 {

  667.                     // x = y = 0;

  668.                     caca_fill_box(m_caca, 0, 0, width, height, ' ');

  669.                 }

  670.                 caca_set_attr(m_caca, savedattr);

  671.                 break;

  672.             case 'K':          /* EL (0x4b) - Erase In Line */

  673.                 msg::debug("ansi EL : cursor at %dx%d\n", x, y);

  674.                 if (!argc || argv[0] == 0)

  675.                 {

  676.                     caca_draw_line(m_caca, x, y, width, y, ' ');

  677.                 }

  678.                 else if (argv[0] == 1)

  679.                 {

  680.                     caca_draw_line(m_caca, 0, y, x, y, ' ');

  681.                 }

  682.                 else if (argv[0] == 2)

  683.                 {

  684.                     caca_draw_line(m_caca, 0, y, width, y, ' ');

  685.                 }

  686.                 break;

  687.             case 'L':          /* IL - Insert line */

  688.                 {

  689.                     unsigned int nb_lines = argc ? argv[0] : 1;

  690.                     for (j = bottom - 1; j >= (unsigned int)y + nb_lines; j--)

  691.                     {

  692.                         for (k = 0; k < width; k++)

  693.                         {

  694.                             caca_put_char(m_caca, k, j,

  695.                                           caca_get_char(m_caca, k,

  696.                                                         j - nb_lines));

  697.                             caca_put_attr(m_caca, k, j,

  698.                                           caca_get_attr(m_caca, k,

  699.                                                         j - nb_lines));

  700.                         }

  701.                         caca_draw_line(m_caca, 0, j - nb_lines, width,

  702.                                        j - nb_lines, ' ');

  703.                     }

  704.                 }

  705.                 break;

  706.             case 'P':          /* DCH (0x50) - Delete Character */

  707.                 if (!argc || argv[0] == 0)

  708.                     argv[0] = 1;        /* echo -ne 'foobar\r\e[0P\n' */

  709. 

  710.                 for (j = x; (unsigned int)(j + argv[0]) < width; j++)

  711.                 {

  712.                     caca_put_char(m_caca, j, y,

  713.                                   caca_get_char(m_caca, j + argv[0], y));

  714.                     caca_put_attr(m_caca, j, y,

  715.                                   caca_get_attr(m_caca, j + argv[0], y));

  716.                 }

  717.                 break;

  718. #if 0

  719.                 savedattr = caca_get_attr(m_caca, -1, -1);

  720.                 caca_set_attr(m_caca, m_clearattr);

  721.                 for (; (unsigned int)j < width; j++)

  722.                     caca_put_char(m_caca, j, y, ' ');

  723.                 caca_set_attr(m_caca, savedattr);

  724. #endif

  725.             case 'X':          /* ECH (0x58) - Erase Character */

  726.                 if (argc && argv[0])

  727.                 {

  728.                     savedattr = caca_get_attr(m_caca, -1, -1);

  729.                     caca_set_attr(m_caca, m_clearattr);

  730.                     caca_draw_line(m_caca, x, y, x + argv[0] - 1, y, ' ');

  731.                     caca_set_attr(m_caca, savedattr);

  732.                 }

  733.             case 'c':          /* DA -- Device Attributes */

  734.                 /*

  735.                    0 Base VT100, no options 1 Processor options (STP) 2

  736.                    Advanced video option (AVO) 3 AVO and STP 4 Graphics

  737.                    processor option (GPO) 5 GPO and STP 6 GPO and AVO 7 GPO,

  738.                    STP, and AVO */

  739.                 /* Warning, argument is Pn */

  740.                 msg::debug("ansi Got command c, argc %d, argv[0] (%d)\n",

  741.                            argc, argv[0], argv[0]);

  742.                 if (!argc || argv[0] == 0)

  743.                 {

  744.                     SendAnsi("\x1b[?1;0c");

  745.                 }

  746.                 else

  747.                 {

  748.                     switch (argv[0])

  749.                     {

  750.                     case 1:

  751.                         SendAnsi("\x1b[?\x1;\x1c");

  752.                         break;

  753.                     case 2:

  754.                         SendAnsi("\x1b[?\x1;\x2c");

  755.                         break;

  756.                     case 3:

  757.                         SendAnsi("\x1b[?\x1;\x3c");

  758.                         break;

  759.                     case 4:

  760.                         SendAnsi("\x1b[?\x1;\x4c");

  761.                         break;

  762.                     case 5:

  763.                         SendAnsi("\x1b[?\x1;\x5c");

  764.                         break;

  765.                     case 6:

  766.                         SendAnsi("\x1b[?\x1;\x6c");

  767.                         break;

  768.                     case 7:

  769.                         SendAnsi("\x1b[?\x1;\x7c");

  770.                         break;

  771.                     default:

  772.                         msg::debug("Unsupported DA option '%d'\n", argv[0]);

  773.                         break;

  774.                     }

  775.                 }

  776.                 break;

  777.             case 'd':          /* VPA (0x64) - Line Position Absolute */

  778.                 y = (argc && argv[0] > 0) ? argv[0] - 1 : 0;

  779.                 break;

  780.             case 'f':          /* HVP (0x66) - Character And Line Position */

  781.                 x = (argc > 1 && argv[1] > 0) ? argv[1] - 1 : 0;

  782.                 y = (argc > 0 && argv[0] > 0) ? argv[0] - 1 : 0;

  783.                 break;

  784.             case 'g':          /* TBC -- Tabulation Clear */

  785.                 break;

  786.             case 'r':          /* FIXME */

  787.                 if (argc == 2)  /* DCSTBM - Set top and bottom margin */

  788.                 {

  789.                     msg::debug("DCSTBM %d %d\n", argv[0], argv[1]);

  790.                     top = argv[0];

  791.                     bottom = argv[1];

  792.                 }

  793.                 else

  794.                     msg::debug("ansi import: command r with %d params\n", argc);

  795.                 break;

  796.             case 'h':          /* SM (0x68) - FIXME */

  797.                 msg::debug("ansi import: set mode %i\n", argc ? (int)argv[0] : -1);

  798.                 break;

  799.             case 'l':          /* RM (0x6c) - FIXME */

  800.                 msg::debug("ansi import: reset mode %i\n", argc ? (int)argv[0] : -1);

  801.                 break;

  802.             case 'm':          /* SGR (0x6d) - Select Graphic Rendition */

  803.                 if (argc)

  804.                     ReadGrcm(argc, argv);

  805.                 else

  806.                     ReadGrcm(1, &dummy);

  807.                 break;

  808.             case 'n':

  809.                 msg::debug("ansi command n, argc %d, argv[0] %d\n", argc, argv[0]);

  810.                 if (!argc)

  811.                     break;

  812. 

  813.                 switch (argv[0])

  814.                 {

  815.                 case 5:

  816.                     /* Term ok */

  817.                     SendAnsi("\x1b[0n");

  818.                     break;

  819.                 case 6:

  820.                     /* Cursor Position */

  821.                     sprintf(b, "\x1b[%d;%dR", y + 1, x + 1);

  822.                     SendAnsi(b);

  823.                     break;

  824.                 }

  825. 

  826.                 break;

  827.             case 's':          /* Private (save cursor position) */

  828.                 save_x = x;

  829.                 save_y = y;

  830.                 break;

  831.             case 'u':          /* Private (reload cursor position) */

  832.                 x = save_x;

  833.                 y = save_y;

  834.                 break;

  835.             default:

  836.                 msg::debug("ansi import: unknown command \"^[%.*s\"\n",

  837.                       final - param + 1, buffer + i + param);

  838.                 break;

  839.             }

  840.         }

  841. 

  842.         /* Parse OSC stuff. */

  843.         else if (buffer[i] == '\033' && buffer[i + 1] == ']')

  844.         {

  845.             char *string;

  846.             unsigned int command = 0;

  847.             unsigned int mode = 2, semicolon, final;

  848. 

  849.             for (semicolon = mode; i + semicolon < size; semicolon++)

  850.             {

  851.                 if (buffer[i + semicolon] < '0' || buffer[i + semicolon] > '9')

  852.                     break;

  853.                 command = 10 * command + (buffer[i + semicolon] - '0');

  854.             }

  855. 

  856.             if (i + semicolon >= size || buffer[i + semicolon] != ';')

  857.                 break;          /* Invalid Mode */

  858. 

  859.             for (final = semicolon + 1; i + final < size; final++)

  860.                 if (buffer[i + final] < 0x20)

  861.                     break;

  862. 

  863.             if (i + final >= size || buffer[i + final] != '\a')

  864.                 break;          /* Not enough data or no bell found */

  865.             /* FIXME: XTerm also reacts to <ESC><backslash> and <ST> */

  866.             /* FIXME: differenciate between not enough data (try again) and

  867.                invalid data (print shit) */

  868. 

  869.             skip += final;

  870. 

  871.             string = (char *)malloc(final - (semicolon + 1) + 1);

  872.             memcpy(string, buffer + i + (semicolon + 1),

  873.                    final - (semicolon + 1));

  874.             string[final - (semicolon + 1)] = '\0';

  875.             msg::debug("ansi import: got OSC command %i string '%s'\n", command,

  876.                   string);

  877.             if (command == 0 || command == 2)

  878.             {

  879.                 if (m_title)

  880.                     free(m_title);

  881.                 m_title = string;

  882.             }

  883.             else

  884.                 free(string);

  885.         }

  886. 

  887.         /* Get the character we’re going to paste */

  888.         else

  889.         {

  890.             size_t bytes;

  891. 

  892.             if (i + 6 < size)

  893.             {

  894.                 ch = caca_utf8_to_utf32((char const *)(buffer + i), &bytes);

  895.             }

  896.             else

  897.             {

  898.                 /* Add a trailing zero to what we're going to read */

  899.                 char tmp[7];

  900.                 memcpy(tmp, buffer + i, size - i);

  901.                 tmp[size - i] = '\0';

  902.                 ch = caca_utf8_to_utf32(tmp, &bytes);

  903.             }

  904. 

  905.             if (!bytes)

  906.             {

  907.                 /* If the Unicode is invalid, assume it was latin1. */

  908.                 ch = buffer[i];

  909.                 bytes = 1;

  910.             }

  911. 

  912.             /* very incomplete ISO-2022 implementation tailored to DEC ACS */

  913.             if (m_conv_state.cs == '@')

  914.             {

  915.                 if (((ch > ' ') && (ch <= '~'))

  916.                     &&

  917.                     (m_conv_state.

  918.                      gn[m_conv_state.ss ? m_conv_state.

  919.                         gn[m_conv_state.ss] : m_conv_state.glr[0]] == '0'))

  920.                 {

  921.                     ch = dec_acs(ch);

  922.                 }

  923.                 else if (((ch > 0x80) && (ch < 0xff))

  924.                          && (m_conv_state.gn[m_conv_state.glr[1]] == '0'))

  925.                 {

  926.                     ch = dec_acs(ch + ' ' - 0x80);

  927.                 }

  928.             }

  929.             m_conv_state.ss = 0;      /* no single-shift (GL) */

  930. 

  931.             wch = caca_utf32_is_fullwidth(ch) ? 2 : 1;

  932. 

  933.             skip += bytes - 1;

  934.         }

  935. 

  936.         /* Wrap long lines or grow horizontally */

  937.         while ((unsigned int)x + wch > width)

  938.         {

  939.             x -= width;

  940.             y++;

  941.         }

  942. 

  943.         /* Scroll or grow vertically */

  944.         if ((unsigned int)y >= bottom)

  945.         {

  946.             int lines = (y - bottom) + 1;

  947. 

  948.             savedattr = caca_get_attr(m_caca, -1, -1);

  949. 

  950.             for (j = top - 1; j + lines < bottom; j++)

  951.             {

  952.                 for (k = 0; k < width; k++)

  953.                 {

  954.                     caca_put_char(m_caca, k, j,

  955.                                   caca_get_char(m_caca, k, j + lines));

  956.                     caca_put_attr(m_caca, k, j,

  957.                                   caca_get_attr(m_caca, k, j + lines));

  958.                 }

  959.             }

  960.             caca_set_attr(m_caca, m_clearattr);

  961.             caca_fill_box(m_caca, 0, bottom - lines, width, bottom - 1, ' ');

  962.             y -= lines;

  963.             caca_set_attr(m_caca, savedattr);

  964.         }

  965. 

  966.         /* Now paste our character, if any */

  967.         if (wch)

  968.         {

  969.             caca_put_char(m_caca, x, y, ch);

  970.             x += wch;

  971.         }

  972.     }

  973. 

  974.     caca_gotoxy(m_caca, x, y);

  975. 

  976.     if (i)

  977.         m_changed = 1;

  978.     return i;

  979. }

  980. 

  981. size_t Term::SendAnsi(char const *str)

  982. {

  983.     size_t ret = strlen(str);

  984. 

  985.     /* FIXME TODO: not implemented */

  986.     msg::debug("Sending %d-character ANSI sequence\n", (int)ret);

  987. 

  988.     return ret;

  989. }

  990. 

  991. /* Coding Method Delimiter (CMD), ECMA-48 (1991), ISO/IEC 6429:1992 (ISO IR

  992.    189) */

  993. void Iso2022Conversion::Reset()

  994. {

  995.     cs = '@';    /* ISO-2022 coding system */

  996.     cn[0] = '@'; /* ISO 646 C0 control charset */

  997.     cn[1] = 'C'; /* ISO 6429-1983 C1 control charset */

  998.     glr[0] = 0;  /* G0 in GL */

  999.     glr[1] = 2;  /* G2 in GR */

  1000.     gn[0] = 'B'; /* US-ASCII G0 charset */

  1001.     gn[1] = '0'; /* DEC ACS G1 charset */

  1002.     gn[2] = LITERAL2CHAR('.', 'A'); /* ISO 8859-1 G2 charset */

  1003.     gn[3] = LITERAL2CHAR('.', 'A'); /* ISO 8859-1 G3 charset */

  1004.     ss = 0;      /* no single-shift (GL) */

  1005.     ctrl8bit = 1;

  1006. }

  1007. 

  1008. /* XXX : ANSI loader helper */

  1009. 

  1010. void Term::ReadGrcm(unsigned int argc, unsigned int const *argv)

  1011. {

  1012.     static uint8_t const ansi2caca[] = {

  1013.         CACA_BLACK, CACA_RED, CACA_GREEN, CACA_BROWN,

  1014.         CACA_BLUE, CACA_MAGENTA, CACA_CYAN, CACA_LIGHTGRAY

  1015.     };

  1016. 

  1017.     unsigned int j;

  1018.     uint8_t efg, ebg;           /* Effective (libcaca) fg/bg */

  1019. 

  1020.     for (j = 0; j < argc; j++)

  1021.     {

  1022.         /* Defined in ECMA-48 8.3.117: SGR - SELECT GRAPHIC RENDITION */

  1023.         if (argv[j] >= 30 && argv[j] <= 37)

  1024.             m_fg = ansi2caca[argv[j] - 30];

  1025.         else if (argv[j] >= 40 && argv[j] <= 47)

  1026.             m_bg = ansi2caca[argv[j] - 40];

  1027.         else if (argv[j] >= 90 && argv[j] <= 97)

  1028.             m_fg = ansi2caca[argv[j] - 90] + 8;

  1029.         else if (argv[j] >= 100 && argv[j] <= 107)

  1030.             m_bg = ansi2caca[argv[j] - 100] + 8;

  1031.         else

  1032.             switch (argv[j])

  1033.             {

  1034.             case 0:            /* default rendition */

  1035.                 m_fg = m_dfg;

  1036.                 m_bg = m_dbg;

  1037.                 m_bold = m_blink = m_italics = m_negative

  1038.                        = m_concealed = m_underline = m_faint = m_strike

  1039.                        = m_proportional = 0;

  1040.                 break;

  1041.             case 1:            /* bold or increased intensity */

  1042.                 m_bold = 1;

  1043.                 break;

  1044.             case 2:            /* faint, decreased intensity or second colour

  1045.                                  */

  1046.                 m_faint = 1;

  1047.                 break;

  1048.             case 3:            /* italicized */

  1049.                 m_italics = 1;

  1050.                 break;

  1051.             case 4:            /* singly underlined */

  1052.                 m_underline = 1;

  1053.                 break;

  1054.             case 5:            /* slowly blinking (less then 150 per minute) */

  1055.             case 6:            /* rapidly blinking (150 per minute or more) */

  1056.                 m_blink = 1;

  1057.                 break;

  1058.             case 7:            /* negative image */

  1059.                 m_negative = 1;

  1060.                 break;

  1061.             case 8:            /* concealed characters */

  1062.                 m_concealed = 1;

  1063.                 break;

  1064.             case 9:            /* crossed-out (characters still legible but

  1065.                                    marked as to be deleted */

  1066.                 m_strike = 1;

  1067.                 break;

  1068.             case 21:           /* doubly underlined */

  1069.                 m_underline = 1;

  1070.                 break;

  1071.             case 22:           /* normal colour or normal intensity (neither

  1072.                                    bold nor faint) */

  1073.                 m_bold = m_faint = 0;

  1074.                 break;

  1075.             case 23:           /* not italicized, not fraktur */

  1076.                 m_italics = 0;

  1077.                 break;

  1078.             case 24:           /* not underlined (neither singly nor doubly) */

  1079.                 m_underline = 0;

  1080.                 break;

  1081.             case 25:           /* steady (not blinking) */

  1082.                 m_blink = 0;

  1083.                 break;

  1084.             case 26:           /* (reserved for proportional spacing as

  1085.                                    specified in CCITT Recommendation T.61) */

  1086.                 m_proportional = 1;

  1087.                 break;

  1088.             case 27:           /* positive image */

  1089.                 m_negative = 0;

  1090.                 break;

  1091.             case 28:           /* revealed characters */

  1092.                 m_concealed = 0;

  1093.                 break;

  1094.             case 29:           /* not crossed out */

  1095.                 m_strike = 0;

  1096.                 break;

  1097.             case 38:           /* (reserved for future standardization,

  1098.                                    intended for setting character foreground

  1099.                                    colour as specified in ISO 8613-6 [CCITT

  1100.                                    Recommendation T.416]) */

  1101.                 break;

  1102.             case 39:           /* default display colour

  1103.                                    (implementation-defined) */

  1104.                 m_fg = m_dfg;

  1105.                 break;

  1106.             case 48:           /* (reserved for future standardization,

  1107.                                    intended for setting character background

  1108.                                    colour as specified in ISO 8613-6 [CCITT

  1109.                                    Recommendation T.416]) */

  1110.                 break;

  1111.             case 49:           /* default background colour

  1112.                                    (implementation-defined) */

  1113.                 m_bg = m_dbg;

  1114.                 break;

  1115.             case 50:           /* (reserved for cancelling the effect of the

  1116.                                    rendering aspect established by parameter

  1117.                                    value 26) */

  1118.                 m_proportional = 0;

  1119.                 break;

  1120.             default:

  1121.                 msg::debug("ansi import: unknown sgr %i\n", argv[j]);

  1122.                 break;

  1123.             }

  1124.     }

  1125. 

  1126.     if (m_concealed)

  1127.     {

  1128.         efg = ebg = CACA_TRANSPARENT;

  1129.     }

  1130.     else

  1131.     {

  1132.         efg = m_negative ? m_bg : m_fg;

  1133.         ebg = m_negative ? m_fg : m_bg;

  1134. 

  1135.         if (m_bold)

  1136.         {

  1137.             if (efg < 8)

  1138.                 efg += 8;

  1139.             else if (efg == CACA_DEFAULT)

  1140.                 efg = CACA_WHITE;

  1141.         }

  1142.     }

  1143. 

  1144.     caca_set_color_ansi(m_caca, efg, ebg);

  1145. }