← Back to branch summary

~ubuntu-branches/ubuntu/raring/mesa/raring

« back to all changes in this revision

Viewing changes to src/glsl/glcpp/glcpp-lex.c

  • Committer: Package Import Robot
  • Author(s): Maarten Lankhorst
  • Date: 2013-01-22 11:54:09 UTC
  • mfrom: (1.7.13)
  • Revision ID: package-import@ubuntu.com-20130122115409-5e9xii2ee1whab3e
Tags: 9.0.2-0ubuntu1
* New upstream release.
* Decrease size of mesa's libgl1-mesa-dri again
  - re-enable 117-static-gallium.patch
  - add 118-dricore-gallium.patch to link against libdricore again

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/glsl/glcpp/glcpp-lex.c
54
54
typedef unsigned char flex_uint8_t; 
55
55
typedef unsigned short int flex_uint16_t;
56
56
typedef unsigned int flex_uint32_t;
57
 
#endif /* ! C99 */
58
57
 
59
58
/* Limits of integral types. */
60
59
#ifndef INT8_MIN
85
84
#define UINT32_MAX             (4294967295U)
86
85
#endif
87
86
 
 
87
#endif /* ! C99 */
 
88
 
88
89
#endif /* ! FLEXINT_H */
89
90
 
90
91
#ifdef __cplusplus
158
159
 
159
160
/* Size of default input buffer. */
160
161
#ifndef YY_BUF_SIZE
 
162
#ifdef __ia64__
 
163
/* On IA-64, the buffer size is 16k, not 8k.
 
164
 * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
 
165
 * Ditto for the __ia64__ case accordingly.
 
166
 */
 
167
#define YY_BUF_SIZE 32768
 
168
#else
161
169
#define YY_BUF_SIZE 16384
 
170
#endif /* __ia64__ */
162
171
#endif
163
172
 
164
173
/* The state buf must be large enough to hold one state per character in the main buffer.
349
358
        *yy_cp = '\0'; \
350
359
        yyg->yy_c_buf_p = yy_cp;
351
360
 
352
 
#define YY_NUM_RULES 42
353
 
#define YY_END_OF_BUFFER 43
 
361
#define YY_NUM_RULES 43
 
362
#define YY_END_OF_BUFFER 44
354
363
/* This struct is not used in this scanner,
355
364
   but its presence is necessary. */
356
365
struct yy_trans_info
358
367
        flex_int32_t yy_verify;
359
368
        flex_int32_t yy_nxt;
360
369
        };
361
 
static yyconst flex_int16_t yy_acclist[106] =
362
 
    {   0,
363
 
        3,    3,   43,   38,   42,   39,   42,   40,   42,   42,
364
 
       37,   42,   42,   37,   42,   37,   42,   37,   42,   24,
365
 
       42,   23,   42,   37,   42,   37,   42,   37,   42,   36,
366
 
       42,   36,   42,   37,   42,   39,   42,   22,   42,    3,
367
 
       42,    4,   42,    5,   42,   41,   42,   17,   42,   17,
368
 
       42,   17,   42,   38,   39,   31,   34,   32,    2,    1,
369
 
       24,   24,   23,   23,   26,   28,   30,   29,   27,   36,
370
 
       36,   33,   39,   22,   22,    3,    4,    5,    6,    5,
371
 
        7,    1,   25,   36,   25,   36,   13,   36,   14,   15,
372
 
       10,   36,   16,   18,   11,   21,   35,   36,   20,   18,
373
 
 
374
 
       12,16403,    9,    8, 8211
375
 
    } ;
376
 
 
377
 
