cacalabs
/
neercs
peilaus alkaen https://github.com/cacalabs/neercs.git
1
0
Fork 0
Koodi Ongelmat 0 Julkaisut 0 Wiki Toiminta
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
106 Commitit
1 Haara
1.8 MiB
 
 
 
 
 
Puu: d4e07923e9
Branchit Tagit
${ item.name }
Create branch ${ searchTerm }
from 'd4e07923e9'
${ noResults }
neercs/neercs/term/ansi.cpp

1144 rivejä
39 KiB
Raaka Blame Historia 

  1. /*

  2.  *  neercs        console-based window manager

  3.  *  Copyright (c) 2006-2010 Sam Hocevar <sam@hocevar.net>

  4.  *                2008-2010 Jean-Yves Lamoureux <jylam@lnxscene.org>

  5.  *                2008-2010 Pascal Terjan <pterjan@linuxfr.org>

  6.  *                All Rights Reserved

  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 Sam Hocevar. See

  12.  *  http://sam.zoy.org/wtfpl/COPYING for more details.

  13.  */

  14. 

  15. #if defined HAVE_CONFIG_H

  16. #   include "config.h"

  17. #endif

  18. 

  19. #include <string.h>

  20. 

  21. #include "core.h"

  22. 

  23. using namespace std;

  24. using namespace lol;

  25. 

  26. #include "../neercs.h"

  27. #include "term.h"

  28. 

  29. /* DEC ACS with common extensions */

  30. static uint32_t dec_acs(uint32_t uc)

  31. {

  32.     switch (uc)

  33.     {

  34.     case '+':

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

  36.     case ',':

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

  38.     case '-':

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

  40.     case '.':

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

  42.     case '0':

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

  44.     case '_':

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

  46.     case '`':

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

  48.     case 'a':

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

  50.     case 'b':

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

  52.     case 'c':

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

  54.     case 'd':

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

  56.     case 'e':

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

  58.     case 'f':

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

  60.     case 'g':

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

  62.     case 'h':

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

  64.     case 'i':

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

  66.     case 'j':

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

  68.     case 'k':

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

  70.     case 'l':

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

  72.     case 'm':

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

  74.     case 'n':

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

  76.     case 'o':

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

  78.     case 'p':

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

  80.     case 'q':

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

  82.     case 'r':

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

  84.     case 's':

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

  86.     case 't':

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

  88.     case 'u':

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

  90.     case 'v':

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

  92.     case 'w':

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

  94.     case 'x':

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

  96.     case 'y':

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

  98.     case 'z':

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

  100.     case '{':

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

  102.     case '|':

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

  104.     case '}':

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

  106.     case '~':

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

  108.     default:

  109.         return uc;

  110.     }

  111. };

  112. 

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

  114. 

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

  116. 

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

  118. {

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

  120.     {

  121.         *x = 0;

  122.     }

  123. 

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

  125.     {

  126.         *x = 0;

  127.         *y = *y + 1;

  128.     }

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

  130.     {

  131.         /* FIXME TODO: in_bell ? */

  132. //        if (!m_bell)

  133. //            screen_list->in_bell = 10;

  134.         m_bell = 1;

  135.     }

  136. 

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

  138.     {

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

  140.     }

  141. 

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

  143.     {

  144.         if (*x > 0)

  145.             *x = *x - 1;

  146.     }

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

  148.     {

  149.         /* Vertical tab */

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

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

  152.             *y = *y + 1;

  153.     }

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

  155.     {

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

  157.            the G1 character set. */

  158.         m_conv_state.glr[0] = 1;

  159.     }

  160. 

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

  162.     {

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

  164.            G0 character set. */

  165.         m_conv_state.glr[0] = 0;

  166.     }

  167.     else

  168.     {

  169.         return 1;

  170.     }

  171.     return 0;

  172. }

  173. 

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

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

  176. {

  177.     int i = 0, j, k;

  178.     unsigned int dummy = 0;

  179. 

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

  181.        character only */

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

  183.     {

  184.         m_conv_state.ss = 2;

  185.         *skip += 1;

  186.     }

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

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

  189.     {

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

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

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

  193.         {

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

  195.             {

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

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

  198.             }

  199.         }

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

  201.         *skip += 1;

  202.     }

  203. 

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

  205.        character only */

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

  207.     {

  208.         m_conv_state.ss = 3;

  209.         *skip += 1;

  210.     }

  211. 

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

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

  214.     {

  215.         m_conv_state.glr[0] = 2;

  216.         *skip += 1;

  217.     }

  218. 

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

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

  221.     {

  222.         m_conv_state.glr[0] = 3;

  223.         *skip += 1;

  224.     }

  225. 

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

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

  228.     {

  229.         m_dfg = CACA_DEFAULT;

  230.         m_dbg = CACA_DEFAULT;

  231. 

  232.         caca_set_color_ansi(m_caca, m_dfg, m_dbg);

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

  234.         ReadGrcm(1, &dummy);

  235. 

  236.         m_conv_state.Reset();

  237.         *skip += 1;

  238.     }

  239. 

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

  241.        IR 189) */

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

  243.     {

  244.         m_conv_state.Reset();

  245.         *skip += 1;

  246.     }

  247.     else

  248.     {

  249.         return 1;

  250.     }

  251. 

  252.     return 0;

  253. }

  254. 

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

  256. {

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

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

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

  260.     uint32_t savedattr;

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

  262.     char b[100];

  263. 

  264.     debug("ansi : import_term\n");

  265. 

  266.     width = caca_get_canvas_width(m_caca);

  267.     height = caca_get_canvas_height(m_caca);

  268.     x = caca_get_cursor_x(m_caca);

  269.     y = caca_get_cursor_y(m_caca);

  270.     top = 1;

  271.     bottom = height;

  272. 

  273.     if (!m_init)

  274.     {

  275.         m_dfg = CACA_LIGHTGRAY;

  276.         m_dbg = CACA_BLACK;

  277. 

  278.         caca_set_color_ansi(m_caca, m_dfg, m_dbg);

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

  280. 

  281.         ReadGrcm(1, &dummy);

  282. 

  283.         m_conv_state.Reset();

  284. 

  285.         m_init = 1;

  286.     }

  287. 

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

  289.     {

  290.         uint32_t ch = 0;

  291.         int wch = 0;

  292. 

  293.         skip = 1;

  294. 

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

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

  297.         {

  298.         }

  299. 

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

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

  302. 

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

  304.             break;

  305. 

  306. 

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

  308.         {

  309. 

  310.         }

  311. 

  312. 

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

  314.            from ISO 2022:1986] */

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

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

  317.         {

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

  319.             skip += 2;

  320.         }

  321. 

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

  323.            these */

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

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

  326.             break;

  327. 

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

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

  330.         {

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

  332.             skip += 2;

  333.         }

  334. 

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

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

  337.         {

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

  339.             skip += 2;

  340.         }

  341. 

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

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

  344.         {

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

  346.             skip += 2;

  347.         }

  348. 

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

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

  351.         {

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

  353.             skip += 2;

  354.         }

  355. 

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

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

  358.         {

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

  360.             skip += 2;

  361.         }

  362. 

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

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

  365.         {

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

  367.             skip += 2;

  368.         }

  369. 

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

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

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

  373.         {

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

  375.             skip += 3;

  376.         }

  377. 

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

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

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

  381.         {

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

  383.             skip += 3;

  384.         }

  385. 

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

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

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

  389.         {

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

  391.             skip += 3;

  392.         }

  393. 

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

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

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

  397.         {

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

  399.             skip += 3;

  400.         }

  401. 

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

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

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

  405.         {

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

  407.             skip += 3;

  408.         }

  409. 

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

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

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

  413.         {

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

  415.             skip += 3;

  416.         }

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

  418.         {

  419.             debug("ansi private '#' sequence\n");

  420. 

  421.             switch (buffer[i + 2])

  422.             {

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

  424.                                    uppercase Es for screen focus and

  425.                                    alignment. */

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

  427.                 {

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

  429.                     {

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

  431.                     }

  432.                 }

  433.                 x = 0;

  434.                 y = 0;

  435.                 skip += 2;

  436.                 break;

  437. 

  438.             default:

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

  440.                 continue;

  441.             }

  442. 

  443.         }

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

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

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

  447.         {

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

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

  450. 

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

  452.             {

  453.                 debug("CSI? %c%c%c%c%c\n",

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

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

  456.             }

  457. 

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

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

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

  461.                +-----+------------------+---------------------+-----------------+

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

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

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

  465.                +-----+------------------+---------------------+-----------------+ */

  466.             param = 2;

  467. 

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

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

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

  471.                nor XTerm sources, thought. */

  472. 

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

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

  475.                 {

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

  477.                 }

  478.                 else

  479.                 {

  480.                     break;

  481.                 }

  482. 

  483.             /* Intermediate offset */

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

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

  486.                 {

  487.                     break;

  488.                 }

  489.             /* Interleaved character */

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

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

  492.                 {

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

  494.                 }

  495.                 else

  496.                 {

  497.                     break;

  498.                 }

  499. 

  500.             /* Final Byte offset */

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

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

  503.                 {

  504.                     break;

  505.                 }

  506.             if (i + final >= size

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

  508.             {

  509.                 debug("ansi Invalid Final Byte (%d %c)\n", buffer[i + final],

  510.                       buffer[i + final]);

  511.                 break;          /* Invalid Final Byte */

  512.             }

  513. 

  514.             skip += final;

  515. 

  516.             /* Sanity checks */

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

  518.             {

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

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

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

  522.                 /* FIXME better parsing */

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

  524.                 {

  525.                     char arg[5], *end;

  526.                     int a = 0;

  527.                     int c, p, Pm;

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

  529.                     {

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

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

  532.                         {

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

  534.                             arg[a + 1] = 0;

  535.                             a++;

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

  537.                         }

  538.                         else

  539.                         {

  540.                             break;

  541.                         }

  542.                     }

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

  544. 

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

  546. 

  547.                     debug("ansi private mouse : command %c, arg %d", c, Pm);

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

  549.                     {

  550. 

  551.                         switch (Pm)

  552.                         {

  553.                             /* FIXME Handle different modes */

  554.                         case 9:

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

  556.                             m_report_mouse = MOUSE_X10;

  557.                             break;

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

  559.                                            and release.  */

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

  561.                             m_report_mouse = MOUSE_VT200;

  562.                             break;

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

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

  565.                             m_report_mouse = MOUSE_VT200_HIGHLIGHT;

  566.                             break;

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

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

  569.                             m_report_mouse = MOUSE_BTN_EVENT;

  570.                             break;

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

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

  573.                             m_report_mouse = MOUSE_ANY_EVENT;

  574.                             break;

  575.                         default:

  576.                             break;

  577.                         }

  578.                     }

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

  580.                     {

  581.                         Pm = atoi(arg);

  582.                         switch (Pm)

  583.                         {

  584.                             /* FIXME Handle different modes */

  585.                         case 9:

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

  587.                                            and release.  */

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

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

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

  591.                             m_report_mouse = MOUSE_NONE;

  592.                             debug("ansi private mouse : NOT reporting mouse");

  593.                             break;

  594.                         default:

  595.                             break;

  596.                         }

  597.                     }

  598.                 }

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

  600.             }

  601. 

  602.             if (final - param > 100)

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

  604. 

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

  606.                format */

  607.             if (param < inter)

  608.             {

  609.                 argv[0] = 0;

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

  611.                 {

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

  613.                         argv[++argc] = 0;

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

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

  616.                 }

  617.                 argc++;

  618.             }

  619. 

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

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

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

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

  624.             switch (buffer[i + final])

  625.             {

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

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

  628.                 if (y < 0)

  629.                     y = 0;

  630.                 break;

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

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

  633.                 break;

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

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

  636.                 break;

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

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

  639.                 if (x < 0)

  640.                     x = 0;

  641.                 break;

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

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

  644.                 break;

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

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

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

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

  649.                 break;

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

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

  652.                 caca_set_attr(m_caca, m_clearattr);

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

  654.                 {

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

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

  657.                 }

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

  659.                 {

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

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

  662.                 }

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

  664.                 {

  665.                     // x = y = 0;

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

  667.                 }

  668.                 caca_set_attr(m_caca, savedattr);

  669.                 break;

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

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

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

  673.                 {

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

  675.                 }

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

  677.                 {

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

  679.                 }

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

  681.                 {

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

  683.                 }

  684.                 break;

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

  686.                 {

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

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

  689.                     {

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

  691.                         {

  692.                             caca_put_char(m_caca, k, j,

  693.                                           caca_get_char(m_caca, k,

  694.                                                         j - nb_lines));

  695.                             caca_put_attr(m_caca, k, j,

  696.                                           caca_get_attr(m_caca, k,

  697.                                                         j - nb_lines));

  698.                         }

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

  700.                                        j - nb_lines, ' ');

  701.                     }

  702.                 }

  703.                 break;

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

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

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

  707. 

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

  709.                 {

  710.                     caca_put_char(m_caca, j, y,

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

  712.                     caca_put_attr(m_caca, j, y,

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

  714.                 }

  715.                 break;

  716. #if 0

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

  718.                 caca_set_attr(m_caca, m_clearattr);

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

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

  721.                 caca_set_attr(m_caca, savedattr);

  722. #endif

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

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

  725.                 {

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

  727.                     caca_set_attr(m_caca, m_clearattr);

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

  729.                     caca_set_attr(m_caca, savedattr);

  730.                 }

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

  732.                 /*

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

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

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

  736.                    STP, and AVO */

  737.                 /* Warning, argument is Pn */

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

  739.                       argv[0], argv[0]);

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

  741.                 {

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

  743.                 }

  744.                 else

  745.                 {

  746.                     switch (argv[0])

  747.                     {

  748.                     case 1:

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

  750.                         break;

  751.                     case 2:

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

  753.                         break;

  754.                     case 3:

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

  756.                         break;

  757.                     case 4:

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

  759.                         break;

  760.                     case 5:

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

  762.                         break;

  763.                     case 6:

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

  765.                         break;

  766.                     case 7:

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

  768.                         break;

  769.                     default:

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

  771.                         break;

  772.                     }

  773.                 }

  774.                 break;

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

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

  777.                 break;

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

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

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

  781.                 break;

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

  783.                 break;

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

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

  786.                 {

  787.                     debug("DCSTBM %d %d", argv[0], argv[1]);

  788.                     top = argv[0];

  789.                     bottom = argv[1];

  790.                 }

  791.                 else

  792.                     debug("ansi import: command r with %d params", argc);

  793.                 break;

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

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

  796.                 break;

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

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

  799.                 break;

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

  801.                 if (argc)

  802.                     ReadGrcm(argc, argv);

  803.                 else

  804.                     ReadGrcm(1, &dummy);

  805.                 break;

  806.             case 'n':

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

  808.                 if (!argc)

  809.                     break;

  810. 

  811.                 switch (argv[0])

  812.                 {

  813.                 case 5:

  814.                     /* Term ok */

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

  816.                     break;

  817.                 case 6:

  818.                     /* Cursor Position */

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

  820.                     SendAnsi(b);

  821.                     break;

  822.                 }

  823. 

  824.                 break;

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

  826.                 save_x = x;

  827.                 save_y = y;

  828.                 break;

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

  830.                 x = save_x;

  831.                 y = save_y;

  832.                 break;

  833.             default:

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

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

  836.                 break;

  837.             }

  838.         }

  839. 

  840.         /* Parse OSC stuff. */

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

  842.         {

  843.             char *string;

  844.             unsigned int command = 0;

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

  846. 

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

  848.             {

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

  850.                     break;

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

  852.             }

  853. 

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

  855.                 break;          /* Invalid Mode */

  856. 

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

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

  859.                     break;

  860. 

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

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

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

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

  865.                invalid data (print shit) */

  866. 

  867.             skip += final;

  868. 

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

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

  871.                    final - (semicolon + 1));

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

  873.             debug("ansi import: got OSC command %i string '%s'", command,

  874.                   string);

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

  876.             {

  877.                 if (m_title)

  878.                     free(m_title);

  879.                 m_title = string;

  880.             }

  881.             else

  882.                 free(string);

  883.         }

  884. 

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

  886.         else

  887.         {

  888.             size_t bytes;

  889. 

  890.             if (i + 6 < size)

  891.             {

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

  893.             }

  894.             else

  895.             {

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

  897.                 char tmp[7];

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

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

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

  901.             }

  902. 

  903.             if (!bytes)

  904.             {

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

  906.                 ch = buffer[i];

  907.                 bytes = 1;

  908.             }

  909. 

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

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

  912.             {

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

  914.                     &&

  915.                     (m_conv_state.

  916.                      gn[m_conv_state.ss ? m_conv_state.

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

  918.                 {

  919.                     ch = dec_acs(ch);

  920.                 }

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

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

  923.                 {

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

  925.                 }

  926.             }

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

  928. 

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

  930. 

  931.             skip += bytes - 1;

  932.         }

  933. 

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

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

  936.         {

  937.             x -= width;

  938.             y++;

  939.         }

  940. 

  941.         /* Scroll or grow vertically */

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

  943.         {

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

  945. 

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

  947. 

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

  949.             {

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

  951.                 {

  952.                     caca_put_char(m_caca, k, j,

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

  954.                     caca_put_attr(m_caca, k, j,

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

  956.                 }

  957.             }

  958.             caca_set_attr(m_caca, m_clearattr);

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

  960.             y -= lines;

  961.             caca_set_attr(m_caca, savedattr);

  962.         }

  963. 

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

  965.         if (wch)

  966.         {

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

  968.             x += wch;

  969.         }

  970.     }

  971. 

  972.     caca_gotoxy(m_caca, x, y);

  973. 

  974.     if (i)

  975.         m_changed = 1;

  976.     return i;

  977. }

  978. 

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

  980. {

  981.     size_t ret = strlen(str);

  982. 

  983.     /* FIXME TODO: not implemented */

  984.     Log::Debug("Sending %d-character ANSI sequence\n", (int)ret);

  985. 

  986.     return ret;

  987. }

  988. 

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

  990.    189) */

  991. void Iso2022Conversion::Reset()

  992. {

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

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

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

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

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

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

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

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

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

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

  1003.     ctrl8bit = 1;

  1004. }

  1005. 

  1006. /* XXX : ANSI loader helper */

  1007. 

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

  1009. {

  1010.     static uint8_t const ansi2caca[] = {

  1011.         CACA_BLACK, CACA_RED, CACA_GREEN, CACA_BROWN,

  1012.         CACA_BLUE, CACA_MAGENTA, CACA_CYAN, CACA_LIGHTGRAY

  1013.     };

  1014. 

  1015.     unsigned int j;

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

  1017. 

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

  1019.     {

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

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

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

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

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

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

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

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

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

  1029.         else

  1030.             switch (argv[j])

  1031.             {

  1032.             case 0:            /* default rendition */

  1033.                 m_fg = m_dfg;

  1034.                 m_bg = m_dbg;

  1035.                 m_bold = m_blink = m_italics = m_negative

  1036.                        = m_concealed = m_underline = m_faint = m_strike

  1037.                        = m_proportional = 0;

  1038.                 break;

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

  1040.                 m_bold = 1;

  1041.                 break;

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

  1043.                                  */

  1044.                 m_faint = 1;

  1045.                 break;

  1046.             case 3:            /* italicized */

  1047.                 m_italics = 1;

  1048.                 break;

  1049.             case 4:            /* singly underlined */

  1050.                 m_underline = 1;

  1051.                 break;

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

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

  1054.                 m_blink = 1;

  1055.                 break;

  1056.             case 7:            /* negative image */

  1057.                 m_negative = 1;

  1058.                 break;

  1059.             case 8:            /* concealed characters */

  1060.                 m_concealed = 1;

  1061.                 break;

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

  1063.                                    marked as to be deleted */

  1064.                 m_strike = 1;

  1065.                 break;

  1066.             case 21:           /* doubly underlined */

  1067.                 m_underline = 1;

  1068.                 break;

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

  1070.                                    bold nor faint) */

  1071.                 m_bold = m_faint = 0;

  1072.                 break;

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

  1074.                 m_italics = 0;

  1075.                 break;

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

  1077.                 m_underline = 0;

  1078.                 break;

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

  1080.                 m_blink = 0;

  1081.                 break;

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

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

  1084.                 m_proportional = 1;

  1085.                 break;

  1086.             case 27:           /* positive image */

  1087.                 m_negative = 0;

  1088.                 break;

  1089.             case 28:           /* revealed characters */

  1090.                 m_concealed = 0;

  1091.                 break;

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

  1093.                 m_strike = 0;

  1094.                 break;

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

  1096.                                    intended for setting character foreground

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

  1098.                                    Recommendation T.416]) */

  1099.                 break;

  1100.             case 39:           /* default display colour

  1101.                                    (implementation-defined) */

  1102.                 m_fg = m_dfg;

  1103.                 break;

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

  1105.                                    intended for setting character background

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

  1107.                                    Recommendation T.416]) */

  1108.                 break;

  1109.             case 49:           /* default background colour

  1110.                                    (implementation-defined) */

  1111.                 m_bg = m_dbg;

  1112.                 break;

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

  1114.                                    rendering aspect established by parameter

  1115.                                    value 26) */

  1116.                 m_proportional = 0;

  1117.                 break;

  1118.             default:

  1119.                 debug("ansi import: unknown sgr %i", argv[j]);

  1120.                 break;

  1121.             }

  1122.     }

  1123. 

  1124.     if (m_concealed)

  1125.     {

  1126.         efg = ebg = CACA_TRANSPARENT;

  1127.     }

  1128.     else

  1129.     {

  1130.         efg = m_negative ? m_bg : m_fg;

  1131.         ebg = m_negative ? m_fg : m_bg;

  1132. 

  1133.         if (m_bold)

  1134.         {

  1135.             if (efg < 8)

  1136.                 efg += 8;

  1137.             else if (efg == CACA_DEFAULT)

  1138.                 efg = CACA_WHITE;

  1139.         }

  1140.     }

  1141. 

  1142.     caca_set_color_ansi(m_caca, efg, ebg);

  1143. }