1 /* $OpenBSD: main.c,v 1.14 2014/03/16 18:38:30 guenther Exp $ */ 2 3 /* flex - tool to generate fast lexical analyzers */ 4 5 /*- 6 * Copyright (c) 1990 The Regents of the University of California. 7 * All rights reserved. 8 * 9 * This code is derived from software contributed to Berkeley by 10 * Vern Paxson. 11 * 12 * The United States Government has rights in this work pursuant 13 * to contract no. DE-AC03-76SF00098 between the United States 14 * Department of Energy and the University of California. 15 * 16 * Redistribution and use in source and binary forms, with or without 17 * modification, are permitted provided that the following conditions 18 * are met: 19 * 20 * 1. Redistributions of source code must retain the above copyright 21 * notice, this list of conditions and the following disclaimer. 22 * 2. Redistributions in binary form must reproduce the above copyright 23 * notice, this list of conditions and the following disclaimer in the 24 * documentation and/or other materials provided with the distribution. 25 * 26 * Neither the name of the University nor the names of its contributors 27 * may be used to endorse or promote products derived from this software 28 * without specific prior written permission. 29 * 30 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR 31 * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED 32 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 33 * PURPOSE. 34 */ 35 36 /* $Header: /home/cvs/src/usr.bin/lex/main.c,v 1.14 2014/03/16 18:38:30 guenther Exp $ */ 37 38 39 #include "flexdef.h" 40 #include "version.h" 41 42 static char flex_version[] = FLEX_VERSION; 43 44 45 /* declare functions that have forward references */ 46 47 void flexinit PROTO((int, char**)); 48 void readin PROTO((void)); 49 void set_up_initial_allocations PROTO((void)); 50 51 #ifdef NEED_ARGV_FIXUP 52 extern void argv_fixup PROTO((int *, char ***)); 53 #endif 54 55 56 /* these globals are all defined and commented in flexdef.h */ 57 int printstats, syntaxerror, eofseen, ddebug, trace, nowarn, spprdflt; 58 int interactive, caseins, lex_compat, do_yylineno, useecs, fulltbl, usemecs; 59 int fullspd, gen_line_dirs, performance_report, backing_up_report; 60 int C_plus_plus, long_align, use_read, yytext_is_array, do_yywrap, csize; 61 int yymore_used, reject, real_reject, continued_action, in_rule; 62 int yymore_really_used, reject_really_used; 63 int datapos, dataline, linenum, out_linenum; 64 FILE *skelfile = NULL; 65 int skel_ind = 0; 66 char *action_array; 67 int action_size, defs1_offset, prolog_offset, action_offset, action_index; 68 char *infilename = NULL, *outfilename = NULL; 69 int did_outfilename; 70 char *prefix, *yyclass; 71 int do_stdinit, use_stdout; 72 int onestate[ONE_STACK_SIZE], onesym[ONE_STACK_SIZE]; 73 int onenext[ONE_STACK_SIZE], onedef[ONE_STACK_SIZE], onesp; 74 int current_mns, current_max_rules; 75 int num_rules, num_eof_rules, default_rule, lastnfa; 76 int *firstst, *lastst, *finalst, *transchar, *trans1, *trans2; 77 int *accptnum, *assoc_rule, *state_type; 78 int *rule_type, *rule_linenum, *rule_useful; 79 int current_state_type; 80 int variable_trailing_context_rules; 81 int numtemps, numprots, protprev[MSP], protnext[MSP], prottbl[MSP]; 82 int protcomst[MSP], firstprot, lastprot, protsave[PROT_SAVE_SIZE]; 83 int numecs, nextecm[CSIZE + 1], ecgroup[CSIZE + 1], nummecs, tecfwd[CSIZE + 1]; 84 int tecbck[CSIZE + 1]; 85 int lastsc, *scset, *scbol, *scxclu, *sceof; 86 int current_max_scs; 87 char **scname; 88 int current_max_dfa_size, current_max_xpairs; 89 int current_max_template_xpairs, current_max_dfas; 90 int lastdfa, *nxt, *chk, *tnxt; 91 int *base, *def, *nultrans, NUL_ec, tblend, firstfree, **dss, *dfasiz; 92 union dfaacc_union *dfaacc; 93 int *accsiz, *dhash, numas; 94 int numsnpairs, jambase, jamstate; 95 int lastccl, *cclmap, *ccllen, *cclng, cclreuse; 96 int current_maxccls, current_max_ccl_tbl_size; 97 Char *ccltbl; 98 char nmstr[MAXLINE]; 99 int sectnum, nummt, hshcol, dfaeql, numeps, eps2, num_reallocs; 100 int tmpuses, totnst, peakpairs, numuniq, numdup, hshsave; 101 int num_backing_up, bol_needed; 102 FILE *backing_up_file; 103 int end_of_buffer_state; 104 char **input_files; 105 int num_input_files; 106 107 /* Make sure program_name is initialized so we don't crash if writing 108 * out an error message before getting the program name from argv[0]. 109 */ 110 char *program_name = "flex"; 111 112 #ifndef SHORT_FILE_NAMES 113 static const char outfile_template[] = "lex.%s.%s"; 114 static const char backing_name[] = "lex.backup"; 115 #else 116 static const char outfile_template[] = "lex%s.%s"; 117 static const char backing_name[] = "lex.bck"; 118 #endif 119 120 #ifdef THINK_C 121 #include <console.h> 122 #endif 123 124 #ifdef MS_DOS 125 extern unsigned _stklen = 16384; 126 #endif 127 128 static char outfile_path[MAXLINE]; 129 static int outfile_created = 0; 130 static char *skelname = NULL; 131 132 133 int main( argc, argv ) 134 int argc; 135 char **argv; 136 { 137 int i; 138 139 #ifdef THINK_C 140 argc = ccommand( &argv ); 141 #endif 142 #ifdef NEED_ARGV_FIXUP 143 argv_fixup( &argc, &argv ); 144 #endif 145 146 flexinit( argc, argv ); 147 148 readin(); 149 150 ntod(); 151 152 for ( i = 1; i <= num_rules; ++i ) 153 if ( ! rule_useful[i] && i != default_rule ) 154 line_warning( _( "rule cannot be matched" ), 155 rule_linenum[i] ); 156 157 if ( spprdflt && ! reject && rule_useful[default_rule] ) 158 line_warning( 159 _( "-s option given but default rule can be matched" ), 160 rule_linenum[default_rule] ); 161 162 /* Generate the C state transition tables from the DFA. */ 163 make_tables(); 164 165 /* Note, flexend does not return. It exits with its argument 166 * as status. 167 */ 168 flexend( 0 ); 169 170 return 0; 171 } 172 173 174 /* check_options - check user-specified options */ 175 176 void check_options() 177 { 178 int i; 179 180 if ( lex_compat ) 181 { 182 if ( C_plus_plus ) 183 flexerror( _( "Can't use -+ with -l option" ) ); 184 185 if ( fulltbl || fullspd ) 186 flexerror( _( "Can't use -f or -F with -l option" ) ); 187 188 /* Don't rely on detecting use of yymore() and REJECT, 189 * just assume they'll be used. 190 */ 191 yymore_really_used = reject_really_used = true; 192 193 yytext_is_array = true; 194 do_yylineno = true; 195 use_read = false; 196 } 197 198 if ( do_yylineno ) 199 /* This should really be "maintain_backup_tables = true" */ 200 reject_really_used = true; 201 202 if ( csize == unspecified ) 203 { 204 if ( (fulltbl || fullspd) && ! useecs ) 205 csize = DEFAULT_CSIZE; 206 else 207 csize = CSIZE; 208 } 209 210 if ( interactive == unspecified ) 211 { 212 if ( fulltbl || fullspd ) 213 interactive = false; 214 else 215 interactive = true; 216 } 217 218 if ( fulltbl || fullspd ) 219 { 220 if ( usemecs ) 221 flexerror( 222 _( "-Cf/-CF and -Cm don't make sense together" ) ); 223 224 if ( interactive ) 225 flexerror( _( "-Cf/-CF and -I are incompatible" ) ); 226 227 if ( lex_compat ) 228 flexerror( 229 _( "-Cf/-CF are incompatible with lex-compatibility mode" ) ); 230 231 if ( do_yylineno ) 232 flexerror( 233 _( "-Cf/-CF and %option yylineno are incompatible" ) ); 234 235 if ( fulltbl && fullspd ) 236 flexerror( _( "-Cf and -CF are mutually exclusive" ) ); 237 } 238 239 if ( C_plus_plus && fullspd ) 240 flexerror( _( "Can't use -+ with -CF option" ) ); 241 242 if ( C_plus_plus && yytext_is_array ) 243 { 244 warn( _( "%array incompatible with -+ option" ) ); 245 yytext_is_array = false; 246 } 247 248 if ( useecs ) 249 { /* Set up doubly-linked equivalence classes. */ 250 251 /* We loop all the way up to csize, since ecgroup[csize] is 252 * the position used for NUL characters. 253 */ 254 ecgroup[1] = NIL; 255 256 for ( i = 2; i <= csize; ++i ) 257 { 258 ecgroup[i] = i - 1; 259 nextecm[i - 1] = i; 260 } 261 262 nextecm[csize] = NIL; 263 } 264 265 else 266 { 267 /* Put everything in its own equivalence class. */ 268 for ( i = 1; i <= csize; ++i ) 269 { 270 ecgroup[i] = i; 271 nextecm[i] = BAD_SUBSCRIPT; /* to catch errors */ 272 } 273 } 274 275 if ( ! use_stdout ) 276 { 277 FILE *prev_stdout; 278 279 if ( ! did_outfilename ) 280 { 281 char *suffix; 282 283 if ( C_plus_plus ) 284 suffix = "cc"; 285 else 286 suffix = "c"; 287 288 snprintf( outfile_path, sizeof outfile_path, 289 outfile_template, prefix, suffix ); 290 291 outfilename = outfile_path; 292 } 293 294 prev_stdout = freopen( outfilename, "w", stdout ); 295 296 if ( prev_stdout == NULL ) 297 lerrsf( _( "could not create %s" ), outfilename ); 298 299 outfile_created = 1; 300 } 301 302 if ( skelname && (skelfile = fopen( skelname, "r" )) == NULL ) 303 lerrsf( _( "can't open skeleton file %s" ), skelname ); 304 305 if ( strcmp( prefix, "yy" ) ) 306 { 307 #define GEN_PREFIX(name) out_str3( "#define yy%s %s%s\n", name, prefix, name ) 308 if ( C_plus_plus ) 309 GEN_PREFIX( "FlexLexer" ); 310 else 311 { 312 GEN_PREFIX( "_create_buffer" ); 313 GEN_PREFIX( "_delete_buffer" ); 314 GEN_PREFIX( "_scan_buffer" ); 315 GEN_PREFIX( "_scan_string" ); 316 GEN_PREFIX( "_scan_bytes" ); 317 GEN_PREFIX( "_flex_debug" ); 318 GEN_PREFIX( "_init_buffer" ); 319 GEN_PREFIX( "_flush_buffer" ); 320 GEN_PREFIX( "_load_buffer_state" ); 321 GEN_PREFIX( "_switch_to_buffer" ); 322 GEN_PREFIX( "in" ); 323 GEN_PREFIX( "leng" ); 324 GEN_PREFIX( "lex" ); 325 GEN_PREFIX( "out" ); 326 GEN_PREFIX( "restart" ); 327 GEN_PREFIX( "text" ); 328 329 if ( do_yylineno ) 330 GEN_PREFIX( "lineno" ); 331 } 332 333 if ( do_yywrap ) 334 GEN_PREFIX( "wrap" ); 335 336 outn( "" ); 337 } 338 339 if ( did_outfilename ) 340 line_directive_out( stdout, 0 ); 341 342 skelout(); 343 } 344 345 346 /* flexend - terminate flex 347 * 348 * note 349 * This routine does not return. 350 */ 351 352 void flexend( exit_status ) 353 int exit_status; 354 355 { 356 int tblsiz; 357 int unlink(); 358 359 if ( skelfile != NULL ) 360 { 361 if ( ferror( skelfile ) ) 362 lerrsf( _( "input error reading skeleton file %s" ), 363 skelname ); 364 365 else if ( fclose( skelfile ) ) 366 lerrsf( _( "error closing skeleton file %s" ), 367 skelname ); 368 } 369 370 if ( exit_status != 0 && outfile_created ) 371 { 372 if ( ferror( stdout ) ) 373 lerrsf( _( "error writing output file %s" ), 374 outfilename ); 375 376 else if ( fclose( stdout ) ) 377 lerrsf( _( "error closing output file %s" ), 378 outfilename ); 379 380 else if ( unlink( outfilename ) ) 381 lerrsf( _( "error deleting output file %s" ), 382 outfilename ); 383 } 384 385 if ( backing_up_report && backing_up_file ) 386 { 387 if ( num_backing_up == 0 ) 388 fprintf( backing_up_file, _( "No backing up.\n" ) ); 389 else if ( fullspd || fulltbl ) 390 fprintf( backing_up_file, 391 _( "%d backing up (non-accepting) states.\n" ), 392 num_backing_up ); 393 else 394 fprintf( backing_up_file, 395 _( "Compressed tables always back up.\n" ) ); 396 397 if ( ferror( backing_up_file ) ) 398 lerrsf( _( "error writing backup file %s" ), 399 backing_name ); 400 401 else if ( fclose( backing_up_file ) ) 402 lerrsf( _( "error closing backup file %s" ), 403 backing_name ); 404 } 405 406 if ( printstats ) 407 { 408 fprintf( stderr, _( "%s version %s usage statistics:\n" ), 409 program_name, flex_version ); 410 411 fprintf( stderr, _( " scanner options: -" ) ); 412 413 if ( C_plus_plus ) 414 putc( '+', stderr ); 415 if ( backing_up_report ) 416 putc( 'b', stderr ); 417 if ( ddebug ) 418 putc( 'd', stderr ); 419 if ( caseins ) 420 putc( 'i', stderr ); 421 if ( lex_compat ) 422 putc( 'l', stderr ); 423 if ( performance_report > 0 ) 424 putc( 'p', stderr ); 425 if ( performance_report > 1 ) 426 putc( 'p', stderr ); 427 if ( spprdflt ) 428 putc( 's', stderr ); 429 if ( use_stdout ) 430 putc( 't', stderr ); 431 if ( printstats ) 432 putc( 'v', stderr ); /* always true! */ 433 if ( nowarn ) 434 putc( 'w', stderr ); 435 if ( interactive == false ) 436 putc( 'B', stderr ); 437 if ( interactive == true ) 438 putc( 'I', stderr ); 439 if ( ! gen_line_dirs ) 440 putc( 'L', stderr ); 441 if ( trace ) 442 putc( 'T', stderr ); 443 444 if ( csize == unspecified ) 445 /* We encountered an error fairly early on, so csize 446 * never got specified. Define it now, to prevent 447 * bogus table sizes being written out below. 448 */ 449 csize = 256; 450 451 if ( csize == 128 ) 452 putc( '7', stderr ); 453 else 454 putc( '8', stderr ); 455 456 fprintf( stderr, " -C" ); 457 458 if ( long_align ) 459 putc( 'a', stderr ); 460 if ( fulltbl ) 461 putc( 'f', stderr ); 462 if ( fullspd ) 463 putc( 'F', stderr ); 464 if ( useecs ) 465 putc( 'e', stderr ); 466 if ( usemecs ) 467 putc( 'm', stderr ); 468 if ( use_read ) 469 putc( 'r', stderr ); 470 471 if ( did_outfilename ) 472 fprintf( stderr, " -o%s", outfilename ); 473 474 if ( skelname ) 475 fprintf( stderr, " -S%s", skelname ); 476 477 if ( strcmp( prefix, "yy" ) ) 478 fprintf( stderr, " -P%s", prefix ); 479 480 putc( '\n', stderr ); 481 482 fprintf( stderr, _( " %d/%d NFA states\n" ), 483 lastnfa, current_mns ); 484 fprintf( stderr, _( " %d/%d DFA states (%d words)\n" ), 485 lastdfa, current_max_dfas, totnst ); 486 fprintf( stderr, _( " %d rules\n" ), 487 num_rules + num_eof_rules - 1 /* - 1 for def. rule */ ); 488 489 if ( num_backing_up == 0 ) 490 fprintf( stderr, _( " No backing up\n" ) ); 491 else if ( fullspd || fulltbl ) 492 fprintf( stderr, 493 _( " %d backing-up (non-accepting) states\n" ), 494 num_backing_up ); 495 else 496 fprintf( stderr, 497 _( " Compressed tables always back-up\n" ) ); 498 499 if ( bol_needed ) 500 fprintf( stderr, 501 _( " Beginning-of-line patterns used\n" ) ); 502 503 fprintf( stderr, _( " %d/%d start conditions\n" ), lastsc, 504 current_max_scs ); 505 fprintf( stderr, 506 _( " %d epsilon states, %d double epsilon states\n" ), 507 numeps, eps2 ); 508 509 if ( lastccl == 0 ) 510 fprintf( stderr, _( " no character classes\n" ) ); 511 else 512 fprintf( stderr, 513 _( " %d/%d character classes needed %d/%d words of storage, %d reused\n" ), 514 lastccl, current_maxccls, 515 cclmap[lastccl] + ccllen[lastccl], 516 current_max_ccl_tbl_size, cclreuse ); 517 518 fprintf( stderr, _( " %d state/nextstate pairs created\n" ), 519 numsnpairs ); 520 fprintf( stderr, _( " %d/%d unique/duplicate transitions\n" ), 521 numuniq, numdup ); 522 523 if ( fulltbl ) 524 { 525 tblsiz = lastdfa * numecs; 526 fprintf( stderr, _( " %d table entries\n" ), tblsiz ); 527 } 528 529 else 530 { 531 tblsiz = 2 * (lastdfa + numtemps) + 2 * tblend; 532 533 fprintf( stderr, 534 _( " %d/%d base-def entries created\n" ), 535 lastdfa + numtemps, current_max_dfas ); 536 fprintf( stderr, 537 _( " %d/%d (peak %d) nxt-chk entries created\n" ), 538 tblend, current_max_xpairs, peakpairs ); 539 fprintf( stderr, 540 _( " %d/%d (peak %d) template nxt-chk entries created\n" ), 541 numtemps * nummecs, 542 current_max_template_xpairs, 543 numtemps * numecs ); 544 fprintf( stderr, _( " %d empty table entries\n" ), 545 nummt ); 546 fprintf( stderr, _( " %d protos created\n" ), 547 numprots ); 548 fprintf( stderr, 549 _( " %d templates created, %d uses\n" ), 550 numtemps, tmpuses ); 551 } 552 553 if ( useecs ) 554 { 555 tblsiz = tblsiz + csize; 556 fprintf( stderr, 557 _( " %d/%d equivalence classes created\n" ), 558 numecs, csize ); 559 } 560 561 if ( usemecs ) 562 { 563 tblsiz = tblsiz + numecs; 564 fprintf( stderr, 565 _( " %d/%d meta-equivalence classes created\n" ), 566 nummecs, csize ); 567 } 568 569 fprintf( stderr, 570 _( " %d (%d saved) hash collisions, %d DFAs equal\n" ), 571 hshcol, hshsave, dfaeql ); 572 fprintf( stderr, _( " %d sets of reallocations needed\n" ), 573 num_reallocs ); 574 fprintf( stderr, _( " %d total table entries needed\n" ), 575 tblsiz ); 576 } 577 578 exit( exit_status ); 579 } 580 581 582 /* flexinit - initialize flex */ 583 584 void flexinit( argc, argv ) 585 int argc; 586 char **argv; 587 { 588 int i, sawcmpflag; 589 char *arg; 590 591 printstats = syntaxerror = trace = spprdflt = caseins = false; 592 lex_compat = C_plus_plus = backing_up_report = ddebug = fulltbl = false; 593 fullspd = long_align = nowarn = yymore_used = continued_action = false; 594 do_yylineno = yytext_is_array = in_rule = reject = do_stdinit = false; 595 yymore_really_used = reject_really_used = unspecified; 596 interactive = csize = unspecified; 597 do_yywrap = gen_line_dirs = usemecs = useecs = true; 598 performance_report = 0; 599 did_outfilename = 0; 600 prefix = "yy"; 601 yyclass = 0; 602 use_read = use_stdout = false; 603 604 sawcmpflag = false; 605 606 /* Initialize dynamic array for holding the rule actions. */ 607 action_size = 2048; /* default size of action array in bytes */ 608 action_array = allocate_character_array( action_size ); 609 defs1_offset = prolog_offset = action_offset = action_index = 0; 610 action_array[0] = '\0'; 611 612 program_name = argv[0]; 613 614 if ( program_name[0] != '\0' && 615 program_name[strlen( program_name ) - 1] == '+' ) 616 C_plus_plus = true; 617 618 /* read flags */ 619 for ( --argc, ++argv; argc ; --argc, ++argv ) 620 { 621 arg = argv[0]; 622 623 if ( arg[0] != '-' || arg[1] == '\0' ) 624 break; 625 626 if ( arg[1] == '-' ) 627 { /* --option */ 628 if ( ! strcmp( arg, "--help" ) ) 629 arg = "-h"; 630 631 else if ( ! strcmp( arg, "--version" ) ) 632 arg = "-V"; 633 634 else if ( ! strcmp( arg, "--" ) ) 635 { /* end of options */ 636 --argc; 637 ++argv; 638 break; 639 } 640 } 641 642 for ( i = 1; arg[i] != '\0'; ++i ) 643 switch ( arg[i] ) 644 { 645 case '+': 646 C_plus_plus = true; 647 break; 648 649 case 'B': 650 interactive = false; 651 break; 652 653 case 'b': 654 backing_up_report = true; 655 break; 656 657 case 'c': 658 break; 659 660 case 'C': 661 if ( i != 1 ) 662 flexerror( 663 _( "-C flag must be given separately" ) ); 664 665 if ( ! sawcmpflag ) 666 { 667 useecs = false; 668 usemecs = false; 669 fulltbl = false; 670 sawcmpflag = true; 671 } 672 673 for ( ++i; arg[i] != '\0'; ++i ) 674 switch ( arg[i] ) 675 { 676 case 'a': 677 long_align = 678 true; 679 break; 680 681 case 'e': 682 useecs = true; 683 break; 684 685 case 'F': 686 fullspd = true; 687 break; 688 689 case 'f': 690 fulltbl = true; 691 break; 692 693 case 'm': 694 usemecs = true; 695 break; 696 697 case 'r': 698 use_read = true; 699 break; 700 701 default: 702 lerrif( 703 _( "unknown -C option '%c'" ), 704 (int) arg[i] ); 705 break; 706 } 707 708 goto get_next_arg; 709 710 case 'd': 711 ddebug = true; 712 break; 713 714 case 'f': 715 useecs = usemecs = false; 716 use_read = fulltbl = true; 717 break; 718 719 case 'F': 720 useecs = usemecs = false; 721 use_read = fullspd = true; 722 break; 723 724 case '?': 725 case 'h': 726 usage(); 727 exit( 0 ); 728 729 case 'I': 730 interactive = true; 731 break; 732 733 case 'i': 734 caseins = true; 735 break; 736 737 case 'l': 738 lex_compat = true; 739 break; 740 741 case 'L': 742 gen_line_dirs = false; 743 break; 744 745 case 'n': 746 /* Stupid do-nothing deprecated 747 * option. 748 */ 749 break; 750 751 case 'o': 752 if ( i != 1 ) 753 flexerror( 754 _( "-o flag must be given separately" ) ); 755 756 outfilename = arg + i + 1; 757 did_outfilename = 1; 758 goto get_next_arg; 759 760 case 'P': 761 if ( i != 1 ) 762 flexerror( 763 _( "-P flag must be given separately" ) ); 764 765 prefix = arg + i + 1; 766 goto get_next_arg; 767 768 case 'p': 769 ++performance_report; 770 break; 771 772 case 'S': 773 if ( i != 1 ) 774 flexerror( 775 _( "-S flag must be given separately" ) ); 776 777 skelname = arg + i + 1; 778 goto get_next_arg; 779 780 case 's': 781 spprdflt = true; 782 break; 783 784 case 't': 785 use_stdout = true; 786 break; 787 788 case 'T': 789 trace = true; 790 break; 791 792 case 'v': 793 printstats = true; 794 break; 795 796 case 'V': 797 printf( _( "%s version %s\n" ), 798 program_name, flex_version ); 799 exit( 0 ); 800 801 case 'w': 802 nowarn = true; 803 break; 804 805 case '7': 806 csize = 128; 807 break; 808 809 case '8': 810 csize = CSIZE; 811 break; 812 813 default: 814 fprintf( stderr, 815 _( "%s: unknown flag '%c'. For usage, try\n\t%s --help\n" ), 816 program_name, (int) arg[i], 817 program_name ); 818 exit( 1 ); 819 } 820 821 /* Used by -C, -S, -o, and -P flags in lieu of a "continue 2" 822 * control. 823 */ 824 get_next_arg: ; 825 } 826 827 num_input_files = argc; 828 input_files = argv; 829 set_input_file( num_input_files > 0 ? input_files[0] : NULL ); 830 831 lastccl = lastsc = lastdfa = lastnfa = 0; 832 num_rules = num_eof_rules = default_rule = 0; 833 numas = numsnpairs = tmpuses = 0; 834 numecs = numeps = eps2 = num_reallocs = hshcol = dfaeql = totnst = 0; 835 numuniq = numdup = hshsave = eofseen = datapos = dataline = 0; 836 num_backing_up = onesp = numprots = 0; 837 variable_trailing_context_rules = bol_needed = false; 838 839 out_linenum = linenum = sectnum = 1; 840 firstprot = NIL; 841 842 /* Used in mkprot() so that the first proto goes in slot 1 843 * of the proto queue. 844 */ 845 lastprot = 1; 846 847 set_up_initial_allocations(); 848 } 849 850 851 /* readin - read in the rules section of the input file(s) */ 852 853 void readin() 854 { 855 static char yy_stdinit[] = "FILE *yyin = stdin, *yyout = stdout;"; 856 static char yy_nostdinit[] = 857 "FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;"; 858 859 line_directive_out( (FILE *) 0, 1 ); 860 861 if ( yyparse() ) 862 { 863 pinpoint_message( _( "fatal parse error" ) ); 864 flexend( 1 ); 865 } 866 867 if ( syntaxerror ) 868 flexend( 1 ); 869 870 if ( backing_up_report ) 871 { 872 backing_up_file = fopen( backing_name, "w" ); 873 if ( backing_up_file == NULL ) 874 lerrsf( 875 _( "could not create backing-up info file %s" ), 876 backing_name ); 877 } 878 879 else 880 backing_up_file = NULL; 881 882 if ( yymore_really_used == true ) 883 yymore_used = true; 884 else if ( yymore_really_used == false ) 885 yymore_used = false; 886 887 if ( reject_really_used == true ) 888 reject = true; 889 else if ( reject_really_used == false ) 890 reject = false; 891 892 if ( performance_report > 0 ) 893 { 894 if ( lex_compat ) 895 { 896 fprintf( stderr, 897 _( "-l AT&T lex compatibility option entails a large performance penalty\n" ) ); 898 fprintf( stderr, 899 _( " and may be the actual source of other reported performance penalties\n" ) ); 900 } 901 902 else if ( do_yylineno ) 903 { 904 fprintf( stderr, 905 _( "%%option yylineno entails a large performance penalty\n" ) ); 906 } 907 908 if ( performance_report > 1 ) 909 { 910 if ( interactive ) 911 fprintf( stderr, 912 _( "-I (interactive) entails a minor performance penalty\n" ) ); 913 914 if ( yymore_used ) 915 fprintf( stderr, 916 _( "yymore() entails a minor performance penalty\n" ) ); 917 } 918 919 if ( reject ) 920 fprintf( stderr, 921 _( "REJECT entails a large performance penalty\n" ) ); 922 923 if ( variable_trailing_context_rules ) 924 fprintf( stderr, 925 _( "Variable trailing context rules entail a large performance penalty\n" ) ); 926 } 927 928 if ( reject ) 929 real_reject = true; 930 931 if ( variable_trailing_context_rules ) 932 reject = true; 933 934 if ( (fulltbl || fullspd) && reject ) 935 { 936 if ( real_reject ) 937 flexerror( 938 _( "REJECT cannot be used with -f or -F" ) ); 939 else if ( do_yylineno ) 940 flexerror( 941 _( "%option yylineno cannot be used with -f or -F" ) ); 942 else 943 flexerror( 944 _( "variable trailing context rules cannot be used with -f or -F" ) ); 945 } 946 947 if ( reject ) 948 outn( "\n#define YY_USES_REJECT" ); 949 950 if ( ! do_yywrap ) 951 { 952 outn( "\n#define yywrap() 1" ); 953 outn( "#define YY_SKIP_YYWRAP" ); 954 } 955 956 if ( ddebug ) 957 outn( "\n#define FLEX_DEBUG" ); 958 959 if ( csize == 256 ) 960 outn( "typedef unsigned char YY_CHAR;" ); 961 else 962 outn( "typedef char YY_CHAR;" ); 963 964 if ( C_plus_plus ) 965 { 966 outn( "#define yytext_ptr yytext" ); 967 968 if ( interactive ) 969 outn( "#define YY_INTERACTIVE" ); 970 } 971 972 else 973 { 974 if ( do_stdinit ) 975 { 976 outn( "#ifdef VMS" ); 977 outn( "#ifndef __VMS_POSIX" ); 978 outn( yy_nostdinit ); 979 outn( "#else" ); 980 outn( yy_stdinit ); 981 outn( "#endif" ); 982 outn( "#else" ); 983 outn( yy_stdinit ); 984 outn( "#endif" ); 985 } 986 987 else 988 outn( yy_nostdinit ); 989 } 990 991 if ( fullspd ) 992 outn( "typedef yyconst struct yy_trans_info *yy_state_type;" ); 993 else if ( ! C_plus_plus ) 994 outn( "typedef int yy_state_type;" ); 995 996 if ( ddebug ) 997 outn( "\n#define FLEX_DEBUG" ); 998 999 if ( lex_compat ) 1000 outn( "#define YY_FLEX_LEX_COMPAT" ); 1001 1002 if ( do_yylineno && ! C_plus_plus ) 1003 { 1004 outn( "extern int yylineno;" ); 1005 outn( "int yylineno = 1;" ); 1006 } 1007 1008 if ( C_plus_plus ) 1009 { 1010 outn( "\n#include <FlexLexer.h>" ); 1011 1012 if ( yyclass ) 1013 { 1014 outn( "int yyFlexLexer::yylex()" ); 1015 outn( "\t{" ); 1016 outn( 1017 "\tLexerError( \"yyFlexLexer::yylex invoked but %option yyclass used\" );" ); 1018 outn( "\treturn 0;" ); 1019 outn( "\t}" ); 1020 1021 out_str( "\n#define YY_DECL int %s::yylex()\n", 1022 yyclass ); 1023 } 1024 } 1025 1026 else 1027 { 1028 if ( yytext_is_array ) 1029 outn( "extern char yytext[];\n" ); 1030 1031 else 1032 { 1033 outn( "extern char *yytext;" ); 1034 outn( "#define yytext_ptr yytext" ); 1035 } 1036 1037 if ( yyclass ) 1038 flexerror( 1039 _( "%option yyclass only meaningful for C++ scanners" ) ); 1040 } 1041 1042 if ( useecs ) 1043 numecs = cre8ecs( nextecm, ecgroup, csize ); 1044 else 1045 numecs = csize; 1046 1047 /* Now map the equivalence class for NUL to its expected place. */ 1048 ecgroup[0] = ecgroup[csize]; 1049 NUL_ec = ABS( ecgroup[0] ); 1050 1051 if ( useecs ) 1052 ccl2ecl(); 1053 } 1054 1055 1056 /* set_up_initial_allocations - allocate memory for internal tables */ 1057 1058 void set_up_initial_allocations() 1059 { 1060 current_mns = INITIAL_MNS; 1061 firstst = allocate_integer_array( current_mns ); 1062 lastst = allocate_integer_array( current_mns ); 1063 finalst = allocate_integer_array( current_mns ); 1064 transchar = allocate_integer_array( current_mns ); 1065 trans1 = allocate_integer_array( current_mns ); 1066 trans2 = allocate_integer_array( current_mns ); 1067 accptnum = allocate_integer_array( current_mns ); 1068 assoc_rule = allocate_integer_array( current_mns ); 1069 state_type = allocate_integer_array( current_mns ); 1070 1071 current_max_rules = INITIAL_MAX_RULES; 1072 rule_type = allocate_integer_array( current_max_rules ); 1073 rule_linenum = allocate_integer_array( current_max_rules ); 1074 rule_useful = allocate_integer_array( current_max_rules ); 1075 1076 current_max_scs = INITIAL_MAX_SCS; 1077 scset = allocate_integer_array( current_max_scs ); 1078 scbol = allocate_integer_array( current_max_scs ); 1079 scxclu = allocate_integer_array( current_max_scs ); 1080 sceof = allocate_integer_array( current_max_scs ); 1081 scname = allocate_char_ptr_array( current_max_scs ); 1082 1083 current_maxccls = INITIAL_MAX_CCLS; 1084 cclmap = allocate_integer_array( current_maxccls ); 1085 ccllen = allocate_integer_array( current_maxccls ); 1086 cclng = allocate_integer_array( current_maxccls ); 1087 1088 current_max_ccl_tbl_size = INITIAL_MAX_CCL_TBL_SIZE; 1089 ccltbl = allocate_Character_array( current_max_ccl_tbl_size ); 1090 1091 current_max_dfa_size = INITIAL_MAX_DFA_SIZE; 1092 1093 current_max_xpairs = INITIAL_MAX_XPAIRS; 1094 nxt = allocate_integer_array( current_max_xpairs ); 1095 chk = allocate_integer_array( current_max_xpairs ); 1096 1097 current_max_template_xpairs = INITIAL_MAX_TEMPLATE_XPAIRS; 1098 tnxt = allocate_integer_array( current_max_template_xpairs ); 1099 1100 current_max_dfas = INITIAL_MAX_DFAS; 1101 base = allocate_integer_array( current_max_dfas ); 1102 def = allocate_integer_array( current_max_dfas ); 1103 dfasiz = allocate_integer_array( current_max_dfas ); 1104 accsiz = allocate_integer_array( current_max_dfas ); 1105 dhash = allocate_integer_array( current_max_dfas ); 1106 dss = allocate_int_ptr_array( current_max_dfas ); 1107 dfaacc = allocate_dfaacc_union( current_max_dfas ); 1108 1109 nultrans = (int *) 0; 1110 } 1111 1112 1113 void usage() 1114 { 1115 FILE *f = stdout; 1116 1117 fprintf( f, 1118 _( "%s [-bdfhilnpstvwBFILTV78+? -C[aefFmr] -ooutput -Pprefix -Sskeleton]\n" ), 1119 program_name ); 1120 fprintf( f, _( "\t[--help --version] [file ...]\n" ) ); 1121 1122 fprintf( f, _( "\t-b generate backing-up information to %s\n" ), 1123 backing_name ); 1124 fprintf( f, _( "\t-d turn on debug mode in generated scanner\n" ) ); 1125 fprintf( f, _( "\t-f generate fast, large scanner\n" ) ); 1126 fprintf( f, _( "\t-h produce this help message\n" ) ); 1127 fprintf( f, _( "\t-i generate case-insensitive scanner\n" ) ); 1128 fprintf( f, _( "\t-l maximal compatibility with original lex\n" ) ); 1129 fprintf( f, _( "\t-n do-nothing POSIX option\n" ) ); 1130 fprintf( f, _( "\t-p generate performance report to stderr\n" ) ); 1131 fprintf( f, 1132 _( "\t-s suppress default rule to ECHO unmatched text\n" ) ); 1133 1134 if ( ! did_outfilename ) 1135 { 1136 snprintf( outfile_path, sizeof outfile_path, outfile_template, 1137 prefix, C_plus_plus ? "cc" : "c" ); 1138 outfilename = outfile_path; 1139 } 1140 1141 fprintf( f, 1142 _( "\t-t write generated scanner on stdout instead of %s\n" ), 1143 outfilename ); 1144 1145 fprintf( f, 1146 _( "\t-v write summary of scanner statistics to f\n" ) ); 1147 fprintf( f, _( "\t-w do not generate warnings\n" ) ); 1148 fprintf( f, _( "\t-B generate batch scanner (opposite of -I)\n" ) ); 1149 fprintf( f, 1150 _( "\t-F use alternative fast scanner representation\n" ) ); 1151 fprintf( f, 1152 _( "\t-I generate interactive scanner (opposite of -B)\n" ) ); 1153 fprintf( f, _( "\t-L suppress #line directives in scanner\n" ) ); 1154 fprintf( f, _( "\t-T %s should run in trace mode\n" ), program_name ); 1155 fprintf( f, _( "\t-V report %s version\n" ), program_name ); 1156 fprintf( f, _( "\t-7 generate 7-bit scanner\n" ) ); 1157 fprintf( f, _( "\t-8 generate 8-bit scanner\n" ) ); 1158 fprintf( f, _( "\t-+ generate C++ scanner class\n" ) ); 1159 fprintf( f, _( "\t-? produce this help message\n" ) ); 1160 fprintf( f, 1161 _( "\t-C specify degree of table compression (default is -Cem):\n" ) ); 1162 fprintf( f, 1163 _( "\t\t-Ca trade off larger tables for better memory alignment\n" ) ); 1164 fprintf( f, _( "\t\t-Ce construct equivalence classes\n" ) ); 1165 fprintf( f, 1166 _( "\t\t-Cf do not compress scanner tables; use -f representation\n" ) ); 1167 fprintf( f, 1168 _( "\t\t-CF do not compress scanner tables; use -F representation\n" ) ); 1169 fprintf( f, _( "\t\t-Cm construct meta-equivalence classes\n" ) ); 1170 fprintf( f, 1171 _( "\t\t-Cr use read() instead of stdio for scanner input\n" ) ); 1172 fprintf( f, _( "\t-o specify output filename\n" ) ); 1173 fprintf( f, _( "\t-P specify scanner prefix other than \"yy\"\n" ) ); 1174 fprintf( f, _( "\t-S specify skeleton file\n" ) ); 1175 fprintf( f, _( "\t--help produce this help message\n" ) ); 1176 fprintf( f, _( "\t--version report %s version\n" ), program_name ); 1177 } 1178