static yyconst flex_int16_t yy_accept[146] =
378
 
    {   0,
379
 
        1,    1,    1,    1,    1,    2,    3,    3,    3,    3,
380
 
        3,    4,    6,    8,   10,   11,   13,   14,   16,   18,
381
 
       20,   22,   24,   26,   28,   30,   32,   34,   36,   38,
382
 
       40,   42,   44,   46,   48,   50,   52,   54,   55,   56,
383
 
       57,   58,   59,   60,   61,   62,   63,   63,   64,   65,
384
 
       66,   67,   68,   69,   70,   71,   72,   73,   74,   75,
385
 
       76,   76,   76,   76,   76,   76,   76,   76,   77,   78,
386
 
       79,   80,   81,   82,   82,   82,   82,   82,   83,   84,
387
 
       85,   85,   85,   85,   85,   85,   85,   85,   85,   85,
388
 
       85,   86,   87,   87,   87,   87,   87,   87,   87,   88,
389
 
 
390
 
       88,   88,   88,   88,   88,   88,   89,   89,   90,   91,
391
 
       91,   91,   91,   91,   91,   92,   92,   92,   92,   93,
392
 
       93,   94,   95,   95,   96,   96,   96,   97,   97,   99,
393
 
      100,  101,  101,  102,  102,  102,  103,  103,  104,  105,
394
 
      105,  105,  106,  106,  106
 
370
static yyconst flex_int16_t yy_accept[147] =
 
371
    {   0,
 
372
        0,    0,    0,    0,    3,    3,    0,    0,    0,    0,
 
373
        0,    0,   44,   39,   40,   41,   43,   38,   43,   38,
 
374
       38,   38,   25,   24,   38,   38,   38,   37,   37,   38,
 
375
       40,   23,    3,    4,    5,   42,   17,   17,   17,   21,
 
376
       39,   40,   32,   35,   33,    2,    1,   25,   25,    0,
 
377
       24,   24,   27,   29,   31,   30,   28,   37,   37,   34,
 
378
       40,   23,   23,    0,    0,    0,    0,    0,    0,    0,
 
379
        3,    4,    5,    6,    5,    7,    0,    0,    0,    0,
 
380
       20,   21,    1,   26,   37,    0,    0,    0,    0,    0,
 
381
        0,    0,    0,    0,    0,   26,   37,    0,    0,    0,
 
382
 
 
383
        0,    0,    0,   13,    0,    0,    0,    0,    0,    0,
 
384
       37,    0,   14,   15,    0,    0,    0,    0,    0,   10,
 
385
        0,    0,    0,   37,    0,   16,   18,    0,   11,    0,
 
386
        0,   22,    0,   36,    0,   18,    0,   12,    0,    0,
 
387
       19,    0,    9,    8,    0,    0
395
388
    } ;
396
389
 
397
390
static yyconst flex_int32_t yy_ec[256] =
428
421
 
429
422
static yyconst flex_int32_t yy_meta[40] =
430
423
    {   0,
431
 
        1,    2,    3,    1,    1,    1,    1,    1,    4,    5,
432
 
        1,    6,    6,    6,    1,    1,    1,    7,    8,    8,
433
 
        8,    7,    9,    7,    7,    8,    8,    8,    8,   10,
434
 
        8,    8,    8,    8,    8,    8,    8,    8,    1
435
 
    } ;
436
 
 
437
 
static yyconst flex_int16_t yy_base[159] =
438
 
    {   0,
439
 
        0,   38,    0,    0,   38,   39,  301,  300,  299,   44,
440
 
      301,  299,  297,  305,  305,  282,  291,  305,  288,   41,
441
 
       41,   44,   44,  279,   49,    0,  270,  254,   61,   79,
442
 
      289,  305,   65,  305,  305,   67,   68,  290,  288,  305,
443
 
      305,  305,  305,    0,   74,  305,    0,   76,  305,  305,
444
 
      305,  305,  305,  305,    0,  264,  305,   72,  282,  281,
445
 
      262,   71,  260,  257,  250,  252,  257,  277,  305,  110,
446
 
      305,  114,  305,   91,   81,  112,   15,    0,   35,  252,
447
 
      253,   57,  254,  243,  240,   96,  244,  251,  249,  238,
448
 
      305,  240,  242,  243,  243,  239,  234,  235,  305,  229,
449
 
 
450
 
      229,  227,  224,  217,  197,  202,  195,  305,  305,  199,
451
 
      184,  177,  164,  114,  305,  108,  110,  107,  110,  108,
452
 
      305,    0,   97,  305,  105,  107,  305,   97,    0,  125,
453
 
        0,   96,  305,    0,   92,  116,   69,    0,  305,   89,
454
 
       52,  305,   63,  305,  139,  149,  159,  169,  174,  184,
455
 
      194,  204,  209,  218,  228,  238,  247,  254
456
 
    } ;
457
 
 
458
 
static yyconst flex_int16_t yy_def[159] =
459
 
    {   0,
460
 
      144,    1,  145,  145,  146,  146,  147,  147,  148,  148,
461
 
      144,  144,  144,  144,  144,  144,  144,  144,  144,  144,
462
 
      144,  144,  144,  144,  144,  149,  149,  144,  144,  144,
463
 
      150,  144,  151,  144,  144,  144,  144,  144,  144,  144,
464
 
      144,  144,  144,  152,  144,  144,  153,  144,  144,  144,
465
 
      144,  144,  144,  144,  149,  149,  144,  144,   30,   30,
466
 
      144,  144,  144,  144,  144,  144,  144,  150,  144,  151,
467
 
      144,  151,  144,  144,  144,  144,  144,  152,  153,  149,
468
 
      144,  144,  144,  144,  144,  154,  144,  144,  144,  144,
469
 
      144,  149,  144,  144,  144,  144,  144,  144,  144,  144,
470
 
 
471
 
      144,  144,  144,  144,  144,  149,  144,  144,  144,  144,
472
 
      144,  144,  144,  144,  144,  144,  144,  144,  149,  144,
473
 
      144,  155,  144,  144,  144,  144,  144,  144,  149,  144,
474
 
      155,  144,  144,  156,  144,  157,  144,  156,  144,  158,
475
 
      144,  144,  158,    0,  144,  144,  144,  144,  144,  144,
476
 
      144,  144,  144,  144,  144,  144,  144,  144
477
 
    } ;
478
 
 
479
 
static yyconst flex_int16_t yy_nxt[345] =
480
 
    {   0,
481
 
       12,   13,   14,   15,   16,   17,   18,   19,   18,   18,
482
 
       20,   21,   22,   22,   23,   24,   25,   26,   26,   26,
483
 
       26,   26,   27,   26,   26,   26,   26,   26,   26,   26,
484
 
       26,   26,   26,   26,   26,   26,   26,   26,   28,   29,
485
 
       32,   32,   82,   30,   83,   36,   14,   33,   33,   37,
486
 
       43,   44,   45,   45,   91,   48,   48,   48,   50,   51,
487
 
       46,   47,   58,   49,   53,   54,   59,   71,   74,   76,
488
 
       91,  142,   75,   58,   72,   73,   46,   59,   47,   49,
489
 
       60,  134,   76,   94,   41,   45,   45,   48,   48,   48,
490
 
       95,   77,   74,   46,   63,   49,   75,  142,   82,  141,
491
 
 
492
 
       83,   61,   62,   84,   77,   63,   64,   63,   85,   46,
493
 
       65,   49,   71,   76,   66,   67,   71,  136,  100,  144,
494
 
      144,  139,  137,   72,   73,  101,  136,  135,  134,  133,
495
 
      132,  130,  129,  128,  127,   77,  126,  125,   63,   15,
496
 
       15,   15,   15,   15,   15,   15,   15,   15,   15,   31,
497
 
       31,   31,   31,   31,   31,   31,   31,   31,   31,   34,
498
 
       34,   34,   34,   34,   34,   34,   34,   34,   34,   35,
499
 
       35,   35,   35,   35,   35,   35,   35,   35,   35,   55,
500
 
       55,   55,   55,   55,   68,   68,   68,   68,  124,   68,
501
 
       68,   68,   68,   68,   70,   70,   70,   70,   70,   70,
502
 
 
503
 
       70,   70,   70,   70,   78,   78,  123,   78,   78,   78,
504
 
       78,   78,   78,   78,   79,   79,  122,   79,   99,   99,
505
 
       99,   99,   99,  121,  120,  119,   99,   99,  131,  131,
506
 
      118,  131,  131,  131,  131,  131,  131,  131,  138,  138,
507
 
      117,  138,  138,  138,  138,  138,  138,  138,  140,  116,
508
 
      115,  114,  113,  140,  140,  140,  140,  143,  112,  143,
509
 
      143,  143,  143,  143,  111,  110,  109,  108,  107,  106,
510
 
      105,  104,  103,  102,   98,   97,   96,   93,   92,   69,
511
 
       90,   89,   88,   87,   86,   81,  144,  144,   80,   39,
512
 
       38,   69,   57,   56,   52,   42,   41,   40,   39,   38,
513
 
 
514
 
      144,   14,   15,   15,   11,  144,  144,  144,  144,  144,
515
 
      144,  144,  144,  144,  144,  144,  144,  144,  144,  144,
516
 
      144,  144,  144,  144,  144,  144,  144,  144,  144,  144,
517
 
      144,  144,  144,  144,  144,  144,  144,  144,  144,  144,
518
 
      144,  144,  144,  144
519
 
    } ;
520
 
 
521
 
static yyconst flex_int16_t yy_chk[345] =
 
424
        1,    1,    2,    1,    1,    1,    1,    1,    3,    4,
 
425
        1,    5,    5,    5,    1,    1,    1,    5,    6,    6,
 
426
        6,    5,    7,    5,    5,    6,    6,    6,    6,    8,
 
427
        6,    6,    6,    6,    6,    6,    6,    6,    1
 
428
    } ;
 
