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 40void gen_next_state PROTO ((int)); 41void genecs PROTO ((void)); 42void indent_put2s PROTO ((const char *, const char *)); 43void indent_puts PROTO ((const char *)); 44 45 46static 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 58static 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 66static 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 73static 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 82void do_indent () 83{ 84 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 */ 101static 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. */ 124static void geneoltbl (void) 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 148void 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 169void 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 202static struct yytbl_data *mkctbl (void) 203{ 204 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 */ 304static 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 333void genctbl () 334{ 335 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 434static struct yytbl_data *mkecstbl (void) 435{ 436 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 463void genecs () 464{ 465 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 498void 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 ("goto find_rule; /* avoid `defined but not used' warning */"); 511 outn ("find_rule: /* we branch to this label when backing up */"); 512 513 indent_puts 514 ("for ( ; ; ) /* until we find what rule we matched */"); 515 516 indent_up (); 517 518 indent_puts ("{"); 519 520 indent_puts 521 ("if ( YY_G(yy_lp) && YY_G(yy_lp) < yy_accept[yy_current_state + 1] )"); 522 indent_up (); 523 indent_puts ("{"); 524 indent_puts ("yy_act = yy_acclist[YY_G(yy_lp)];"); 525 526 if (variable_trailing_context_rules) { 527 indent_puts 528 ("if ( yy_act & YY_TRAILING_HEAD_MASK ||"); 529 indent_puts (" YY_G(yy_looking_for_trail_begin) )"); 530 indent_up (); 531 indent_puts ("{"); 532 533 indent_puts 534 ("if ( yy_act == YY_G(yy_looking_for_trail_begin) )"); 535 indent_up (); 536 indent_puts ("{"); 537 indent_puts ("YY_G(yy_looking_for_trail_begin) = 0;"); 538 indent_puts ("yy_act &= ~YY_TRAILING_HEAD_MASK;"); 539 indent_puts ("break;"); 540 indent_puts ("}"); 541 indent_down (); 542 543 indent_puts ("}"); 544 indent_down (); 545 546 indent_puts 547 ("else if ( yy_act & YY_TRAILING_MASK )"); 548 indent_up (); 549 indent_puts ("{"); 550 indent_puts 551 ("YY_G(yy_looking_for_trail_begin) = yy_act & ~YY_TRAILING_MASK;"); 552 indent_puts 553 ("YY_G(yy_looking_for_trail_begin) |= YY_TRAILING_HEAD_MASK;"); 554 555 if (real_reject) { 556 /* Remember matched text in case we back up 557 * due to REJECT. 558 */ 559 indent_puts 560 ("YY_G(yy_full_match) = yy_cp;"); 561 indent_puts 562 ("YY_G(yy_full_state) = YY_G(yy_state_ptr);"); 563 indent_puts ("YY_G(yy_full_lp) = YY_G(yy_lp);"); 564 } 565 566 indent_puts ("}"); 567 indent_down (); 568 569 indent_puts ("else"); 570 indent_up (); 571 indent_puts ("{"); 572 indent_puts ("YY_G(yy_full_match) = yy_cp;"); 573 indent_puts 574 ("YY_G(yy_full_state) = YY_G(yy_state_ptr);"); 575 indent_puts ("YY_G(yy_full_lp) = YY_G(yy_lp);"); 576 indent_puts ("break;"); 577 indent_puts ("}"); 578 indent_down (); 579 580 indent_puts ("++YY_G(yy_lp);"); 581 indent_puts ("goto find_rule;"); 582 } 583 584 else { 585 /* Remember matched text in case we back up due to 586 * trailing context plus REJECT. 587 */ 588 indent_up (); 589 indent_puts ("{"); 590 indent_puts ("YY_G(yy_full_match) = yy_cp;"); 591 indent_puts ("break;"); 592 indent_puts ("}"); 593 indent_down (); 594 } 595 596 indent_puts ("}"); 597 indent_down (); 598 599 indent_puts ("--yy_cp;"); 600 601 /* We could consolidate the following two lines with those at 602 * the beginning, but at the cost of complaints that we're 603 * branching inside a loop. 604 */ 605 indent_puts ("yy_current_state = *--YY_G(yy_state_ptr);"); 606 indent_puts ("YY_G(yy_lp) = yy_accept[yy_current_state];"); 607 608 indent_puts ("}"); 609 610 indent_down (); 611 } 612 613 else { /* compressed */ 614 indent_puts ("yy_act = yy_accept[yy_current_state];"); 615 616 if (interactive && !reject) { 617 /* Do the guaranteed-needed backing up to figure out 618 * the match. 619 */ 620 indent_puts ("if ( yy_act == 0 )"); 621 indent_up (); 622 indent_puts ("{ /* have to back up */"); 623 indent_puts 624 ("yy_cp = YY_G(yy_last_accepting_cpos);"); 625 indent_puts 626 ("yy_current_state = YY_G(yy_last_accepting_state);"); 627 indent_puts 628 ("yy_act = yy_accept[yy_current_state];"); 629 indent_puts ("}"); 630 indent_down (); 631 } 632 } 633} 634 635/* mkftbl - make the full table and return the struct . 636 * you should call mkecstbl() after this. 637 */ 638 639struct yytbl_data *mkftbl (void) 640{ 641 int i; 642 int end_of_buffer_action = num_rules + 1; 643 struct yytbl_data *tbl; 644 flex_int32_t *tdata = 0; 645 646 tbl = (struct yytbl_data *) calloc (1, sizeof (struct yytbl_data)); 647 yytbl_data_init (tbl, YYTD_ID_ACCEPT); 648 tbl->td_flags |= YYTD_DATA32; 649 tbl->td_hilen = 0; /* it's a one-dimensional array */ 650 tbl->td_lolen = lastdfa + 1; 651 652 tbl->td_data = tdata = 653 (flex_int32_t *) calloc (tbl->td_lolen, sizeof (flex_int32_t)); 654 655 dfaacc[end_of_buffer_state].dfaacc_state = end_of_buffer_action; 656 657 for (i = 1; i <= lastdfa; ++i) { 658 int anum = dfaacc[i].dfaacc_state; 659 660 tdata[i] = anum; 661 662 if (trace && anum) 663 fprintf (stderr, _("state # %d accepts: [%d]\n"), 664 i, anum); 665 } 666 667 buf_prints (&yydmap_buf, 668 "\t{YYTD_ID_ACCEPT, (void**)&yy_accept, sizeof(%s)},\n", 669 long_align ? "flex_int32_t" : "flex_int16_t"); 670 return tbl; 671} 672 673 674/* genftbl - generate full transition table */ 675 676void genftbl () 677{ 678 int i; 679 int end_of_buffer_action = num_rules + 1; 680 681 out_str_dec (long_align ? get_int32_decl () : get_int16_decl (), 682 "yy_accept", lastdfa + 1); 683 684 dfaacc[end_of_buffer_state].dfaacc_state = end_of_buffer_action; 685 686 for (i = 1; i <= lastdfa; ++i) { 687 int anum = dfaacc[i].dfaacc_state; 688 689 mkdata (anum); 690 691 if (trace && anum) 692 fprintf (stderr, _("state # %d accepts: [%d]\n"), 693 i, anum); 694 } 695 696 dataend (); 697 698 if (useecs) 699 genecs (); 700 701 /* Don't have to dump the actual full table entries - they were 702 * created on-the-fly. 703 */ 704} 705 706 707/* Generate the code to find the next compressed-table state. */ 708 709void gen_next_compressed_state (char_map) 710 char *char_map; 711{ 712 indent_put2s ("YY_CHAR yy_c = %s;", char_map); 713 714 /* Save the backing-up info \before/ computing the next state 715 * because we always compute one more state than needed - we 716 * always proceed until we reach a jam state 717 */ 718 gen_backing_up (); 719 720 indent_puts 721 ("while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )"); 722 indent_up (); 723 indent_puts ("{"); 724 indent_puts ("yy_current_state = (int) yy_def[yy_current_state];"); 725 726 if (usemecs) { 727 /* We've arrange it so that templates are never chained 728 * to one another. This means we can afford to make a 729 * very simple test to see if we need to convert to 730 * yy_c's meta-equivalence class without worrying 731 * about erroneously looking up the meta-equivalence 732 * class twice 733 */ 734 do_indent (); 735 736 /* lastdfa + 2 is the beginning of the templates */ 737 out_dec ("if ( yy_current_state >= %d )\n", lastdfa + 2); 738 739 indent_up (); 740 indent_puts ("yy_c = yy_meta[(unsigned int) yy_c];"); 741 indent_down (); 742 } 743 744 indent_puts ("}"); 745 indent_down (); 746 747 indent_puts 748 ("yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];"); 749} 750 751 752/* Generate the code to find the next match. */ 753 754void gen_next_match () 755{ 756 /* NOTE - changes in here should be reflected in gen_next_state() and 757 * gen_NUL_trans(). 758 */ 759 char *char_map = useecs ? 760 "yy_ec[YY_SC_TO_UI(*yy_cp)] " : "YY_SC_TO_UI(*yy_cp)"; 761 762 char *char_map_2 = useecs ? 763 "yy_ec[YY_SC_TO_UI(*++yy_cp)] " : "YY_SC_TO_UI(*++yy_cp)"; 764 765 if (fulltbl) { 766 if (gentables) 767 indent_put2s 768 ("while ( (yy_current_state = yy_nxt[yy_current_state][ %s ]) > 0 )", 769 char_map); 770 else 771 indent_put2s 772 ("while ( (yy_current_state = yy_nxt[yy_current_state*YY_NXT_LOLEN + %s ]) > 0 )", 773 char_map); 774 775 indent_up (); 776 777 if (num_backing_up > 0) { 778 indent_puts ("{"); 779 gen_backing_up (); 780 outc ('\n'); 781 } 782 783 indent_puts ("++yy_cp;"); 784 785 if (num_backing_up > 0) 786 787 indent_puts ("}"); 788 789 indent_down (); 790 791 outc ('\n'); 792 indent_puts ("yy_current_state = -yy_current_state;"); 793 } 794 795 else if (fullspd) { 796 indent_puts ("{"); 797 indent_puts 798 ("yyconst struct yy_trans_info *yy_trans_info;\n"); 799 indent_puts ("YY_CHAR yy_c;\n"); 800 indent_put2s ("for ( yy_c = %s;", char_map); 801 indent_puts 802 (" (yy_trans_info = &yy_current_state[(unsigned int) yy_c])->"); 803 indent_puts ("yy_verify == yy_c;"); 804 indent_put2s (" yy_c = %s )", char_map_2); 805 806 indent_up (); 807 808 if (num_backing_up > 0) 809 indent_puts ("{"); 810 811 indent_puts ("yy_current_state += yy_trans_info->yy_nxt;"); 812 813 if (num_backing_up > 0) { 814 outc ('\n'); 815 gen_backing_up (); 816 indent_puts ("}"); 817 } 818 819 indent_down (); 820 indent_puts ("}"); 821 } 822 823 else { /* compressed */ 824 indent_puts ("do"); 825 826 indent_up (); 827 indent_puts ("{"); 828 829 gen_next_state (false); 830 831 indent_puts ("++yy_cp;"); 832 833 834 indent_puts ("}"); 835 indent_down (); 836 837 do_indent (); 838 839 if (interactive) 840 out_dec ("while ( yy_base[yy_current_state] != %d );\n", jambase); 841 else 842 out_dec ("while ( yy_current_state != %d );\n", 843 jamstate); 844 845 if (!reject && !interactive) { 846 /* Do the guaranteed-needed backing up to figure out 847 * the match. 848 */ 849 indent_puts 850 ("yy_cp = YY_G(yy_last_accepting_cpos);"); 851 indent_puts 852 ("yy_current_state = YY_G(yy_last_accepting_state);"); 853 } 854 } 855} 856 857 858/* Generate the code to find the next state. */ 859 860void gen_next_state (worry_about_NULs) 861 int worry_about_NULs; 862{ /* NOTE - changes in here should be reflected in gen_next_match() */ 863 char char_map[256]; 864 865 if (worry_about_NULs && !nultrans) { 866 if (useecs) 867 snprintf (char_map, sizeof(char_map), 868 "(*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : %d)", 869 NUL_ec); 870 else 871 snprintf (char_map, sizeof(char_map), 872 "(*yy_cp ? YY_SC_TO_UI(*yy_cp) : %d)", 873 NUL_ec); 874 } 875 876 else 877 strcpy (char_map, useecs ? 878 "yy_ec[YY_SC_TO_UI(*yy_cp)] " : 879 "YY_SC_TO_UI(*yy_cp)"); 880 881 if (worry_about_NULs && nultrans) { 882 if (!fulltbl && !fullspd) 883 /* Compressed tables back up *before* they match. */ 884 gen_backing_up (); 885 886 indent_puts ("if ( *yy_cp )"); 887 indent_up (); 888 indent_puts ("{"); 889 } 890 891 if (fulltbl) { 892 if (gentables) 893 indent_put2s 894 ("yy_current_state = yy_nxt[yy_current_state][%s];", 895 char_map); 896 else 897 indent_put2s 898 ("yy_current_state = yy_nxt[yy_current_state*YY_NXT_LOLEN + %s];", 899 char_map); 900 } 901 902 else if (fullspd) 903 indent_put2s 904 ("yy_current_state += yy_current_state[%s].yy_nxt;", 905 char_map); 906 907 else 908 gen_next_compressed_state (char_map); 909 910 if (worry_about_NULs && nultrans) { 911 912 indent_puts ("}"); 913 indent_down (); 914 indent_puts ("else"); 915 indent_up (); 916 indent_puts 917 ("yy_current_state = yy_NUL_trans[yy_current_state];"); 918 indent_down (); 919 } 920 921 if (fullspd || fulltbl) 922 gen_backing_up (); 923 924 if (reject) 925 indent_puts ("*YY_G(yy_state_ptr)++ = yy_current_state;"); 926} 927 928 929/* Generate the code to make a NUL transition. */ 930 931void gen_NUL_trans () 932{ /* NOTE - changes in here should be reflected in gen_next_match() */ 933 /* Only generate a definition for "yy_cp" if we'll generate code 934 * that uses it. Otherwise lint and the like complain. 935 */ 936 int need_backing_up = (num_backing_up > 0 && !reject); 937 938 if (need_backing_up && (!nultrans || fullspd || fulltbl)) 939 /* We're going to need yy_cp lying around for the call 940 * below to gen_backing_up(). 941 */ 942 indent_puts ("char *yy_cp = YY_G(yy_c_buf_p);"); 943 944 outc ('\n'); 945 946 if (nultrans) { 947 indent_puts 948 ("yy_current_state = yy_NUL_trans[yy_current_state];"); 949 indent_puts ("yy_is_jam = (yy_current_state == 0);"); 950 } 951 952 else if (fulltbl) { 953 do_indent (); 954 if (gentables) 955 out_dec ("yy_current_state = yy_nxt[yy_current_state][%d];\n", NUL_ec); 956 else 957 out_dec ("yy_current_state = yy_nxt[yy_current_state*YY_NXT_LOLEN + %d];\n", NUL_ec); 958 indent_puts ("yy_is_jam = (yy_current_state <= 0);"); 959 } 960 961 else if (fullspd) { 962 do_indent (); 963 out_dec ("int yy_c = %d;\n", NUL_ec); 964 965 indent_puts 966 ("yyconst struct yy_trans_info *yy_trans_info;\n"); 967 indent_puts 968 ("yy_trans_info = &yy_current_state[(unsigned int) yy_c];"); 969 indent_puts ("yy_current_state += yy_trans_info->yy_nxt;"); 970 971 indent_puts 972 ("yy_is_jam = (yy_trans_info->yy_verify != yy_c);"); 973 } 974 975 else { 976 char NUL_ec_str[20]; 977 978 snprintf (NUL_ec_str, sizeof(NUL_ec_str), "%d", NUL_ec); 979 gen_next_compressed_state (NUL_ec_str); 980 981 do_indent (); 982 out_dec ("yy_is_jam = (yy_current_state == %d);\n", 983 jamstate); 984 985 if (reject) { 986 /* Only stack this state if it's a transition we 987 * actually make. If we stack it on a jam, then 988 * the state stack and yy_c_buf_p get out of sync. 989 */ 990 indent_puts ("if ( ! yy_is_jam )"); 991 indent_up (); 992 indent_puts 993 ("*YY_G(yy_state_ptr)++ = yy_current_state;"); 994 indent_down (); 995 } 996 } 997 998 /* If we've entered an accepting state, back up; note that 999 * compressed tables have *already* done such backing up, so 1000 * we needn't bother with it again. 1001 */ 1002 if (need_backing_up && (fullspd || fulltbl)) { 1003 outc ('\n'); 1004 indent_puts ("if ( ! yy_is_jam )"); 1005 indent_up (); 1006 indent_puts ("{"); 1007 gen_backing_up (); 1008 indent_puts ("}"); 1009 indent_down (); 1010 } 1011} 1012 1013 1014/* Generate the code to find the start state. */ 1015 1016void gen_start_state () 1017{ 1018 if (fullspd) { 1019 if (bol_needed) { 1020 indent_puts 1021 ("yy_current_state = yy_start_state_list[YY_G(yy_start) + YY_AT_BOL()];"); 1022 } 1023 else 1024 indent_puts 1025 ("yy_current_state = yy_start_state_list[YY_G(yy_start)];"); 1026 } 1027 1028 else { 1029 indent_puts ("yy_current_state = YY_G(yy_start);"); 1030 1031 if (bol_needed) 1032 indent_puts ("yy_current_state += YY_AT_BOL();"); 1033 1034 if (reject) { 1035 /* Set up for storing up states. */ 1036 outn ("m4_ifdef( [[M4_YY_USES_REJECT]],\n[["); 1037 indent_puts 1038 ("YY_G(yy_state_ptr) = YY_G(yy_state_buf);"); 1039 indent_puts 1040 ("*YY_G(yy_state_ptr)++ = yy_current_state;"); 1041 outn ("]])"); 1042 } 1043 } 1044} 1045 1046 1047/* gentabs - generate data statements for the transition tables */ 1048 1049void gentabs () 1050{ 1051 int i, j, k, *accset, nacc, *acc_array, total_states; 1052 int end_of_buffer_action = num_rules + 1; 1053 struct yytbl_data *yyacc_tbl = 0, *yymeta_tbl = 0, *yybase_tbl = 0, 1054 *yydef_tbl = 0, *yynxt_tbl = 0, *yychk_tbl = 0, *yyacclist_tbl=0; 1055 flex_int32_t *yyacc_data = 0, *yybase_data = 0, *yydef_data = 0, 1056 *yynxt_data = 0, *yychk_data = 0, *yyacclist_data=0; 1057 flex_int32_t yybase_curr = 0, yyacclist_curr=0,yyacc_curr=0; 1058 1059 acc_array = allocate_integer_array (current_max_dfas); 1060 nummt = 0; 1061 1062 /* The compressed table format jams by entering the "jam state", 1063 * losing information about the previous state in the process. 1064 * In order to recover the previous state, we effectively need 1065 * to keep backing-up information. 1066 */ 1067 ++num_backing_up; 1068 1069 if (reject) { 1070 /* Write out accepting list and pointer list. 1071 1072 * First we generate the "yy_acclist" array. In the process, 1073 * we compute the indices that will go into the "yy_accept" 1074 * array, and save the indices in the dfaacc array. 1075 */ 1076 int EOB_accepting_list[2]; 1077 1078 /* Set up accepting structures for the End Of Buffer state. */ 1079 EOB_accepting_list[0] = 0; 1080 EOB_accepting_list[1] = end_of_buffer_action; 1081 accsiz[end_of_buffer_state] = 1; 1082 dfaacc[end_of_buffer_state].dfaacc_set = 1083 EOB_accepting_list; 1084 1085 out_str_dec (long_align ? get_int32_decl () : 1086 get_int16_decl (), "yy_acclist", MAX (numas, 1087 1) + 1); 1088 1089 buf_prints (&yydmap_buf, 1090 "\t{YYTD_ID_ACCLIST, (void**)&yy_acclist, sizeof(%s)},\n", 1091 long_align ? "flex_int32_t" : "flex_int16_t"); 1092 1093 yyacclist_tbl = (struct yytbl_data*)calloc(1,sizeof(struct yytbl_data)); 1094 yytbl_data_init (yyacclist_tbl, YYTD_ID_ACCLIST); 1095 yyacclist_tbl->td_lolen = MAX(numas,1) + 1; 1096 yyacclist_tbl->td_data = yyacclist_data = 1097 (flex_int32_t *) calloc (yyacclist_tbl->td_lolen, sizeof (flex_int32_t)); 1098 yyacclist_curr = 1; 1099 1100 j = 1; /* index into "yy_acclist" array */ 1101 1102 for (i = 1; i <= lastdfa; ++i) { 1103 acc_array[i] = j; 1104 1105 if (accsiz[i] != 0) { 1106 accset = dfaacc[i].dfaacc_set; 1107 nacc = accsiz[i]; 1108 1109 if (trace) 1110 fprintf (stderr, 1111 _("state # %d accepts: "), 1112 i); 1113 1114 for (k = 1; k <= nacc; ++k) { 1115 int accnum = accset[k]; 1116 1117 ++j; 1118 1119 if (variable_trailing_context_rules 1120 && !(accnum & 1121 YY_TRAILING_HEAD_MASK) 1122 && accnum > 0 1123 && accnum <= num_rules 1124 && rule_type[accnum] == 1125 RULE_VARIABLE) { 1126 /* Special hack to flag 1127 * accepting number as part 1128 * of trailing context rule. 1129 */ 1130 accnum |= YY_TRAILING_MASK; 1131 } 1132 1133 mkdata (accnum); 1134 yyacclist_data[yyacclist_curr++] = accnum; 1135 1136 if (trace) { 1137 fprintf (stderr, "[%d]", 1138 accset[k]); 1139 1140 if (k < nacc) 1141 fputs (", ", 1142 stderr); 1143 else 1144 putc ('\n', 1145 stderr); 1146 } 1147 } 1148 } 1149 } 1150 1151 /* add accepting number for the "jam" state */ 1152 acc_array[i] = j; 1153 1154 dataend (); 1155 if (tablesext) { 1156 yytbl_data_compress (yyacclist_tbl); 1157 if (yytbl_data_fwrite (&tableswr, yyacclist_tbl) < 0) 1158 flexerror (_("Could not write yyacclist_tbl")); 1159 yytbl_data_destroy (yyacclist_tbl); 1160 yyacclist_tbl = NULL; 1161 } 1162 } 1163 1164 else { 1165 dfaacc[end_of_buffer_state].dfaacc_state = 1166 end_of_buffer_action; 1167 1168 for (i = 1; i <= lastdfa; ++i) 1169 acc_array[i] = dfaacc[i].dfaacc_state; 1170 1171 /* add accepting number for jam state */ 1172 acc_array[i] = 0; 1173 } 1174 1175 /* Begin generating yy_accept */ 1176 1177 /* Spit out "yy_accept" array. If we're doing "reject", it'll be 1178 * pointers into the "yy_acclist" array. Otherwise it's actual 1179 * accepting numbers. In either case, we just dump the numbers. 1180 */ 1181 1182 /* "lastdfa + 2" is the size of "yy_accept"; includes room for C arrays 1183 * beginning at 0 and for "jam" state. 1184 */ 1185 k = lastdfa + 2; 1186 1187 if (reject) 1188 /* We put a "cap" on the table associating lists of accepting 1189 * numbers with state numbers. This is needed because we tell 1190 * where the end of an accepting list is by looking at where 1191 * the list for the next state starts. 1192 */ 1193 ++k; 1194 1195 out_str_dec (long_align ? get_int32_decl () : get_int16_decl (), 1196 "yy_accept", k); 1197 1198 buf_prints (&yydmap_buf, 1199 "\t{YYTD_ID_ACCEPT, (void**)&yy_accept, sizeof(%s)},\n", 1200 long_align ? "flex_int32_t" : "flex_int16_t"); 1201 1202 yyacc_tbl = 1203 (struct yytbl_data *) calloc (1, 1204 sizeof (struct yytbl_data)); 1205 yytbl_data_init (yyacc_tbl, YYTD_ID_ACCEPT); 1206 yyacc_tbl->td_lolen = k; 1207 yyacc_tbl->td_data = yyacc_data = 1208 (flex_int32_t *) calloc (yyacc_tbl->td_lolen, sizeof (flex_int32_t)); 1209 yyacc_curr=1; 1210 1211 for (i = 1; i <= lastdfa; ++i) { 1212 mkdata (acc_array[i]); 1213 yyacc_data[yyacc_curr++] = acc_array[i]; 1214 1215 if (!reject && trace && acc_array[i]) 1216 fprintf (stderr, _("state # %d accepts: [%d]\n"), 1217 i, acc_array[i]); 1218 } 1219 1220 /* Add entry for "jam" state. */ 1221 mkdata (acc_array[i]); 1222 yyacc_data[yyacc_curr++] = acc_array[i]; 1223 1224 if (reject) { 1225 /* Add "cap" for the list. */ 1226 mkdata (acc_array[i]); 1227 yyacc_data[yyacc_curr++] = acc_array[i]; 1228 } 1229 1230 dataend (); 1231 if (tablesext) { 1232 yytbl_data_compress (yyacc_tbl); 1233 if (yytbl_data_fwrite (&tableswr, yyacc_tbl) < 0) 1234 flexerror (_("Could not write yyacc_tbl")); 1235 yytbl_data_destroy (yyacc_tbl); 1236 yyacc_tbl = NULL; 1237 } 1238 /* End generating yy_accept */ 1239 1240 if (useecs) { 1241 1242 genecs (); 1243 if (tablesext) { 1244 struct yytbl_data *tbl; 1245 1246 tbl = mkecstbl (); 1247 yytbl_data_compress (tbl); 1248 if (yytbl_data_fwrite (&tableswr, tbl) < 0) 1249 flexerror (_("Could not write ecstbl")); 1250 yytbl_data_destroy (tbl); 1251 tbl = 0; 1252 } 1253 } 1254 1255 if (usemecs) { 1256 /* Begin generating yy_meta */ 1257 /* Write out meta-equivalence classes (used to index 1258 * templates with). 1259 */ 1260 flex_int32_t *yymecs_data = 0; 1261 yymeta_tbl = 1262 (struct yytbl_data *) calloc (1, 1263 sizeof (struct 1264 yytbl_data)); 1265 yytbl_data_init (yymeta_tbl, YYTD_ID_META); 1266 yymeta_tbl->td_lolen = numecs + 1; 1267 yymeta_tbl->td_data = yymecs_data = 1268 (flex_int32_t *) calloc (yymeta_tbl->td_lolen, 1269 sizeof (flex_int32_t)); 1270 1271 if (trace) 1272 fputs (_("\n\nMeta-Equivalence Classes:\n"), 1273 stderr); 1274 1275 out_str_dec (get_int32_decl (), "yy_meta", numecs + 1); 1276 buf_prints (&yydmap_buf, 1277 "\t{YYTD_ID_META, (void**)&yy_meta, sizeof(%s)},\n", 1278 "flex_int32_t"); 1279 1280 for (i = 1; i <= numecs; ++i) { 1281 if (trace) 1282 fprintf (stderr, "%d = %d\n", 1283 i, ABS (tecbck[i])); 1284 1285 mkdata (ABS (tecbck[i])); 1286 yymecs_data[i] = ABS (tecbck[i]); 1287 } 1288 1289 dataend (); 1290 if (tablesext) { 1291 yytbl_data_compress (yymeta_tbl); 1292 if (yytbl_data_fwrite (&tableswr, yymeta_tbl) < 0) 1293 flexerror (_ 1294 ("Could not write yymeta_tbl")); 1295 yytbl_data_destroy (yymeta_tbl); 1296 yymeta_tbl = NULL; 1297 } 1298 /* End generating yy_meta */ 1299 } 1300 1301 total_states = lastdfa + numtemps; 1302 1303 /* Begin generating yy_base */ 1304 out_str_dec ((tblend >= INT16_MAX || long_align) ? 1305 get_int32_decl () : get_int16_decl (), 1306 "yy_base", total_states + 1); 1307 1308 buf_prints (&yydmap_buf, 1309 "\t{YYTD_ID_BASE, (void**)&yy_base, sizeof(%s)},\n", 1310 (tblend >= INT16_MAX 1311 || long_align) ? "flex_int32_t" : "flex_int16_t"); 1312 yybase_tbl = 1313 (struct yytbl_data *) calloc (1, 1314 sizeof (struct yytbl_data)); 1315 yytbl_data_init (yybase_tbl, YYTD_ID_BASE); 1316 yybase_tbl->td_lolen = total_states + 1; 1317 yybase_tbl->td_data = yybase_data = 1318 (flex_int32_t *) calloc (yybase_tbl->td_lolen, 1319 sizeof (flex_int32_t)); 1320 yybase_curr = 1; 1321 1322 for (i = 1; i <= lastdfa; ++i) { 1323 int d = def[i]; 1324 1325 if (base[i] == JAMSTATE) 1326 base[i] = jambase; 1327 1328 if (d == JAMSTATE) 1329 def[i] = jamstate; 1330 1331 else if (d < 0) { 1332 /* Template reference. */ 1333 ++tmpuses; 1334 def[i] = lastdfa - d + 1; 1335 } 1336 1337 mkdata (base[i]); 1338 yybase_data[yybase_curr++] = base[i]; 1339 } 1340 1341 /* Generate jam state's base index. */ 1342 mkdata (base[i]); 1343 yybase_data[yybase_curr++] = base[i]; 1344 1345 for (++i /* skip jam state */ ; i <= total_states; ++i) { 1346 mkdata (base[i]); 1347 yybase_data[yybase_curr++] = base[i]; 1348 def[i] = jamstate; 1349 } 1350 1351 dataend (); 1352 if (tablesext) { 1353 yytbl_data_compress (yybase_tbl); 1354 if (yytbl_data_fwrite (&tableswr, yybase_tbl) < 0) 1355 flexerror (_("Could not write yybase_tbl")); 1356 yytbl_data_destroy (yybase_tbl); 1357 yybase_tbl = NULL; 1358 } 1359 /* End generating yy_base */ 1360 1361 1362 /* Begin generating yy_def */ 1363 out_str_dec ((total_states >= INT16_MAX || long_align) ? 1364 get_int32_decl () : get_int16_decl (), 1365 "yy_def", total_states + 1); 1366 1367 buf_prints (&yydmap_buf, 1368 "\t{YYTD_ID_DEF, (void**)&yy_def, sizeof(%s)},\n", 1369 (total_states >= INT16_MAX 1370 || long_align) ? "flex_int32_t" : "flex_int16_t"); 1371 1372 yydef_tbl = 1373 (struct yytbl_data *) calloc (1, 1374 sizeof (struct yytbl_data)); 1375 yytbl_data_init (yydef_tbl, YYTD_ID_DEF); 1376 yydef_tbl->td_lolen = total_states + 1; 1377 yydef_tbl->td_data = yydef_data = 1378 (flex_int32_t *) calloc (yydef_tbl->td_lolen, sizeof (flex_int32_t)); 1379 1380 for (i = 1; i <= total_states; ++i) { 1381 mkdata (def[i]); 1382 yydef_data[i] = def[i]; 1383 } 1384 1385 dataend (); 1386 if (tablesext) { 1387 yytbl_data_compress (yydef_tbl); 1388 if (yytbl_data_fwrite (&tableswr, yydef_tbl) < 0) 1389 flexerror (_("Could not write yydef_tbl")); 1390 yytbl_data_destroy (yydef_tbl); 1391 yydef_tbl = NULL; 1392 } 1393 /* End generating yy_def */ 1394 1395 1396 /* Begin generating yy_nxt */ 1397 out_str_dec ((total_states >= INT16_MAX || long_align) ? 1398 get_int32_decl () : get_int16_decl (), "yy_nxt", 1399 tblend + 1); 1400 1401 buf_prints (&yydmap_buf, 1402 "\t{YYTD_ID_NXT, (void**)&yy_nxt, sizeof(%s)},\n", 1403 (total_states >= INT16_MAX 1404 || long_align) ? "flex_int32_t" : "flex_int16_t"); 1405 1406 yynxt_tbl = 1407 (struct yytbl_data *) calloc (1, 1408 sizeof (struct yytbl_data)); 1409 yytbl_data_init (yynxt_tbl, YYTD_ID_NXT); 1410 yynxt_tbl->td_lolen = tblend + 1; 1411 yynxt_tbl->td_data = yynxt_data = 1412 (flex_int32_t *) calloc (yynxt_tbl->td_lolen, sizeof (flex_int32_t)); 1413 1414 for (i = 1; i <= tblend; ++i) { 1415 /* Note, the order of the following test is important. 1416 * If chk[i] is 0, then nxt[i] is undefined. 1417 */ 1418 if (chk[i] == 0 || nxt[i] == 0) 1419 nxt[i] = jamstate; /* new state is the JAM state */ 1420 1421 mkdata (nxt[i]); 1422 yynxt_data[i] = nxt[i]; 1423 } 1424 1425 dataend (); 1426 if (tablesext) { 1427 yytbl_data_compress (yynxt_tbl); 1428 if (yytbl_data_fwrite (&tableswr, yynxt_tbl) < 0) 1429 flexerror (_("Could not write yynxt_tbl")); 1430 yytbl_data_destroy (yynxt_tbl); 1431 yynxt_tbl = NULL; 1432 } 1433 /* End generating yy_nxt */ 1434 1435 /* Begin generating yy_chk */ 1436 out_str_dec ((total_states >= INT16_MAX || long_align) ? 1437 get_int32_decl () : get_int16_decl (), "yy_chk", 1438 tblend + 1); 1439 1440 buf_prints (&yydmap_buf, 1441 "\t{YYTD_ID_CHK, (void**)&yy_chk, sizeof(%s)},\n", 1442 (total_states >= INT16_MAX 1443 || long_align) ? "flex_int32_t" : "flex_int16_t"); 1444 1445 yychk_tbl = 1446 (struct yytbl_data *) calloc (1, 1447 sizeof (struct yytbl_data)); 1448 yytbl_data_init (yychk_tbl, YYTD_ID_CHK); 1449 yychk_tbl->td_lolen = tblend + 1; 1450 yychk_tbl->td_data = yychk_data = 1451 (flex_int32_t *) calloc (yychk_tbl->td_lolen, sizeof (flex_int32_t)); 1452 1453 for (i = 1; i <= tblend; ++i) { 1454 if (chk[i] == 0) 1455 ++nummt; 1456 1457 mkdata (chk[i]); 1458 yychk_data[i] = chk[i]; 1459 } 1460 1461 dataend (); 1462 if (tablesext) { 1463 yytbl_data_compress (yychk_tbl); 1464 if (yytbl_data_fwrite (&tableswr, yychk_tbl) < 0) 1465 flexerror (_("Could not write yychk_tbl")); 1466 yytbl_data_destroy (yychk_tbl); 1467 yychk_tbl = NULL; 1468 } 1469 /* End generating yy_chk */ 1470 1471 flex_free ((void *) acc_array); 1472} 1473 1474 1475/* Write out a formatted string (with a secondary string argument) at the 1476 * current indentation level, adding a final newline. 1477 */ 1478 1479void indent_put2s (fmt, arg) 1480 const char *fmt, *arg; 1481{ 1482 do_indent (); 1483 out_str (fmt, arg); 1484 outn (""); 1485} 1486 1487 1488/* Write out a string at the current indentation level, adding a final 1489 * newline. 1490 */ 1491 1492void indent_puts (str) 1493 const char *str; 1494{ 1495 do_indent (); 1496 outn (str); 1497} 1498 1499 1500/* make_tables - generate transition tables and finishes generating output file 1501 */ 1502 1503void make_tables () 1504{ 1505 int i; 1506 int did_eof_rule = false; 1507 struct yytbl_data *yynultrans_tbl; 1508 1509 1510 skelout (); /* %% [2.0] - break point in skel */ 1511 1512 /* First, take care of YY_DO_BEFORE_ACTION depending on yymore 1513 * being used. 1514 */ 1515 set_indent (1); 1516 1517 if (yymore_used && !yytext_is_array) { 1518 indent_puts ("YY_G(yytext_ptr) -= YY_G(yy_more_len); \\"); 1519 indent_puts 1520 ("yyleng = (size_t) (yy_cp - YY_G(yytext_ptr)); \\"); 1521 } 1522 1523 else 1524 indent_puts ("yyleng = (size_t) (yy_cp - yy_bp); \\"); 1525 1526 /* Now also deal with copying yytext_ptr to yytext if needed. */ 1527 skelout (); /* %% [3.0] - break point in skel */ 1528 if (yytext_is_array) { 1529 if (yymore_used) 1530 indent_puts 1531 ("if ( yyleng + YY_G(yy_more_offset) >= YYLMAX ) \\"); 1532 else 1533 indent_puts ("if ( yyleng >= YYLMAX ) \\"); 1534 1535 indent_up (); 1536 indent_puts 1537 ("YY_FATAL_ERROR( \"token too large, exceeds YYLMAX\" ); \\"); 1538 indent_down (); 1539 1540 if (yymore_used) { 1541 indent_puts 1542 ("yy_flex_strncpy( &yytext[YY_G(yy_more_offset)], YY_G(yytext_ptr), yyleng + 1 M4_YY_CALL_LAST_ARG); \\"); 1543 indent_puts ("yyleng += YY_G(yy_more_offset); \\"); 1544 indent_puts 1545 ("YY_G(yy_prev_more_offset) = YY_G(yy_more_offset); \\"); 1546 indent_puts ("YY_G(yy_more_offset) = 0; \\"); 1547 } 1548 else { 1549 indent_puts 1550 ("yy_flex_strncpy( yytext, YY_G(yytext_ptr), yyleng + 1 M4_YY_CALL_LAST_ARG); \\"); 1551 } 1552 } 1553 1554 set_indent (0); 1555 1556 skelout (); /* %% [4.0] - break point in skel */ 1557 1558 1559 /* This is where we REALLY begin generating the tables. */ 1560 1561 out_dec ("#define YY_NUM_RULES %d\n", num_rules); 1562 out_dec ("#define YY_END_OF_BUFFER %d\n", num_rules + 1); 1563 1564 if (fullspd) { 1565 /* Need to define the transet type as a size large 1566 * enough to hold the biggest offset. 1567 */ 1568 int total_table_size = tblend + numecs + 1; 1569 char *trans_offset_type = 1570 (total_table_size >= INT16_MAX || long_align) ? 1571 "flex_int32_t" : "flex_int16_t"; 1572 1573 set_indent (0); 1574 indent_puts ("struct yy_trans_info"); 1575 indent_up (); 1576 indent_puts ("{"); 1577 1578 /* We require that yy_verify and yy_nxt must be of the same size int. */ 1579 indent_put2s ("%s yy_verify;", trans_offset_type); 1580 1581 /* In cases where its sister yy_verify *is* a "yes, there is 1582 * a transition", yy_nxt is the offset (in records) to the 1583 * next state. In most cases where there is no transition, 1584 * the value of yy_nxt is irrelevant. If yy_nxt is the -1th 1585 * record of a state, though, then yy_nxt is the action number 1586 * for that state. 1587 */ 1588 1589 indent_put2s ("%s yy_nxt;", trans_offset_type); 1590 indent_puts ("};"); 1591 indent_down (); 1592 } 1593 else { 1594 /* We generate a bogus 'struct yy_trans_info' data type 1595 * so we can guarantee that it is always declared in the skel. 1596 * This is so we can compile "sizeof(struct yy_trans_info)" 1597 * in any scanner. 1598 */ 1599 indent_puts 1600 ("/* This struct is not used in this scanner,"); 1601 indent_puts (" but its presence is necessary. */"); 1602 indent_puts ("struct yy_trans_info"); 1603 indent_up (); 1604 indent_puts ("{"); 1605 indent_puts ("flex_int32_t yy_verify;"); 1606 indent_puts ("flex_int32_t yy_nxt;"); 1607 indent_puts ("};"); 1608 indent_down (); 1609 } 1610 1611 if (fullspd) { 1612 genctbl (); 1613 if (tablesext) { 1614 struct yytbl_data *tbl; 1615 1616 tbl = mkctbl (); 1617 yytbl_data_compress (tbl); 1618 if (yytbl_data_fwrite (&tableswr, tbl) < 0) 1619 flexerror (_("Could not write ftbl")); 1620 yytbl_data_destroy (tbl); 1621 1622 tbl = mkssltbl (); 1623 yytbl_data_compress (tbl); 1624 if (yytbl_data_fwrite (&tableswr, tbl) < 0) 1625 flexerror (_("Could not write ssltbl")); 1626 yytbl_data_destroy (tbl); 1627 tbl = 0; 1628 1629 if (useecs) { 1630 tbl = mkecstbl (); 1631 yytbl_data_compress (tbl); 1632 if (yytbl_data_fwrite (&tableswr, tbl) < 0) 1633 flexerror (_ 1634 ("Could not write ecstbl")); 1635 yytbl_data_destroy (tbl); 1636 tbl = 0; 1637 } 1638 } 1639 } 1640 else if (fulltbl) { 1641 genftbl (); 1642 if (tablesext) { 1643 struct yytbl_data *tbl; 1644 1645 tbl = mkftbl (); 1646 yytbl_data_compress (tbl); 1647 if (yytbl_data_fwrite (&tableswr, tbl) < 0) 1648 flexerror (_("Could not write ftbl")); 1649 yytbl_data_destroy (tbl); 1650 tbl = 0; 1651 1652 if (useecs) { 1653 tbl = mkecstbl (); 1654 yytbl_data_compress (tbl); 1655 if (yytbl_data_fwrite (&tableswr, tbl) < 0) 1656 flexerror (_ 1657 ("Could not write ecstbl")); 1658 yytbl_data_destroy (tbl); 1659 tbl = 0; 1660 } 1661 } 1662 } 1663 else 1664 gentabs (); 1665 1666 if (do_yylineno) { 1667 1668 geneoltbl (); 1669 1670 if (tablesext) { 1671 struct yytbl_data *tbl; 1672 1673 tbl = mkeoltbl (); 1674 yytbl_data_compress (tbl); 1675 if (yytbl_data_fwrite (&tableswr, tbl) < 0) 1676 flexerror (_("Could not write eoltbl")); 1677 yytbl_data_destroy (tbl); 1678 tbl = 0; 1679 } 1680 } 1681 1682 /* Definitions for backing up. We don't need them if REJECT 1683 * is being used because then we use an alternative backin-up 1684 * technique instead. 1685 */ 1686 if (num_backing_up > 0 && !reject) { 1687 if (!C_plus_plus && !reentrant) { 1688 indent_puts 1689 ("static yy_state_type yy_last_accepting_state;"); 1690 indent_puts 1691 ("static char *yy_last_accepting_cpos;\n"); 1692 } 1693 } 1694 1695 if (nultrans) { 1696 flex_int32_t *yynultrans_data = 0; 1697 1698 /* Begin generating yy_NUL_trans */ 1699 out_str_dec (get_state_decl (), "yy_NUL_trans", 1700 lastdfa + 1); 1701 buf_prints (&yydmap_buf, 1702 "\t{YYTD_ID_NUL_TRANS, (void**)&yy_NUL_trans, sizeof(%s)},\n", 1703 (fullspd) ? "struct yy_trans_info*" : 1704 "flex_int32_t"); 1705 1706 yynultrans_tbl = 1707 (struct yytbl_data *) calloc (1, 1708 sizeof (struct 1709 yytbl_data)); 1710 yytbl_data_init (yynultrans_tbl, YYTD_ID_NUL_TRANS); 1711 if (fullspd) 1712 yynultrans_tbl->td_flags |= YYTD_PTRANS; 1713 yynultrans_tbl->td_lolen = lastdfa + 1; 1714 yynultrans_tbl->td_data = yynultrans_data = 1715 (flex_int32_t *) calloc (yynultrans_tbl->td_lolen, 1716 sizeof (flex_int32_t)); 1717 1718 for (i = 1; i <= lastdfa; ++i) { 1719 if (fullspd) { 1720 out_dec (" &yy_transition[%d],\n", 1721 base[i]); 1722 yynultrans_data[i] = base[i]; 1723 } 1724 else { 1725 mkdata (nultrans[i]); 1726 yynultrans_data[i] = nultrans[i]; 1727 } 1728 } 1729 1730 dataend (); 1731 if (tablesext) { 1732 yytbl_data_compress (yynultrans_tbl); 1733 if (yytbl_data_fwrite (&tableswr, yynultrans_tbl) < 1734 0) 1735 flexerror (_ 1736 ("Could not write yynultrans_tbl")); 1737 yytbl_data_destroy (yynultrans_tbl); 1738 yynultrans_tbl = NULL; 1739 } 1740 /* End generating yy_NUL_trans */ 1741 } 1742 1743 if (!C_plus_plus && !reentrant) { 1744 indent_puts ("extern int yy_flex_debug;"); 1745 indent_put2s ("int yy_flex_debug = %s;\n", 1746 ddebug ? "1" : "0"); 1747 } 1748 1749 if (ddebug) { /* Spit out table mapping rules to line numbers. */ 1750 out_str_dec (long_align ? get_int32_decl () : 1751 get_int16_decl (), "yy_rule_linenum", 1752 num_rules); 1753 for (i = 1; i < num_rules; ++i) 1754 mkdata (rule_linenum[i]); 1755 dataend (); 1756 } 1757 1758 if (reject) { 1759 outn ("m4_ifdef( [[M4_YY_USES_REJECT]],\n[["); 1760 /* Declare state buffer variables. */ 1761 if (!C_plus_plus && !reentrant) { 1762 outn ("static yy_state_type *yy_state_buf=0, *yy_state_ptr=0;"); 1763 outn ("static char *yy_full_match;"); 1764 outn ("static int yy_lp;"); 1765 } 1766 1767 if (variable_trailing_context_rules) { 1768 if (!C_plus_plus && !reentrant) { 1769 outn ("static int yy_looking_for_trail_begin = 0;"); 1770 outn ("static int yy_full_lp;"); 1771 outn ("static int *yy_full_state;"); 1772 } 1773 1774 out_hex ("#define YY_TRAILING_MASK 0x%x\n", 1775 (unsigned int) YY_TRAILING_MASK); 1776 out_hex ("#define YY_TRAILING_HEAD_MASK 0x%x\n", 1777 (unsigned int) YY_TRAILING_HEAD_MASK); 1778 } 1779 1780 outn ("#define REJECT \\"); 1781 outn ("{ \\"); 1782 outn ("*yy_cp = YY_G(yy_hold_char); /* undo effects of setting up yytext */ \\"); 1783 outn ("yy_cp = YY_G(yy_full_match); /* restore poss. backed-over text */ \\"); 1784 1785 if (variable_trailing_context_rules) { 1786 outn ("YY_G(yy_lp) = YY_G(yy_full_lp); /* restore orig. accepting pos. */ \\"); 1787 outn ("YY_G(yy_state_ptr) = YY_G(yy_full_state); /* restore orig. state */ \\"); 1788 outn ("yy_current_state = *YY_G(yy_state_ptr); /* restore curr. state */ \\"); 1789 } 1790 1791 outn ("++YY_G(yy_lp); \\"); 1792 outn ("goto find_rule; \\"); 1793 1794 outn ("}"); 1795 outn ("]])\n"); 1796 } 1797 1798 else { 1799 outn ("/* The intent behind this definition is that it'll catch"); 1800 outn (" * any uses of REJECT which flex missed."); 1801 outn (" */"); 1802 outn ("#define REJECT reject_used_but_not_detected"); 1803 } 1804 1805 if (yymore_used) { 1806 if (!C_plus_plus) { 1807 if (yytext_is_array) { 1808 if (!reentrant){ 1809 indent_puts ("static int yy_more_offset = 0;"); 1810 indent_puts ("static int yy_prev_more_offset = 0;"); 1811 } 1812 } 1813 else if (!reentrant) { 1814 indent_puts 1815 ("static int yy_more_flag = 0;"); 1816 indent_puts 1817 ("static int yy_more_len = 0;"); 1818 } 1819 } 1820 1821 if (yytext_is_array) { 1822 indent_puts 1823 ("#define yymore() (YY_G(yy_more_offset) = yy_flex_strlen( yytext M4_YY_CALL_LAST_ARG))"); 1824 indent_puts ("#define YY_NEED_STRLEN"); 1825 indent_puts ("#define YY_MORE_ADJ 0"); 1826 indent_puts 1827 ("#define YY_RESTORE_YY_MORE_OFFSET \\"); 1828 indent_up (); 1829 indent_puts ("{ \\"); 1830 indent_puts 1831 ("YY_G(yy_more_offset) = YY_G(yy_prev_more_offset); \\"); 1832 indent_puts ("yyleng -= YY_G(yy_more_offset); \\"); 1833 indent_puts ("}"); 1834 indent_down (); 1835 } 1836 else { 1837 indent_puts 1838 ("#define yymore() (YY_G(yy_more_flag) = 1)"); 1839 indent_puts 1840 ("#define YY_MORE_ADJ YY_G(yy_more_len)"); 1841 indent_puts ("#define YY_RESTORE_YY_MORE_OFFSET"); 1842 } 1843 } 1844 1845 else { 1846 indent_puts 1847 ("#define yymore() yymore_used_but_not_detected"); 1848 indent_puts ("#define YY_MORE_ADJ 0"); 1849 indent_puts ("#define YY_RESTORE_YY_MORE_OFFSET"); 1850 } 1851 1852 if (!C_plus_plus) { 1853 if (yytext_is_array) { 1854 outn ("#ifndef YYLMAX"); 1855 outn ("#define YYLMAX 8192"); 1856 outn ("#endif\n"); 1857 if (!reentrant){ 1858 outn ("char yytext[YYLMAX];"); 1859 outn ("char *yytext_ptr;"); 1860 } 1861 } 1862 1863 else { 1864 if(! reentrant) 1865 outn ("char *yytext;"); 1866 } 1867 } 1868 1869 out (&action_array[defs1_offset]); 1870 1871 line_directive_out (stdout, 0); 1872 1873 skelout (); /* %% [5.0] - break point in skel */ 1874 1875 if (!C_plus_plus) { 1876 if (use_read) { 1877 outn ("\terrno=0; \\"); 1878 outn ("\twhile ( (result = read( fileno(yyin), (char *) buf, max_size )) < 0 ) \\"); 1879 outn ("\t{ \\"); 1880 outn ("\t\tif( errno != EINTR) \\"); 1881 outn ("\t\t{ \\"); 1882 outn ("\t\t\tYY_FATAL_ERROR( \"input in flex scanner failed\" ); \\"); 1883 outn ("\t\t\tbreak; \\"); 1884 outn ("\t\t} \\"); 1885 outn ("\t\terrno=0; \\"); 1886 outn ("\t\tclearerr(yyin); \\"); 1887 outn ("\t}\\"); 1888 } 1889 1890 else { 1891 outn ("\tif ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \\"); 1892 outn ("\t\t{ \\"); 1893 outn ("\t\tint c = '*'; \\"); 1894 outn ("\t\tsize_t n; \\"); 1895 outn ("\t\tfor ( n = 0; n < max_size && \\"); 1896 outn ("\t\t\t (c = getc( yyin )) != EOF && c != '\\n'; ++n ) \\"); 1897 outn ("\t\t\tbuf[n] = (char) c; \\"); 1898 outn ("\t\tif ( c == '\\n' ) \\"); 1899 outn ("\t\t\tbuf[n++] = (char) c; \\"); 1900 outn ("\t\tif ( c == EOF && ferror( yyin ) ) \\"); 1901 outn ("\t\t\tYY_FATAL_ERROR( \"input in flex scanner failed\" ); \\"); 1902 outn ("\t\tresult = n; \\"); 1903 outn ("\t\t} \\"); 1904 outn ("\telse \\"); 1905 outn ("\t\t{ \\"); 1906 outn ("\t\terrno=0; \\"); 1907 outn ("\t\twhile ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \\"); 1908 outn ("\t\t\t{ \\"); 1909 outn ("\t\t\tif( errno != EINTR) \\"); 1910 outn ("\t\t\t\t{ \\"); 1911 outn ("\t\t\t\tYY_FATAL_ERROR( \"input in flex scanner failed\" ); \\"); 1912 outn ("\t\t\t\tbreak; \\"); 1913 outn ("\t\t\t\t} \\"); 1914 outn ("\t\t\terrno=0; \\"); 1915 outn ("\t\t\tclearerr(yyin); \\"); 1916 outn ("\t\t\t} \\"); 1917 outn ("\t\t}\\"); 1918 } 1919 } 1920 1921 skelout (); /* %% [6.0] - break point in skel */ 1922 1923 indent_puts ("#define YY_RULE_SETUP \\"); 1924 indent_up (); 1925 if (bol_needed) { 1926 indent_puts ("if ( yyleng > 0 ) \\"); 1927 indent_up (); 1928 indent_puts ("YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \\"); 1929 indent_puts ("\t\t(yytext[yyleng - 1] == '\\n'); \\"); 1930 indent_down (); 1931 } 1932 indent_puts ("YY_USER_ACTION"); 1933 indent_down (); 1934 1935 skelout (); /* %% [7.0] - break point in skel */ 1936 1937 /* Copy prolog to output file. */ 1938 out (&action_array[prolog_offset]); 1939 1940 line_directive_out (stdout, 0); 1941 1942 skelout (); /* %% [8.0] - break point in skel */ 1943 1944 set_indent (2); 1945 1946 if (yymore_used && !yytext_is_array) { 1947 indent_puts ("YY_G(yy_more_len) = 0;"); 1948 indent_puts ("if ( YY_G(yy_more_flag) )"); 1949 indent_up (); 1950 indent_puts ("{"); 1951 indent_puts 1952 ("YY_G(yy_more_len) = YY_G(yy_c_buf_p) - YY_G(yytext_ptr);"); 1953 indent_puts ("YY_G(yy_more_flag) = 0;"); 1954 indent_puts ("}"); 1955 indent_down (); 1956 } 1957 1958 skelout (); /* %% [9.0] - break point in skel */ 1959 1960 gen_start_state (); 1961 1962 /* Note, don't use any indentation. */ 1963 outn ("yy_match:"); 1964 gen_next_match (); 1965 1966 skelout (); /* %% [10.0] - break point in skel */ 1967 set_indent (2); 1968 gen_find_action (); 1969 1970 skelout (); /* %% [11.0] - break point in skel */ 1971 outn ("m4_ifdef( [[M4_YY_USE_LINENO]],[["); 1972 indent_puts 1973 ("if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] )"); 1974 indent_up (); 1975 indent_puts ("{"); 1976 indent_puts ("yy_size_t yyl;"); 1977 do_indent (); 1978 out_str ("for ( yyl = %s; yyl < yyleng; ++yyl )\n", 1979 yymore_used ? (yytext_is_array ? "YY_G(yy_prev_more_offset)" : 1980 "YY_G(yy_more_len)") : "0"); 1981 indent_up (); 1982 indent_puts ("if ( yytext[yyl] == '\\n' )"); 1983 indent_up (); 1984 indent_puts ("M4_YY_INCR_LINENO();"); 1985 indent_down (); 1986 indent_down (); 1987 indent_puts ("}"); 1988 indent_down (); 1989 outn ("]])"); 1990 1991 skelout (); /* %% [12.0] - break point in skel */ 1992 if (ddebug) { 1993 indent_puts ("if ( yy_flex_debug )"); 1994 indent_up (); 1995 1996 indent_puts ("{"); 1997 indent_puts ("if ( yy_act == 0 )"); 1998 indent_up (); 1999 indent_puts (C_plus_plus ? 2000 "std::cerr << \"--scanner backing up\\n\";" : 2001 "fprintf( stderr, \"--scanner backing up\\n\" );"); 2002 indent_down (); 2003 2004 do_indent (); 2005 out_dec ("else if ( yy_act < %d )\n", num_rules); 2006 indent_up (); 2007 2008 if (C_plus_plus) { 2009 indent_puts 2010 ("std::cerr << \"--accepting rule at line \" << yy_rule_linenum[yy_act] <<"); 2011 indent_puts 2012 (" \"(\\\"\" << yytext << \"\\\")\\n\";"); 2013 } 2014 else { 2015 indent_puts 2016 ("fprintf( stderr, \"--accepting rule at line %ld (\\\"%s\\\")\\n\","); 2017 2018 indent_puts 2019 (" (long)yy_rule_linenum[yy_act], yytext );"); 2020 } 2021 2022 indent_down (); 2023 2024 do_indent (); 2025 out_dec ("else if ( yy_act == %d )\n", num_rules); 2026 indent_up (); 2027 2028 if (C_plus_plus) { 2029 indent_puts 2030 ("std::cerr << \"--accepting default rule (\\\"\" << yytext << \"\\\")\\n\";"); 2031 } 2032 else { 2033 indent_puts 2034 ("fprintf( stderr, \"--accepting default rule (\\\"%s\\\")\\n\","); 2035 indent_puts (" yytext );"); 2036 } 2037 2038 indent_down (); 2039 2040 do_indent (); 2041 out_dec ("else if ( yy_act == %d )\n", num_rules + 1); 2042 indent_up (); 2043 2044 indent_puts (C_plus_plus ? 2045 "std::cerr << \"--(end of buffer or a NUL)\\n\";" : 2046 "fprintf( stderr, \"--(end of buffer or a NUL)\\n\" );"); 2047 2048 indent_down (); 2049 2050 do_indent (); 2051 outn ("else"); 2052 indent_up (); 2053 2054 if (C_plus_plus) { 2055 indent_puts 2056 ("std::cerr << \"--EOF (start condition \" << YY_START << \")\\n\";"); 2057 } 2058 else { 2059 indent_puts 2060 ("fprintf( stderr, \"--EOF (start condition %d)\\n\", YY_START );"); 2061 } 2062 2063 indent_down (); 2064 2065 indent_puts ("}"); 2066 indent_down (); 2067 } 2068 2069 /* Copy actions to output file. */ 2070 skelout (); /* %% [13.0] - break point in skel */ 2071 indent_up (); 2072 gen_bu_action (); 2073 out (&action_array[action_offset]); 2074 2075 line_directive_out (stdout, 0); 2076 2077 /* generate cases for any missing EOF rules */ 2078 for (i = 1; i <= lastsc; ++i) 2079 if (!sceof[i]) { 2080 do_indent (); 2081 out_str ("case YY_STATE_EOF(%s):\n", scname[i]); 2082 did_eof_rule = true; 2083 } 2084 2085 if (did_eof_rule) { 2086 indent_up (); 2087 indent_puts ("yyterminate();"); 2088 indent_down (); 2089 } 2090 2091 2092 /* Generate code for handling NUL's, if needed. */ 2093 2094 /* First, deal with backing up and setting up yy_cp if the scanner 2095 * finds that it should JAM on the NUL. 2096 */ 2097 skelout (); /* %% [14.0] - break point in skel */ 2098 set_indent (4); 2099 2100 if (fullspd || fulltbl) 2101 indent_puts ("yy_cp = YY_G(yy_c_buf_p);"); 2102 2103 else { /* compressed table */ 2104 if (!reject && !interactive) { 2105 /* Do the guaranteed-needed backing up to figure 2106 * out the match. 2107 */ 2108 indent_puts 2109 ("yy_cp = YY_G(yy_last_accepting_cpos);"); 2110 indent_puts 2111 ("yy_current_state = YY_G(yy_last_accepting_state);"); 2112 } 2113 2114 else 2115 /* Still need to initialize yy_cp, though 2116 * yy_current_state was set up by 2117 * yy_get_previous_state(). 2118 */ 2119 indent_puts ("yy_cp = YY_G(yy_c_buf_p);"); 2120 } 2121 2122 2123 /* Generate code for yy_get_previous_state(). */ 2124 set_indent (1); 2125 skelout (); /* %% [15.0] - break point in skel */ 2126 2127 gen_start_state (); 2128 2129 set_indent (2); 2130 skelout (); /* %% [16.0] - break point in skel */ 2131 gen_next_state (true); 2132 2133 set_indent (1); 2134 skelout (); /* %% [17.0] - break point in skel */ 2135 gen_NUL_trans (); 2136 2137 skelout (); /* %% [18.0] - break point in skel */ 2138 skelout (); /* %% [19.0] - break point in skel */ 2139 /* Update BOL and yylineno inside of input(). */ 2140 if (bol_needed) { 2141 indent_puts 2142 ("YY_CURRENT_BUFFER_LVALUE->yy_at_bol = (c == '\\n');"); 2143 if (do_yylineno) { 2144 indent_puts 2145 ("if ( YY_CURRENT_BUFFER_LVALUE->yy_at_bol )"); 2146 indent_up (); 2147 indent_puts ("M4_YY_INCR_LINENO();"); 2148 indent_down (); 2149 } 2150 } 2151 2152 else if (do_yylineno) { 2153 indent_puts ("if ( c == '\\n' )"); 2154 indent_up (); 2155 indent_puts ("M4_YY_INCR_LINENO();"); 2156 indent_down (); 2157 } 2158 2159 skelout (); 2160 2161 /* Copy remainder of input to output. */ 2162 2163 line_directive_out (stdout, 1); 2164 2165 if (sectnum == 3) { 2166 OUT_BEGIN_CODE (); 2167 (void) flexscan (); /* copy remainder of input to output */ 2168 OUT_END_CODE (); 2169 } 2170} 2171