cacalabs
/
neercs
의 미러 https://github.com/cacalabs/neercs.git
1
0
포크 0
코드 이슈 0 릴리즈 0 위키 활동
25개 이상의 토픽을 선택하실 수 없습니다. Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
220 커밋
1 브렌치
2.7 MiB
 
 
 
 
 
트리: 8915c4b685
브랜치 태그
${ item.name }
${ searchTerm } 브랜치 생성
from '8915c4b685'
${ noResults }
neercs/neercs/old/ansi.c

1157 lines
40 KiB
Raw Blame 히스토리 

  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://www.wtfpl.net/ for more details.

  13.  */

  14. 

  15. #if defined HAVE_CONFIG_H

  16. #   include "config.h"

  17. #endif

  18. 

  19. #if defined _MSC_VER

  20. #   define inline __inline

  21. #endif

  22. 

  23. #include <string.h>

  24. #include <caca.h>

  25. #include "neercs.h"

  26. 

  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. static void reset_conv_state(struct screen *);

  113. 

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

  115. 

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

  117. 

  118. static void ansi_parse_grcm(struct screen *,

  119.                             unsigned int, unsigned int const *);

  120. 

  121. inline int handle_single_char(unsigned char c, int *x, int *y,

  122.                               struct screen_list *screen_list,

  123.                               struct screen *sc);

  124. static inline int handle_duplet(unsigned char const *buffer, struct screen *sc,

  125.                          unsigned int *skip, int top, int bottom, int width,

  126.                          int height);

  127. 

  128. 

  129. inline int handle_single_char(unsigned char c, int *x, int *y,

  130.                               struct screen_list *screen_list,

  131.                               struct screen *sc)

  132. {

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

  134.     {

  135.         *x = 0;

  136.     }

  137. 

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

  139.     {

  140.         *x = 0;

  141.         *y = *y + 1;

  142.     }

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

  144.     {

  145.         if (!sc->bell)

  146.             screen_list->in_bell = 10;

  147.         sc->bell = 1;

  148.     }

  149. 

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

  151.     {

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

  153.     }

  154. 

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

  156.     {

  157.         if (*x > 0)

  158.             *x = *x - 1;

  159.     }

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

  161.     {

  162.         /* Vertical tab */

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

  164.         if (*y < caca_get_canvas_height(sc->cv))

  165.             *y = *y + 1;

  166.     }

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

  168.     {

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

  170.            the G1 character set. */

  171.         sc->conv_state.glr[0] = 1;

  172.     }

  173. 

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

  175.     {

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

  177.            G0 character set. */

  178.         sc->conv_state.glr[0] = 0;

  179.     }

  180.     else

  181.     {

  182.         return 1;

  183.     }

  184.     return 0;

  185. }

  186. 

  187. static inline int handle_duplet(unsigned char const *buffer, struct screen *sc,

  188.                          unsigned int *skip, int top, int bottom, int width,

  189.                          int height)

  190. {

  191.     int i = 0, j, k;

  192.     unsigned int dummy = 0;

  193. 

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

  195.        character only */

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

  197.     {

  198.         sc->conv_state.ss = 2;

  199.         *skip += 1;

  200.     }

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

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

  203.     {

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

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

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

  207.         {

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

  209.             {

  210.                 caca_put_char(sc->cv, k, j, caca_get_char(sc->cv, k, j - 1));

  211.                 caca_put_attr(sc->cv, k, j, caca_get_attr(sc->cv, k, j - 1));

  212.             }

  213.         }

  214.         caca_draw_line(sc->cv, 0, top - 1, width - 1, top - 1, ' ');

  215.         *skip += 1;

  216.     }

  217. 

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

  219.        character only */

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

  221.     {

  222.         sc->conv_state.ss = 3;

  223.         *skip += 1;

  224.     }

  225. 

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

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

  228.     {

  229.         sc->conv_state.glr[0] = 2;

  230.         *skip += 1;

  231.     }

  232. 

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

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

  235.     {

  236.         sc->conv_state.glr[0] = 3;

  237.         *skip += 1;

  238.     }

  239. 

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

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

  242.     {

  243.         sc->dfg = CACA_DEFAULT;

  244.         sc->dbg = CACA_DEFAULT;

  245. 

  246.         caca_set_color_ansi(sc->cv, sc->dfg, sc->dbg);

  247.         sc->clearattr = caca_get_attr(sc->cv, -1, -1);

  248.         ansi_parse_grcm(sc, 1, &dummy);

  249. 

  250.         reset_conv_state(sc);

  251.         *skip += 1;

  252.     }

  253. 

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

  255.        IR 189) */

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

  257.     {

  258.         reset_conv_state(sc);

  259.         *skip += 1;

  260.     }

  261.     else

  262.     {

  263.         return 1;

  264.     }

  265. 

  266.     return 0;

  267. }

  268. 

  269. 

  270. long int import_term(struct screen_list *screen_list, struct screen *sc,

  271.                      void const *data, unsigned int size)

  272. {

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

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

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

  276.     uint32_t savedattr;

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

  278.     char b[100];

  279. 

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

  281. 

  282.     width = caca_get_canvas_width(sc->cv);

  283.     height = caca_get_canvas_height(sc->cv);

  284.     x = caca_get_cursor_x(sc->cv);

  285.     y = caca_get_cursor_y(sc->cv);

  286.     top = 1;

  287.     bottom = height;

  288. 

  289.     if (!sc->init)

  290.     {

  291.         sc->dfg = CACA_LIGHTGRAY;

  292.         sc->dbg = CACA_BLACK;

  293. 

  294.         caca_set_color_ansi(sc->cv, sc->dfg, sc->dbg);

  295.         sc->clearattr = caca_get_attr(sc->cv, -1, -1);

  296. 

  297.         ansi_parse_grcm(sc, 1, &dummy);

  298. 

  299.         reset_conv_state(sc);

  300. 

  301.         sc->init = 1;

  302.     }

  303. 

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

  305.     {

  306.         uint32_t ch = 0;

  307.         int wch = 0;

  308. 

  309.         skip = 1;

  310. 

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

  312.         if (!handle_single_char(buffer[i], &x, &y, screen_list, sc))

  313.         {

  314.         }

  315. 

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

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

  318. 

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

  320.             break;

  321. 

  322. 

  323.         else if (!handle_duplet(&buffer[i], sc, &skip,

  324.                                 top, bottom, width, height))

  325.         {

  326. 

  327.         }

  328. 

  329. 

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

  331.            from ISO 2022:1986] */

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

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

  334.         {

  335.             sc->conv_state.gn[0] = LITERAL2CHAR('$', buffer[i + 2]);

  336.             skip += 2;

  337.         }

  338. 

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

  340.            these */

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

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

  343.             break;

  344. 

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

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

  347.         {

  348.             sc->conv_state.gn[0] = buffer[i + 2];

  349.             skip += 2;

  350.         }

  351. 

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

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

  354.         {

  355.             sc->conv_state.gn[1] = buffer[i + 2];

  356.             skip += 2;

  357.         }

  358. 

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

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

  361.         {

  362.             sc->conv_state.gn[2] = buffer[i + 2];

  363.             skip += 2;

  364.         }

  365. 

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

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

  368.         {

  369.             sc->conv_state.gn[3] = buffer[i + 2];

  370.             skip += 2;

  371.         }

  372. 

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

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

  375.         {

  376.             sc->conv_state.gn[2] = LITERAL2CHAR('.', buffer[i + 2]);

  377.             skip += 2;

  378.         }

  379. 

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

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

  382.         {

  383.             sc->conv_state.gn[3] = LITERAL2CHAR('.', buffer[i + 2]);

  384.             skip += 2;

  385.         }

  386. 

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

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

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

  390.         {

  391.             sc->conv_state.gn[0] = LITERAL2CHAR('$', buffer[i + 3]);

  392.             skip += 3;

  393.         }

  394. 

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

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

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

  398.         {

  399.             sc->conv_state.gn[1] = LITERAL2CHAR('$', buffer[i + 3]);

  400.             skip += 3;

  401.         }

  402. 

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

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

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

  406.         {

  407.             sc->conv_state.gn[2] = LITERAL2CHAR('$', buffer[i + 3]);

  408.             skip += 3;

  409.         }

  410. 

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

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

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

  414.         {

  415.             sc->conv_state.gn[3] = LITERAL2CHAR('$', buffer[i + 3]);

  416.             skip += 3;

  417.         }

  418. 

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

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

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

  422.         {

  423.             sc->conv_state.gn[2] = LITERAL3CHAR('$', '.', buffer[i + 3]);

  424.             skip += 3;

  425.         }

  426. 

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

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

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

  430.         {

  431.             sc->conv_state.gn[3] = LITERAL3CHAR('$', '.', buffer[i + 3]);

  432.             skip += 3;

  433.         }

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

  435.         {

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

  437. 

  438.             switch (buffer[i + 2])

  439.             {

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

  441.                                    uppercase Es for screen focus and

  442.                                    alignment. */

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

  444.                 {

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

  446.                     {

  447.                         caca_put_char(sc->cv, k, j, 'E');

  448.                     }

  449.                 }

  450.                 x = 0;

  451.                 y = 0;

  452.                 skip += 2;

  453.                 break;

  454. 

  455.             default:

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

  457.                 continue;

  458.             }

  459. 

  460.         }

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

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

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

  464.         {

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

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

  467. 

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

  469.             {

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

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

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

  473.             }

  474. 

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

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

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

  478.                +-----+------------------+---------------------+-----------------+

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

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

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

  482.                +-----+------------------+---------------------+-----------------+ */

  483.             param = 2;

  484. 

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

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

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

  488.                nor XTerm sources, thought. */

  489. 

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

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

  492.                 {

  493.                     handle_single_char(buffer[i + junk], &x, &y, screen_list,

  494.                                        sc);

  495.                 }

  496.                 else

  497.                 {

  498.                     break;

  499.                 }

  500. 

  501.             /* Intermediate offset */

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

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

  504.                 {

  505.                     break;

  506.                 }

  507.             /* Interleaved character */

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

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

  510.                 {

  511.                     handle_single_char(buffer[i + junk], &x, &y, screen_list,

  512.                                        sc);

  513.                 }

  514.                 else

  515.                 {

  516.                     break;

  517.                 }

  518. 

  519.             /* Final Byte offset */

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

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

  522.                 {

  523.                     break;

  524.                 }

  525.             if (i + final >= size

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

  527.             {

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

  529.                       buffer[i + final]);

  530.                 break;          /* Invalid Final Byte */

  531.             }

  532. 

  533.             skip += final;

  534. 

  535.             /* Sanity checks */

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

  537.             {

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

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

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

  541.                 /* FIXME better parsing */

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

  543.                 {

  544.                     char arg[5], *end;

  545.                     int a = 0;

  546.                     int c, p, Pm;

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

  548.                     {

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

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

  551.                         {

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

  553.                             arg[a + 1] = 0;

  554.                             a++;

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

  556.                         }

  557.                         else

  558.                         {

  559.                             break;

  560.                         }

  561.                     }

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

  563. 

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

  565. 

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

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

  568.                     {

  569. 

  570.                         switch (Pm)

  571.                         {

  572.                             /* FIXME Handle different modes */

  573.                         case 9:

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

  575.                             sc->report_mouse = MOUSE_X10;

  576.                             break;

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

  578.                                            and release.  */

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

  580.                             sc->report_mouse = MOUSE_VT200;

  581.                             break;

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

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

  584.                             sc->report_mouse = MOUSE_VT200_HIGHLIGHT;

  585.                             break;

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

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

  588.                             sc->report_mouse = MOUSE_BTN_EVENT;

  589.                             break;

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

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

  592.                             sc->report_mouse = MOUSE_ANY_EVENT;

  593.                             break;

  594.                         default:

  595.                             break;

  596.                         }

  597.                     }

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

  599.                     {

  600.                         Pm = atoi(arg);

  601.                         switch (Pm)

  602.                         {

  603.                             /* FIXME Handle different modes */

  604.                         case 9:

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

  606.                                            and release.  */

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

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

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

  610.                             sc->report_mouse = MOUSE_NONE;

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

  612.                             break;

  613.                         default:

  614.                             break;

  615.                         }

  616.                     }

  617.                 }

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

  619.             }

  620. 

  621.             if (final - param > 100)

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

  623. 

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

  625.                format */

  626.             if (param < inter)

  627.             {

  628.                 argv[0] = 0;

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

  630.                 {

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

  632.                         argv[++argc] = 0;

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

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

  635.                 }

  636.                 argc++;

  637.             }

  638. 

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

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

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

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

  643.             switch (buffer[i + final])

  644.             {

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

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

  647.                 if (y < 0)

  648.                     y = 0;

  649.                 break;

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

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

  652.                 break;

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

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

  655.                 break;

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

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

  658.                 if (x < 0)

  659.                     x = 0;

  660.                 break;

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

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

  663.                 break;

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

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

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

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

  668.                 break;

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

  670.                 savedattr = caca_get_attr(sc->cv, -1, -1);

  671.                 caca_set_attr(sc->cv, sc->clearattr);

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

  673.                 {

  674.                     caca_draw_line(sc->cv, x, y, width, y, ' ');

  675.                     caca_fill_box(sc->cv, 0, y + 1, width, height - 1, ' ');

  676.                 }

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

  678.                 {

  679.                     caca_fill_box(sc->cv, 0, 0, width, y, ' ');

  680.                     caca_draw_line(sc->cv, 0, y, x, y, ' ');

  681.                 }

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

  683.                 {

  684.                     // x = y = 0;

  685.                     caca_fill_box(sc->cv, 0, 0, width, height, ' ');

  686.                 }

  687.                 caca_set_attr(sc->cv, savedattr);

  688.                 break;

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

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

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

  692.                 {

  693.                     caca_draw_line(sc->cv, x, y, width, y, ' ');

  694.                 }

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

  696.                 {

  697.                     caca_draw_line(sc->cv, 0, y, x, y, ' ');

  698.                 }

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

  700.                 {

  701.                     caca_draw_line(sc->cv, 0, y, width, y, ' ');

  702.                 }

  703.                 break;

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

  705.                 {

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

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

  708.                     {

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

  710.                         {

  711.                             caca_put_char(sc->cv, k, j,

  712.                                           caca_get_char(sc->cv, k,

  713.                                                         j - nb_lines));

  714.                             caca_put_attr(sc->cv, k, j,

  715.                                           caca_get_attr(sc->cv, k,

  716.                                                         j - nb_lines));

  717.                         }

  718.                         caca_draw_line(sc->cv, 0, j - nb_lines, width,

  719.                                        j - nb_lines, ' ');

  720.                     }

  721.                 }

  722.                 break;

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

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

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

  726. 

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

  728.                 {

  729.                     caca_put_char(sc->cv, j, y,

  730.                                   caca_get_char(sc->cv, j + argv[0], y));

  731.                     caca_put_attr(sc->cv, j, y,

  732.                                   caca_get_attr(sc->cv, j + argv[0], y));

  733.                 }

  734.                 break;

  735. #if 0

  736.                 savedattr = caca_get_attr(sc->cv, -1, -1);

  737.                 caca_set_attr(sc->cv, sc->clearattr);

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

  739.                     caca_put_char(sc->cv, j, y, ' ');

  740.                 caca_set_attr(sc->cv, savedattr);

  741. #endif

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

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

  744.                 {

  745.                     savedattr = caca_get_attr(sc->cv, -1, -1);

  746.                     caca_set_attr(sc->cv, sc->clearattr);

  747.                     caca_draw_line(sc->cv, x, y, x + argv[0] - 1, y, ' ');

  748.                     caca_set_attr(sc->cv, savedattr);

  749.                 }

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

  751.                 /*

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

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

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

  755.                    STP, and AVO */

  756.                 /* Warning, argument is Pn */

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

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

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

  760.                 {

  761.                     send_ansi_sequence(screen_list, "\x1b[?1;0c");

  762.                 }

  763.                 else

  764.                 {

  765.                     switch (argv[0])

  766.                     {

  767.                     case 1:

  768.                         send_ansi_sequence(screen_list, "\x1b[?\x1;\x1c");

  769.                         break;

  770.                     case 2:

  771.                         send_ansi_sequence(screen_list, "\x1b[?\x1;\x2c");

  772.                         break;

  773.                     case 3:

  774.                         send_ansi_sequence(screen_list, "\x1b[?\x1;\x3c");

  775.                         break;

  776.                     case 4:

  777.                         send_ansi_sequence(screen_list, "\x1b[?\x1;\x4c");

  778.                         break;

  779.                     case 5:

  780.                         send_ansi_sequence(screen_list, "\x1b[?\x1;\x5c");

  781.                         break;

  782.                     case 6:

  783.                         send_ansi_sequence(screen_list, "\x1b[?\x1;\x6c");

  784.                         break;

  785.                     case 7:

  786.                         send_ansi_sequence(screen_list, "\x1b[?\x1;\x7c");

  787.                         break;

  788.                     default:

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

  790.                         break;

  791.                     }

  792.                 }

  793.                 break;

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

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

  796.                 break;

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

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

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

  800.                 break;

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

  802.                 break;

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

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

  805.                 {

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

  807.                     top = argv[0];

  808.                     bottom = argv[1];

  809.                 }

  810.                 else

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

  812.                 break;

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

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

  815.                 break;

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

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

  818.                 break;

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

  820.                 if (argc)

  821.                     ansi_parse_grcm(sc, argc, argv);

  822.                 else

  823.                     ansi_parse_grcm(sc, 1, &dummy);

  824.                 break;

  825.             case 'n':

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

  827.                 if (!argc)

  828.                     break;

  829. 

  830.                 switch (argv[0])

  831.                 {

  832.                 case 5:

  833.                     /* Term ok */

  834.                     send_ansi_sequence(screen_list, "\x1b[0n");

  835.                     break;

  836.                 case 6:

  837.                     /* Cursor Position */

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

  839.                     send_ansi_sequence(screen_list, b);

  840.                     break;

  841.                 }

  842. 

  843.                 break;

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

  845.                 save_x = x;

  846.                 save_y = y;

  847.                 break;

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

  849.                 x = save_x;

  850.                 y = save_y;

  851.                 break;

  852.             default:

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

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

  855.                 break;

  856.             }

  857.         }

  858. 

  859.         /* Parse OSC stuff. */

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

  861.         {

  862.             char *string;

  863.             unsigned int command = 0;

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

  865. 

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

  867.             {

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

  869.                     break;

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

  871.             }

  872. 

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

  874.                 break;          /* Invalid Mode */

  875. 

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

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

  878.                     break;

  879. 

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

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

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

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

  884.                invalid data (print shit) */

  885. 

  886.             skip += final;

  887. 

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

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

  890.                    final - (semicolon + 1));

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

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

  893.                   string);

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

  895.             {

  896.                 if (sc->title)

  897.                     free(sc->title);

  898.                 sc->title = string;

  899.             }

  900.             else

  901.                 free(string);

  902.         }

  903. 

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

  905.         else

  906.         {

  907.             size_t bytes;

  908. 

  909.             if (i + 6 < size)

  910.             {

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

  912.             }

  913.             else

  914.             {

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

  916.                 char tmp[7];

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

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

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

  920.             }

  921. 

  922.             if (!bytes)

  923.             {

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

  925.                 ch = buffer[i];

  926.                 bytes = 1;

  927.             }

  928. 

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

  930.             if (sc->conv_state.cs == '@')

  931.             {

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

  933.                     &&

  934.                     (sc->conv_state.

  935.                      gn[sc->conv_state.ss ? sc->conv_state.

  936.                         gn[sc->conv_state.ss] : sc->conv_state.glr[0]] == '0'))

  937.                 {

  938.                     ch = dec_acs(ch);

  939.                 }

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

  941.                          && (sc->conv_state.gn[sc->conv_state.glr[1]] == '0'))

  942.                 {

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

  944.                 }

  945.             }

  946.             sc->conv_state.ss = 0;      /* no single-shift (GL) */

  947. 

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

  949. 

  950.             skip += bytes - 1;

  951.         }

  952. 

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

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

  955.         {

  956.             x -= width;

  957.             y++;

  958.         }

  959. 

  960.         /* Scroll or grow vertically */

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

  962.         {

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

  964. 

  965.             savedattr = caca_get_attr(sc->cv, -1, -1);

  966. 

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

  968.             {

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

  970.                 {

  971.                     caca_put_char(sc->cv, k, j,

  972.                                   caca_get_char(sc->cv, k, j + lines));

  973.                     caca_put_attr(sc->cv, k, j,

  974.                                   caca_get_attr(sc->cv, k, j + lines));

  975.                 }

  976.             }

  977.             caca_set_attr(sc->cv, sc->clearattr);

  978.             caca_fill_box(sc->cv, 0, bottom - lines, width, bottom - 1, ' ');

  979.             y -= lines;

  980.             caca_set_attr(sc->cv, savedattr);

  981.         }

  982. 

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

  984.         if (wch)

  985.         {

  986.             caca_put_char(sc->cv, x, y, ch);

  987.             x += wch;

  988.         }

  989.     }

  990. 

  991.     caca_gotoxy(sc->cv, x, y);

  992. 

  993.     if (i)

  994.         sc->changed = 1;

  995.     return i;

  996. }

  997. 

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

  999.    189) */

  1000. 

  1001. static void reset_conv_state(struct screen *sc)

  1002. {

  1003.     sc->conv_state.cs = '@';    /* ISO-2022 coding system */

  1004.     sc->conv_state.cn[0] = '@'; /* ISO 646 C0 control charset */

  1005.     sc->conv_state.cn[1] = 'C'; /* ISO 6429-1983 C1 control charset */

  1006.     sc->conv_state.glr[0] = 0;  /* G0 in GL */

  1007.     sc->conv_state.glr[1] = 2;  /* G2 in GR */

  1008.     sc->conv_state.gn[0] = 'B'; /* US-ASCII G0 charset */

  1009.     sc->conv_state.gn[1] = '0'; /* DEC ACS G1 charset */

  1010.     sc->conv_state.gn[2] = LITERAL2CHAR('.', 'A');      /* ISO 8859-1 G2

  1011.                                                            charset */

  1012.     sc->conv_state.gn[3] = LITERAL2CHAR('.', 'A');      /* ISO 8859-1 G3

  1013.                                                            charset */

  1014.     sc->conv_state.ss = 0;      /* no single-shift (GL) */

  1015.     sc->conv_state.ctrl8bit = 1;

  1016. }

  1017. 

  1018. /* XXX : ANSI loader helper */

  1019. 

  1020. static void ansi_parse_grcm(struct screen *sc,

  1021.                             unsigned int argc, unsigned int const *argv)

  1022. {

  1023.     static uint8_t const ansi2caca[] = {

  1024.         CACA_BLACK, CACA_RED, CACA_GREEN, CACA_BROWN,

  1025.         CACA_BLUE, CACA_MAGENTA, CACA_CYAN, CACA_LIGHTGRAY

  1026.     };

  1027. 

  1028.     unsigned int j;

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

  1030. 

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

  1032.     {

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

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

  1035.             sc->fg = ansi2caca[argv[j] - 30];

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

  1037.             sc->bg = ansi2caca[argv[j] - 40];

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

  1039.             sc->fg = ansi2caca[argv[j] - 90] + 8;

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

  1041.             sc->bg = ansi2caca[argv[j] - 100] + 8;

  1042.         else

  1043.             switch (argv[j])

  1044.             {

  1045.             case 0:            /* default rendition */

  1046.                 sc->fg = sc->dfg;

  1047.                 sc->bg = sc->dbg;

  1048.                 sc->bold = sc->blink = sc->italics = sc->negative

  1049.                     = sc->concealed = sc->underline = sc->faint = sc->strike

  1050.                     = sc->proportional = 0;

  1051.                 break;

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

  1053.                 sc->bold = 1;

  1054.                 break;

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

  1056.                                  */

  1057.                 sc->faint = 1;

  1058.                 break;

  1059.             case 3:            /* italicized */

  1060.                 sc->italics = 1;

  1061.                 break;

  1062.             case 4:            /* singly underlined */

  1063.                 sc->underline = 1;

  1064.                 break;

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

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

  1067.                 sc->blink = 1;

  1068.                 break;

  1069.             case 7:            /* negative image */

  1070.                 sc->negative = 1;

  1071.                 break;

  1072.             case 8:            /* concealed characters */

  1073.                 sc->concealed = 1;

  1074.                 break;

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

  1076.                                    marked as to be deleted */

  1077.                 sc->strike = 1;

  1078.                 break;

  1079.             case 21:           /* doubly underlined */

  1080.                 sc->underline = 1;

  1081.                 break;

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

  1083.                                    bold nor faint) */

  1084.                 sc->bold = sc->faint = 0;

  1085.                 break;

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

  1087.                 sc->italics = 0;

  1088.                 break;

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

  1090.                 sc->underline = 0;

  1091.                 break;

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

  1093.                 sc->blink = 0;

  1094.                 break;

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

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

  1097.                 sc->proportional = 1;

  1098.                 break;

  1099.             case 27:           /* positive image */

  1100.                 sc->negative = 0;

  1101.                 break;

  1102.             case 28:           /* revealed characters */

  1103.                 sc->concealed = 0;

  1104.                 break;

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

  1106.                 sc->strike = 0;

  1107.                 break;

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

  1109.                                    intended for setting character foreground

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

  1111.                                    Recommendation T.416]) */

  1112.                 break;

  1113.             case 39:           /* default display colour

  1114.                                    (implementation-defined) */

  1115.                 sc->fg = sc->dfg;

  1116.                 break;

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

  1118.                                    intended for setting character background

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

  1120.                                    Recommendation T.416]) */

  1121.                 break;

  1122.             case 49:           /* default background colour

  1123.                                    (implementation-defined) */

  1124.                 sc->bg = sc->dbg;

  1125.                 break;

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

  1127.                                    rendering aspect established by parameter

  1128.                                    value 26) */

  1129.                 sc->proportional = 0;

  1130.                 break;

  1131.             default:

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

  1133.                 break;

  1134.             }

  1135.     }

  1136. 

  1137.     if (sc->concealed)

  1138.     {

  1139.         efg = ebg = CACA_TRANSPARENT;

  1140.     }

  1141.     else

  1142.     {

  1143.         efg = sc->negative ? sc->bg : sc->fg;

  1144.         ebg = sc->negative ? sc->fg : sc->bg;

  1145. 

  1146.         if (sc->bold)

  1147.         {

  1148.             if (efg < 8)

  1149.                 efg += 8;

  1150.             else if (efg == CACA_DEFAULT)

  1151.                 efg = CACA_WHITE;

  1152.         }

  1153.     }

  1154. 

  1155.     caca_set_color_ansi(sc->cv, efg, ebg);

  1156. }