429
 
 
430
static yyconst flex_int16_t yy_base[160] =
 
431
    {   0,
 
432
        0,   38,    0,    0,   38,   39,  313,  312,  311,   44,
 
433
       50,    0,  313,  311,  309,  317,  317,  294,  303,  317,
 
434
      300,   80,   80,   83,   83,  291,   88,    0,  282,  266,
 
435
      100,  118,  301,  317,  104,  317,  317,  106,  107,  294,
 
436
      301,  299,  317,  317,  317,  317,    0,  113,  317,    0,
 
437
      115,  317,  317,  317,  317,  317,  317,    0,  275,  317,
 
438
      111,  293,  292,  273,  110,  271,  268,  261,  263,  268,
 
439
      288,  317,  149,  317,  153,  317,  130,  120,  151,   15,
 
440
      317,  281,    0,   74,  262,  263,   96,  264,  253,  250,
 
441
      135,  254,  261,  259,  248,  317,  250,  252,  253,  253,
 
442
 
 
443
      249,  244,  250,  317,  249,  249,  241,  231,  229,  218,
 
444
      222,  208,  317,  317,  207,  185,  147,  151,  150,  317,
 
445
      144,  147,  144,  147,  145,  317,    0,  134,  317,  142,
 
446
      144,  317,  131,    0,  159,    0,  130,  317,    0,  109,
 
447
      135,   90,    0,  317,   81,  317,  178,  186,  194,  202,
 
448
      206,  214,  222,  228,  236,  240,  247,  255,  263
 
449
    } ;
 
450
 
 
451
static yyconst flex_int16_t yy_def[160] =
 
452
    {   0,
 
453
      146,    1,  147,  147,  148,  148,  149,  149,  150,  150,
 
454
      146,   11,  146,  146,  146,  146,  146,  146,  146,  146,
 
455
      146,  146,  146,  146,  146,  146,  146,  151,  151,  146,
 
456
      146,  146,  152,  146,  153,  146,  146,  146,  146,  154,
 
457
      146,  146,  146,  146,  146,  146,  155,  146,  146,  156,
 
458
      146,  146,  146,  146,  146,  146,  146,  151,  151,  146,
 
459
      146,   32,   32,  146,  146,  146,  146,  146,  146,  146,
 
460
      152,  146,  153,  146,  153,  146,  146,  146,  146,  146,
 
461
      146,  154,  155,  156,  151,  146,  146,  146,  146,  146,
 
462
      157,  146,  146,  146,  146,  146,  151,  146,  146,  146,
 
463
 
 
464
      146,  146,  146,  146,  146,  146,  146,  146,  146,  146,
 
465
      151,  146,  146,  146,  146,  146,  146,  146,  146,  146,
 
466
      146,  146,  146,  151,  146,  146,  158,  146,  146,  146,
 
467
      146,  146,  146,  151,  146,  158,  146,  146,  159,  146,
 
468
      146,  146,  159,  146,  146,    0,  146,  146,  146,  146,
 
469
      146,  146,  146,  146,  146,  146,  146,  146,  146
 
470
    } ;
 
471
 
 
472
static yyconst flex_int16_t yy_nxt[357] =
 
473
    {   0,
 
474
       14,   15,   16,   17,   18,   19,   20,   21,   20,   20,
 
475
       22,   23,   24,   24,   25,   26,   27,   28,   28,   28,
 
476
       28,   28,   29,   28,   28,   28,   28,   28,   28,   28,
 
477
       28,   28,   28,   28,   28,   28,   28,   28,   30,   31,
 
478
       34,   34,   87,   32,   88,   38,   16,   35,   35,   39,
 
479
       17,   17,   17,   17,   17,   17,   17,   17,   17,   17,
 
480
       17,   17,   17,   17,   17,   17,   17,   40,   40,   40,
 
481
       40,   40,   40,   40,   40,   40,   40,   40,   40,   40,
 
482
       40,   40,   40,   40,   40,   40,   40,   40,   17,   46,
 
483
       47,   48,   48,   96,   51,   51,   51,   53,   54,   49,
 
484
 
 
485
       50,   61,   52,   56,   57,   62,   74,   77,   79,   96,
 
486
      139,   78,   61,   75,   76,   49,   62,   50,   52,   63,
 
487
      145,   79,   99,   44,   48,   48,   51,   51,   51,  100,
 
488
       80,   77,   49,   66,   52,   78,  141,   87,  144,   88,
 
489
       64,   65,   89,   80,   66,   67,   66,   90,   49,   68,
 
490
       52,   74,   79,   69,   70,   74,  142,  105,  146,  146,
 
491
      141,  140,   75,   76,  106,  139,  138,  137,  135,  134,
 
492
      133,  132,  131,  130,   80,  129,  128,   66,   17,   17,
 
493
       17,   17,   17,   17,   17,   17,   33,   33,   33,   33,
 
494
       33,   33,   33,   33,   36,   36,   36,   36,   36,   36,
 
495
 
 
496
       36,   36,   37,   37,   37,   37,   37,   37,   37,   37,
 
497
       58,   58,   58,   58,   71,   71,   71,  127,   71,   71,
 
498
       71,   71,   73,   73,   73,   73,   73,   73,   73,   73,
 
499
       82,  126,   82,   82,   82,   82,   83,  125,   83,   83,
 
500
       83,   83,   83,   83,   84,  124,   84,  104,  104,  104,
 
501
      104,  123,  122,  104,  104,  136,  121,  136,  136,  136,
 
502
      136,  136,  136,  143,  120,  143,  143,  143,  143,  143,
 
503
      143,  119,  118,  117,  116,  115,  114,  113,  112,  111,
 
504
      110,  109,  108,  107,  103,  102,  101,   98,   97,   81,
 
505
       72,   95,   94,   93,   92,   91,   86,  146,  146,   85,
 
506
 
 
507
       42,   41,   81,   72,   60,   59,   55,   45,   44,   43,
 
508
       42,   41,  146,   16,   17,   17,   13,  146,  146,  146,
 
509
      146,  146,  146,  146,  146,  146,  146,  146,  146,  146,
 
510
      146,  146,  146,  146,  146,  146,  146,  146,  146,  146,
 
511
      146,  146,  146,  146,  146,  146,  146,  146,  146,  146,
 
512
      146,  146,  146,  146,  146,  146
 
513
    } ;
 
