commit 55d228ff16234513b0df0dd12de8bc58160fc196 · pci.express/flanterm.zig

+48 -14

src/flanterm.c

···

       96
       96
        
           ctx->reverse_video = false;

     

       97
       97
        
           ctx->dec_private = false;

     

       98
       98
        
           ctx->insert_mode = false;

     

       99
       99
       +
           ctx->csi_unhandled = false;

     

       99
       100
        
           ctx->unicode_remaining = 0;

     

       100
       101
        
           ctx->g_select = 0;

     

       101
       102
        
           ctx->charsets[0] = CHARSET_DEFAULT;

     
···

       463
       464
        
           }

     

       464
       465
        
       }

     

       465
       466
        
       

     

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

     

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

     

       468
       468
       -
               goto cleanup;

     

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

     

       468
       468
       +
           // ESC \ terminates an OSC sequence cleanly

     

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

     

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

     

       471
       471
       +
           if (ctx->osc_escape) {

     

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

     

       473
       473
       +
                   ctx->osc = false;

     

       474
       474
       +
                   ctx->osc_escape = false;

     

       475
       475
       +
                   ctx->escape = false;

     

       476
       476
       +
                   return true;

     

       477
       477
       +
               } else {

     

       478
       478
       +
                   ctx->osc_escape = false;

     

       479
       479
       +
                   ctx->osc = false;

     

       480
       480
       +
                   // escape stays true here

     

       481
       481
       +
                   return false;

     

       482
       482
       +
               }

     

       469
       483
        
           }

     

       470
       470
       -
       

     

       471
       471
       -
           ctx->osc_escape = false;

     

       472
       472
       -
       

     

       473
       484
        
           switch (c) {

     

       474
       485
        
               case 0x1b:

     

       475
       486
        
                   ctx->osc_escape = true;

     

       476
       476
       -
                   return;

     

       487
       487
       +
                   break;

     

       488
       488
       +
               // BEL is the other terminator 

     

       477
       489
        
               case '\a':

     

       490
       490
       +
                   ctx->osc_escape = false;

     

       491
       491
       +
                   ctx->osc = false;

     

       492
       492
       +
                   ctx->escape = false;

     

       493
       493
       +
                   break;

     

       478
       494
        
               default:

     

       479
       495
        
                   break;

     

       480
       496
        
           }

     

       481
       481
       -
       

     

       482
       482
       -
       cleanup:

     

       483
       483
       -
           ctx->osc_escape = false;

     

       484
       484
       -
           ctx->osc = false;

     

       485
       485
       -
           ctx->escape = false;

     

       497
       497
       +
           return true;

     

       486
       498
        
       }

     

       487
       499
        
       

     

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

     
···

       542
       554
        
           ctx->scroll_enabled = false;

     

       543
       555
        
           size_t x, y;

     

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

     

       557
       557
       +
          

     

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

     

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

     

       560
       560
       +
           if (ctx->csi_unhandled) {

     

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

     

       562
       562
       +
                   ctx->csi_unhandled = false;

     

       563
       563
       +
                   goto cleanup;

     

       564
       564
       +
               }

     

       565
       565
       +
               return;

     

       566
       566
       +
           }

     

       545
       567
        
       

     

       546
       568
        
           switch (c) {

     

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

     

       570
       570
       +
               case 0x1B:

     

       571
       571
       +
                   return;

     

       547
       572
        
               case 'F':

     

       548
       573
        
                   x = 0;

     

       549
       574
        
                   // FALLTHRU

     
···

       782
       807
        
               case ']':

     

       783
       808
        
                   linux_private_parse(ctx);

     

       784
       809
        
                   break;

     

       810
       810
       +
               default:

     

       811
       811
       +
                   ctx->csi_unhandled = true;

     

       812
       812
       +
                   return;

     

       785
       813
        
           }

     

       786
       814
        
       

     

       787
       815
        
           ctx->scroll_enabled = r;

     
···

       817
       845
        
           ctx->escape_offset++;

     

       818
       846
        
       

     

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

     

       820
       820
       -
               osc_parse(ctx, c);

     

       821
       821
       -
               return;

     

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

     

       849
       849
       +
               // so osc_parse consumes ESC.

     

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

     

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

     

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

     

       853
       853
       +
                   return;

     

       854
       854
       +
               }

     

       822
       855
        
           }

     

       823
       856
        
       

     

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

     
···

       839
       872
        
                       ctx->esc_values[i] = 0;

     

       840
       873
        
                   ctx->esc_values_i = 0;

     

       841
       874
        
                   ctx->rrr = false;

     

       875
       875
       +
                   ctx->csi_unhandled = false;

     

       842
       876
        
                   ctx->control_sequence = true;

     

       843
       877
        
                   return;

     

       844
       878
        
               case '7':

src/flanterm_private.h

···

       58
       58
        
           bool reverse_video;

     

       59
       59
        
           bool dec_private;

     

       60
       60
        
           bool insert_mode;

     

       61
       61
       +
           bool csi_unhandled;

     

       61
       62
        
           uint64_t code_point;

     

       62
       63
        
           size_t unicode_remaining;

     

       63
       64
        
           uint8_t g_select;