commit 66b0c6a9e0be4e6cdb1b9bbca4daf7080b482fb4 · pci.express/flanterm.zig

+30 -14
src/flanterm.c
···

       463
       463
        
           }

     

       464
       464
        
       }

     

       465
       465
        
       

     

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

     

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

     

       468
       468
       -
               goto cleanup;

     

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

     

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

     

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

     

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

     

       470
       470
       +
           if (ctx->osc_escape) {

     

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

     

       472
       472
       +
                   ctx->osc = false;

     

       473
       473
       +
                   ctx->osc_escape = false;

     

       474
       474
       +
                   ctx->escape = false;

     

       475
       475
       +
                   return true;

     

       476
       476
       +
               } else {

     

       477
       477
       +
                   ctx->osc_escape = false;

     

       478
       478
       +
                   ctx->osc = false;

     

       479
       479
       +
                   // escape stays true here

     

       480
       480
       +
                   return false;

     

       481
       481
       +
               }

     

       469
       482
        
           }

     

       470
       470
       -
       

     

       471
       471
       -
           ctx->osc_escape = false;

     

       472
       472
       -
       

     

       473
       483
        
           switch (c) {

     

       474
       484
        
               case 0x1b:

     

       475
       485
        
                   ctx->osc_escape = true;

     

       476
       476
       -
                   return;

     

       486
       486
       +
                   break;

     

       487
       487
       +
               // BEL is the other terminator 

     

       477
       488
        
               case '\a':

     

       489
       489
       +
                   ctx->osc_escape = false;

     

       490
       490
       +
                   ctx->osc = false;

     

       491
       491
       +
                   ctx->escape = false;

     

       492
       492
       +
                   break;

     

       478
       493
        
               default:

     

       479
       494
        
                   break;

     

       480
       495
        
           }

     

       481
       481
       -
       

     

       482
       482
       -
       cleanup:

     

       483
       483
       -
           ctx->osc_escape = false;

     

       484
       484
       -
           ctx->osc = false;

     

       485
       485
       -
           ctx->escape = false;

     

       496
       496
       +
           return true;

     

       486
       497
        
       }

     

       487
       498
        
       

     

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

     
···

       817
       828
        
           ctx->escape_offset++;

     

       818
       829
        
       

     

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

     

       820
       820
       -
               osc_parse(ctx, c);

     

       821
       821
       -
               return;

     

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

     

       832
       832
       +
               // so osc_parse consumes ESC.

     

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

     

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

     

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

     

       836
       836
       +
                   return;

     

       837
       837
       +
               }

     

       822
       838
        
           }

     

       823
       839
        
       

     

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