514
 
 
515
static yyconst flex_int16_t yy_chk[357] =
522
516
    {   0,
523
517
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
524
518
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
525
519
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
526
520
        1,    1,    1,    1,    1,    1,    1,    1,    1,    2,
527
 
        5,    6,   77,    2,   77,   10,   10,    5,    6,   10,
528
 
       20,   20,   21,   21,   79,   22,   22,   22,   23,   23,
529
 
       21,   21,   29,   22,   25,   25,   29,   33,   36,   37,
530
 
       79,  143,   36,   58,   33,   33,   21,   58,   21,   22,
531
 
       30,  141,   75,   82,   30,   45,   45,   48,   48,   48,
532
 
       82,   37,   74,   45,   37,   48,   74,  140,   62,  137,
533
 
 
534
 
       62,   30,   30,   62,   75,   30,   30,   75,   62,   45,
535
 
       30,   48,   70,   76,   30,   30,   72,  136,   86,   70,
536
 
       70,  135,  132,   72,   72,   86,  130,  128,  126,  125,
537
 
      123,  120,  119,  118,  117,   76,  116,  114,   76,  145,
538
 
      145,  145,  145,  145,  145,  145,  145,  145,  145,  146,
539
 
      146,  146,  146,  146,  146,  146,  146,  146,  146,  147,
540
 
      147,  147,  147,  147,  147,  147,  147,  147,  147,  148,
541
 
      148,  148,  148,  148,  148,  148,  148,  148,  148,  149,
542
 
      149,  149,  149,  149,  150,  150,  150,  150,  113,  150,
543
 
      150,  150,  150,  150,  151,  151,  151,  151,  151,  151,
544
 
 
545
 
      151,  151,  151,  151,  152,  152,  112,  152,  152,  152,
546
 
      152,  152,  152,  152,  153,  153,  111,  153,  154,  154,
547
 
      154,  154,  154,  110,  107,  106,  154,  154,  155,  155,
548
 
      105,  155,  155,  155,  155,  155,  155,  155,  156,  156,
549
 
      104,  156,  156,  156,  156,  156,  156,  156,  157,  103,
550
 
      102,  101,  100,  157,  157,  157,  157,  158,   98,  158,
551
 
      158,  158,  158,  158,   97,   96,   95,   94,   93,   92,
552
 
       90,   89,   88,   87,   85,   84,   83,   81,   80,   68,
553
 
       67,   66,   65,   64,   63,   61,   60,   59,   56,   39,
554
 
       38,   31,   28,   27,   24,   19,   17,   16,   13,   12,
555
 
 
556
 
       11,    9,    8,    7,  144,  144,  144,  144,  144,  144,
557
 
      144,  144,  144,  144,  144,  144,  144,  144,  144,  144,
558
 
      144,  144,  144,  144,  144,  144,  144,  144,  144,  144,
559
 
      144,  144,  144,  144,  144,  144,  144,  144,  144,  144,
560
 
      144,  144,  144,  144
 
521
        5,    6,   80,    2,   80,   10,   10,    5,    6,   10,
 
522
       11,   11,   11,   11,   11,   11,   11,   11,   11,   11,
 
523
       11,   11,   11,   11,   11,   11,   11,   11,   11,   11,
 
524
       11,   11,   11,   11,   11,   11,   11,   11,   11,   11,
 
525
       11,   11,   11,   11,   11,   11,   11,   11,   11,   22,
 
526
       22,   23,   23,   84,   24,   24,   24,   25,   25,   23,
 
527
 
 
528
       23,   31,   24,   27,   27,   31,   35,   38,   39,   84,
 
529
      145,   38,   61,   35,   35,   23,   61,   23,   24,   32,
 
530
      142,   78,   87,   32,   48,   48,   51,   51,   51,   87,
 
531
       39,   77,   48,   39,   51,   77,  141,   65,  140,   65,
 
532
       32,   32,   65,   78,   32,   32,   78,   65,   48,   32,
 
533
       51,   73,   79,   32,   32,   75,  137,   91,   73,   73,
 
534
      135,  133,   75,   75,   91,  131,  130,  128,  125,  124,
 
535
      123,  122,  121,  119,   79,  118,  117,   79,  147,  147,
 
536
      147,  147,  147,  147,  147,  147,  148,  148,  148,  148,
 
537
      148,  148,  148,  148,  149,  149,  149,  149,  149,  149,
 
538
 
 
539
      149,  149,  150,  150,  150,  150,  150,  150,  150,  150,
 
540
      151,  151,  151,  151,  152,  152,  152,  116,  152,  152,
 
541
      152,  152,  153,  153,  153,  153,  153,  153,  153,  153,
 
542
      154,  115,  154,  154,  154,  154,  155,  112,  155,  155,
 
543
      155,  155,  155,  155,  156,  111,  156,  157,  157,  157,
 
544
      157,  110,  109,  157,  157,  158,  108,  158,  158,  158,
 
545
      158,  158,  158,  159,  107,  159,  159,  159,  159,  159,
 
546
      159,  106,  105,  103,  102,  101,  100,   99,   98,   97,
 
547
       95,   94,   93,   92,   90,   89,   88,   86,   85,   82,
 
548
       71,   70,   69,   68,   67,   66,   64,   63,   62,   59,
 
549
 
 
550
       42,   41,   40,   33,   30,   29,   26,   21,   19,   18,
 
551
       15,   14,   13,    9,    8,    7,  146,  146,  146,  146,
 
552
      146,  146,  146,  146,  146,  146,  146,  146,  146,  146,
 
553
      146,  146,  146,  146,  146,  146,  146,  146,  146,  146,
 
554
      146,  146,  146,  146,  146,  146,  146,  146,  146,  146,
 
555
      146,  146,  146,  146,  146,  146
561
556
    } ;
