contrib/flex/gen.c

   1 /* gen - actual generation (writing) of flex scanners */
   2
   3 /*  Copyright (c) 1990 The Regents of the University of California. */
   4 /*  All rights reserved. */
   5
   6 /*  This code is derived from software contributed to Berkeley by */
   7 /*  Vern Paxson. */
   8
   9 /*  The United States Government has rights in this work pursuant */
  10 /*  to contract no. DE-AC03-76SF00098 between the United States */
  11 /*  Department of Energy and the University of California. */
  12
  13 /*  This file is part of flex. */
  14
  15 /*  Redistribution and use in source and binary forms, with or without */
  16 /*  modification, are permitted provided that the following conditions */
  17 /*  are met: */
  18
  19 /*  1. Redistributions of source code must retain the above copyright */
  20 /*     notice, this list of conditions and the following disclaimer. */
  21 /*  2. Redistributions in binary form must reproduce the above copyright */
  22 /*     notice, this list of conditions and the following disclaimer in the */
  23 /*     documentation and/or other materials provided with the distribution. */
  24
  25 /*  Neither the name of the University nor the names of its contributors */
  26 /*  may be used to endorse or promote products derived from this software */
  27 /*  without specific prior written permission. */
  28
  29 /*  THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR */
  30 /*  IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED */
  31 /*  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR */
  32 /*  PURPOSE. */
  33
  34 #include "flexdef.h"
  35 #include "tables.h"
  36
  37
  38 /* declare functions that have forward references */
  39
  40 void gen_next_state PROTO ((int));
  41 void genecs PROTO ((void));
  42 void indent_put2s PROTO ((const char *, const char *));
  43 void indent_puts PROTO ((const char *));
  44
  45
  46 static int indent_level = 0;    /* each level is 8 spaces */
  47
  48 #define indent_up() (++indent_level)
  49 #define indent_down() (--indent_level)
  50 #define set_indent(indent_val) indent_level = indent_val
  51
  52 /* Almost everything is done in terms of arrays starting at 1, so provide
  53  * a null entry for the zero element of all C arrays.  (The exception
  54  * to this is that the fast table representation generally uses the
  55  * 0 elements of its arrays, too.)
  56  */
  57
  58 static const char *get_int16_decl (void)
  59 {
  60         return (gentables)
  61                 ? "static yyconst flex_int16_t %s[%d] =\n    {   0,\n"
  62                 : "static yyconst flex_int16_t * %s = 0;\n";
  63 }
  64
  65
  66 static const char *get_int32_decl (void)
  67 {
  68         return (gentables)
  69                 ? "static yyconst flex_int32_t %s[%d] =\n    {   0,\n"
  70                 : "static yyconst flex_int32_t * %s = 0;\n";
  71 }
  72
  73 static const char *get_state_decl (void)
  74 {
  75         return (gentables)
  76                 ? "static yyconst yy_state_type %s[%d] =\n    {   0,\n"
  77                 : "static yyconst yy_state_type * %s = 0;\n";
  78 }
  79
  80 /* Indent to the current level. */
  81
  82 void do_indent ()
  83 {
  84         register int i = indent_level * 8;
  85
  86         while (i >= 8) {
  87                 outc ('\t');
  88                 i -= 8;
  89         }
  90
  91         while (i > 0) {
  92                 outc (' ');
  93                 --i;
  94         }
  95 }
  96
  97
  98 /** Make the table for possible eol matches.
  99  *  @return the newly allocated rule_can_match_eol table
 100  */
 101 static struct yytbl_data *mkeoltbl (void)
 102 {
 103         int     i;
 104         flex_int8_t *tdata = 0;
 105         struct yytbl_data *tbl;
 106
 107         tbl = (struct yytbl_data *) calloc (1, sizeof (struct yytbl_data));
 108         yytbl_data_init (tbl, YYTD_ID_RULE_CAN_MATCH_EOL);
 109         tbl->td_flags = YYTD_DATA8;
 110         tbl->td_lolen = num_rules + 1;
 111         tbl->td_data = tdata =
 112                 (flex_int8_t *) calloc (tbl->td_lolen, sizeof (flex_int8_t));
 113
 114         for (i = 1; i <= num_rules; i++)
 115                 tdata[i] = rule_has_nl[i] ? 1 : 0;
 116
 117         buf_prints (&yydmap_buf,
 118                     "\t{YYTD_ID_RULE_CAN_MATCH_EOL, (void**)&yy_rule_can_match_eol, sizeof(%s)},\n",
 119                     "flex_int32_t");
 120         return tbl;
 121 }
 122
 123 /* Generate the table for possible eol matches. */
 124 static void geneoltbl ()
 125 {
 126         int     i;
 127
 128         outn ("m4_ifdef( [[M4_YY_USE_LINENO]],[[");
 129         outn ("/* Table of booleans, true if rule could match eol. */");
 130         out_str_dec (get_int32_decl (), "yy_rule_can_match_eol",
 131                      num_rules + 1);
 132
 133         if (gentables) {
 134                 for (i = 1; i <= num_rules; i++) {
 135                         out_dec ("%d, ", rule_has_nl[i] ? 1 : 0);
 136                         /* format nicely, 20 numbers per line. */
 137                         if ((i % 20) == 19)
 138                                 out ("\n    ");
 139                 }
 140                 out ("    };\n");
 141         }
 142         outn ("]])");
 143 }
 144
 145
 146 /* Generate the code to keep backing-up information. */
 147
 148 void gen_backing_up ()
 149 {
 150         if (reject || num_backing_up == 0)
 151                 return;
 152
 153         if (fullspd)
 154                 indent_puts ("if ( yy_current_state[-1].yy_nxt )");
 155         else
 156                 indent_puts ("if ( yy_accept[yy_current_state] )");
 157
 158         indent_up ();
 159         indent_puts ("{");
 160         indent_puts ("YY_G(yy_last_accepting_state) = yy_current_state;");
 161         indent_puts ("YY_G(yy_last_accepting_cpos) = yy_cp;");
 162         indent_puts ("}");
 163         indent_down ();
 164 }
 165
 166
 167 /* Generate the code to perform the backing up. */
 168
 169 void gen_bu_action ()
 170 {
 171         if (reject || num_backing_up == 0)
 172                 return;
 173
 174         set_indent (3);
 175
 176         indent_puts ("case 0: /* must back up */");
 177         indent_puts ("/* undo the effects of YY_DO_BEFORE_ACTION */");
 178         indent_puts ("*yy_cp = YY_G(yy_hold_char);");
 179
 180         if (fullspd || fulltbl)
 181                 indent_puts ("yy_cp = YY_G(yy_last_accepting_cpos) + 1;");
 182         else
 183                 /* Backing-up info for compressed tables is taken \after/
 184                  * yy_cp has been incremented for the next state.
 185                  */
 186                 indent_puts ("yy_cp = YY_G(yy_last_accepting_cpos);");
 187
 188         indent_puts ("yy_current_state = YY_G(yy_last_accepting_state);");
 189         indent_puts ("goto yy_find_action;");
 190         outc ('\n');
 191
 192         set_indent (0);
 193 }
 194
 195 /** mkctbl - make full speed compressed transition table
 196  * This is an array of structs; each struct a pair of integers.
 197  * You should call mkssltbl() immediately after this.
 198  * Then, I think, mkecstbl(). Arrrg.
 199  * @return the newly allocated trans table
 200  */
 201
 202 static struct yytbl_data *mkctbl (void)
 203 {
 204         register int i;
 205         struct yytbl_data *tbl = 0;
 206         flex_int32_t *tdata = 0, curr = 0;
 207         int     end_of_buffer_action = num_rules + 1;
 208
 209         buf_prints (&yydmap_buf,
 210                     "\t{YYTD_ID_TRANSITION, (void**)&yy_transition, sizeof(%s)},\n",
 211                     ((tblend + numecs + 1) >= INT16_MAX
 212                      || long_align) ? "flex_int32_t" : "flex_int16_t");
 213
 214         tbl = (struct yytbl_data *) calloc (1, sizeof (struct yytbl_data));
 215         yytbl_data_init (tbl, YYTD_ID_TRANSITION);
 216         tbl->td_flags = YYTD_DATA32 | YYTD_STRUCT;
 217         tbl->td_hilen = 0;
 218         tbl->td_lolen = tblend + numecs + 1;    /* number of structs */
 219
 220         tbl->td_data = tdata =
 221                 (flex_int32_t *) calloc (tbl->td_lolen * 2, sizeof (flex_int32_t));
 222
 223         /* We want the transition to be represented as the offset to the
 224          * next state, not the actual state number, which is what it currently
 225          * is.  The offset is base[nxt[i]] - (base of current state)].  That's
 226          * just the difference between the starting points of the two involved
 227          * states (to - from).
 228          *
 229          * First, though, we need to find some way to put in our end-of-buffer
 230          * flags and states.  We do this by making a state with absolutely no
 231          * transitions.  We put it at the end of the table.
 232          */
 233
 234         /* We need to have room in nxt/chk for two more slots: One for the
 235          * action and one for the end-of-buffer transition.  We now *assume*
 236          * that we're guaranteed the only character we'll try to index this
 237          * nxt/chk pair with is EOB, i.e., 0, so we don't have to make sure
 238          * there's room for jam entries for other characters.
 239          */
 240
 241         while (tblend + 2 >= current_max_xpairs)
 242                 expand_nxt_chk ();
 243
 244         while (lastdfa + 1 >= current_max_dfas)
 245                 increase_max_dfas ();
 246
 247         base[lastdfa + 1] = tblend + 2;
 248         nxt[tblend + 1] = end_of_buffer_action;
 249         chk[tblend + 1] = numecs + 1;
 250         chk[tblend + 2] = 1;    /* anything but EOB */
 251
 252         /* So that "make test" won't show arb. differences. */
 253         nxt[tblend + 2] = 0;
 254
 255         /* Make sure every state has an end-of-buffer transition and an
 256          * action #.
 257          */
 258         for (i = 0; i <= lastdfa; ++i) {
 259                 int     anum = dfaacc[i].dfaacc_state;
 260                 int     offset = base[i];
 261
 262                 chk[offset] = EOB_POSITION;
 263                 chk[offset - 1] = ACTION_POSITION;
 264                 nxt[offset - 1] = anum; /* action number */
 265         }
 266
 267         for (i = 0; i <= tblend; ++i) {
 268                 if (chk[i] == EOB_POSITION) {
 269                         tdata[curr++] = 0;
 270                         tdata[curr++] = base[lastdfa + 1] - i;
 271                 }
 272
 273                 else if (chk[i] == ACTION_POSITION) {
 274                         tdata[curr++] = 0;
 275                         tdata[curr++] = nxt[i];
 276                 }
 277
 278                 else if (chk[i] > numecs || chk[i] == 0) {
 279                         tdata[curr++] = 0;
 280                         tdata[curr++] = 0;
 281                 }
 282                 else {          /* verify, transition */
 283
 284                         tdata[curr++] = chk[i];
 285                         tdata[curr++] = base[nxt[i]] - (i - chk[i]);
 286                 }
 287         }
 288
 289
 290         /* Here's the final, end-of-buffer state. */
 291         tdata[curr++] = chk[tblend + 1];
 292         tdata[curr++] = nxt[tblend + 1];
 293
 294         tdata[curr++] = chk[tblend + 2];
 295         tdata[curr++] = nxt[tblend + 2];
 296
 297         return tbl;
 298 }
 299
 300
 301 /** Make start_state_list table.
 302  *  @return the newly allocated start_state_list table
 303  */
 304 static struct yytbl_data *mkssltbl (void)
 305 {
 306         struct yytbl_data *tbl = 0;
 307         flex_int32_t *tdata = 0;
 308         flex_int32_t i;
 309
 310         tbl = (struct yytbl_data *) calloc (1, sizeof (struct yytbl_data));
 311         yytbl_data_init (tbl, YYTD_ID_START_STATE_LIST);
 312         tbl->td_flags = YYTD_DATA32 | YYTD_PTRANS;
 313         tbl->td_hilen = 0;
 314         tbl->td_lolen = lastsc * 2 + 1;
 315
 316         tbl->td_data = tdata =
 317                 (flex_int32_t *) calloc (tbl->td_lolen, sizeof (flex_int32_t));
 318
 319         for (i = 0; i <= lastsc * 2; ++i)
 320                 tdata[i] = base[i];
 321
 322         buf_prints (&yydmap_buf,
 323                     "\t{YYTD_ID_START_STATE_LIST, (void**)&yy_start_state_list, sizeof(%s)},\n",
 324                     "struct yy_trans_info*");
 325
 326         return tbl;
 327 }
 328
 329
 330
 331 /* genctbl - generates full speed compressed transition table */
 332
 333 void genctbl ()
 334 {
 335         register int i;
 336         int     end_of_buffer_action = num_rules + 1;
 337
 338         /* Table of verify for transition and offset to next state. */
 339         if (gentables)
 340                 out_dec ("static yyconst struct yy_trans_info yy_transition[%d] =\n    {\n", tblend + numecs + 1);
 341         else
 342                 outn ("static yyconst struct yy_trans_info *yy_transition = 0;");
 343
 344         /* We want the transition to be represented as the offset to the
 345          * next state, not the actual state number, which is what it currently
 346          * is.  The offset is base[nxt[i]] - (base of current state)].  That's
 347          * just the difference between the starting points of the two involved
 348          * states (to - from).
 349          *
 350          * First, though, we need to find some way to put in our end-of-buffer
 351          * flags and states.  We do this by making a state with absolutely no
 352          * transitions.  We put it at the end of the table.
 353          */
 354
 355         /* We need to have room in nxt/chk for two more slots: One for the
 356          * action and one for the end-of-buffer transition.  We now *assume*
 357          * that we're guaranteed the only character we'll try to index this
 358          * nxt/chk pair with is EOB, i.e., 0, so we don't have to make sure
 359          * there's room for jam entries for other characters.
 360          */
 361
 362         while (tblend + 2 >= current_max_xpairs)
 363                 expand_nxt_chk ();
 364
 365         while (lastdfa + 1 >= current_max_dfas)
 366                 increase_max_dfas ();
 367
 368         base[lastdfa + 1] = tblend + 2;
 369         nxt[tblend + 1] = end_of_buffer_action;
 370         chk[tblend + 1] = numecs + 1;
 371         chk[tblend + 2] = 1;    /* anything but EOB */
 372
 373         /* So that "make test" won't show arb. differences. */
 374         nxt[tblend + 2] = 0;
 375
 376         /* Make sure every state has an end-of-buffer transition and an
 377          * action #.
 378          */
 379         for (i = 0; i <= lastdfa; ++i) {
 380                 int     anum = dfaacc[i].dfaacc_state;
 381                 int     offset = base[i];
 382
 383                 chk[offset] = EOB_POSITION;
 384                 chk[offset - 1] = ACTION_POSITION;
 385                 nxt[offset - 1] = anum; /* action number */
 386         }
 387
 388         for (i = 0; i <= tblend; ++i) {
 389                 if (chk[i] == EOB_POSITION)
 390                         transition_struct_out (0, base[lastdfa + 1] - i);
 391
 392                 else if (chk[i] == ACTION_POSITION)
 393                         transition_struct_out (0, nxt[i]);
 394
 395                 else if (chk[i] > numecs || chk[i] == 0)
 396                         transition_struct_out (0, 0);   /* unused slot */
 397
 398                 else            /* verify, transition */
 399                         transition_struct_out (chk[i],
 400                                                base[nxt[i]] - (i -
 401                                                                chk[i]));
 402         }
 403
 404
 405         /* Here's the final, end-of-buffer state. */
 406         transition_struct_out (chk[tblend + 1], nxt[tblend + 1]);
 407         transition_struct_out (chk[tblend + 2], nxt[tblend + 2]);
 408
 409         if (gentables)
 410                 outn ("    };\n");
 411
 412         /* Table of pointers to start states. */
 413         if (gentables)
 414                 out_dec ("static yyconst struct yy_trans_info *yy_start_state_list[%d] =\n", lastsc * 2 + 1);
 415         else
 416                 outn ("static yyconst struct yy_trans_info **yy_start_state_list =0;");
 417
 418         if (gentables) {
 419                 outn ("    {");
 420
 421                 for (i = 0; i <= lastsc * 2; ++i)
 422                         out_dec ("    &yy_transition[%d],\n", base[i]);
 423
 424                 dataend ();
 425         }
 426
 427         if (useecs)
 428                 genecs ();
 429 }
 430
 431
 432 /* mkecstbl - Make equivalence-class tables.  */
 433
 434 struct yytbl_data *mkecstbl (void)
 435 {
 436         register int i;
 437         struct yytbl_data *tbl = 0;
 438         flex_int32_t *tdata = 0;
 439
 440         tbl = (struct yytbl_data *) calloc (1, sizeof (struct yytbl_data));
 441         yytbl_data_init (tbl, YYTD_ID_EC);
 442         tbl->td_flags |= YYTD_DATA32;
 443         tbl->td_hilen = 0;
 444         tbl->td_lolen = csize;
 445
 446         tbl->td_data = tdata =
 447                 (flex_int32_t *) calloc (tbl->td_lolen, sizeof (flex_int32_t));
 448
 449         for (i = 1; i < csize; ++i) {
 450                 ecgroup[i] = ABS (ecgroup[i]);
 451                 tdata[i] = ecgroup[i];
 452         }
 453
 454         buf_prints (&yydmap_buf,
 455                     "\t{YYTD_ID_EC, (void**)&yy_ec, sizeof(%s)},\n",
 456                     "flex_int32_t");
 457
 458         return tbl;
 459 }
 460
 461 /* Generate equivalence-class tables. */
 462
 463 void genecs ()
 464 {
 465         register int i, j;
 466         int     numrows;
 467
 468         out_str_dec (get_int32_decl (), "yy_ec", csize);
 469
 470         for (i = 1; i < csize; ++i) {
 471                 ecgroup[i] = ABS (ecgroup[i]);
 472                 mkdata (ecgroup[i]);
 473         }
 474
 475         dataend ();
 476
 477         if (trace) {
 478                 fputs (_("\n\nEquivalence Classes:\n\n"), stderr);
 479
 480                 numrows = csize / 8;
 481
 482                 for (j = 0; j < numrows; ++j) {
 483                         for (i = j; i < csize; i = i + numrows) {
 484                                 fprintf (stderr, "%4s = %-2d",
 485                                          readable_form (i), ecgroup[i]);
 486
 487                                 putc (' ', stderr);
 488                         }
 489
 490                         putc ('\n', stderr);
 491                 }
 492         }
 493 }
 494
 495
 496 /* Generate the code to find the action number. */
 497
 498 void gen_find_action ()
 499 {
 500         if (fullspd)
 501                 indent_puts ("yy_act = yy_current_state[-1].yy_nxt;");
 502
 503         else if (fulltbl)
 504                 indent_puts ("yy_act = yy_accept[yy_current_state];");
 505
 506         else if (reject) {
 507                 indent_puts ("yy_current_state = *--YY_G(yy_state_ptr);");
 508                 indent_puts ("YY_G(yy_lp) = yy_accept[yy_current_state];");
 509
 510                 outn ("find_rule: /* we branch to this label when backing up */");
 511
 512                 indent_puts
 513                         ("for ( ; ; ) /* until we find what rule we matched */");
 514
 515                 indent_up ();
 516
 517                 indent_puts ("{");
 518
 519                 indent_puts
 520                         ("if ( YY_G(yy_lp) && YY_G(yy_lp) < yy_accept[yy_current_state + 1] )");
 521                 indent_up ();
 522                 indent_puts ("{");
 523                 indent_puts ("yy_act = yy_acclist[YY_G(yy_lp)];");
 524
 525                 if (variable_trailing_context_rules) {
 526                         indent_puts
 527                                 ("if ( yy_act & YY_TRAILING_HEAD_MASK ||");
 528                         indent_puts ("     YY_G(yy_looking_for_trail_begin) )");
 529                         indent_up ();
 530                         indent_puts ("{");
 531
 532                         indent_puts
 533                                 ("if ( yy_act == YY_G(yy_looking_for_trail_begin) )");
 534                         indent_up ();
 535                         indent_puts ("{");
 536                         indent_puts ("YY_G(yy_looking_for_trail_begin) = 0;");
 537                         indent_puts ("yy_act &= ~YY_TRAILING_HEAD_MASK;");
 538                         indent_puts ("break;");
 539                         indent_puts ("}");
 540                         indent_down ();
 541
 542                         indent_puts ("}");
 543                         indent_down ();
 544
 545                         indent_puts
 546                                 ("else if ( yy_act & YY_TRAILING_MASK )");
 547                         indent_up ();
 548                         indent_puts ("{");
 549                         indent_puts
 550                                 ("YY_G(yy_looking_for_trail_begin) = yy_act & ~YY_TRAILING_MASK;");
 551                         indent_puts
 552                                 ("YY_G(yy_looking_for_trail_begin) |= YY_TRAILING_HEAD_MASK;");
 553
 554                         if (real_reject) {
 555                                 /* Remember matched text in case we back up
 556                                  * due to REJECT.
 557                                  */
 558                                 indent_puts
 559                                         ("YY_G(yy_full_match) = yy_cp;");
 560                                 indent_puts
 561                                         ("YY_G(yy_full_state) = YY_G(yy_state_ptr);");
 562                                 indent_puts ("YY_G(yy_full_lp) = YY_G(yy_lp);");
 563                         }
 564
 565                         indent_puts ("}");
 566                         indent_down ();
 567
 568                         indent_puts ("else");
 569                         indent_up ();
 570                         indent_puts ("{");
 571                         indent_puts ("YY_G(yy_full_match) = yy_cp;");
 572                         indent_puts
 573                                 ("YY_G(yy_full_state) = YY_G(yy_state_ptr);");
 574                         indent_puts ("YY_G(yy_full_lp) = YY_G(yy_lp);");
 575                         indent_puts ("break;");
 576                         indent_puts ("}");
 577                         indent_down ();
 578
 579                         indent_puts ("++YY_G(yy_lp);");
 580                         indent_puts ("goto find_rule;");
 581                 }
 582
 583                 else {
 584                         /* Remember matched text in case we back up due to
 585                          * trailing context plus REJECT.
 586                          */
 587                         indent_up ();
 588                         indent_puts ("{");
 589                         indent_puts ("YY_G(yy_full_match) = yy_cp;");
 590                         indent_puts ("break;");
 591                         indent_puts ("}");
 592                         indent_down ();
 593                 }
 594
 595                 indent_puts ("}");
 596                 indent_down ();
 597
 598                 indent_puts ("--yy_cp;");
 599
 600                 /* We could consolidate the following two lines with those at
 601                  * the beginning, but at the cost of complaints that we're
 602                  * branching inside a loop.
 603                  */
 604                 indent_puts ("yy_current_state = *--YY_G(yy_state_ptr);");
 605                 indent_puts ("YY_G(yy_lp) = yy_accept[yy_current_state];");
 606
 607                 indent_puts ("}");
 608
 609                 indent_down ();
 610         }
 611
 612         else {                  /* compressed */
 613                 indent_puts ("yy_act = yy_accept[yy_current_state];");
 614
 615                 if (interactive && !reject) {
 616                         /* Do the guaranteed-needed backing up to figure out
 617                          * the match.
 618                          */
 619                         indent_puts ("if ( yy_act == 0 )");
 620                         indent_up ();
 621                         indent_puts ("{ /* have to back up */");
 622                         indent_puts
 623                                 ("yy_cp = YY_G(yy_last_accepting_cpos);");
 624                         indent_puts
 625                                 ("yy_current_state = YY_G(yy_last_accepting_state);");
 626                         indent_puts
 627                                 ("yy_act = yy_accept[yy_current_state];");
 628                         indent_puts ("}");
 629                         indent_down ();
 630                 }
 631         }
 632 }
 633
 634 /* mkftbl - make the full table and return the struct .
 635  * you should call mkecstbl() after this.
 636  */
 637
 638 struct yytbl_data *mkftbl (void)
 639 {
 640         register int i;
 641         int     end_of_buffer_action = num_rules + 1;
 642         struct yytbl_data *tbl;
 643         flex_int32_t *tdata = 0;
 644
 645         tbl = (struct yytbl_data *) calloc (1, sizeof (struct yytbl_data));
 646         yytbl_data_init (tbl, YYTD_ID_ACCEPT);
 647         tbl->td_flags |= YYTD_DATA32;
 648         tbl->td_hilen = 0;      /* it's a one-dimensional array */
 649         tbl->td_lolen = lastdfa + 1;
 650
 651         tbl->td_data = tdata =
 652                 (flex_int32_t *) calloc (tbl->td_lolen, sizeof (flex_int32_t));
 653
 654         dfaacc[end_of_buffer_state].dfaacc_state = end_of_buffer_action;
 655
 656         for (i = 1; i <= lastdfa; ++i) {
 657                 register int anum = dfaacc[i].dfaacc_state;
 658
 659                 tdata[i] = anum;
 660
 661                 if (trace && anum)
 662                         fprintf (stderr, _("state # %d accepts: [%d]\n"),
 663                                  i, anum);
 664         }
 665
 666         buf_prints (&yydmap_buf,
 667                     "\t{YYTD_ID_ACCEPT, (void**)&yy_accept, sizeof(%s)},\n",
 668                     long_align ? "flex_int32_t" : "flex_int16_t");
 669         return tbl;
 670 }
 671
 672
 673 /* genftbl - generate full transition table */
 674
 675 void genftbl ()
 676 {
 677         register int i;
 678         int     end_of_buffer_action = num_rules + 1;
 679
 680         out_str_dec (long_align ? get_int32_decl () : get_int16_decl (),
 681                      "yy_accept", lastdfa + 1);
 682
 683         dfaacc[end_of_buffer_state].dfaacc_state = end_of_buffer_action;
 684
 685         for (i = 1; i <= lastdfa; ++i) {
 686                 register int anum = dfaacc[i].dfaacc_state;
 687
 688                 mkdata (anum);
 689
 690                 if (trace && anum)
 691                         fprintf (stderr, _("state # %d accepts: [%d]\n"),
 692                                  i, anum);
 693         }
 694
 695         dataend ();
 696
 697         if (useecs)
 698                 genecs ();
 699
 700         /* Don't have to dump the actual full table entries - they were
 701          * created on-the-fly.
 702          */
 703 }
 704
 705
 706 /* Generate the code to find the next compressed-table state. */
 707
 708 void gen_next_compressed_state (char_map)
 709      char   *char_map;
 710 {
 711         indent_put2s ("register YY_CHAR yy_c = %s;", char_map);
 712
 713         /* Save the backing-up info \before/ computing the next state
 714          * because we always compute one more state than needed - we
 715          * always proceed until we reach a jam state
 716          */
 717         gen_backing_up ();
 718
 719         indent_puts
 720                 ("while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )");
 721         indent_up ();
 722         indent_puts ("{");
 723         indent_puts ("yy_current_state = (int) yy_def[yy_current_state];");
 724
 725         if (usemecs) {
 726                 /* We've arrange it so that templates are never chained
 727                  * to one another.  This means we can afford to make a
 728                  * very simple test to see if we need to convert to
 729                  * yy_c's meta-equivalence class without worrying
 730                  * about erroneously looking up the meta-equivalence
 731                  * class twice
 732                  */
 733                 do_indent ();
 734
 735                 /* lastdfa + 2 is the beginning of the templates */
 736                 out_dec ("if ( yy_current_state >= %d )\n", lastdfa + 2);
 737
 738                 indent_up ();
 739                 indent_puts ("yy_c = yy_meta[(unsigned int) yy_c];");
 740                 indent_down ();
 741         }
 742
 743         indent_puts ("}");
 744         indent_down ();
 745
 746         indent_puts
 747                 ("yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];");
 748 }
 749
 750
 751 /* Generate the code to find the next match. */
 752
 753 void gen_next_match ()
 754 {
 755         /* NOTE - changes in here should be reflected in gen_next_state() and
 756          * gen_NUL_trans().
 757          */
 758         char   *char_map = useecs ?
 759                 "yy_ec[YY_SC_TO_UI(*yy_cp)] " : "YY_SC_TO_UI(*yy_cp)";
 760
 761         char   *char_map_2 = useecs ?
 762                 "yy_ec[YY_SC_TO_UI(*++yy_cp)] " : "YY_SC_TO_UI(*++yy_cp)";
 763
 764         if (fulltbl) {
 765                 if (gentables)
 766                         indent_put2s
 767                                 ("while ( (yy_current_state = yy_nxt[yy_current_state][ %s ]) > 0 )",
 768                                  char_map);
 769                 else
 770                         indent_put2s
 771                                 ("while ( (yy_current_state = yy_nxt[yy_current_state*YY_NXT_LOLEN +  %s ]) > 0 )",
 772                                  char_map);
 773
 774                 indent_up ();
 775
 776                 if (num_backing_up > 0) {
 777                         indent_puts ("{");
 778                         gen_backing_up ();
 779                         outc ('\n');
 780                 }
 781
 782                 indent_puts ("++yy_cp;");
 783
 784                 if (num_backing_up > 0)
 785
 786                         indent_puts ("}");
 787
 788                 indent_down ();
 789
 790                 outc ('\n');
 791                 indent_puts ("yy_current_state = -yy_current_state;");
 792         }
 793
 794         else if (fullspd) {
 795                 indent_puts ("{");
 796                 indent_puts
 797                         ("register yyconst struct yy_trans_info *yy_trans_info;\n");
 798                 indent_puts ("register YY_CHAR yy_c;\n");
 799                 indent_put2s ("for ( yy_c = %s;", char_map);
 800                 indent_puts
 801                         ("      (yy_trans_info = &yy_current_state[(unsigned int) yy_c])->");
 802                 indent_puts ("yy_verify == yy_c;");
 803                 indent_put2s ("      yy_c = %s )", char_map_2);
 804
 805                 indent_up ();
 806
 807                 if (num_backing_up > 0)
 808                         indent_puts ("{");
 809
 810                 indent_puts ("yy_current_state += yy_trans_info->yy_nxt;");
 811
 812                 if (num_backing_up > 0) {
 813                         outc ('\n');
 814                         gen_backing_up ();
 815                         indent_puts ("}");
 816                 }
 817
 818                 indent_down ();
 819                 indent_puts ("}");
 820         }
 821
 822         else {                  /* compressed */
 823                 indent_puts ("do");
 824
 825                 indent_up ();
 826                 indent_puts ("{");
 827
 828                 gen_next_state (false);
 829
 830                 indent_puts ("++yy_cp;");
 831
 832
 833                 indent_puts ("}");
 834                 indent_down ();
 835
 836                 do_indent ();
 837
 838                 if (interactive)
 839                         out_dec ("while ( yy_base[yy_current_state] != %d );\n", jambase);
 840                 else
 841                         out_dec ("while ( yy_current_state != %d );\n",
 842                                  jamstate);
 843
 844                 if (!reject && !interactive) {
 845                         /* Do the guaranteed-needed backing up to figure out
 846                          * the match.
 847                          */
 848                         indent_puts
 849                                 ("yy_cp = YY_G(yy_last_accepting_cpos);");
 850                         indent_puts
 851                                 ("yy_current_state = YY_G(yy_last_accepting_state);");
 852                 }
 853         }
 854 }
 855
 856
 857 /* Generate the code to find the next state. */
 858
 859 void gen_next_state (worry_about_NULs)
 860      int worry_about_NULs;
 861 {                               /* NOTE - changes in here should be reflected in gen_next_match() */
 862         char    char_map[256];
 863
 864         if (worry_about_NULs && !nultrans) {
 865                 if (useecs)
 866                         snprintf (char_map, sizeof(char_map),
 867                                         "(*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : %d)",
 868                                         NUL_ec);
 869                 else
 870             snprintf (char_map, sizeof(char_map),
 871                                         "(*yy_cp ? YY_SC_TO_UI(*yy_cp) : %d)",
 872                                         NUL_ec);
 873         }
 874
 875         else
 876                 strcpy (char_map, useecs ?
 877                         "yy_ec[YY_SC_TO_UI(*yy_cp)]" :
 878                         "YY_SC_TO_UI(*yy_cp)");
 879
 880         if (worry_about_NULs && nultrans) {
 881                 if (!fulltbl && !fullspd)
 882                         /* Compressed tables back up *before* they match. */
 883                         gen_backing_up ();
 884
 885                 indent_puts ("if ( *yy_cp )");
 886                 indent_up ();
 887                 indent_puts ("{");
 888         }
 889
 890         if (fulltbl) {
 891                 if (gentables)
 892                         indent_put2s
 893                                 ("yy_current_state = yy_nxt[yy_current_state][%s];",
 894                                  char_map);
 895                 else
 896                         indent_put2s
 897                                 ("yy_current_state = yy_nxt[yy_current_state*YY_NXT_LOLEN + %s];",
 898                                  char_map);
 899         }
 900
 901         else if (fullspd)
 902                 indent_put2s
 903                         ("yy_current_state += yy_current_state[%s].yy_nxt;",
 904                          char_map);
 905
 906         else
 907                 gen_next_compressed_state (char_map);
 908
 909         if (worry_about_NULs && nultrans) {
 910
 911                 indent_puts ("}");
 912                 indent_down ();
 913                 indent_puts ("else");
 914                 indent_up ();
 915                 indent_puts
 916                         ("yy_current_state = yy_NUL_trans[yy_current_state];");
 917                 indent_down ();
 918         }
 919
 920         if (fullspd || fulltbl)
 921                 gen_backing_up ();
 922
 923         if (reject)
 924                 indent_puts ("*YY_G(yy_state_ptr)++ = yy_current_state;");
 925 }
 926
 927
 928 /* Generate the code to make a NUL transition. */
 929
 930 void gen_NUL_trans ()
 931 {                               /* NOTE - changes in here should be reflected in gen_next_match() */
 932         /* Only generate a definition for "yy_cp" if we'll generate code
 933          * that uses it.  Otherwise lint and the like complain.
 934          */
 935         int     need_backing_up = (num_backing_up > 0 && !reject);
 936
 937         if (need_backing_up && (!nultrans || fullspd || fulltbl))
 938                 /* We're going to need yy_cp lying around for the call
 939                  * below to gen_backing_up().
 940                  */
 941                 indent_puts ("register char *yy_cp = YY_G(yy_c_buf_p);");
 942
 943         outc ('\n');
 944
 945         if (nultrans) {
 946                 indent_puts
 947                         ("yy_current_state = yy_NUL_trans[yy_current_state];");
 948                 indent_puts ("yy_is_jam = (yy_current_state == 0);");
 949         }
 950
 951         else if (fulltbl) {
 952                 do_indent ();
 953                 if (gentables)
 954                         out_dec ("yy_current_state = yy_nxt[yy_current_state][%d];\n", NUL_ec);
 955                 else
 956                         out_dec ("yy_current_state = yy_nxt[yy_current_state*YY_NXT_LOLEN + %d];\n", NUL_ec);
 957                 indent_puts ("yy_is_jam = (yy_current_state <= 0);");
 958         }
 959
 960         else if (fullspd) {
 961                 do_indent ();
 962                 out_dec ("register int yy_c = %d;\n", NUL_ec);
 963
 964                 indent_puts
 965                         ("register yyconst struct yy_trans_info *yy_trans_info;\n");
 966                 indent_puts
 967                         ("yy_trans_info = &yy_current_state[(unsigned int) yy_c];");
 968                 indent_puts ("yy_current_state += yy_trans_info->yy_nxt;");
 969
 970                 indent_puts
 971                         ("yy_is_jam = (yy_trans_info->yy_verify != yy_c);");
 972         }
 973
 974         else {
 975                 char    NUL_ec_str[20];
 976
 977                 snprintf (NUL_ec_str, sizeof(NUL_ec_str), "%d", NUL_ec);
 978                 gen_next_compressed_state (NUL_ec_str);
 979
 980                 do_indent ();
 981                 out_dec ("yy_is_jam = (yy_current_state == %d);\n",
 982                          jamstate);
 983
 984                 if (reject) {
 985                         /* Only stack this state if it's a transition we
 986                          * actually make.  If we stack it on a jam, then
 987                          * the state stack and yy_c_buf_p get out of sync.
 988                          */
 989                         indent_puts ("if ( ! yy_is_jam )");
 990                         indent_up ();
 991                         indent_puts
 992                                 ("*YY_G(yy_state_ptr)++ = yy_current_state;");
 993                         indent_down ();
 994                 }
 995         }
 996
 997         /* If we've entered an accepting state, back up; note that
 998          * compressed tables have *already* done such backing up, so
 999          * we needn't bother with it again.
1000          */
1001         if (need_backing_up && (fullspd || fulltbl)) {
1002                 outc ('\n');
1003                 indent_puts ("if ( ! yy_is_jam )");
1004                 indent_up ();
1005                 indent_puts ("{");
1006                 gen_backing_up ();
1007                 indent_puts ("}");
1008                 indent_down ();
1009         }
1010 }
1011
1012
1013 /* Generate the code to find the start state. */
1014
1015 void gen_start_state ()
1016 {
1017         if (fullspd) {
1018                 if (bol_needed) {
1019                         indent_puts
1020                                 ("yy_current_state = yy_start_state_list[YY_G(yy_start) + YY_AT_BOL()];");
1021                 }
1022                 else
1023                         indent_puts
1024                                 ("yy_current_state = yy_start_state_list[YY_G(yy_start)];");
1025         }
1026
1027         else {
1028                 indent_puts ("yy_current_state = YY_G(yy_start);");
1029
1030                 if (bol_needed)
1031                         indent_puts ("yy_current_state += YY_AT_BOL();");
1032
1033                 if (reject) {
1034                         /* Set up for storing up states. */
1035                         outn ("m4_ifdef( [[M4_YY_USES_REJECT]],\n[[");
1036                         indent_puts
1037                                 ("YY_G(yy_state_ptr) = YY_G(yy_state_buf);");
1038                         indent_puts
1039                                 ("*YY_G(yy_state_ptr)++ = yy_current_state;");
1040                         outn ("]])");
1041                 }
1042         }
1043 }
1044
1045
1046 /* gentabs - generate data statements for the transition tables */
1047
1048 void gentabs ()
1049 {
1050         int     i, j, k, *accset, nacc, *acc_array, total_states;
1051         int     end_of_buffer_action = num_rules + 1;
1052         struct yytbl_data *yyacc_tbl = 0, *yymeta_tbl = 0, *yybase_tbl = 0,
1053                 *yydef_tbl = 0, *yynxt_tbl = 0, *yychk_tbl = 0, *yyacclist_tbl=0;
1054         flex_int32_t *yyacc_data = 0, *yybase_data = 0, *yydef_data = 0,
1055                 *yynxt_data = 0, *yychk_data = 0, *yyacclist_data=0;
1056         flex_int32_t yybase_curr = 0, yyacclist_curr=0,yyacc_curr=0;
1057
1058         acc_array = allocate_integer_array (current_max_dfas);
1059         nummt = 0;
1060
1061         /* The compressed table format jams by entering the "jam state",
1062          * losing information about the previous state in the process.
1063          * In order to recover the previous state, we effectively need
1064          * to keep backing-up information.
1065          */
1066         ++num_backing_up;
1067
1068         if (reject) {
1069                 /* Write out accepting list and pointer list.
1070
1071                  * First we generate the "yy_acclist" array.  In the process,
1072                  * we compute the indices that will go into the "yy_accept"
1073                  * array, and save the indices in the dfaacc array.
1074                  */
1075                 int     EOB_accepting_list[2];
1076
1077                 /* Set up accepting structures for the End Of Buffer state. */
1078                 EOB_accepting_list[0] = 0;
1079                 EOB_accepting_list[1] = end_of_buffer_action;
1080                 accsiz[end_of_buffer_state] = 1;
1081                 dfaacc[end_of_buffer_state].dfaacc_set =
1082                         EOB_accepting_list;
1083
1084                 out_str_dec (long_align ? get_int32_decl () :
1085                              get_int16_decl (), "yy_acclist", MAX (numas,
1086                                                                    1) + 1);
1087
1088         buf_prints (&yydmap_buf,
1089                 "\t{YYTD_ID_ACCLIST, (void**)&yy_acclist, sizeof(%s)},\n",
1090                 long_align ? "flex_int32_t" : "flex_int16_t");
1091
1092         yyacclist_tbl = (struct yytbl_data*)calloc(1,sizeof(struct yytbl_data));
1093         yytbl_data_init (yyacclist_tbl, YYTD_ID_ACCLIST);
1094         yyacclist_tbl->td_lolen  = MAX(numas,1) + 1;
1095         yyacclist_tbl->td_data = yyacclist_data =
1096             (flex_int32_t *) calloc (yyacclist_tbl->td_lolen, sizeof (flex_int32_t));
1097         yyacclist_curr = 1;
1098
1099                 j = 1;          /* index into "yy_acclist" array */
1100
1101                 for (i = 1; i <= lastdfa; ++i) {
1102                         acc_array[i] = j;
1103
1104                         if (accsiz[i] != 0) {
1105                                 accset = dfaacc[i].dfaacc_set;
1106                                 nacc = accsiz[i];
1107
1108                                 if (trace)
1109                                         fprintf (stderr,
1110                                                  _("state # %d accepts: "),
1111                                                  i);
1112
1113                                 for (k = 1; k <= nacc; ++k) {
1114                                         int     accnum = accset[k];
1115
1116                                         ++j;
1117
1118                                         if (variable_trailing_context_rules
1119                                             && !(accnum &
1120                                                  YY_TRAILING_HEAD_MASK)
1121                                             && accnum > 0
1122                                             && accnum <= num_rules
1123                                             && rule_type[accnum] ==
1124                                             RULE_VARIABLE) {
1125                                                 /* Special hack to flag
1126                                                  * accepting number as part
1127                                                  * of trailing context rule.
1128                                                  */
1129                                                 accnum |= YY_TRAILING_MASK;
1130                                         }
1131
1132                                         mkdata (accnum);
1133                     yyacclist_data[yyacclist_curr++] = accnum;
1134
1135                                         if (trace) {
1136                                                 fprintf (stderr, "[%d]",
1137                                                          accset[k]);
1138
1139                                                 if (k < nacc)
1140                                                         fputs (", ",
1141                                                                stderr);
1142                                                 else
1143                                                         putc ('\n',
1144                                                               stderr);
1145                                         }
1146                                 }
1147                         }
1148                 }
1149
1150                 /* add accepting number for the "jam" state */
1151                 acc_array[i] = j;
1152
1153                 dataend ();
1154         if (tablesext) {
1155             yytbl_data_compress (yyacclist_tbl);
1156             if (yytbl_data_fwrite (&tableswr, yyacclist_tbl) < 0)
1157                 flexerror (_("Could not write yyacclist_tbl"));
1158             yytbl_data_destroy (yyacclist_tbl);
1159             yyacclist_tbl = NULL;
1160         }
1161         }
1162
1163         else {
1164                 dfaacc[end_of_buffer_state].dfaacc_state =
1165                         end_of_buffer_action;
1166
1167                 for (i = 1; i <= lastdfa; ++i)
1168                         acc_array[i] = dfaacc[i].dfaacc_state;
1169
1170                 /* add accepting number for jam state */
1171                 acc_array[i] = 0;
1172         }
1173
1174         /* Begin generating yy_accept */
1175
1176         /* Spit out "yy_accept" array.  If we're doing "reject", it'll be
1177          * pointers into the "yy_acclist" array.  Otherwise it's actual
1178          * accepting numbers.  In either case, we just dump the numbers.
1179          */
1180
1181         /* "lastdfa + 2" is the size of "yy_accept"; includes room for C arrays
1182          * beginning at 0 and for "jam" state.
1183          */
1184         k = lastdfa + 2;
1185
1186         if (reject)
1187                 /* We put a "cap" on the table associating lists of accepting
1188                  * numbers with state numbers.  This is needed because we tell
1189                  * where the end of an accepting list is by looking at where
1190                  * the list for the next state starts.
1191                  */
1192                 ++k;
1193
1194         out_str_dec (long_align ? get_int32_decl () : get_int16_decl (),
1195                      "yy_accept", k);
1196
1197         buf_prints (&yydmap_buf,
1198                     "\t{YYTD_ID_ACCEPT, (void**)&yy_accept, sizeof(%s)},\n",
1199                     long_align ? "flex_int32_t" : "flex_int16_t");
1200
1201         yyacc_tbl =
1202                 (struct yytbl_data *) calloc (1,
1203                                               sizeof (struct yytbl_data));
1204         yytbl_data_init (yyacc_tbl, YYTD_ID_ACCEPT);
1205         yyacc_tbl->td_lolen = k;
1206         yyacc_tbl->td_data = yyacc_data =
1207                 (flex_int32_t *) calloc (yyacc_tbl->td_lolen, sizeof (flex_int32_t));
1208     yyacc_curr=1;
1209
1210         for (i = 1; i <= lastdfa; ++i) {
1211                 mkdata (acc_array[i]);
1212                 yyacc_data[yyacc_curr++] = acc_array[i];
1213
1214                 if (!reject && trace && acc_array[i])
1215                         fprintf (stderr, _("state # %d accepts: [%d]\n"),
1216                                  i, acc_array[i]);
1217         }
1218
1219         /* Add entry for "jam" state. */
1220         mkdata (acc_array[i]);
1221         yyacc_data[yyacc_curr++] = acc_array[i];
1222
1223         if (reject) {
1224                 /* Add "cap" for the list. */
1225                 mkdata (acc_array[i]);
1226                 yyacc_data[yyacc_curr++] = acc_array[i];
1227         }
1228
1229         dataend ();
1230         if (tablesext) {
1231                 yytbl_data_compress (yyacc_tbl);
1232                 if (yytbl_data_fwrite (&tableswr, yyacc_tbl) < 0)
1233                         flexerror (_("Could not write yyacc_tbl"));
1234                 yytbl_data_destroy (yyacc_tbl);
1235                 yyacc_tbl = NULL;
1236         }
1237         /* End generating yy_accept */
1238
1239         if (useecs) {
1240
1241                 genecs ();
1242                 if (tablesext) {
1243                         struct yytbl_data *tbl;
1244
1245                         tbl = mkecstbl ();
1246                         yytbl_data_compress (tbl);
1247                         if (yytbl_data_fwrite (&tableswr, tbl) < 0)
1248                                 flexerror (_("Could not write ecstbl"));
1249                         yytbl_data_destroy (tbl);
1250                         tbl = 0;
1251                 }
1252         }
1253
1254         if (usemecs) {
1255                 /* Begin generating yy_meta */
1256                 /* Write out meta-equivalence classes (used to index
1257                  * templates with).
1258                  */
1259                 flex_int32_t *yymecs_data = 0;
1260                 yymeta_tbl =
1261                         (struct yytbl_data *) calloc (1,
1262                                                       sizeof (struct
1263                                                               yytbl_data));
1264                 yytbl_data_init (yymeta_tbl, YYTD_ID_META);
1265                 yymeta_tbl->td_lolen = numecs + 1;
1266                 yymeta_tbl->td_data = yymecs_data =
1267                         (flex_int32_t *) calloc (yymeta_tbl->td_lolen,
1268                                             sizeof (flex_int32_t));
1269
1270                 if (trace)
1271                         fputs (_("\n\nMeta-Equivalence Classes:\n"),
1272                                stderr);
1273
1274                 out_str_dec (get_int32_decl (), "yy_meta", numecs + 1);
1275                 buf_prints (&yydmap_buf,
1276                             "\t{YYTD_ID_META, (void**)&yy_meta, sizeof(%s)},\n",
1277                             "flex_int32_t");
1278
1279                 for (i = 1; i <= numecs; ++i) {
1280                         if (trace)
1281                                 fprintf (stderr, "%d = %d\n",
1282                                          i, ABS (tecbck[i]));
1283
1284                         mkdata (ABS (tecbck[i]));
1285                         yymecs_data[i] = ABS (tecbck[i]);
1286                 }
1287
1288                 dataend ();
1289                 if (tablesext) {
1290                         yytbl_data_compress (yymeta_tbl);
1291                         if (yytbl_data_fwrite (&tableswr, yymeta_tbl) < 0)
1292                                 flexerror (_
1293                                            ("Could not write yymeta_tbl"));
1294                         yytbl_data_destroy (yymeta_tbl);
1295                         yymeta_tbl = NULL;
1296                 }
1297                 /* End generating yy_meta */
1298         }
1299
1300         total_states = lastdfa + numtemps;
1301
1302         /* Begin generating yy_base */
1303         out_str_dec ((tblend >= INT16_MAX || long_align) ?
1304                      get_int32_decl () : get_int16_decl (),
1305                      "yy_base", total_states + 1);
1306
1307         buf_prints (&yydmap_buf,
1308                     "\t{YYTD_ID_BASE, (void**)&yy_base, sizeof(%s)},\n",
1309                     (tblend >= INT16_MAX
1310                      || long_align) ? "flex_int32_t" : "flex_int16_t");
1311         yybase_tbl =
1312                 (struct yytbl_data *) calloc (1,
1313                                               sizeof (struct yytbl_data));
1314         yytbl_data_init (yybase_tbl, YYTD_ID_BASE);
1315         yybase_tbl->td_lolen = total_states + 1;
1316         yybase_tbl->td_data = yybase_data =
1317                 (flex_int32_t *) calloc (yybase_tbl->td_lolen,
1318                                     sizeof (flex_int32_t));
1319         yybase_curr = 1;
1320
1321         for (i = 1; i <= lastdfa; ++i) {
1322                 register int d = def[i];
1323
1324                 if (base[i] == JAMSTATE)
1325                         base[i] = jambase;
1326
1327                 if (d == JAMSTATE)
1328                         def[i] = jamstate;
1329
1330                 else if (d < 0) {
1331                         /* Template reference. */
1332                         ++tmpuses;
1333                         def[i] = lastdfa - d + 1;
1334                 }
1335
1336                 mkdata (base[i]);
1337                 yybase_data[yybase_curr++] = base[i];
1338         }
1339
1340         /* Generate jam state's base index. */
1341         mkdata (base[i]);
1342         yybase_data[yybase_curr++] = base[i];
1343
1344         for (++i /* skip jam state */ ; i <= total_states; ++i) {
1345                 mkdata (base[i]);
1346                 yybase_data[yybase_curr++] = base[i];
1347                 def[i] = jamstate;
1348         }
1349
1350         dataend ();
1351         if (tablesext) {
1352                 yytbl_data_compress (yybase_tbl);
1353                 if (yytbl_data_fwrite (&tableswr, yybase_tbl) < 0)
1354                         flexerror (_("Could not write yybase_tbl"));
1355                 yytbl_data_destroy (yybase_tbl);
1356                 yybase_tbl = NULL;
1357         }
1358         /* End generating yy_base */
1359
1360
1361         /* Begin generating yy_def */
1362         out_str_dec ((total_states >= INT16_MAX || long_align) ?
1363                      get_int32_decl () : get_int16_decl (),
1364                      "yy_def", total_states + 1);
1365
1366         buf_prints (&yydmap_buf,
1367                     "\t{YYTD_ID_DEF, (void**)&yy_def, sizeof(%s)},\n",
1368                     (total_states >= INT16_MAX
1369                      || long_align) ? "flex_int32_t" : "flex_int16_t");
1370
1371         yydef_tbl =
1372                 (struct yytbl_data *) calloc (1,
1373                                               sizeof (struct yytbl_data));
1374         yytbl_data_init (yydef_tbl, YYTD_ID_DEF);
1375         yydef_tbl->td_lolen = total_states + 1;
1376         yydef_tbl->td_data = yydef_data =
1377                 (flex_int32_t *) calloc (yydef_tbl->td_lolen, sizeof (flex_int32_t));
1378
1379         for (i = 1; i <= total_states; ++i) {
1380                 mkdata (def[i]);
1381                 yydef_data[i] = def[i];
1382         }
1383
1384         dataend ();
1385         if (tablesext) {
1386                 yytbl_data_compress (yydef_tbl);
1387                 if (yytbl_data_fwrite (&tableswr, yydef_tbl) < 0)
1388                         flexerror (_("Could not write yydef_tbl"));
1389                 yytbl_data_destroy (yydef_tbl);
1390                 yydef_tbl = NULL;
1391         }
1392         /* End generating yy_def */
1393
1394
1395         /* Begin generating yy_nxt */
1396         out_str_dec ((total_states >= INT16_MAX || long_align) ?
1397                      get_int32_decl () : get_int16_decl (), "yy_nxt",
1398                      tblend + 1);
1399
1400         buf_prints (&yydmap_buf,
1401                     "\t{YYTD_ID_NXT, (void**)&yy_nxt, sizeof(%s)},\n",
1402                     (total_states >= INT16_MAX
1403                      || long_align) ? "flex_int32_t" : "flex_int16_t");
1404
1405         yynxt_tbl =
1406                 (struct yytbl_data *) calloc (1,
1407                                               sizeof (struct yytbl_data));
1408         yytbl_data_init (yynxt_tbl, YYTD_ID_NXT);
1409         yynxt_tbl->td_lolen = tblend + 1;
1410         yynxt_tbl->td_data = yynxt_data =
1411                 (flex_int32_t *) calloc (yynxt_tbl->td_lolen, sizeof (flex_int32_t));
1412
1413         for (i = 1; i <= tblend; ++i) {
1414                 /* Note, the order of the following test is important.
1415                  * If chk[i] is 0, then nxt[i] is undefined.
1416                  */
1417                 if (chk[i] == 0 || nxt[i] == 0)
1418                         nxt[i] = jamstate;      /* new state is the JAM state */
1419
1420                 mkdata (nxt[i]);
1421                 yynxt_data[i] = nxt[i];
1422         }
1423
1424         dataend ();
1425         if (tablesext) {
1426                 yytbl_data_compress (yynxt_tbl);
1427                 if (yytbl_data_fwrite (&tableswr, yynxt_tbl) < 0)
1428                         flexerror (_("Could not write yynxt_tbl"));
1429                 yytbl_data_destroy (yynxt_tbl);
1430                 yynxt_tbl = NULL;
1431         }
1432         /* End generating yy_nxt */
1433
1434         /* Begin generating yy_chk */
1435         out_str_dec ((total_states >= INT16_MAX || long_align) ?
1436                      get_int32_decl () : get_int16_decl (), "yy_chk",
1437                      tblend + 1);
1438
1439         buf_prints (&yydmap_buf,
1440                     "\t{YYTD_ID_CHK, (void**)&yy_chk, sizeof(%s)},\n",
1441                     (total_states >= INT16_MAX
1442                      || long_align) ? "flex_int32_t" : "flex_int16_t");
1443
1444         yychk_tbl =
1445                 (struct yytbl_data *) calloc (1,
1446                                               sizeof (struct yytbl_data));
1447         yytbl_data_init (yychk_tbl, YYTD_ID_CHK);
1448         yychk_tbl->td_lolen = tblend + 1;
1449         yychk_tbl->td_data = yychk_data =
1450                 (flex_int32_t *) calloc (yychk_tbl->td_lolen, sizeof (flex_int32_t));
1451
1452         for (i = 1; i <= tblend; ++i) {
1453                 if (chk[i] == 0)
1454                         ++nummt;
1455
1456                 mkdata (chk[i]);
1457                 yychk_data[i] = chk[i];
1458         }
1459
1460         dataend ();
1461         if (tablesext) {
1462                 yytbl_data_compress (yychk_tbl);
1463                 if (yytbl_data_fwrite (&tableswr, yychk_tbl) < 0)
1464                         flexerror (_("Could not write yychk_tbl"));
1465                 yytbl_data_destroy (yychk_tbl);
1466                 yychk_tbl = NULL;
1467         }
1468         /* End generating yy_chk */
1469
1470         flex_free ((void *) acc_array);
1471 }
1472
1473
1474 /* Write out a formatted string (with a secondary string argument) at the
1475  * current indentation level, adding a final newline.
1476  */
1477
1478 void indent_put2s (fmt, arg)
1479      const char *fmt, *arg;
1480 {
1481         do_indent ();
1482         out_str (fmt, arg);
1483         outn ("");
1484 }
1485
1486
1487 /* Write out a string at the current indentation level, adding a final
1488  * newline.
1489  */
1490
1491 void indent_puts (str)
1492      const char *str;
1493 {
1494         do_indent ();
1495         outn (str);
1496 }
1497
1498
1499 /* make_tables - generate transition tables and finishes generating output file
1500  */
1501
1502 void make_tables ()
1503 {
1504         register int i;
1505         int     did_eof_rule = false;
1506         struct yytbl_data *yynultrans_tbl;
1507
1508
1509         skelout ();             /* %% [2.0] - break point in skel */
1510
1511         /* First, take care of YY_DO_BEFORE_ACTION depending on yymore
1512          * being used.
1513          */
1514         set_indent (1);
1515
1516         if (yymore_used && !yytext_is_array) {
1517                 indent_puts ("YY_G(yytext_ptr) -= YY_G(yy_more_len); \\");
1518                 indent_puts
1519                         ("yyleng = (size_t) (yy_cp - YY_G(yytext_ptr)); \\");
1520         }
1521
1522         else
1523                 indent_puts ("yyleng = (size_t) (yy_cp - yy_bp); \\");
1524
1525         /* Now also deal with copying yytext_ptr to yytext if needed. */
1526         skelout ();             /* %% [3.0] - break point in skel */
1527         if (yytext_is_array) {
1528                 if (yymore_used)
1529                         indent_puts
1530                                 ("if ( yyleng + YY_G(yy_more_offset) >= YYLMAX ) \\");
1531                 else
1532                         indent_puts ("if ( yyleng >= YYLMAX ) \\");
1533
1534                 indent_up ();
1535                 indent_puts
1536                         ("YY_FATAL_ERROR( \"token too large, exceeds YYLMAX\" ); \\");
1537                 indent_down ();
1538
1539                 if (yymore_used) {
1540                         indent_puts
1541                                 ("yy_flex_strncpy( &yytext[YY_G(yy_more_offset)], YY_G(yytext_ptr), yyleng + 1 M4_YY_CALL_LAST_ARG); \\");
1542                         indent_puts ("yyleng += YY_G(yy_more_offset); \\");
1543                         indent_puts
1544                                 ("YY_G(yy_prev_more_offset) = YY_G(yy_more_offset); \\");
1545                         indent_puts ("YY_G(yy_more_offset) = 0; \\");
1546                 }
1547                 else {
1548                         indent_puts
1549                                 ("yy_flex_strncpy( yytext, YY_G(yytext_ptr), yyleng + 1 M4_YY_CALL_LAST_ARG); \\");
1550                 }
1551         }
1552
1553         set_indent (0);
1554
1555         skelout ();             /* %% [4.0] - break point in skel */
1556
1557
1558         /* This is where we REALLY begin generating the tables. */
1559
1560         out_dec ("#define YY_NUM_RULES %d\n", num_rules);
1561         out_dec ("#define YY_END_OF_BUFFER %d\n", num_rules + 1);
1562
1563         if (fullspd) {
1564                 /* Need to define the transet type as a size large
1565                  * enough to hold the biggest offset.
1566                  */
1567                 int     total_table_size = tblend + numecs + 1;
1568                 char   *trans_offset_type =
1569                         (total_table_size >= INT16_MAX || long_align) ?
1570                         "flex_int32_t" : "flex_int16_t";
1571
1572                 set_indent (0);
1573                 indent_puts ("struct yy_trans_info");
1574                 indent_up ();
1575                 indent_puts ("{");
1576
1577                 /* We require that yy_verify and yy_nxt must be of the same size int. */
1578                 indent_put2s ("%s yy_verify;", trans_offset_type);
1579
1580                 /* In cases where its sister yy_verify *is* a "yes, there is
1581                  * a transition", yy_nxt is the offset (in records) to the
1582                  * next state.  In most cases where there is no transition,
1583                  * the value of yy_nxt is irrelevant.  If yy_nxt is the -1th
1584                  * record of a state, though, then yy_nxt is the action number
1585                  * for that state.
1586                  */
1587
1588                 indent_put2s ("%s yy_nxt;", trans_offset_type);
1589                 indent_puts ("};");
1590                 indent_down ();
1591         }
1592         else {
1593                 /* We generate a bogus 'struct yy_trans_info' data type
1594                  * so we can guarantee that it is always declared in the skel.
1595                  * This is so we can compile "sizeof(struct yy_trans_info)"
1596                  * in any scanner.
1597                  */
1598                 indent_puts
1599                         ("/* This struct is not used in this scanner,");
1600                 indent_puts ("   but its presence is necessary. */");
1601                 indent_puts ("struct yy_trans_info");
1602                 indent_up ();
1603                 indent_puts ("{");
1604                 indent_puts ("flex_int32_t yy_verify;");
1605                 indent_puts ("flex_int32_t yy_nxt;");
1606                 indent_puts ("};");
1607                 indent_down ();
1608         }
1609
1610         if (fullspd) {
1611                 genctbl ();
1612                 if (tablesext) {
1613                         struct yytbl_data *tbl;
1614
1615                         tbl = mkctbl ();
1616                         yytbl_data_compress (tbl);
1617                         if (yytbl_data_fwrite (&tableswr, tbl) < 0)
1618                                 flexerror (_("Could not write ftbl"));
1619                         yytbl_data_destroy (tbl);
1620
1621                         tbl = mkssltbl ();
1622                         yytbl_data_compress (tbl);
1623                         if (yytbl_data_fwrite (&tableswr, tbl) < 0)
1624                                 flexerror (_("Could not write ssltbl"));
1625                         yytbl_data_destroy (tbl);
1626                         tbl = 0;
1627
1628                         if (useecs) {
1629                                 tbl = mkecstbl ();
1630                                 yytbl_data_compress (tbl);
1631                                 if (yytbl_data_fwrite (&tableswr, tbl) < 0)
1632                                         flexerror (_
1633                                                    ("Could not write ecstbl"));
1634                                 yytbl_data_destroy (tbl);
1635                                 tbl = 0;
1636                         }
1637                 }
1638         }
1639         else if (fulltbl) {
1640                 genftbl ();
1641                 if (tablesext) {
1642                         struct yytbl_data *tbl;
1643
1644                         tbl = mkftbl ();
1645                         yytbl_data_compress (tbl);
1646                         if (yytbl_data_fwrite (&tableswr, tbl) < 0)
1647                                 flexerror (_("Could not write ftbl"));
1648                         yytbl_data_destroy (tbl);
1649                         tbl = 0;
1650
1651                         if (useecs) {
1652                                 tbl = mkecstbl ();
1653                                 yytbl_data_compress (tbl);
1654                                 if (yytbl_data_fwrite (&tableswr, tbl) < 0)
1655                                         flexerror (_
1656                                                    ("Could not write ecstbl"));
1657                                 yytbl_data_destroy (tbl);
1658                                 tbl = 0;
1659                         }
1660                 }
1661         }
1662         else
1663                 gentabs ();
1664
1665         if (do_yylineno) {
1666
1667                 geneoltbl ();
1668
1669                 if (tablesext) {
1670                         struct yytbl_data *tbl;
1671
1672                         tbl = mkeoltbl ();
1673                         yytbl_data_compress (tbl);
1674                         if (yytbl_data_fwrite (&tableswr, tbl) < 0)
1675                                 flexerror (_("Could not write eoltbl"));
1676                         yytbl_data_destroy (tbl);
1677                         tbl = 0;
1678                 }
1679         }
1680
1681         /* Definitions for backing up.  We don't need them if REJECT
1682          * is being used because then we use an alternative backin-up
1683          * technique instead.
1684          */
1685         if (num_backing_up > 0 && !reject) {
1686                 if (!C_plus_plus && !reentrant) {
1687                         indent_puts
1688                                 ("static yy_state_type yy_last_accepting_state;");
1689                         indent_puts
1690                                 ("static char *yy_last_accepting_cpos;\n");
1691                 }
1692         }
1693
1694         if (nultrans) {
1695                 flex_int32_t *yynultrans_data = 0;
1696
1697                 /* Begin generating yy_NUL_trans */
1698                 out_str_dec (get_state_decl (), "yy_NUL_trans",
1699                              lastdfa + 1);
1700                 buf_prints (&yydmap_buf,
1701                             "\t{YYTD_ID_NUL_TRANS, (void**)&yy_NUL_trans, sizeof(%s)},\n",
1702                             (fullspd) ? "struct yy_trans_info*" :
1703                             "flex_int32_t");
1704
1705                 yynultrans_tbl =
1706                         (struct yytbl_data *) calloc (1,
1707                                                       sizeof (struct
1708                                                               yytbl_data));
1709                 yytbl_data_init (yynultrans_tbl, YYTD_ID_NUL_TRANS);
1710                 if (fullspd)
1711                         yynultrans_tbl->td_flags |= YYTD_PTRANS;
1712                 yynultrans_tbl->td_lolen = lastdfa + 1;
1713                 yynultrans_tbl->td_data = yynultrans_data =
1714                         (flex_int32_t *) calloc (yynultrans_tbl->td_lolen,
1715                                             sizeof (flex_int32_t));
1716
1717                 for (i = 1; i <= lastdfa; ++i) {
1718                         if (fullspd) {
1719                                 out_dec ("    &yy_transition[%d],\n",
1720                                          base[i]);
1721                                 yynultrans_data[i] = base[i];
1722                         }
1723                         else {
1724                                 mkdata (nultrans[i]);
1725                                 yynultrans_data[i] = nultrans[i];
1726                         }
1727                 }
1728
1729                 dataend ();
1730                 if (tablesext) {
1731                         yytbl_data_compress (yynultrans_tbl);
1732                         if (yytbl_data_fwrite (&tableswr, yynultrans_tbl) <
1733                             0)
1734                                 flexerror (_
1735                                            ("Could not write yynultrans_tbl"));
1736                         yytbl_data_destroy (yynultrans_tbl);
1737                         yynultrans_tbl = NULL;
1738                 }
1739                 /* End generating yy_NUL_trans */
1740         }
1741
1742         if (!C_plus_plus && !reentrant) {
1743                 indent_puts ("extern int yy_flex_debug;");
1744                 indent_put2s ("int yy_flex_debug = %s;\n",
1745                               ddebug ? "1" : "0");
1746         }
1747
1748         if (ddebug) {           /* Spit out table mapping rules to line numbers. */
1749                 out_str_dec (long_align ? get_int32_decl () :
1750                              get_int16_decl (), "yy_rule_linenum",
1751                              num_rules);
1752                 for (i = 1; i < num_rules; ++i)
1753                         mkdata (rule_linenum[i]);
1754                 dataend ();
1755         }
1756
1757         if (reject) {
1758                 outn ("m4_ifdef( [[M4_YY_USES_REJECT]],\n[[");
1759                 /* Declare state buffer variables. */
1760                 if (!C_plus_plus && !reentrant) {
1761                         outn ("static yy_state_type *yy_state_buf=0, *yy_state_ptr=0;");
1762                         outn ("static char *yy_full_match;");
1763                         outn ("static int yy_lp;");
1764                 }
1765
1766                 if (variable_trailing_context_rules) {
1767                         if (!C_plus_plus && !reentrant) {
1768                                 outn ("static int yy_looking_for_trail_begin = 0;");
1769                                 outn ("static int yy_full_lp;");
1770                                 outn ("static int *yy_full_state;");
1771                         }
1772
1773                         out_hex ("#define YY_TRAILING_MASK 0x%x\n",
1774                                  (unsigned int) YY_TRAILING_MASK);
1775                         out_hex ("#define YY_TRAILING_HEAD_MASK 0x%x\n",
1776                                  (unsigned int) YY_TRAILING_HEAD_MASK);
1777                 }
1778
1779                 outn ("#define REJECT \\");
1780                 outn ("{ \\");
1781                 outn ("*yy_cp = YY_G(yy_hold_char); /* undo effects of setting up yytext */ \\");
1782                 outn ("yy_cp = YY_G(yy_full_match); /* restore poss. backed-over text */ \\");
1783
1784                 if (variable_trailing_context_rules) {
1785                         outn ("YY_G(yy_lp) = YY_G(yy_full_lp); /* restore orig. accepting pos. */ \\");
1786                         outn ("YY_G(yy_state_ptr) = YY_G(yy_full_state); /* restore orig. state */ \\");
1787                         outn ("yy_current_state = *YY_G(yy_state_ptr); /* restore curr. state */ \\");
1788                 }
1789
1790                 outn ("++YY_G(yy_lp); \\");
1791                 outn ("goto find_rule; \\");
1792
1793                 outn ("}");
1794                 outn ("]])\n");
1795         }
1796
1797         else {
1798                 outn ("/* The intent behind this definition is that it'll catch");
1799                 outn (" * any uses of REJECT which flex missed.");
1800                 outn (" */");
1801                 outn ("#define REJECT reject_used_but_not_detected");
1802         }
1803
1804         if (yymore_used) {
1805                 if (!C_plus_plus) {
1806                         if (yytext_is_array) {
1807                                 if (!reentrant){
1808                                 indent_puts ("static int yy_more_offset = 0;");
1809                     indent_puts ("static int yy_prev_more_offset = 0;");
1810                 }
1811                         }
1812                         else if (!reentrant) {
1813                                 indent_puts
1814                                         ("static int yy_more_flag = 0;");
1815                                 indent_puts
1816                                         ("static int yy_more_len = 0;");
1817                         }
1818                 }
1819
1820                 if (yytext_is_array) {
1821                         indent_puts
1822                                 ("#define yymore() (YY_G(yy_more_offset) = yy_flex_strlen( yytext M4_YY_CALL_LAST_ARG))");
1823                         indent_puts ("#define YY_NEED_STRLEN");
1824                         indent_puts ("#define YY_MORE_ADJ 0");
1825                         indent_puts
1826                                 ("#define YY_RESTORE_YY_MORE_OFFSET \\");
1827                         indent_up ();
1828                         indent_puts ("{ \\");
1829                         indent_puts
1830                                 ("YY_G(yy_more_offset) = YY_G(yy_prev_more_offset); \\");
1831                         indent_puts ("yyleng -= YY_G(yy_more_offset); \\");
1832                         indent_puts ("}");
1833                         indent_down ();
1834                 }
1835                 else {
1836                         indent_puts
1837                                 ("#define yymore() (YY_G(yy_more_flag) = 1)");
1838                         indent_puts
1839                                 ("#define YY_MORE_ADJ YY_G(yy_more_len)");
1840                         indent_puts ("#define YY_RESTORE_YY_MORE_OFFSET");
1841                 }
1842         }
1843
1844         else {
1845                 indent_puts
1846                         ("#define yymore() yymore_used_but_not_detected");
1847                 indent_puts ("#define YY_MORE_ADJ 0");
1848                 indent_puts ("#define YY_RESTORE_YY_MORE_OFFSET");
1849         }
1850
1851         if (!C_plus_plus) {
1852                 if (yytext_is_array) {
1853                         outn ("#ifndef YYLMAX");
1854                         outn ("#define YYLMAX 8192");
1855                         outn ("#endif\n");
1856                         if (!reentrant){
1857                 outn ("char yytext[YYLMAX];");
1858                 outn ("char *yytext_ptr;");
1859             }
1860                 }
1861
1862                 else {
1863                         if(! reentrant)
1864                 outn ("char *yytext;");
1865                 }
1866         }
1867
1868         out (&action_array[defs1_offset]);
1869
1870         line_directive_out (stdout, 0);
1871
1872         skelout ();             /* %% [5.0] - break point in skel */
1873
1874         if (!C_plus_plus) {
1875                 if (use_read) {
1876                         outn ("\terrno=0; \\");
1877                         outn ("\twhile ( (result = read( fileno(yyin), (char *) buf, max_size )) < 0 ) \\");
1878                         outn ("\t{ \\");
1879                         outn ("\t\tif( errno != EINTR) \\");
1880                         outn ("\t\t{ \\");
1881                         outn ("\t\t\tYY_FATAL_ERROR( \"input in flex scanner failed\" ); \\");
1882                         outn ("\t\t\tbreak; \\");
1883                         outn ("\t\t} \\");
1884                         outn ("\t\terrno=0; \\");
1885                         outn ("\t\tclearerr(yyin); \\");
1886                         outn ("\t}\\");
1887                 }
1888
1889                 else {
1890                         outn ("\tif ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \\");
1891                         outn ("\t\t{ \\");
1892                         outn ("\t\tint c = '*'; \\");
1893                         outn ("\t\tsize_t n; \\");
1894                         outn ("\t\tfor ( n = 0; n < max_size && \\");
1895                         outn ("\t\t\t     (c = getc( yyin )) != EOF && c != '\\n'; ++n ) \\");
1896                         outn ("\t\t\tbuf[n] = (char) c; \\");
1897                         outn ("\t\tif ( c == '\\n' ) \\");
1898                         outn ("\t\t\tbuf[n++] = (char) c; \\");
1899                         outn ("\t\tif ( c == EOF && ferror( yyin ) ) \\");
1900                         outn ("\t\t\tYY_FATAL_ERROR( \"input in flex scanner failed\" ); \\");
1901                         outn ("\t\tresult = n; \\");
1902                         outn ("\t\t} \\");
1903                         outn ("\telse \\");
1904                         outn ("\t\t{ \\");
1905                         outn ("\t\terrno=0; \\");
1906                         outn ("\t\twhile ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \\");
1907                         outn ("\t\t\t{ \\");
1908                         outn ("\t\t\tif( errno != EINTR) \\");
1909                         outn ("\t\t\t\t{ \\");
1910                         outn ("\t\t\t\tYY_FATAL_ERROR( \"input in flex scanner failed\" ); \\");
1911                         outn ("\t\t\t\tbreak; \\");
1912                         outn ("\t\t\t\t} \\");
1913                         outn ("\t\t\terrno=0; \\");
1914                         outn ("\t\t\tclearerr(yyin); \\");
1915                         outn ("\t\t\t} \\");
1916                         outn ("\t\t}\\");
1917                 }
1918         }
1919
1920         skelout ();             /* %% [6.0] - break point in skel */
1921
1922         indent_puts ("#define YY_RULE_SETUP \\");
1923         indent_up ();
1924         if (bol_needed) {
1925                 indent_puts ("if ( yyleng > 0 ) \\");
1926                 indent_up ();
1927                 indent_puts ("YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \\");
1928                 indent_puts ("\t\t(yytext[yyleng - 1] == '\\n'); \\");
1929                 indent_down ();
1930         }
1931         indent_puts ("YY_USER_ACTION");
1932         indent_down ();
1933
1934         skelout ();             /* %% [7.0] - break point in skel */
1935
1936         /* Copy prolog to output file. */
1937         out (&action_array[prolog_offset]);
1938
1939         line_directive_out (stdout, 0);
1940
1941         skelout ();             /* %% [8.0] - break point in skel */
1942
1943         set_indent (2);
1944
1945         if (yymore_used && !yytext_is_array) {
1946                 indent_puts ("YY_G(yy_more_len) = 0;");
1947                 indent_puts ("if ( YY_G(yy_more_flag) )");
1948                 indent_up ();
1949                 indent_puts ("{");
1950                 indent_puts
1951                         ("YY_G(yy_more_len) = YY_G(yy_c_buf_p) - YY_G(yytext_ptr);");
1952                 indent_puts ("YY_G(yy_more_flag) = 0;");
1953                 indent_puts ("}");
1954                 indent_down ();
1955         }
1956
1957         skelout ();             /* %% [9.0] - break point in skel */
1958
1959         gen_start_state ();
1960
1961         /* Note, don't use any indentation. */
1962         outn ("yy_match:");
1963         gen_next_match ();
1964
1965         skelout ();             /* %% [10.0] - break point in skel */
1966         set_indent (2);
1967         gen_find_action ();
1968
1969         skelout ();             /* %% [11.0] - break point in skel */
1970         outn ("m4_ifdef( [[M4_YY_USE_LINENO]],[[");
1971         indent_puts
1972                 ("if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] )");
1973         indent_up ();
1974         indent_puts ("{");
1975         indent_puts ("int yyl;");
1976         do_indent ();
1977         out_str ("for ( yyl = %s; yyl < yyleng; ++yyl )\n",
1978                  yymore_used ? (yytext_is_array ? "YY_G(yy_prev_more_offset)" :
1979                                 "YY_G(yy_more_len)") : "0");
1980         indent_up ();
1981         indent_puts ("if ( yytext[yyl] == '\\n' )");
1982         indent_up ();
1983         indent_puts ("M4_YY_INCR_LINENO();");
1984         indent_down ();
1985         indent_down ();
1986         indent_puts ("}");
1987         indent_down ();
1988         outn ("]])");
1989
1990         skelout ();             /* %% [12.0] - break point in skel */
1991         if (ddebug) {
1992                 indent_puts ("if ( yy_flex_debug )");
1993                 indent_up ();
1994
1995                 indent_puts ("{");
1996                 indent_puts ("if ( yy_act == 0 )");
1997                 indent_up ();
1998                 indent_puts (C_plus_plus ?
1999                              "std::cerr << \"--scanner backing up\\n\";" :
2000                              "fprintf( stderr, \"--scanner backing up\\n\" );");
2001                 indent_down ();
2002
2003                 do_indent ();
2004                 out_dec ("else if ( yy_act < %d )\n", num_rules);
2005                 indent_up ();
2006
2007                 if (C_plus_plus) {
2008                         indent_puts
2009                                 ("std::cerr << \"--accepting rule at line \" << yy_rule_linenum[yy_act] <<");
2010                         indent_puts
2011                                 ("         \"(\\\"\" << yytext << \"\\\")\\n\";");
2012                 }
2013                 else {
2014                         indent_puts
2015                                 ("fprintf( stderr, \"--accepting rule at line %ld (\\\"%s\\\")\\n\",");
2016
2017                         indent_puts
2018                                 ("         (long)yy_rule_linenum[yy_act], yytext );");
2019                 }
2020
2021                 indent_down ();
2022
2023                 do_indent ();
2024                 out_dec ("else if ( yy_act == %d )\n", num_rules);
2025                 indent_up ();
2026
2027                 if (C_plus_plus) {
2028                         indent_puts
2029                                 ("std::cerr << \"--accepting default rule (\\\"\" << yytext << \"\\\")\\n\";");
2030                 }
2031                 else {
2032                         indent_puts
2033                                 ("fprintf( stderr, \"--accepting default rule (\\\"%s\\\")\\n\",");
2034                         indent_puts ("         yytext );");
2035                 }
2036
2037                 indent_down ();
2038
2039                 do_indent ();
2040                 out_dec ("else if ( yy_act == %d )\n", num_rules + 1);
2041                 indent_up ();
2042
2043                 indent_puts (C_plus_plus ?
2044                              "std::cerr << \"--(end of buffer or a NUL)\\n\";" :
2045                              "fprintf( stderr, \"--(end of buffer or a NUL)\\n\" );");
2046
2047                 indent_down ();
2048
2049                 do_indent ();
2050                 outn ("else");
2051                 indent_up ();
2052
2053                 if (C_plus_plus) {
2054                         indent_puts
2055                                 ("std::cerr << \"--EOF (start condition \" << YY_START << \")\\n\";");
2056                 }
2057                 else {
2058                         indent_puts
2059                                 ("fprintf( stderr, \"--EOF (start condition %d)\\n\", YY_START );");
2060                 }
2061
2062                 indent_down ();
2063
2064                 indent_puts ("}");
2065                 indent_down ();
2066         }
2067
2068         /* Copy actions to output file. */
2069         skelout ();             /* %% [13.0] - break point in skel */
2070         indent_up ();
2071         gen_bu_action ();
2072         out (&action_array[action_offset]);
2073
2074         line_directive_out (stdout, 0);
2075
2076         /* generate cases for any missing EOF rules */
2077         for (i = 1; i <= lastsc; ++i)
2078                 if (!sceof[i]) {
2079                         do_indent ();
2080                         out_str ("case YY_STATE_EOF(%s):\n", scname[i]);
2081                         did_eof_rule = true;
2082                 }
2083
2084         if (did_eof_rule) {
2085                 indent_up ();
2086                 indent_puts ("yyterminate();");
2087                 indent_down ();
2088         }
2089
2090
2091         /* Generate code for handling NUL's, if needed. */
2092
2093         /* First, deal with backing up and setting up yy_cp if the scanner
2094          * finds that it should JAM on the NUL.
2095          */
2096         skelout ();             /* %% [14.0] - break point in skel */
2097         set_indent (4);
2098
2099         if (fullspd || fulltbl)
2100                 indent_puts ("yy_cp = YY_G(yy_c_buf_p);");
2101
2102         else {                  /* compressed table */
2103                 if (!reject && !interactive) {
2104                         /* Do the guaranteed-needed backing up to figure
2105                          * out the match.
2106                          */
2107                         indent_puts
2108                                 ("yy_cp = YY_G(yy_last_accepting_cpos);");
2109                         indent_puts
2110                                 ("yy_current_state = YY_G(yy_last_accepting_state);");
2111                 }
2112
2113                 else
2114                         /* Still need to initialize yy_cp, though
2115                          * yy_current_state was set up by
2116                          * yy_get_previous_state().
2117                          */
2118                         indent_puts ("yy_cp = YY_G(yy_c_buf_p);");
2119         }
2120
2121
2122         /* Generate code for yy_get_previous_state(). */
2123         set_indent (1);
2124         skelout ();             /* %% [15.0] - break point in skel */
2125
2126         gen_start_state ();
2127
2128         set_indent (2);
2129         skelout ();             /* %% [16.0] - break point in skel */
2130         gen_next_state (true);
2131
2132         set_indent (1);
2133         skelout ();             /* %% [17.0] - break point in skel */
2134         gen_NUL_trans ();
2135
2136         skelout ();             /* %% [18.0] - break point in skel */
2137         skelout ();             /* %% [19.0] - break point in skel */
2138         /* Update BOL and yylineno inside of input(). */
2139         if (bol_needed) {
2140                 indent_puts
2141                         ("YY_CURRENT_BUFFER_LVALUE->yy_at_bol = (c == '\\n');");
2142                 if (do_yylineno) {
2143                         indent_puts
2144                                 ("if ( YY_CURRENT_BUFFER_LVALUE->yy_at_bol )");
2145                         indent_up ();
2146                         indent_puts ("M4_YY_INCR_LINENO();");
2147                         indent_down ();
2148                 }
2149         }
2150
2151         else if (do_yylineno) {
2152                 indent_puts ("if ( c == '\\n' )");
2153                 indent_up ();
2154                 indent_puts ("M4_YY_INCR_LINENO();");
2155                 indent_down ();
2156         }
2157
2158         skelout ();
2159
2160         /* Copy remainder of input to output. */
2161
2162         line_directive_out (stdout, 1);
2163
2164         if (sectnum == 3) {
2165                 OUT_BEGIN_CODE ();
2166                 (void) flexscan ();     /* copy remainder of input to output */
2167                 OUT_END_CODE ();
2168         }
2169 }