commit 55d228ff16234513b0df0dd12de8bc58160fc196 · pci.express/flanterm.zig

+48 -14

src/flanterm.c

···

       96
        
           ctx->reverse_video = false;

     

       97
        
           ctx->dec_private = false;

     

       98
        
           ctx->insert_mode = false;

     

       0
        
       
     

       99
        
           ctx->unicode_remaining = 0;

     

       100
        
           ctx->g_select = 0;

     

       101
        
           ctx->charsets[0] = CHARSET_DEFAULT;

     
···

       463
        
           }

     

       464
        
       }

     

       465
        
       

     

       466
       -
       static void osc_parse(struct flanterm_context *ctx, uint8_t c) {

     

       467
       -
           if (ctx->osc_escape && c == '\\') {

     

       468
       -
               goto cleanup;

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       469
        
           }

     

       470
       -
       

     

       471
       -
           ctx->osc_escape = false;

     

       472
       -
       

     

       473
        
           switch (c) {

     

       474
        
               case 0x1b:

     

       475
        
                   ctx->osc_escape = true;

     

       476
       -
                   return;

     

       0
        
       
     

       477
        
               case '\a':

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       478
        
               default:

     

       479
        
                   break;

     

       480
        
           }

     

       481
       -
       

     

       482
       -
       cleanup:

     

       483
       -
           ctx->osc_escape = false;

     

       484
       -
           ctx->osc = false;

     

       485
       -
           ctx->escape = false;

     

       486
        
       }

     

       487
        
       

     

       488
        
       static void control_sequence_parse(struct flanterm_context *ctx, uint8_t c) {

     
···

       542
        
           ctx->scroll_enabled = false;

     

       543
        
           size_t x, y;

     

       544
        
           ctx->get_cursor_pos(ctx, &x, &y);

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       545
        
       

     

       546
        
           switch (c) {

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       547
        
               case 'F':

     

       548
        
                   x = 0;

     

       549
        
                   // FALLTHRU

     
···

       782
        
               case ']':

     

       783
        
                   linux_private_parse(ctx);

     

       784
        
                   break;

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       785
        
           }

     

       786
        
       

     

       787
        
           ctx->scroll_enabled = r;

     
···

       817
        
           ctx->escape_offset++;

     

       818
        
       

     

       819
        
           if (ctx->osc == true) {

     

       820
       -
               osc_parse(ctx, c);

     

       821
       -
               return;

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       822
        
           }

     

       823
        
       

     

       824
        
           if (ctx->control_sequence == true) {

     
···

       839
        
                       ctx->esc_values[i] = 0;

     

       840
        
                   ctx->esc_values_i = 0;

     

       841
        
                   ctx->rrr = false;

     

       0
        
       
     

       842
        
                   ctx->control_sequence = true;

     

       843
        
                   return;

     

       844
        
               case '7':

···

       96
        
           ctx->reverse_video = false;

     

       97
        
           ctx->dec_private = false;

     

       98
        
           ctx->insert_mode = false;

     

       99
       +
           ctx->csi_unhandled = false;

     

       100
        
           ctx->unicode_remaining = 0;

     

       101
        
           ctx->g_select = 0;

     

       102
        
           ctx->charsets[0] = CHARSET_DEFAULT;

     
···

       464
        
           }

     

       465
        
       }

     

       466
        
       

     

       467
       +
       static bool osc_parse(struct flanterm_context *ctx, uint8_t c) {

     

       468
       +
           // ESC \ terminates an OSC sequence cleanly

     

       469
       +
           // but if ESC is followed by non-\, report failure from osc_parse and

     

       470
       +
           // try parsing the character as another escape code

     

       471
       +
           if (ctx->osc_escape) {

     

       472
       +
               if (c == '\\') {

     

       473
       +
                   ctx->osc = false;

     

       474
       +
                   ctx->osc_escape = false;

     

       475
       +
                   ctx->escape = false;

     

       476
       +
                   return true;

     

       477
       +
               } else {

     

       478
       +
                   ctx->osc_escape = false;

     

       479
       +
                   ctx->osc = false;

     

       480
       +
                   // escape stays true here

     

       481
       +
                   return false;

     

       482
       +
               }

     

       483
        
           }

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       484
        
           switch (c) {

     

       485
        
               case 0x1b:

     

       486
        
                   ctx->osc_escape = true;

     

       487
       +
                   break;

     

       488
       +
               // BEL is the other terminator 

     

       489
        
               case '\a':

     

       490
       +
                   ctx->osc_escape = false;

     

       491
       +
                   ctx->osc = false;

     

       492
       +
                   ctx->escape = false;

     

       493
       +
                   break;

     

       494
        
               default:

     

       495
        
                   break;

     

       496
        
           }

     

       497
       +
           return true;

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       498
        
       }

     

       499
        
       

     

       500
        
       static void control_sequence_parse(struct flanterm_context *ctx, uint8_t c) {

     
···

       554
        
           ctx->scroll_enabled = false;

     

       555
        
           size_t x, y;

     

       556
        
           ctx->get_cursor_pos(ctx, &x, &y);

     

       557
       +
          

     

       558
       +
           // CSI sequences are terminated by a byte in [0x40,0x7E]

     

       559
       +
           // so skip all bytes until the terminator byte

     

       560
       +
           if (ctx->csi_unhandled) {

     

       561
       +
               if (c >= 0x40 && c <= 0x7E) {

     

       562
       +
                   ctx->csi_unhandled = false;

     

       563
       +
                   goto cleanup;

     

       564
       +
               }

     

       565
       +
               return;

     

       566
       +
           }

     

       567
        
       

     

       568
        
           switch (c) {

     

       569
       +
               // Got ESC in the middle of an escape sequence, start a new one

     

       570
       +
               case 0x1B:

     

       571
       +
                   return;

     

       572
        
               case 'F':

     

       573
        
                   x = 0;

     

       574
        
                   // FALLTHRU

     
···

       807
        
               case ']':

     

       808
        
                   linux_private_parse(ctx);

     

       809
        
                   break;

     

       810
       +
               default:

     

       811
       +
                   ctx->csi_unhandled = true;

     

       812
       +
                   return;

     

       813
        
           }

     

       814
        
       

     

       815
        
           ctx->scroll_enabled = r;

     
···

       845
        
           ctx->escape_offset++;

     

       846
        
       

     

       847
        
           if (ctx->osc == true) {

     

       848
       +
               // ESC \ is one of the two possible terminators of OSC sequences,

     

       849
       +
               // so osc_parse consumes ESC.

     

       850
       +
               // If it is then followed by \ it cleans correctly,

     

       851
       +
               // otherwise it returns false, and it tries parsing it as another escape sequence

     

       852
       +
               if (osc_parse(ctx, c)) {

     

       853
       +
                   return;

     

       854
       +
               }

     

       855
        
           }

     

       856
        
       

     

       857
        
           if (ctx->control_sequence == true) {

     
···

       872
        
                       ctx->esc_values[i] = 0;

     

       873
        
                   ctx->esc_values_i = 0;

     

       874
        
                   ctx->rrr = false;

     

       875
       +
                   ctx->csi_unhandled = false;

     

       876
        
                   ctx->control_sequence = true;

     

       877
        
                   return;

     

       878
        
               case '7':

src/flanterm_private.h

···

       58
        
           bool reverse_video;

     

       59
        
           bool dec_private;

     

       60
        
           bool insert_mode;

     

       0
        
       
     

       61
        
           uint64_t code_point;

     

       62
        
           size_t unicode_remaining;

     

       63
        
           uint8_t g_select;

···

       58
        
           bool reverse_video;

     

       59
        
           bool dec_private;

     

       60
        
           bool insert_mode;

     

       61
       +
           bool csi_unhandled;

     

       62
        
           uint64_t code_point;

     

       63
        
           size_t unicode_remaining;

     

       64
        
           uint8_t g_select;