562
557
 
563
 
#define YY_TRAILING_MASK 0x2000
564
 
#define YY_TRAILING_HEAD_MASK 0x4000
565
 
#define REJECT \
566
 
{ \
567
 
*yy_cp = yyg->yy_hold_char; /* undo effects of setting up yytext */ \
568
 
yy_cp = yyg->yy_full_match; /* restore poss. backed-over text */ \
569
 
yyg->yy_lp = yyg->yy_full_lp; /* restore orig. accepting pos. */ \
570
 
yyg->yy_state_ptr = yyg->yy_full_state; /* restore orig. state */ \
571
 
yy_current_state = *yyg->yy_state_ptr; /* restore curr. state */ \
572
 
++yyg->yy_lp; \
573
 
goto find_rule; \
574
 
}
575
 
 
 
558
/* The intent behind this definition is that it'll catch
 
559
 * any uses of REJECT which flex missed.
 
560
 */
 
561
#define REJECT reject_used_but_not_detected
576
562
#define yymore() yymore_used_but_not_detected
577
563
#define YY_MORE_ADJ 0
578
564
#define YY_RESTORE_YY_MORE_OFFSET
645
631
strings, we have to be careful to avoid OTHER matching and hiding
646
632
something that CPP does care about. So we simply exclude all
647
633
characters that appear in any other expressions. */
648
 
#line 649 "glcpp-lex.c"
 
634
#line 635 "glcpp-lex.c"
649
635
 
650
636
#define INITIAL 0
651
637
#define DONE 1
652
638
#define COMMENT 2
653
639
#define UNREACHABLE 3
654
640
#define SKIP 4
 
641
#define DEFINE 5
655
642
 
656
643
#define YY_EXTRA_TYPE glcpp_parser_t *
657
644
 
683
670
    int yylineno_r;
684
671
    int yy_flex_debug_r;
685
672
 
686
 
    yy_state_type *yy_state_buf;
687
 
    yy_state_type *yy_state_ptr;
688
 
    char *yy_full_match;
689
 
    int yy_lp;
690
 
 
691
 
    /* These are only needed for trailing context rules,
692
 
     * but there's no conditional variable for that yet. */
693
 
    int yy_looking_for_trail_begin;
694
 
    int yy_full_lp;
695
 
    int *yy_full_state;
696
 
 
697
673
    char *yytext_r;
698
674
    int yy_more_flag;
699
675
    int yy_more_len;
797
773
    
798
774
/* Amount of stuff to slurp up with each read. */
799
775
#ifndef YY_READ_BUF_SIZE
 
776
#ifdef __ia64__
 
777
/* On IA-64, the buffer size is 16k, not 8k */
 
778
#define YY_READ_BUF_SIZE 16384
 
779
#else
800
780
#define YY_READ_BUF_SIZE 8192
 
781
#endif /* __ia64__ */
801
782
#endif
802
783
 
803
784
/* Copy whatever the last rule matched to the standard output. */
816
797
        if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
817
798
                { \
818
799
                int c = '*'; \
819
 
                unsigned n; \
 
800
                size_t n; \
820
801
                for ( n = 0; n < max_size && \
821
802
                             (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
822
803
                        buf[n] = (char) c; \
919
900
        }
920
901
 
921
902
        /* Single-line comments */
922
 
#line 923 "glcpp-lex.c"
 
903
#line 904 "glcpp-lex.c"
923
904
 
924
905
    yylval = yylval_param;
925
906
 
933
914
                YY_USER_INIT;
934
915
#endif
935
916
 
936
 
        /* Create the reject buffer large enough to save one state per allowed character. */
937
 
        if ( ! yyg->yy_state_buf )
938
 
            yyg->yy_state_buf = (yy_state_type *)glcpp_alloc(YY_STATE_BUF_SIZE  ,yyscanner);
939
 
            if ( ! yyg->yy_state_buf )
940
 
                YY_FATAL_ERROR( "out of dynamic memory in glcpp_lex()" );
941
 
 
942
917
                if ( ! yyg->yy_start )
943
918
                        yyg->yy_start = 1;      /* first start state */
944
919
 
971
946
 
972
947
                yy_current_state = yyg->yy_start;
973
948
                yy_current_state += YY_AT_BOL();
974
 
 
975
 
                yyg->yy_state_ptr = yyg->yy_state_buf;
976
 
                *yyg->yy_state_ptr++ = yy_current_state;
977
 
 
978
949
yy_match:
979
950
                do
980
951
                        {
981
952
                        register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
 
953
                        if ( yy_accept[yy_current_state] )
 
954
                                {
 
955
                                yyg->yy_last_accepting_state = yy_current_state;
 
956
                                yyg->yy_last_accepting_cpos = yy_cp;
 
957
                                }
982
958
                        while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
983
959
                                {
984
960
                                yy_current_state = (int) yy_def[yy_current_state];
985
 
                                if ( yy_current_state >= 145 )
 
961
                                if ( yy_current_state >= 147 )
986
962
                                        yy_c = yy_meta[(unsigned int) yy_c];
987
963
                                }
988
964
                        yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
989
 
                        *yyg->yy_state_ptr++ = yy_current_state;
990
965
                        ++yy_cp;
991
966
                        }
992
 
                while ( yy_current_state != 144 );
 
967
                while ( yy_current_state != 146 );
 
968
                yy_cp = yyg->yy_last_accepting_cpos;
 
969
                yy_current_state = yyg->yy_last_accepting_state;
993
970
 
994
971
yy_find_action:
995
 
                yy_current_state = *--yyg->yy_state_ptr;
996
 
                yyg->yy_lp = yy_accept[yy_current_state];
997
 
find_rule: /* we branch to this label when backing up */
998
 
                for ( ; ; ) /* until we find what rule we matched */
999
 
                        {
1000
 
                        if ( yyg->yy_lp && yyg->yy_lp < yy_accept[yy_current_state + 1] )
1001
 
                                {
1002
 
                                yy_act = yy_acclist[yyg->yy_lp];
1003
 
                                if ( yy_act & YY_TRAILING_HEAD_MASK ||
1004
 
                                     yyg->yy_looking_for_trail_begin )
1005
 
                                        {
1006
 
                                        if ( yy_act == yyg->yy_looking_for_trail_begin )
1007
 
                                                {
1008
 
                                                yyg->yy_looking_for_trail_begin = 0;
1009
 
                                                yy_act &= ~YY_TRAILING_HEAD_MASK;
1010
 
                                                break;
1011
 
                                                }
1012
 
                                        }
1013
 
                                else if ( yy_act & YY_TRAILING_MASK )
1014
 
                                        {
1015
 
                                        yyg->yy_looking_for_trail_begin = yy_act & ~YY_TRAILING_MASK;
1016
 
                                        yyg->yy_looking_for_trail_begin |= YY_TRAILING_HEAD_MASK;
1017
 
                                        }
1018
 
                                else
1019
 
                                        {
1020
 
                                        yyg->yy_full_match = yy_cp;
1021
 
                                        yyg->yy_full_state = yyg->yy_state_ptr;
1022
 
                                        yyg->yy_full_lp = yyg->yy_lp;
1023
 
                                        break;
1024
 
                                        }
1025
 
                                ++yyg->yy_lp;
1026
 
                                goto find_rule;
1027
 
                                }
1028
 
                        --yy_cp;
1029
 
                        yy_current_state = *--yyg->yy_state_ptr;
1030
 
                        yyg->yy_lp = yy_accept[yy_current_state];
1031
 
                        }
 
972
                yy_act = yy_accept[yy_current_state];
1032
973
 
1033
974
                YY_DO_BEFORE_ACTION;
1034
975
 
1036
977
 
1037
978
                switch ( yy_act )
1038
979
        { /* beginning of action switch */
 
980
                        case 0: /* must back up */
 
981
                        /* undo the effects of YY_DO_BEFORE_ACTION */
 
982
                        *yy_cp = yyg->yy_hold_char;
 
983
                        yy_cp = yyg->yy_last_accepting_cpos;
 
984
                        yy_current_state = yyg->yy_last_accepting_state;
 
985
                        goto yy_find_action;
 
986
 
1039
987
case 1:
1040
988
YY_RULE_SETUP
1041
989
#line 108 "glcpp-lex.l"
1185
1133
#line 187 "glcpp-lex.l"
1186
1134
{
1187
1135
        yyextra->space_tokens = 0;
1188
 
        return HASH_DEFINE_FUNC;
 
1136
        yy_push_state(DEFINE, yyscanner);
 
1137
        return HASH_DEFINE;
1189
1138
}
1190
1139
        YY_BREAK
1191
1140
case 20:
 
1141
*yy_cp = yyg->yy_hold_char; /* undo effects of setting up yytext */
 
1142
yyg->yy_c_buf_p = yy_cp -= 1;
 
1143
YY_DO_BEFORE_ACTION; /* set up yytext again */
1192
1144
YY_RULE_SETUP
1193
 
#line 192 "glcpp-lex.l"
 
1145
#line 193 "glcpp-lex.l"
1194
1146
{
1195
 
        yyextra->space_tokens = 0;
1196
 
        return HASH_DEFINE_OBJ;
 
1147
        yy_pop_state(yyscanner);
 
1148
        yylval->str = ralloc_strdup (yyextra, yytext);
 
1149
        return FUNC_IDENTIFIER;
1197
1150
}
1198
1151
        YY_BREAK
1199
1152
case 21:
1200
1153
YY_RULE_SETUP
1201
 
#line 197 "glcpp-lex.l"
 
1154
#line 199 "glcpp-lex.l"
 
1155
{
 
1156
        yy_pop_state(yyscanner);
 
1157
        yylval->str = ralloc_strdup (yyextra, yytext);
 
1158
        return OBJ_IDENTIFIER;
 
1159
}
 
1160
        YY_BREAK
 
1161
case 22:
 
1162
YY_RULE_SETUP
 
1163
#line 205 "glcpp-lex.l"
1202
1164
{
1203
1165
        yyextra->space_tokens = 0;
1204
1166
        return HASH_UNDEF;
1205
1167
}
1206
1168
        YY_BREAK
1207
 
case 22:
 
1169
case 23:
1208
1170
YY_RULE_SETUP
1209
 
#line 202 "glcpp-lex.l"
 
1171
#line 210 "glcpp-lex.l"
1210
1172
{
1211
1173
        yyextra->space_tokens = 0;
1212
1174
        return HASH;
1213
1175
}
1214
1176
        YY_BREAK
1215
 
case 23:
1216
 
YY_RULE_SETUP
1217
 
#line 207 "glcpp-lex.l"
1218
 
{
1219
 
        yylval->str = ralloc_strdup (yyextra, yytext);
1220
 
        return INTEGER_STRING;
1221
 
}
1222
 
        YY_BREAK
1223
1177
case 24:
1224
1178
YY_RULE_SETUP
1225
 
#line 212 "glcpp-lex.l"
 
1179
#line 215 "glcpp-lex.l"
1226
1180
{
1227
1181
        yylval->str = ralloc_strdup (yyextra, yytext);
1228
1182
        return INTEGER_STRING;
1230
1184
        YY_BREAK
1231
1185
case 25:
1232
1186
YY_RULE_SETUP
1233
 
#line 217 "glcpp-lex.l"
 
1187
#line 220 "glcpp-lex.l"
1234
1188
{
1235
1189
        yylval->str = ralloc_strdup (yyextra, yytext);
1236
1190
        return INTEGER_STRING;
1238
1192
        YY_BREAK
1239
1193
case 26:
1240
1194
YY_RULE_SETUP
1241
 
#line 222 "glcpp-lex.l"
 
1195
#line 225 "glcpp-lex.l"
 
1196
{
 
1197
        yylval->str = ralloc_strdup (yyextra, yytext);
 
1198
        return INTEGER_STRING;
 
1199
}
 
1200
        YY_BREAK
 
1201
case 27:
 
1202
YY_RULE_SETUP
 
1203
#line 230 "glcpp-lex.l"
1242
1204
{
1243
1205
        return LEFT_SHIFT;
1244
1206
}
1245
1207
        YY_BREAK
1246
 
case 27:
 
1208
case 28:
1247
1209
YY_RULE_SETUP
1248
 
#line 226 "glcpp-lex.l"
 
1210
#line 234 "glcpp-lex.l"
1249
1211
{
1250
1212
        return RIGHT_SHIFT;
1251
1213
}
1252
1214
        YY_BREAK
1253
 
case 28:
 
1215
case 29:
1254
1216
YY_RULE_SETUP
1255
 
#line 230 "glcpp-lex.l"
 
1217
#line 238 "glcpp-lex.l"
1256
1218
{
1257
1219
        return LESS_OR_EQUAL;
1258
1220
}
1259
1221
        YY_BREAK
1260
 
case 29:
 
1222
case 30:
1261
1223
YY_RULE_SETUP
1262
 
#line 234 "glcpp-lex.l"
 
1224
#line 242 "glcpp-lex.l"
1263
1225
{
1264
1226
        return GREATER_OR_EQUAL;
1265
1227
}
1266
1228
        YY_BREAK
1267
 
case 30:
 
1229
case 31:
1268
1230
YY_RULE_SETUP
1269
 
#line 238 "glcpp-lex.l"
 
1231
#line 246 "glcpp-lex.l"
1270
1232
{
1271
1233
        return EQUAL;
1272
1234
}
1273
1235
        YY_BREAK
1274
 
case 31:
 
1236
case 32:
1275
1237
YY_RULE_SETUP
1276
 
#line 242 "glcpp-lex.l"
 
1238
#line 250 "glcpp-lex.l"
1277
1239
{
1278
1240
        return NOT_EQUAL;
1279
1241
}
1280
1242
        YY_BREAK
1281
 
case 32:
 
1243
case 33:
1282
1244
YY_RULE_SETUP
1283
 
#line 246 "glcpp-lex.l"
 
1245
#line 254 "glcpp-lex.l"
1284
1246
{
1285
1247
        return AND;
1286
1248
}
1287
1249
        YY_BREAK
1288
 
case 33:
 
1250
case 34:
1289
1251
YY_RULE_SETUP
1290
 
#line 250 "glcpp-lex.l"
 
1252
#line 258 "glcpp-lex.l"
1291
1253
{
1292
1254
        return OR;
1293
1255
}
1294
1256
        YY_BREAK
1295
 
case 34:
 
1257
case 35:
1296
1258
YY_RULE_SETUP
1297
 
#line 254 "glcpp-lex.l"
 
1259
#line 262 "glcpp-lex.l"
1298
1260
{
1299
1261
        return PASTE;
1300
1262
}
1301
1263
        YY_BREAK
1302
 
case 35:
 
1264
case 36:
1303
1265
YY_RULE_SETUP
1304
 
#line 258 "glcpp-lex.l"
 
1266
#line 266 "glcpp-lex.l"
1305
1267
{
1306
1268
        return DEFINED;
1307
1269
}
1308
1270
        YY_BREAK
1309
 
case 36:
 
1271
case 37:
1310
1272
YY_RULE_SETUP
1311
 
#line 262 "glcpp-lex.l"
 
1273
#line 270 "glcpp-lex.l"
1312
1274
{
1313
1275
        yylval->str = ralloc_strdup (yyextra, yytext);
1314
1276
        return IDENTIFIER;
1315
1277
}
1316
1278
        YY_BREAK
1317
 
case 37:
 
1279
case 38:
1318
1280
YY_RULE_SETUP
1319
 
#line 267 "glcpp-lex.l"
 
1281
#line 275 "glcpp-lex.l"
1320
1282
{
1321
1283
        return yytext[0];
1322
1284
}
1323
1285
        YY_BREAK
1324
 
case 38:
1325
 
YY_RULE_SETUP
1326
 
#line 271 "glcpp-lex.l"
1327
 
{
1328
 
        yylval->str = ralloc_strdup (yyextra, yytext);
1329
 
        return OTHER;
1330
 
}
1331
 
        YY_BREAK
1332
1286
case 39:
1333
1287
YY_RULE_SETUP
1334
 
#line 276 "glcpp-lex.l"
 
1288
#line 279 "glcpp-lex.l"
 
1289
{
 
1290
        yylval->str = ralloc_strdup (yyextra, yytext);
 
1291
        return OTHER;
 
1292
}
 
1293
        YY_BREAK
 
1294
case 40:
 
1295
YY_RULE_SETUP
 
1296
#line 284 "glcpp-lex.l"
1335
1297
{
1336
1298
        if (yyextra->space_tokens) {
1337
1299
                return SPACE;
1338
1300
        }
1339
1301
}
1340
1302
        YY_BREAK
1341
 
case 40:
1342
 
/* rule 40 can match eol */
 
1303
case 41:
 
1304
/* rule 41 can match eol */
1343
1305
YY_RULE_SETUP
1344
 
#line 282 "glcpp-lex.l"
 
1306
#line 290 "glcpp-lex.l"
1345
1307
{
1346
1308
        yyextra->lexing_if = 0;
1347
1309
        yylineno++;
1351
1313
        YY_BREAK
1352
1314
/* Handle missing newline at EOF. */
1353
1315
case YY_STATE_EOF(INITIAL):
1354
 
#line 290 "glcpp-lex.l"
 
1316
#line 298 "glcpp-lex.l"
1355
1317
{
1356
1318
        BEGIN DONE; /* Don't keep matching this rule forever. */
1357
1319
        yyextra->lexing_if = 0;
1362
1324
        only have this action here so that we can pretend to call some
1363
1325
        generated functions, (to avoid "defined but not used"
1364
1326
        warnings. */
1365
 
case 41:
 
1327
case 42:
1366
1328
YY_RULE_SETUP
1367
 
#line 300 "glcpp-lex.l"
 
1329
#line 308 "glcpp-lex.l"
1368
1330
{
1369
1331
        unput('.');
1370
1332
        yy_top_state(yyextra);
1371
1333
}
1372
1334
        YY_BREAK
1373
 
case 42:
 
1335
case 43:
1374
1336
YY_RULE_SETUP
1375
 
#line 305 "glcpp-lex.l"
 
1337
#line 313 "glcpp-lex.l"
1376
1338
ECHO;
1377
1339
        YY_BREAK
1378
 
#line 1379 "glcpp-lex.c"
1379
 
                        case YY_STATE_EOF(DONE):
1380
 
                        case YY_STATE_EOF(COMMENT):
1381
 
                        case YY_STATE_EOF(UNREACHABLE):
1382
 
                        case YY_STATE_EOF(SKIP):
1383
 
                                yyterminate();
 
1340
#line 1341 "glcpp-lex.c"
 
1341
case YY_STATE_EOF(DONE):
 
1342
case YY_STATE_EOF(COMMENT):
 
1343
case YY_STATE_EOF(UNREACHABLE):
 
1344
case YY_STATE_EOF(SKIP):
 
1345
case YY_STATE_EOF(DEFINE):
 
1346
        yyterminate();
1384
1347
 
1385
1348
        case YY_END_OF_BUFFER:
1386
1349
                {
1445
1408
 
1446
1409
                        else
1447
1410
                                {
1448
 
                                yy_cp = yyg->yy_c_buf_p;
 
1411
                                yy_cp = yyg->yy_last_accepting_cpos;
 
1412
                                yy_current_state = yyg->yy_last_accepting_state;
1449
1413
                                goto yy_find_action;
1450
1414
                                }
1451
1415
                        }
1571
1535
                while ( num_to_read <= 0 )
1572
1536
                        { /* Not enough room in the buffer - grow it. */
1573
1537
 
1574
 
                        YY_FATAL_ERROR(
1575
 
"input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
 
1538
                        /* just a shorter name for the current buffer */
 
1539
                        YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
 
1540
 
 
1541
                        int yy_c_buf_p_offset =
 
1542
                                (int) (yyg->yy_c_buf_p - b->yy_ch_buf);
 
1543
 
 
1544
                        if ( b->yy_is_our_buffer )
 
1545
                                {
 
1546
                                int new_size = b->yy_buf_size * 2;
 
1547
 
 
1548
                                if ( new_size <= 0 )
 
1549
                                        b->yy_buf_size += b->yy_buf_size / 8;
 
1550
                                else
 
1551
                                        b->yy_buf_size *= 2;
 
1552
 
 
1553
                                b->yy_ch_buf = (char *)
 
1554
                                        /* Include room in for 2 EOB chars. */
 
1555
                                        glcpp_realloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 ,yyscanner );
 
1556
                                }
 
1557
                        else
 
1558
                                /* Can't grow it, we don't own it. */
 
1559
                                b->yy_ch_buf = 0;
 
1560
 
 
1561
                        if ( ! b->yy_ch_buf )
 
1562
                                YY_FATAL_ERROR(
 
1563
                                "fatal error - scanner input buffer overflow" );
 
1564
 
 
1565
                        yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
 
1566
 
 
1567
                        num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
 
1568
                                                number_to_move - 1;
1576
1569
 
1577
1570
                        }
1578
1571
 
1633
1626
        yy_current_state = yyg->yy_start;
1634
1627
        yy_current_state += YY_AT_BOL();
1635
1628
 
1636
 
        yyg->yy_state_ptr = yyg->yy_state_buf;
1637
 
        *yyg->yy_state_ptr++ = yy_current_state;
1638
 
 
1639
1629
        for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp )
1640
1630
                {
1641
1631
                register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
 
1632
                if ( yy_accept[yy_current_state] )
 
1633
                        {
 
1634
                        yyg->yy_last_accepting_state = yy_current_state;
 
1635
                        yyg->yy_last_accepting_cpos = yy_cp;
 
1636
                        }
1642
1637
                while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1643
1638
                        {
1644
1639
                        yy_current_state = (int) yy_def[yy_current_state];
1645
 
                        if ( yy_current_state >= 145 )
 
1640
                        if ( yy_current_state >= 147 )
1646
1641
                                yy_c = yy_meta[(unsigned int) yy_c];
1647
1642
                        }
1648
1643
                yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1649
 
                *yyg->yy_state_ptr++ = yy_current_state;
1650
1644
                }
1651
1645
 
1652
1646
        return yy_current_state;
1661
1655
{
1662
1656
        register int yy_is_jam;
1663
1657
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* This var may be unused depending upon options. */
 
1658
        register char *yy_cp = yyg->yy_c_buf_p;
1664
1659
 
1665
1660
        register YY_CHAR yy_c = 1;
 
1661
        if ( yy_accept[yy_current_state] )
 
1662
                {
 
1663
                yyg->yy_last_accepting_state = yy_current_state;
 
1664
                yyg->yy_last_accepting_cpos = yy_cp;
 
1665
                }
1666
1666
        while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1667
1667
                {
1668
1668
                yy_current_state = (int) yy_def[yy_current_state];
1669
 
                if ( yy_current_state >= 145 )
 
1669
                if ( yy_current_state >= 147 )
1670
1670
                        yy_c = yy_meta[(unsigned int) yy_c];
1671
1671
                }
1672
1672
        yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1673
 
        yy_is_jam = (yy_current_state == 144);
1674
 
        if ( ! yy_is_jam )
1675
 
                *yyg->yy_state_ptr++ = yy_current_state;
 
1673
        yy_is_jam = (yy_current_state == 146);
1676
1674
 
1677
1675
        return yy_is_jam ? 0 : yy_current_state;
1678
1676
}
2115
2113
 
2116
2114
/** Setup the input buffer state to scan the given bytes. The next call to glcpp_lex() will
2117
2115
 * scan from a @e copy of @a bytes.
2118
 
 * @param bytes the byte buffer to scan
2119
 
 * @param len the number of bytes in the buffer pointed to by @a bytes.
 
2116
 * @param yybytes the byte buffer to scan
 
2117
 * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
2120
2118
 * @param yyscanner The scanner object.
2121
2119
 * @return the newly allocated buffer state object.
2122
2120
 */
2469
2467
    yyg->yy_start_stack_depth = 0;
2470
2468
    yyg->yy_start_stack =  NULL;
2471
2469
 
2472
 
    yyg->yy_state_buf = 0;
2473
 
    yyg->yy_state_ptr = 0;
2474
 
    yyg->yy_full_match = 0;
2475
 
    yyg->yy_lp = 0;
2476
 
 
2477
2470
/* Defined in main.c */
2478
2471
#ifdef YY_STDINIT
2479
2472
    yyin = stdin;
2509
2502
        glcpp_free(yyg->yy_start_stack ,yyscanner );
2510
2503
        yyg->yy_start_stack = NULL;
2511
2504
 
2512
 
    glcpp_free ( yyg->yy_state_buf , yyscanner);
2513
 
    yyg->yy_state_buf  = NULL;
2514
 
 
2515
2505
    /* Reset the globals. This is important in a non-reentrant scanner so the next time
2516
2506
     * glcpp_lex() is called, initialization will occur. */
2517
2507
    yy_init_globals( yyscanner);
2570
2560
 
2571
2561
#define YYTABLES_NAME "yytables"
2572
2562
 
2573
 
#line 305 "glcpp-lex.l"
 
2563
#line 313 "glcpp-lex.l"
2574
2564
 
2575
2565
 
2576
2566