contrib/flex/main.c

   1 /* flex - tool to generate fast lexical analyzers */
   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 \f
  34
  35 #include "flexdef.h"
  36 #include "version.h"
  37 #include "options.h"
  38 #include "tables.h"
  39
  40 static char flex_version[] = FLEX_VERSION;
  41
  42 /* declare functions that have forward references */
  43
  44 void flexinit PROTO ((int, char **));
  45 void readin PROTO ((void));
  46 void set_up_initial_allocations PROTO ((void));
  47 static char *basename2 PROTO ((char *path, int should_strip_ext));
  48
  49
  50 /* these globals are all defined and commented in flexdef.h */
  51 int     printstats, syntaxerror, eofseen, ddebug, trace, nowarn, spprdflt;
  52 int     interactive, lex_compat, posix_compat, do_yylineno,
  53         useecs, fulltbl, usemecs;
  54 int     fullspd, gen_line_dirs, performance_report, backing_up_report;
  55 int     C_plus_plus, long_align, use_read, yytext_is_array, do_yywrap,
  56         csize;
  57 int     reentrant, bison_bridge_lval, bison_bridge_lloc;
  58 int     yymore_used, reject, real_reject, continued_action, in_rule;
  59 int     yymore_really_used, reject_really_used;
  60 int     datapos, dataline, linenum;
  61 FILE   *skelfile = NULL;
  62 int     skel_ind = 0;
  63 char   *action_array;
  64 int     action_size, defs1_offset, prolog_offset, action_offset,
  65         action_index;
  66 char   *infilename = NULL, *outfilename = NULL, *headerfilename = NULL;
  67 int     did_outfilename;
  68 char   *prefix, *yyclass, *extra_type = NULL;
  69 int     do_stdinit, use_stdout;
  70 int     onestate[ONE_STACK_SIZE], onesym[ONE_STACK_SIZE];
  71 int     onenext[ONE_STACK_SIZE], onedef[ONE_STACK_SIZE], onesp;
  72 int     maximum_mns, current_mns, current_max_rules;
  73 int     num_rules, num_eof_rules, default_rule, lastnfa;
  74 int    *firstst, *lastst, *finalst, *transchar, *trans1, *trans2;
  75 int    *accptnum, *assoc_rule, *state_type;
  76 int    *rule_type, *rule_linenum, *rule_useful;
  77 int     current_state_type;
  78 int     variable_trailing_context_rules;
  79 int     numtemps, numprots, protprev[MSP], protnext[MSP], prottbl[MSP];
  80 int     protcomst[MSP], firstprot, lastprot, protsave[PROT_SAVE_SIZE];
  81 int     numecs, nextecm[CSIZE + 1], ecgroup[CSIZE + 1], nummecs,
  82         tecfwd[CSIZE + 1];
  83 int     tecbck[CSIZE + 1];
  84 int     lastsc, *scset, *scbol, *scxclu, *sceof;
  85 int     current_max_scs;
  86 char  **scname;
  87 int     current_max_dfa_size, current_max_xpairs;
  88 int     current_max_template_xpairs, current_max_dfas;
  89 int     lastdfa, *nxt, *chk, *tnxt;
  90 int    *base, *def, *nultrans, NUL_ec, tblend, firstfree, **dss, *dfasiz;
  91 union dfaacc_union *dfaacc;
  92 int    *accsiz, *dhash, numas;
  93 int     numsnpairs, jambase, jamstate;
  94 int     lastccl, *cclmap, *ccllen, *cclng, cclreuse;
  95 int     current_maxccls, current_max_ccl_tbl_size;
  96 Char   *ccltbl;
  97 char    nmstr[MAXLINE];
  98 int     sectnum, nummt, hshcol, dfaeql, numeps, eps2, num_reallocs;
  99 int     tmpuses, totnst, peakpairs, numuniq, numdup, hshsave;
 100 int     num_backing_up, bol_needed;
 101 FILE   *backing_up_file;
 102 int     end_of_buffer_state;
 103 char  **input_files;
 104 int     num_input_files;
 105 jmp_buf flex_main_jmp_buf;
 106 bool   *rule_has_nl, *ccl_has_nl;
 107 int     nlch = '\n';
 108 bool    ansi_func_defs, ansi_func_protos;
 109
 110 bool    tablesext, tablesverify, gentables;
 111 char   *tablesfilename=0,*tablesname=0;
 112 struct yytbl_writer tableswr;
 113
 114 /* Make sure program_name is initialized so we don't crash if writing
 115  * out an error message before getting the program name from argv[0].
 116  */
 117 char   *program_name = "flex";
 118
 119 #ifndef SHORT_FILE_NAMES
 120 static char *outfile_template = "lex.%s.%s";
 121 static char *backing_name = "lex.backup";
 122 static char *tablesfile_template = "lex.%s.tables";
 123 #else
 124 static char *outfile_template = "lex%s.%s";
 125 static char *backing_name = "lex.bck";
 126 static char *tablesfile_template = "lex%s.tbl";
 127 #endif
 128
 129 #ifdef MS_DOS
 130 extern unsigned _stklen = 16384;
 131 #endif
 132
 133 /* From scan.l */
 134 extern FILE* yyout;
 135
 136 static char outfile_path[MAXLINE];
 137 static int outfile_created = 0;
 138 static char *skelname = NULL;
 139 static int _stdout_closed = 0; /* flag to prevent double-fclose() on stdout. */
 140 const char *escaped_qstart = "[[]]M4_YY_NOOP[M4_YY_NOOP[M4_YY_NOOP[[]]";
 141 const char *escaped_qend   = "[[]]M4_YY_NOOP]M4_YY_NOOP]M4_YY_NOOP[[]]";
 142
 143 /* For debugging. The max number of filters to apply to skeleton. */
 144 static int preproc_level = 1000;
 145
 146 int flex_main PROTO ((int argc, char *argv[]));
 147 int main PROTO ((int argc, char *argv[]));
 148
 149 int flex_main (argc, argv)
 150      int argc;
 151      char   *argv[];
 152 {
 153         int     i, exit_status, child_status;
 154
 155         /* Set a longjmp target. Yes, I know it's a hack, but it gets worse: The
 156          * return value of setjmp, if non-zero, is the desired exit code PLUS ONE.
 157          * For example, if you want 'main' to return with code '2', then call
 158          * longjmp() with an argument of 3. This is because it is invalid to
 159          * specify a value of 0 to longjmp. FLEX_EXIT(n) should be used instead of
 160          * exit(n);
 161          */
 162         exit_status = setjmp (flex_main_jmp_buf);
 163         if (exit_status){
 164         if (stdout && !_stdout_closed && !ferror(stdout)){
 165             fflush(stdout);
 166             fclose(stdout);
 167         }
 168         while (wait(&child_status) > 0){
 169             if (!WIFEXITED (child_status)
 170                 || WEXITSTATUS (child_status) != 0){
 171                 /* report an error of a child
 172                  */
 173                 if( exit_status <= 1 )
 174                     exit_status = 2;
 175
 176             }
 177         }
 178         return exit_status - 1;
 179     }
 180
 181         flexinit (argc, argv);
 182
 183         readin ();
 184
 185         ntod ();
 186
 187         for (i = 1; i <= num_rules; ++i)
 188                 if (!rule_useful[i] && i != default_rule)
 189                         line_warning (_("rule cannot be matched"),
 190                                       rule_linenum[i]);
 191
 192         if (spprdflt && !reject && rule_useful[default_rule])
 193                 line_warning (_
 194                               ("-s option given but default rule can be matched"),
 195                               rule_linenum[default_rule]);
 196
 197         /* Generate the C state transition tables from the DFA. */
 198         make_tables ();
 199
 200         /* Note, flexend does not return.  It exits with its argument
 201          * as status.
 202          */
 203         flexend (0);
 204
 205         return 0;               /* keep compilers/lint happy */
 206 }
 207
 208 /* Wrapper around flex_main, so flex_main can be built as a library. */
 209 int main (argc, argv)
 210      int argc;
 211      char   *argv[];
 212 {
 213 #if ENABLE_NLS
 214 #if HAVE_LOCALE_H
 215         setlocale (LC_MESSAGES, "");
 216         setlocale (LC_CTYPE, "");
 217         textdomain (PACKAGE);
 218         bindtextdomain (PACKAGE, LOCALEDIR);
 219 #endif
 220 #endif
 221
 222         return flex_main (argc, argv);
 223 }
 224
 225 /* check_options - check user-specified options */
 226
 227 void check_options ()
 228 {
 229         int     i;
 230     const char * m4 = NULL;
 231
 232         if (lex_compat) {
 233                 if (C_plus_plus)
 234                         flexerror (_("Can't use -+ with -l option"));
 235
 236                 if (fulltbl || fullspd)
 237                         flexerror (_("Can't use -f or -F with -l option"));
 238
 239                 if (reentrant || bison_bridge_lval)
 240                         flexerror (_
 241                                    ("Can't use --reentrant or --bison-bridge with -l option"));
 242
 243                 /* Don't rely on detecting use of yymore() and REJECT,
 244                  * just assume they'll be used.
 245                  */
 246                 yymore_really_used = reject_really_used = true;
 247
 248                 yytext_is_array = true;
 249                 do_yylineno = true;
 250                 use_read = false;
 251         }
 252
 253
 254 #if 0
 255         /* This makes no sense whatsoever. I'm removing it. */
 256         if (do_yylineno)
 257                 /* This should really be "maintain_backup_tables = true" */
 258                 reject_really_used = true;
 259 #endif
 260
 261         if (csize == unspecified) {
 262                 if ((fulltbl || fullspd) && !useecs)
 263                         csize = DEFAULT_CSIZE;
 264                 else
 265                         csize = CSIZE;
 266         }
 267
 268         if (interactive == unspecified) {
 269                 if (fulltbl || fullspd)
 270                         interactive = false;
 271                 else
 272                         interactive = true;
 273         }
 274
 275         if (fulltbl || fullspd) {
 276                 if (usemecs)
 277                         flexerror (_
 278                                    ("-Cf/-CF and -Cm don't make sense together"));
 279
 280                 if (interactive)
 281                         flexerror (_("-Cf/-CF and -I are incompatible"));
 282
 283                 if (lex_compat)
 284                         flexerror (_
 285                                    ("-Cf/-CF are incompatible with lex-compatibility mode"));
 286
 287
 288                 if (fulltbl && fullspd)
 289                         flexerror (_
 290                                    ("-Cf and -CF are mutually exclusive"));
 291         }
 292
 293         if (C_plus_plus && fullspd)
 294                 flexerror (_("Can't use -+ with -CF option"));
 295
 296         if (C_plus_plus && yytext_is_array) {
 297                 warn (_("%array incompatible with -+ option"));
 298                 yytext_is_array = false;
 299         }
 300
 301         if (C_plus_plus && (reentrant))
 302                 flexerror (_("Options -+ and --reentrant are mutually exclusive."));
 303
 304         if (C_plus_plus && bison_bridge_lval)
 305                 flexerror (_("bison bridge not supported for the C++ scanner."));
 306
 307
 308         if (useecs) {           /* Set up doubly-linked equivalence classes. */
 309
 310                 /* We loop all the way up to csize, since ecgroup[csize] is
 311                  * the position used for NUL characters.
 312                  */
 313                 ecgroup[1] = NIL;
 314
 315                 for (i = 2; i <= csize; ++i) {
 316                         ecgroup[i] = i - 1;
 317                         nextecm[i - 1] = i;
 318                 }
 319
 320                 nextecm[csize] = NIL;
 321         }
 322
 323         else {
 324                 /* Put everything in its own equivalence class. */
 325                 for (i = 1; i <= csize; ++i) {
 326                         ecgroup[i] = i;
 327                         nextecm[i] = BAD_SUBSCRIPT;     /* to catch errors */
 328                 }
 329         }
 330
 331     if (!ansi_func_defs)
 332         buf_m4_define( &m4defs_buf, "M4_YY_NO_ANSI_FUNC_DEFS", NULL);
 333
 334     if (!ansi_func_protos)
 335         buf_m4_define( &m4defs_buf, "M4_YY_NO_ANSI_FUNC_PROTOS", NULL);
 336
 337     if (extra_type)
 338         buf_m4_define( &m4defs_buf, "M4_EXTRA_TYPE_DEFS", extra_type);
 339
 340         if (!use_stdout) {
 341                 FILE   *prev_stdout;
 342
 343                 if (!did_outfilename) {
 344                         char   *suffix;
 345
 346                         if (C_plus_plus)
 347                                 suffix = "cc";
 348                         else
 349                                 suffix = "c";
 350
 351                         snprintf (outfile_path, sizeof(outfile_path), outfile_template,
 352                                  prefix, suffix);
 353
 354                         outfilename = outfile_path;
 355                 }
 356
 357                 prev_stdout = freopen (outfilename, "w+", stdout);
 358
 359                 if (prev_stdout == NULL)
 360                         lerrsf (_("could not create %s"), outfilename);
 361
 362                 outfile_created = 1;
 363         }
 364
 365
 366     /* Setup the filter chain. */
 367     output_chain = filter_create_int(NULL, filter_tee_header, headerfilename);
 368     if ( !(m4 = getenv("M4")))
 369         m4 = M4;
 370     filter_create_ext(output_chain, m4, "-P", 0);
 371     filter_create_int(output_chain, filter_fix_linedirs, NULL);
 372
 373     /* For debugging, only run the requested number of filters. */
 374     if (preproc_level > 0) {
 375         filter_truncate(output_chain, preproc_level);
 376         filter_apply_chain(output_chain);
 377     }
 378     yyout = stdout;
 379
 380
 381         /* always generate the tablesverify flag. */
 382         buf_m4_define (&m4defs_buf, "M4_YY_TABLES_VERIFY", tablesverify ? "1" : "0");
 383         if (tablesext)
 384                 gentables = false;
 385
 386         if (tablesverify)
 387                 /* force generation of C tables. */
 388                 gentables = true;
 389
 390
 391         if (tablesext) {
 392                 FILE   *tablesout;
 393                 struct yytbl_hdr hdr;
 394                 char   *pname = 0;
 395                 int     nbytes = 0;
 396
 397                 buf_m4_define (&m4defs_buf, "M4_YY_TABLES_EXTERNAL", NULL);
 398
 399                 if (!tablesfilename) {
 400                         nbytes = strlen (prefix) + strlen (tablesfile_template) + 2;
 401                         tablesfilename = pname = (char *) calloc (nbytes, 1);
 402                         snprintf (pname, nbytes, tablesfile_template, prefix);
 403                 }
 404
 405                 if ((tablesout = fopen (tablesfilename, "w")) == NULL)
 406                         lerrsf (_("could not create %s"), tablesfilename);
 407                 if (pname)
 408                         free (pname);
 409                 tablesfilename = 0;
 410
 411                 yytbl_writer_init (&tableswr, tablesout);
 412
 413                 nbytes = strlen (prefix) + strlen ("tables") + 2;
 414                 tablesname = (char *) calloc (nbytes, 1);
 415                 snprintf (tablesname, nbytes, "%stables", prefix);
 416                 yytbl_hdr_init (&hdr, flex_version, tablesname);
 417
 418                 if (yytbl_hdr_fwrite (&tableswr, &hdr) <= 0)
 419                         flexerror (_("could not write tables header"));
 420         }
 421
 422         if (skelname && (skelfile = fopen (skelname, "r")) == NULL)
 423                 lerrsf (_("can't open skeleton file %s"), skelname);
 424
 425         if (reentrant) {
 426         buf_m4_define (&m4defs_buf, "M4_YY_REENTRANT", NULL);
 427                 if (yytext_is_array)
 428                         buf_m4_define (&m4defs_buf, "M4_YY_TEXT_IS_ARRAY", NULL);
 429         }
 430
 431         if ( bison_bridge_lval)
 432                 buf_m4_define (&m4defs_buf, "M4_YY_BISON_LVAL", NULL);
 433
 434         if ( bison_bridge_lloc)
 435         buf_m4_define (&m4defs_buf, "<M4_YY_BISON_LLOC>", NULL);
 436
 437     buf_m4_define(&m4defs_buf, "M4_YY_PREFIX", prefix);
 438
 439         if (did_outfilename)
 440                 line_directive_out (stdout, 0);
 441
 442         if (do_yylineno)
 443                 buf_m4_define (&m4defs_buf, "M4_YY_USE_LINENO", NULL);
 444
 445         /* Create the alignment type. */
 446         buf_strdefine (&userdef_buf, "YY_INT_ALIGNED",
 447                        long_align ? "long int" : "short int");
 448
 449     /* Define the start condition macros. */
 450     {
 451         struct Buf tmpbuf;
 452         buf_init(&tmpbuf, sizeof(char));
 453         for (i = 1; i <= lastsc; i++) {
 454              char *str, *fmt = "#define %s %d\n";
 455              size_t strsz;
 456
 457              str = (char*)flex_alloc(strsz = strlen(fmt) + strlen(scname[i]) + (int)(1 + log10(i)) + 2);
 458              if (!str)
 459                flexfatal(_("allocation of macro definition failed"));
 460              snprintf(str, strsz, fmt,      scname[i], i - 1);
 461              buf_strappend(&tmpbuf, str);
 462              free(str);
 463         }
 464         buf_m4_define(&m4defs_buf, "M4_YY_SC_DEFS", tmpbuf.elts);
 465         buf_destroy(&tmpbuf);
 466     }
 467
 468     /* This is where we begin writing to the file. */
 469
 470     /* Dump the %top code. */
 471     if( top_buf.elts)
 472         outn((char*) top_buf.elts);
 473
 474     /* Dump the m4 definitions. */
 475     buf_print_strings(&m4defs_buf, stdout);
 476     m4defs_buf.nelts = 0; /* memory leak here. */
 477
 478     /* Place a bogus line directive, it will be fixed in the filter. */
 479     outn("#line 0 \"M4_YY_OUTFILE_NAME\"\n");
 480
 481         /* Dump the user defined preproc directives. */
 482         if (userdef_buf.elts)
 483                 outn ((char *) (userdef_buf.elts));
 484
 485         skelout ();
 486         /* %% [1.0] */
 487 }
 488
 489 /* flexend - terminate flex
 490  *
 491  * note
 492  *    This routine does not return.
 493  */
 494
 495 void flexend (exit_status)
 496      int exit_status;
 497
 498 {
 499         static int called_before = -1;  /* prevent infinite recursion. */
 500         int     tblsiz;
 501
 502         if (++called_before)
 503                 FLEX_EXIT (exit_status);
 504
 505         if (skelfile != NULL) {
 506                 if (ferror (skelfile))
 507                         lerrsf (_("input error reading skeleton file %s"),
 508                                 skelname);
 509
 510                 else if (fclose (skelfile))
 511                         lerrsf (_("error closing skeleton file %s"),
 512                                 skelname);
 513         }
 514
 515 #if 0
 516                 fprintf (header_out,
 517                          "#ifdef YY_HEADER_EXPORT_START_CONDITIONS\n");
 518                 fprintf (header_out,
 519                          "/* Beware! Start conditions are not prefixed. */\n");
 520
 521                 /* Special case for "INITIAL" */
 522                 fprintf (header_out,
 523                          "#undef INITIAL\n#define INITIAL 0\n");
 524                 for (i = 2; i <= lastsc; i++)
 525                         fprintf (header_out, "#define %s %d\n", scname[i], i - 1);
 526                 fprintf (header_out,
 527                          "#endif /* YY_HEADER_EXPORT_START_CONDITIONS */\n\n");
 528
 529                 /* Kill ALL flex-related macros. This is so the user
 530                  * can #include more than one generated header file. */
 531                 fprintf (header_out, "#ifndef YY_HEADER_NO_UNDEFS\n");
 532                 fprintf (header_out,
 533                          "/* Undefine all internal macros, etc., that do no belong in the header. */\n\n");
 534
 535         {
 536             const char * undef_list[] = {
 537
 538                 "BEGIN",
 539                 "ECHO",
 540                 "EOB_ACT_CONTINUE_SCAN",
 541                 "EOB_ACT_END_OF_FILE",
 542                 "EOB_ACT_LAST_MATCH",
 543                 "FLEX_SCANNER",
 544                 "FLEX_STD",
 545                 "REJECT",
 546                 "YYFARGS0",
 547                 "YYFARGS1",
 548                 "YYFARGS2",
 549                 "YYFARGS3",
 550                 "YYLMAX",
 551                 "YYSTATE",
 552                 "YY_AT_BOL",
 553                 "YY_BREAK",
 554                 "YY_BUFFER_EOF_PENDING",
 555                 "YY_BUFFER_NEW",
 556                 "YY_BUFFER_NORMAL",
 557                 "YY_BUF_SIZE",
 558                 "M4_YY_CALL_LAST_ARG",
 559                 "M4_YY_CALL_ONLY_ARG",
 560                 "YY_CURRENT_BUFFER",
 561                 "YY_DECL",
 562                 "M4_YY_DECL_LAST_ARG",
 563                 "M4_YY_DEF_LAST_ARG",
 564                 "M4_YY_DEF_ONLY_ARG",
 565                 "YY_DO_BEFORE_ACTION",
 566                 "YY_END_OF_BUFFER",
 567                 "YY_END_OF_BUFFER_CHAR",
 568                 "YY_EXIT_FAILURE",
 569                 "YY_EXTRA_TYPE",
 570                 "YY_FATAL_ERROR",
 571                 "YY_FLEX_DEFINED_ECHO",
 572                 "YY_FLEX_LEX_COMPAT",
 573                 "YY_FLEX_MAJOR_VERSION",
 574                 "YY_FLEX_MINOR_VERSION",
 575                 "YY_FLEX_SUBMINOR_VERSION",
 576                 "YY_FLUSH_BUFFER",
 577                 "YY_G",
 578                 "YY_INPUT",
 579                 "YY_INTERACTIVE",
 580                 "YY_INT_ALIGNED",
 581                 "YY_LAST_ARG",
 582                 "YY_LESS_LINENO",
 583                 "YY_LEX_ARGS",
 584                 "YY_LEX_DECLARATION",
 585                 "YY_LEX_PROTO",
 586                 "YY_MAIN",
 587                 "YY_MORE_ADJ",
 588                 "YY_NEED_STRLEN",
 589                 "YY_NEW_FILE",
 590                 "YY_NULL",
 591                 "YY_NUM_RULES",
 592                 "YY_ONLY_ARG",
 593                 "YY_PARAMS",
 594                 "YY_PROTO",
 595                 "M4_YY_PROTO_LAST_ARG",
 596                 "M4_YY_PROTO_ONLY_ARG void",
 597                 "YY_READ_BUF_SIZE",
 598                 "YY_REENTRANT",
 599                 "YY_RESTORE_YY_MORE_OFFSET",
 600                 "YY_RULE_SETUP",
 601                 "YY_SC_TO_UI",
 602                 "YY_SKIP_YYWRAP",
 603                 "YY_START",
 604                 "YY_START_STACK_INCR",
 605                 "YY_STATE_EOF",
 606                 "YY_STDINIT",
 607                 "YY_TRAILING_HEAD_MASK",
 608                 "YY_TRAILING_MASK",
 609                 "YY_USER_ACTION",
 610                 "YY_USE_CONST",
 611                 "YY_USE_PROTOS",
 612                 "unput",
 613                 "yyTABLES_NAME",
 614                 "yy_create_buffer",
 615                 "yy_delete_buffer",
 616                 "yy_flex_debug",
 617                 "yy_flush_buffer",
 618                 "yy_init_buffer",
 619                 "yy_load_buffer_state",
 620                 "yy_new_buffer",
 621                 "yy_scan_buffer",
 622                 "yy_scan_bytes",
 623                 "yy_scan_string",
 624                 "yy_set_bol",
 625                 "yy_set_interactive",
 626                 "yy_switch_to_buffer",
 627                                 "yypush_buffer_state",
 628                                 "yypop_buffer_state",
 629                                 "yyensure_buffer_stack",
 630                 "yyalloc",
 631                 "yyconst",
 632                 "yyextra",
 633                 "yyfree",
 634                 "yyget_debug",
 635                 "yyget_extra",
 636                 "yyget_in",
 637                 "yyget_leng",
 638                 "yyget_lineno",
 639                 "yyget_lloc",
 640                 "yyget_lval",
 641                 "yyget_out",
 642                 "yyget_text",
 643                 "yyin",
 644                 "yyleng",
 645                 "yyless",
 646                 "yylex",
 647                 "yylex_destroy",
 648                 "yylex_init",
 649                 "yylex_init_extra",
 650                 "yylineno",
 651                 "yylloc",
 652                 "yylval",
 653                 "yymore",
 654                 "yyout",
 655                 "yyrealloc",
 656                 "yyrestart",
 657                 "yyset_debug",
 658                 "yyset_extra",
 659                 "yyset_in",
 660                 "yyset_lineno",
 661                 "yyset_lloc",
 662                 "yyset_lval",
 663                 "yyset_out",
 664                 "yytables_destroy",
 665                 "yytables_fload",
 666                 "yyterminate",
 667                 "yytext",
 668                 "yytext_ptr",
 669                 "yywrap",
 670
 671                 /* must be null-terminated */
 672                 NULL};
 673
 674
 675                 for (i=0; undef_list[i] != NULL; i++)
 676                     fprintf (header_out, "#undef %s\n", undef_list[i]);
 677         }
 678
 679                 /* undef any of the auto-generated symbols. */
 680                 for (i = 0; i < defs_buf.nelts; i++) {
 681
 682                         /* don't undef start conditions */
 683                         if (sclookup (((char **) defs_buf.elts)[i]) > 0)
 684                                 continue;
 685                         fprintf (header_out, "#undef %s\n",
 686                                  ((char **) defs_buf.elts)[i]);
 687                 }
 688
 689                 fprintf (header_out,
 690                          "#endif /* !YY_HEADER_NO_UNDEFS */\n");
 691                 fprintf (header_out, "\n");
 692                 fprintf (header_out, "#undef %sIN_HEADER\n", prefix);
 693                 fprintf (header_out, "#endif /* %sHEADER_H */\n", prefix);
 694
 695                 if (ferror (header_out))
 696                         lerrsf (_("error creating header file %s"),
 697                                 headerfilename);
 698                 fflush (header_out);
 699                 fclose (header_out);
 700 #endif
 701
 702         if (exit_status != 0 && outfile_created) {
 703                 if (ferror (stdout))
 704                         lerrsf (_("error writing output file %s"),
 705                                 outfilename);
 706
 707                 else if ((_stdout_closed = 1) && fclose (stdout))
 708                         lerrsf (_("error closing output file %s"),
 709                                 outfilename);
 710
 711                 else if (unlink (outfilename))
 712                         lerrsf (_("error deleting output file %s"),
 713                                 outfilename);
 714         }
 715
 716
 717         if (backing_up_report && backing_up_file) {
 718                 if (num_backing_up == 0)
 719                         fprintf (backing_up_file, _("No backing up.\n"));
 720                 else if (fullspd || fulltbl)
 721                         fprintf (backing_up_file,
 722                                  _
 723                                  ("%d backing up (non-accepting) states.\n"),
 724                                  num_backing_up);
 725                 else
 726                         fprintf (backing_up_file,
 727                                  _("Compressed tables always back up.\n"));
 728
 729                 if (ferror (backing_up_file))
 730                         lerrsf (_("error writing backup file %s"),
 731                                 backing_name);
 732
 733                 else if (fclose (backing_up_file))
 734                         lerrsf (_("error closing backup file %s"),
 735                                 backing_name);
 736         }
 737
 738         if (printstats) {
 739                 fprintf (stderr, _("%s version %s usage statistics:\n"),
 740                          program_name, flex_version);
 741
 742                 fprintf (stderr, _("  scanner options: -"));
 743
 744                 if (C_plus_plus)
 745                         putc ('+', stderr);
 746                 if (backing_up_report)
 747                         putc ('b', stderr);
 748                 if (ddebug)
 749                         putc ('d', stderr);
 750                 if (sf_case_ins())
 751                         putc ('i', stderr);
 752                 if (lex_compat)
 753                         putc ('l', stderr);
 754                 if (posix_compat)
 755                         putc ('X', stderr);
 756                 if (performance_report > 0)
 757                         putc ('p', stderr);
 758                 if (performance_report > 1)
 759                         putc ('p', stderr);
 760                 if (spprdflt)
 761                         putc ('s', stderr);
 762                 if (reentrant)
 763                         fputs ("--reentrant", stderr);
 764         if (bison_bridge_lval)
 765             fputs ("--bison-bridge", stderr);
 766         if (bison_bridge_lloc)
 767             fputs ("--bison-locations", stderr);
 768                 if (use_stdout)
 769                         putc ('t', stderr);
 770                 if (printstats)
 771                         putc ('v', stderr);     /* always true! */
 772                 if (nowarn)
 773                         putc ('w', stderr);
 774                 if (interactive == false)
 775                         putc ('B', stderr);
 776                 if (interactive == true)
 777                         putc ('I', stderr);
 778                 if (!gen_line_dirs)
 779                         putc ('L', stderr);
 780                 if (trace)
 781                         putc ('T', stderr);
 782
 783                 if (csize == unspecified)
 784                         /* We encountered an error fairly early on, so csize
 785                          * never got specified.  Define it now, to prevent
 786                          * bogus table sizes being written out below.
 787                          */
 788                         csize = 256;
 789
 790                 if (csize == 128)
 791                         putc ('7', stderr);
 792                 else
 793                         putc ('8', stderr);
 794
 795                 fprintf (stderr, " -C");
 796
 797                 if (long_align)
 798                         putc ('a', stderr);
 799                 if (fulltbl)
 800                         putc ('f', stderr);
 801                 if (fullspd)
 802                         putc ('F', stderr);
 803                 if (useecs)
 804                         putc ('e', stderr);
 805                 if (usemecs)
 806                         putc ('m', stderr);
 807                 if (use_read)
 808                         putc ('r', stderr);
 809
 810                 if (did_outfilename)
 811                         fprintf (stderr, " -o%s", outfilename);
 812
 813                 if (skelname)
 814                         fprintf (stderr, " -S%s", skelname);
 815
 816                 if (strcmp (prefix, "yy"))
 817                         fprintf (stderr, " -P%s", prefix);
 818
 819                 putc ('\n', stderr);
 820
 821                 fprintf (stderr, _("  %d/%d NFA states\n"),
 822                          lastnfa, current_mns);
 823                 fprintf (stderr, _("  %d/%d DFA states (%d words)\n"),
 824                          lastdfa, current_max_dfas, totnst);
 825                 fprintf (stderr, _("  %d rules\n"),
 826                          num_rules + num_eof_rules -
 827                          1 /* - 1 for def. rule */ );
 828
 829                 if (num_backing_up == 0)
 830                         fprintf (stderr, _("  No backing up\n"));
 831                 else if (fullspd || fulltbl)
 832                         fprintf (stderr,
 833                                  _
 834                                  ("  %d backing-up (non-accepting) states\n"),
 835                                  num_backing_up);
 836                 else
 837                         fprintf (stderr,
 838                                  _
 839                                  ("  Compressed tables always back-up\n"));
 840
 841                 if (bol_needed)
 842                         fprintf (stderr,
 843                                  _("  Beginning-of-line patterns used\n"));
 844
 845                 fprintf (stderr, _("  %d/%d start conditions\n"), lastsc,
 846                          current_max_scs);
 847                 fprintf (stderr,
 848                          _
 849                          ("  %d epsilon states, %d double epsilon states\n"),
 850                          numeps, eps2);
 851
 852                 if (lastccl == 0)
 853                         fprintf (stderr, _("  no character classes\n"));
 854                 else
 855                         fprintf (stderr,
 856                                  _
 857                                  ("  %d/%d character classes needed %d/%d words of storage, %d reused\n"),
 858                                  lastccl, current_maxccls,
 859                                  cclmap[lastccl] + ccllen[lastccl],
 860                                  current_max_ccl_tbl_size, cclreuse);
 861
 862                 fprintf (stderr, _("  %d state/nextstate pairs created\n"),
 863                          numsnpairs);
 864                 fprintf (stderr,
 865                          _("  %d/%d unique/duplicate transitions\n"),
 866                          numuniq, numdup);
 867
 868                 if (fulltbl) {
 869                         tblsiz = lastdfa * numecs;
 870                         fprintf (stderr, _("  %d table entries\n"),
 871                                  tblsiz);
 872                 }
 873
 874                 else {
 875                         tblsiz = 2 * (lastdfa + numtemps) + 2 * tblend;
 876
 877                         fprintf (stderr,
 878                                  _("  %d/%d base-def entries created\n"),
 879                                  lastdfa + numtemps, current_max_dfas);
 880                         fprintf (stderr,
 881                                  _
 882                                  ("  %d/%d (peak %d) nxt-chk entries created\n"),
 883                                  tblend, current_max_xpairs, peakpairs);
 884                         fprintf (stderr,
 885                                  _
 886                                  ("  %d/%d (peak %d) template nxt-chk entries created\n"),
 887                                  numtemps * nummecs,
 888                                  current_max_template_xpairs,
 889                                  numtemps * numecs);
 890                         fprintf (stderr, _("  %d empty table entries\n"),
 891                                  nummt);
 892                         fprintf (stderr, _("  %d protos created\n"),
 893                                  numprots);
 894                         fprintf (stderr,
 895                                  _("  %d templates created, %d uses\n"),
 896                                  numtemps, tmpuses);
 897                 }
 898
 899                 if (useecs) {
 900                         tblsiz = tblsiz + csize;
 901                         fprintf (stderr,
 902                                  _
 903                                  ("  %d/%d equivalence classes created\n"),
 904                                  numecs, csize);
 905                 }
 906
 907                 if (usemecs) {
 908                         tblsiz = tblsiz + numecs;
 909                         fprintf (stderr,
 910                                  _
 911                                  ("  %d/%d meta-equivalence classes created\n"),
 912                                  nummecs, csize);
 913                 }
 914
 915                 fprintf (stderr,
 916                          _
 917                          ("  %d (%d saved) hash collisions, %d DFAs equal\n"),
 918                          hshcol, hshsave, dfaeql);
 919                 fprintf (stderr, _("  %d sets of reallocations needed\n"),
 920                          num_reallocs);
 921                 fprintf (stderr, _("  %d total table entries needed\n"),
 922                          tblsiz);
 923         }
 924
 925         FLEX_EXIT (exit_status);
 926 }
 927
 928
 929 /* flexinit - initialize flex */
 930
 931 void flexinit (argc, argv)
 932      int argc;
 933      char  **argv;
 934 {
 935         int     i, sawcmpflag, rv, optind;
 936         char   *arg;
 937         scanopt_t sopt;
 938
 939         printstats = syntaxerror = trace = spprdflt = false;
 940         lex_compat = posix_compat = C_plus_plus = backing_up_report =
 941                 ddebug = fulltbl = false;
 942         fullspd = long_align = nowarn = yymore_used = continued_action =
 943                 false;
 944         do_yylineno = yytext_is_array = in_rule = reject = do_stdinit =
 945                 false;
 946         yymore_really_used = reject_really_used = unspecified;
 947         interactive = csize = unspecified;
 948         do_yywrap = gen_line_dirs = usemecs = useecs = true;
 949         reentrant = bison_bridge_lval = bison_bridge_lloc = false;
 950         performance_report = 0;
 951         did_outfilename = 0;
 952         prefix = "yy";
 953         yyclass = 0;
 954         use_read = use_stdout = false;
 955         tablesext = tablesverify = false;
 956         gentables = true;
 957         tablesfilename = tablesname = NULL;
 958     ansi_func_defs = ansi_func_protos = true;
 959
 960         sawcmpflag = false;
 961
 962         /* Initialize dynamic array for holding the rule actions. */
 963         action_size = 2048;     /* default size of action array in bytes */
 964         action_array = allocate_character_array (action_size);
 965         defs1_offset = prolog_offset = action_offset = action_index = 0;
 966         action_array[0] = '\0';
 967
 968         /* Initialize any buffers. */
 969         buf_init (&userdef_buf, sizeof (char)); /* one long string */
 970         buf_init (&defs_buf, sizeof (char *));  /* list of strings */
 971         buf_init (&yydmap_buf, sizeof (char));  /* one long string */
 972         buf_init (&top_buf, sizeof (char));         /* one long string */
 973
 974     {
 975         const char * m4defs_init_str[] = {"m4_changequote\n",
 976                                           "m4_changequote([[, ]])\n"};
 977         buf_init (&m4defs_buf, sizeof (char *));
 978         buf_append (&m4defs_buf, &m4defs_init_str, 2);
 979     }
 980
 981     sf_init ();
 982
 983     /* initialize regex lib */
 984     flex_init_regex();
 985
 986         /* Enable C++ if program name ends with '+'. */
 987         program_name = basename2 (argv[0], 0);
 988
 989         if (program_name[0] != '\0' &&
 990             program_name[strlen (program_name) - 1] == '+')
 991                 C_plus_plus = true;
 992
 993         /* read flags */
 994         sopt = scanopt_init (flexopts, argc, argv, 0);
 995         if (!sopt) {
 996                 /* This will only happen when flexopts array is altered. */
 997                 fprintf (stderr,
 998                          _("Internal error. flexopts are malformed.\n"));
 999                 FLEX_EXIT (1);
1000         }
1001
1002         while ((rv = scanopt (sopt, &arg, &optind)) != 0) {
1003
1004                 if (rv < 0) {
1005                         /* Scanopt has already printed an option-specific error message. */
1006                         fprintf (stderr,
1007                                  _
1008                                  ("Try `%s --help' for more information.\n"),
1009                                  program_name);
1010                         FLEX_EXIT (1);
1011                 }
1012
1013                 switch ((enum flexopt_flag_t) rv) {
1014                 case OPT_CPLUSPLUS:
1015                         C_plus_plus = true;
1016                         break;
1017
1018                 case OPT_BATCH:
1019                         interactive = false;
1020                         break;
1021
1022                 case OPT_BACKUP:
1023                         backing_up_report = true;
1024                         break;
1025
1026                 case OPT_DONOTHING:
1027                         break;
1028
1029                 case OPT_COMPRESSION:
1030                         if (!sawcmpflag) {
1031                                 useecs = false;
1032                                 usemecs = false;
1033                                 fulltbl = false;
1034                                 sawcmpflag = true;
1035                         }
1036
1037                         for (i = 0; arg && arg[i] != '\0'; i++)
1038                                 switch (arg[i]) {
1039                                 case 'a':
1040                                         long_align = true;
1041                                         break;
1042
1043                                 case 'e':
1044                                         useecs = true;
1045                                         break;
1046
1047                                 case 'F':
1048                                         fullspd = true;
1049                                         break;
1050
1051                                 case 'f':
1052                                         fulltbl = true;
1053                                         break;
1054
1055                                 case 'm':
1056                                         usemecs = true;
1057                                         break;
1058
1059                                 case 'r':
1060                                         use_read = true;
1061                                         break;
1062
1063                                 default:
1064                                         lerrif (_
1065                                                 ("unknown -C option '%c'"),
1066                                                 (int) arg[i]);
1067                                         break;
1068                                 }
1069                         break;
1070
1071                 case OPT_DEBUG:
1072                         ddebug = true;
1073                         break;
1074
1075                 case OPT_NO_DEBUG:
1076                         ddebug = false;
1077                         break;
1078
1079                 case OPT_FULL:
1080                         useecs = usemecs = false;
1081                         use_read = fulltbl = true;
1082                         break;
1083
1084                 case OPT_FAST:
1085                         useecs = usemecs = false;
1086                         use_read = fullspd = true;
1087                         break;
1088
1089                 case OPT_HELP:
1090                         usage ();
1091                         FLEX_EXIT (0);
1092
1093                 case OPT_INTERACTIVE:
1094                         interactive = true;
1095                         break;
1096
1097                 case OPT_CASE_INSENSITIVE:
1098                         sf_set_case_ins(true);
1099                         break;
1100
1101                 case OPT_LEX_COMPAT:
1102                         lex_compat = true;
1103                         break;
1104
1105                 case OPT_POSIX_COMPAT:
1106                         posix_compat = true;
1107                         break;
1108
1109         case OPT_PREPROC_LEVEL:
1110             preproc_level = strtol(arg,NULL,0);
1111             break;
1112
1113                 case OPT_MAIN:
1114                         buf_strdefine (&userdef_buf, "YY_MAIN", "1");
1115                         do_yywrap = false;
1116                         break;
1117
1118                 case OPT_NO_MAIN:
1119                         buf_strdefine (&userdef_buf, "YY_MAIN", "0");
1120                         break;
1121
1122                 case OPT_NO_LINE:
1123                         gen_line_dirs = false;
1124                         break;
1125
1126                 case OPT_OUTFILE:
1127                         outfilename = arg;
1128                         did_outfilename = 1;
1129                         break;
1130
1131                 case OPT_PREFIX:
1132                         prefix = arg;
1133                         break;
1134
1135                 case OPT_PERF_REPORT:
1136                         ++performance_report;
1137                         break;
1138
1139                 case OPT_BISON_BRIDGE:
1140                         bison_bridge_lval = true;
1141                         break;
1142
1143                 case OPT_BISON_BRIDGE_LOCATIONS:
1144                         bison_bridge_lval = bison_bridge_lloc = true;
1145                         break;
1146
1147                 case OPT_REENTRANT:
1148                         reentrant = true;
1149                         break;
1150
1151                 case OPT_NO_REENTRANT:
1152                         reentrant = false;
1153                         break;
1154
1155                 case OPT_SKEL:
1156                         skelname = arg;
1157                         break;
1158
1159                 case OPT_DEFAULT:
1160                         spprdflt = false;
1161                         break;
1162
1163                 case OPT_NO_DEFAULT:
1164                         spprdflt = true;
1165                         break;
1166
1167                 case OPT_STDOUT:
1168                         use_stdout = true;
1169                         break;
1170
1171                 case OPT_NO_UNISTD_H:
1172                         //buf_strdefine (&userdef_buf, "YY_NO_UNISTD_H", "1");
1173             buf_m4_define( &m4defs_buf, "M4_YY_NO_UNISTD_H",0);
1174                         break;
1175
1176                 case OPT_TABLES_FILE:
1177                         tablesext = true;
1178                         tablesfilename = arg;
1179                         break;
1180
1181                 case OPT_TABLES_VERIFY:
1182                         tablesverify = true;
1183                         break;
1184
1185                 case OPT_TRACE:
1186                         trace = true;
1187                         break;
1188
1189                 case OPT_VERBOSE:
1190                         printstats = true;
1191                         break;
1192
1193                 case OPT_VERSION:
1194                         printf (_("%s %s\n"), program_name, flex_version);
1195                         FLEX_EXIT (0);
1196
1197                 case OPT_WARN:
1198                         nowarn = false;
1199                         break;
1200
1201                 case OPT_NO_WARN:
1202                         nowarn = true;
1203                         break;
1204
1205                 case OPT_7BIT:
1206                         csize = 128;
1207                         break;
1208
1209                 case OPT_8BIT:
1210                         csize = CSIZE;
1211                         break;
1212
1213                 case OPT_ALIGN:
1214                         long_align = true;
1215                         break;
1216
1217                 case OPT_NO_ALIGN:
1218                         long_align = false;
1219                         break;
1220
1221                 case OPT_ALWAYS_INTERACTIVE:
1222                         buf_m4_define (&m4defs_buf, "M4_YY_ALWAYS_INTERACTIVE", 0);
1223                         break;
1224
1225                 case OPT_NEVER_INTERACTIVE:
1226             buf_m4_define( &m4defs_buf, "M4_YY_NEVER_INTERACTIVE", 0);
1227                         break;
1228
1229                 case OPT_ARRAY:
1230                         yytext_is_array = true;
1231                         break;
1232
1233                 case OPT_POINTER:
1234                         yytext_is_array = false;
1235                         break;
1236
1237                 case OPT_ECS:
1238                         useecs = true;
1239                         break;
1240
1241                 case OPT_NO_ECS:
1242                         useecs = false;
1243                         break;
1244
1245                 case OPT_HEADER_FILE:
1246                         headerfilename = arg;
1247                         break;
1248
1249                 case OPT_META_ECS:
1250                         usemecs = true;
1251                         break;
1252
1253                 case OPT_NO_META_ECS:
1254                         usemecs = false;
1255                         break;
1256
1257                 case OPT_PREPROCDEFINE:
1258                         {
1259                                 /* arg is "symbol" or "symbol=definition". */
1260                                 char   *def;
1261
1262                                 for (def = arg;
1263                                      *def != '\0' && *def != '='; ++def) ;
1264
1265                                 buf_strappend (&userdef_buf, "#define ");
1266                                 if (*def == '\0') {
1267                                         buf_strappend (&userdef_buf, arg);
1268                                         buf_strappend (&userdef_buf,
1269                                                        " 1\n");
1270                                 }
1271                                 else {
1272                                         buf_strnappend (&userdef_buf, arg,
1273                                                         def - arg);
1274                                         buf_strappend (&userdef_buf, " ");
1275                                         buf_strappend (&userdef_buf,
1276                                                        def + 1);
1277                                         buf_strappend (&userdef_buf, "\n");
1278                                 }
1279                         }
1280                         break;
1281
1282                 case OPT_READ:
1283                         use_read = true;
1284                         break;
1285
1286                 case OPT_STACK:
1287                         //buf_strdefine (&userdef_buf, "YY_STACK_USED", "1");
1288             buf_m4_define( &m4defs_buf, "M4_YY_STACK_USED",0);
1289                         break;
1290
1291                 case OPT_STDINIT:
1292                         do_stdinit = true;
1293                         break;
1294
1295                 case OPT_NO_STDINIT:
1296                         do_stdinit = false;
1297                         break;
1298
1299                 case OPT_YYCLASS:
1300                         yyclass = arg;
1301                         break;
1302
1303                 case OPT_YYLINENO:
1304                         do_yylineno = true;
1305                         break;
1306
1307                 case OPT_NO_YYLINENO:
1308                         do_yylineno = false;
1309                         break;
1310
1311                 case OPT_YYWRAP:
1312                         do_yywrap = true;
1313                         break;
1314
1315                 case OPT_NO_YYWRAP:
1316                         do_yywrap = false;
1317                         break;
1318
1319                 case OPT_YYMORE:
1320                         yymore_really_used = true;
1321                         break;
1322
1323                 case OPT_NO_YYMORE:
1324                         yymore_really_used = false;
1325                         break;
1326
1327                 case OPT_REJECT:
1328                         reject_really_used = true;
1329                         break;
1330
1331                 case OPT_NO_REJECT:
1332                         reject_really_used = false;
1333                         break;
1334
1335         case OPT_NO_ANSI_FUNC_DEFS:
1336             ansi_func_defs = false;
1337             break;
1338
1339         case OPT_NO_ANSI_FUNC_PROTOS:
1340             ansi_func_protos = false;
1341             break;
1342
1343                 case OPT_NO_YY_PUSH_STATE:
1344                         //buf_strdefine (&userdef_buf, "YY_NO_PUSH_STATE", "1");
1345             buf_m4_define( &m4defs_buf, "M4_YY_NO_PUSH_STATE",0);
1346                         break;
1347                 case OPT_NO_YY_POP_STATE:
1348                         //buf_strdefine (&userdef_buf, "YY_NO_POP_STATE", "1");
1349             buf_m4_define( &m4defs_buf, "M4_YY_NO_POP_STATE",0);
1350                         break;
1351                 case OPT_NO_YY_TOP_STATE:
1352                         //buf_strdefine (&userdef_buf, "YY_NO_TOP_STATE", "1");
1353             buf_m4_define( &m4defs_buf, "M4_YY_NO_TOP_STATE",0);
1354                         break;
1355                 case OPT_NO_UNPUT:
1356                         //buf_strdefine (&userdef_buf, "YY_NO_UNPUT", "1");
1357             buf_m4_define( &m4defs_buf, "M4_YY_NO_UNPUT",0);
1358                         break;
1359                 case OPT_NO_YY_SCAN_BUFFER:
1360                         //buf_strdefine (&userdef_buf, "YY_NO_SCAN_BUFFER", "1");
1361             buf_m4_define( &m4defs_buf, "M4_YY_NO_SCAN_BUFFER",0);
1362                         break;
1363                 case OPT_NO_YY_SCAN_BYTES:
1364                         //buf_strdefine (&userdef_buf, "YY_NO_SCAN_BYTES", "1");
1365             buf_m4_define( &m4defs_buf, "M4_YY_NO_SCAN_BYTES",0);
1366                         break;
1367                 case OPT_NO_YY_SCAN_STRING:
1368                         //buf_strdefine (&userdef_buf, "YY_NO_SCAN_STRING", "1");
1369             buf_m4_define( &m4defs_buf, "M4_YY_NO_SCAN_STRING",0);
1370                         break;
1371                 case OPT_NO_YYGET_EXTRA:
1372                         //buf_strdefine (&userdef_buf, "YY_NO_GET_EXTRA", "1");
1373             buf_m4_define( &m4defs_buf, "M4_YY_NO_GET_EXTRA",0);
1374                         break;
1375                 case OPT_NO_YYSET_EXTRA:
1376                         //buf_strdefine (&userdef_buf, "YY_NO_SET_EXTRA", "1");
1377             buf_m4_define( &m4defs_buf, "M4_YY_NO_SET_EXTRA",0);
1378                         break;
1379                 case OPT_NO_YYGET_LENG:
1380                         //buf_strdefine (&userdef_buf, "YY_NO_GET_LENG", "1");
1381             buf_m4_define( &m4defs_buf, "M4_YY_NO_GET_LENG",0);
1382                         break;
1383                 case OPT_NO_YYGET_TEXT:
1384                         //buf_strdefine (&userdef_buf, "YY_NO_GET_TEXT", "1");
1385             buf_m4_define( &m4defs_buf, "M4_YY_NO_GET_TEXT",0);
1386                         break;
1387                 case OPT_NO_YYGET_LINENO:
1388                         //buf_strdefine (&userdef_buf, "YY_NO_GET_LINENO", "1");
1389             buf_m4_define( &m4defs_buf, "M4_YY_NO_GET_LINENO",0);
1390                         break;
1391                 case OPT_NO_YYSET_LINENO:
1392                         //buf_strdefine (&userdef_buf, "YY_NO_SET_LINENO", "1");
1393             buf_m4_define( &m4defs_buf, "M4_YY_NO_SET_LINENO",0);
1394                         break;
1395                 case OPT_NO_YYGET_IN:
1396                         //buf_strdefine (&userdef_buf, "YY_NO_GET_IN", "1");
1397             buf_m4_define( &m4defs_buf, "M4_YY_NO_GET_IN",0);
1398                         break;
1399                 case OPT_NO_YYSET_IN:
1400                         //buf_strdefine (&userdef_buf, "YY_NO_SET_IN", "1");
1401             buf_m4_define( &m4defs_buf, "M4_YY_NO_SET_IN",0);
1402                         break;
1403                 case OPT_NO_YYGET_OUT:
1404                         //buf_strdefine (&userdef_buf, "YY_NO_GET_OUT", "1");
1405             buf_m4_define( &m4defs_buf, "M4_YY_NO_GET_OUT",0);
1406                         break;
1407                 case OPT_NO_YYSET_OUT:
1408                         //buf_strdefine (&userdef_buf, "YY_NO_SET_OUT", "1");
1409             buf_m4_define( &m4defs_buf, "M4_YY_NO_SET_OUT",0);
1410                         break;
1411                 case OPT_NO_YYGET_LVAL:
1412                         //buf_strdefine (&userdef_buf, "YY_NO_GET_LVAL", "1");
1413             buf_m4_define( &m4defs_buf, "M4_YY_NO_GET_LVAL",0);
1414                         break;
1415                 case OPT_NO_YYSET_LVAL:
1416                         //buf_strdefine (&userdef_buf, "YY_NO_SET_LVAL", "1");
1417             buf_m4_define( &m4defs_buf, "M4_YY_NO_SET_LVAL",0);
1418                         break;
1419                 case OPT_NO_YYGET_LLOC:
1420                         //buf_strdefine (&userdef_buf, "YY_NO_GET_LLOC", "1");
1421             buf_m4_define( &m4defs_buf, "M4_YY_NO_GET_LLOC",0);
1422                         break;
1423                 case OPT_NO_YYSET_LLOC:
1424                         //buf_strdefine (&userdef_buf, "YY_NO_SET_LLOC", "1");
1425             buf_m4_define( &m4defs_buf, "M4_YY_NO_SET_LLOC",0);
1426                         break;
1427
1428                 }               /* switch */
1429         }                       /* while scanopt() */
1430
1431         scanopt_destroy (sopt);
1432
1433         num_input_files = argc - optind;
1434         input_files = argv + optind;
1435         set_input_file (num_input_files > 0 ? input_files[0] : NULL);
1436
1437         lastccl = lastsc = lastdfa = lastnfa = 0;
1438         num_rules = num_eof_rules = default_rule = 0;
1439         numas = numsnpairs = tmpuses = 0;
1440         numecs = numeps = eps2 = num_reallocs = hshcol = dfaeql = totnst =
1441                 0;
1442         numuniq = numdup = hshsave = eofseen = datapos = dataline = 0;
1443         num_backing_up = onesp = numprots = 0;
1444         variable_trailing_context_rules = bol_needed = false;
1445
1446         linenum = sectnum = 1;
1447         firstprot = NIL;
1448
1449         /* Used in mkprot() so that the first proto goes in slot 1
1450          * of the proto queue.
1451          */
1452         lastprot = 1;
1453
1454         set_up_initial_allocations ();
1455 }
1456
1457
1458 /* readin - read in the rules section of the input file(s) */
1459
1460 void readin ()
1461 {
1462         static char yy_stdinit[] = "FILE *yyin = stdin, *yyout = stdout;";
1463         static char yy_nostdinit[] =
1464                 "FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;";
1465
1466         line_directive_out ((FILE *) 0, 1);
1467
1468         if (yyparse ()) {
1469                 pinpoint_message (_("fatal parse error"));
1470                 flexend (1);
1471         }
1472
1473         if (syntaxerror)
1474                 flexend (1);
1475
1476         /* If the user explicitly requested posix compatibility by specifing the
1477          * posix-compat option, then we check for conflicting options. However, if
1478          * the POSIXLY_CORRECT variable is set, then we quietly make flex as
1479          * posix-compatible as possible.  This is the recommended behavior
1480          * according to the GNU Coding Standards.
1481          *
1482          * Note: The posix option was added to flex to provide the posix behavior
1483          * of the repeat operator in regular expressions, e.g., `ab{3}'
1484          */
1485         if (posix_compat) {
1486                 /* TODO: This is where we try to make flex behave according to
1487                  * posiz, AND check for conflicting options. How far should we go
1488                  * with this? Should we disable all the neat-o flex features?
1489                  */
1490                 /* Update: Estes says no, since other flex features don't violate posix. */
1491         }
1492
1493         if (getenv ("POSIXLY_CORRECT")) {
1494                 posix_compat = true;
1495         }
1496
1497         if (backing_up_report) {
1498                 backing_up_file = fopen (backing_name, "w");
1499                 if (backing_up_file == NULL)
1500                         lerrsf (_
1501                                 ("could not create backing-up info file %s"),
1502                                 backing_name);
1503         }
1504
1505         else
1506                 backing_up_file = NULL;
1507
1508         if (yymore_really_used == true)
1509                 yymore_used = true;
1510         else if (yymore_really_used == false)
1511                 yymore_used = false;
1512
1513         if (reject_really_used == true)
1514                 reject = true;
1515         else if (reject_really_used == false)
1516                 reject = false;
1517
1518         if (performance_report > 0) {
1519                 if (lex_compat) {
1520                         fprintf (stderr,
1521                                  _
1522                                  ("-l AT&T lex compatibility option entails a large performance penalty\n"));
1523                         fprintf (stderr,
1524                                  _
1525                                  (" and may be the actual source of other reported performance penalties\n"));
1526                 }
1527
1528                 else if (do_yylineno) {
1529                         fprintf (stderr,
1530                                  _
1531                                  ("%%option yylineno entails a performance penalty ONLY on rules that can match newline characters\n"));
1532                 }
1533
1534                 if (performance_report > 1) {
1535                         if (interactive)
1536                                 fprintf (stderr,
1537                                          _
1538                                          ("-I (interactive) entails a minor performance penalty\n"));
1539
1540                         if (yymore_used)
1541                                 fprintf (stderr,
1542                                          _
1543                                          ("yymore() entails a minor performance penalty\n"));
1544                 }
1545
1546                 if (reject)
1547                         fprintf (stderr,
1548                                  _
1549                                  ("REJECT entails a large performance penalty\n"));
1550
1551                 if (variable_trailing_context_rules)
1552                         fprintf (stderr,
1553                                  _
1554                                  ("Variable trailing context rules entail a large performance penalty\n"));
1555         }
1556
1557         if (reject)
1558                 real_reject = true;
1559
1560         if (variable_trailing_context_rules)
1561                 reject = true;
1562
1563         if ((fulltbl || fullspd) && reject) {
1564                 if (real_reject)
1565                         flexerror (_
1566                                    ("REJECT cannot be used with -f or -F"));
1567                 else if (do_yylineno)
1568                         flexerror (_
1569                                    ("%option yylineno cannot be used with REJECT"));
1570                 else
1571                         flexerror (_
1572                                    ("variable trailing context rules cannot be used with -f or -F"));
1573         }
1574
1575         if (reject){
1576         out_m4_define( "M4_YY_USES_REJECT", NULL);
1577                 //outn ("\n#define YY_USES_REJECT");
1578     }
1579
1580         if (!do_yywrap) {
1581                 if (!C_plus_plus) {
1582                          if (reentrant)
1583                                 outn ("\n#define yywrap(yyscanner) 1");
1584                          else
1585                                 outn ("\n#define yywrap() 1");
1586                 }
1587                 outn ("#define YY_SKIP_YYWRAP");
1588         }
1589
1590         if (ddebug)
1591                 outn ("\n#define FLEX_DEBUG");
1592
1593         OUT_BEGIN_CODE ();
1594         if (csize == 256)
1595                 outn ("typedef unsigned char YY_CHAR;");
1596         else
1597                 outn ("typedef char YY_CHAR;");
1598         OUT_END_CODE ();
1599
1600         if (C_plus_plus) {
1601                 outn ("#define yytext_ptr yytext");
1602
1603                 if (interactive)
1604                         outn ("#define YY_INTERACTIVE");
1605         }
1606
1607         else {
1608                 OUT_BEGIN_CODE ();
1609                 /* In reentrant scanner, stdinit is handled in flex.skl. */
1610                 if (do_stdinit) {
1611                         if (reentrant){
1612                 outn ("#ifdef VMS");
1613                 outn ("#ifdef __VMS_POSIX");
1614                 outn ("#define YY_STDINIT");
1615                 outn ("#endif");
1616                 outn ("#else");
1617                 outn ("#define YY_STDINIT");
1618                 outn ("#endif");
1619             }
1620
1621                         outn ("#ifdef VMS");
1622                         outn ("#ifndef __VMS_POSIX");
1623                         outn (yy_nostdinit);
1624                         outn ("#else");
1625                         outn (yy_stdinit);
1626                         outn ("#endif");
1627                         outn ("#else");
1628                         outn (yy_stdinit);
1629                         outn ("#endif");
1630                 }
1631
1632                 else {
1633                         if(!reentrant)
1634                 outn (yy_nostdinit);
1635                 }
1636                 OUT_END_CODE ();
1637         }
1638
1639         OUT_BEGIN_CODE ();
1640         if (fullspd)
1641                 outn ("typedef yyconst struct yy_trans_info *yy_state_type;");
1642         else if (!C_plus_plus)
1643                 outn ("typedef int yy_state_type;");
1644         OUT_END_CODE ();
1645
1646         if (lex_compat)
1647                 outn ("#define YY_FLEX_LEX_COMPAT");
1648
1649         if (!C_plus_plus && !reentrant) {
1650                 outn ("extern int yylineno;");
1651                 OUT_BEGIN_CODE ();
1652                 outn ("int yylineno = 1;");
1653                 OUT_END_CODE ();
1654         }
1655
1656         if (C_plus_plus) {
1657                 outn ("\n#include <FlexLexer.h>");
1658
1659                 if (!do_yywrap) {
1660                         outn("\nint yyFlexLexer::yywrap() { return 1; }");
1661                 }
1662
1663                 if (yyclass) {
1664                         outn ("int yyFlexLexer::yylex()");
1665                         outn ("\t{");
1666                         outn ("\tLexerError( \"yyFlexLexer::yylex invoked but %option yyclass used\" );");
1667                         outn ("\treturn 0;");
1668                         outn ("\t}");
1669
1670                         out_str ("\n#define YY_DECL int %s::yylex()\n",
1671                                  yyclass);
1672                 }
1673         }
1674
1675         else {
1676
1677                 /* Watch out: yytext_ptr is a variable when yytext is an array,
1678                  * but it's a macro when yytext is a pointer.
1679                  */
1680                 if (yytext_is_array) {
1681                         if (!reentrant)
1682                                 outn ("extern char yytext[];\n");
1683                 }
1684                 else {
1685                         if (reentrant) {
1686                                 outn ("#define yytext_ptr yytext_r");
1687                         }
1688                         else {
1689                                 outn ("extern char *yytext;");
1690                                 outn ("#define yytext_ptr yytext");
1691                         }
1692                 }
1693
1694                 if (yyclass)
1695                         flexerror (_
1696                                    ("%option yyclass only meaningful for C++ scanners"));
1697         }
1698
1699         if (useecs)
1700                 numecs = cre8ecs (nextecm, ecgroup, csize);
1701         else
1702                 numecs = csize;
1703
1704         /* Now map the equivalence class for NUL to its expected place. */
1705         ecgroup[0] = ecgroup[csize];
1706         NUL_ec = ABS (ecgroup[0]);
1707
1708         if (useecs)
1709                 ccl2ecl ();
1710 }
1711
1712
1713 /* set_up_initial_allocations - allocate memory for internal tables */
1714
1715 void set_up_initial_allocations ()
1716 {
1717         maximum_mns = (long_align ? MAXIMUM_MNS_LONG : MAXIMUM_MNS);
1718         current_mns = INITIAL_MNS;
1719         firstst = allocate_integer_array (current_mns);
1720         lastst = allocate_integer_array (current_mns);
1721         finalst = allocate_integer_array (current_mns);
1722         transchar = allocate_integer_array (current_mns);
1723         trans1 = allocate_integer_array (current_mns);
1724         trans2 = allocate_integer_array (current_mns);
1725         accptnum = allocate_integer_array (current_mns);
1726         assoc_rule = allocate_integer_array (current_mns);
1727         state_type = allocate_integer_array (current_mns);
1728
1729         current_max_rules = INITIAL_MAX_RULES;
1730         rule_type = allocate_integer_array (current_max_rules);
1731         rule_linenum = allocate_integer_array (current_max_rules);
1732         rule_useful = allocate_integer_array (current_max_rules);
1733         rule_has_nl = allocate_bool_array (current_max_rules);
1734
1735         current_max_scs = INITIAL_MAX_SCS;
1736         scset = allocate_integer_array (current_max_scs);
1737         scbol = allocate_integer_array (current_max_scs);
1738         scxclu = allocate_integer_array (current_max_scs);
1739         sceof = allocate_integer_array (current_max_scs);
1740         scname = allocate_char_ptr_array (current_max_scs);
1741
1742         current_maxccls = INITIAL_MAX_CCLS;
1743         cclmap = allocate_integer_array (current_maxccls);
1744         ccllen = allocate_integer_array (current_maxccls);
1745         cclng = allocate_integer_array (current_maxccls);
1746         ccl_has_nl = allocate_bool_array (current_maxccls);
1747
1748         current_max_ccl_tbl_size = INITIAL_MAX_CCL_TBL_SIZE;
1749         ccltbl = allocate_Character_array (current_max_ccl_tbl_size);
1750
1751         current_max_dfa_size = INITIAL_MAX_DFA_SIZE;
1752
1753         current_max_xpairs = INITIAL_MAX_XPAIRS;
1754         nxt = allocate_integer_array (current_max_xpairs);
1755         chk = allocate_integer_array (current_max_xpairs);
1756
1757         current_max_template_xpairs = INITIAL_MAX_TEMPLATE_XPAIRS;
1758         tnxt = allocate_integer_array (current_max_template_xpairs);
1759
1760         current_max_dfas = INITIAL_MAX_DFAS;
1761         base = allocate_integer_array (current_max_dfas);
1762         def = allocate_integer_array (current_max_dfas);
1763         dfasiz = allocate_integer_array (current_max_dfas);
1764         accsiz = allocate_integer_array (current_max_dfas);
1765         dhash = allocate_integer_array (current_max_dfas);
1766         dss = allocate_int_ptr_array (current_max_dfas);
1767         dfaacc = allocate_dfaacc_union (current_max_dfas);
1768
1769         nultrans = (int *) 0;
1770 }
1771
1772
1773 /* extracts basename from path, optionally stripping the extension "\.*"
1774  * (same concept as /bin/sh `basename`, but different handling of extension). */
1775 static char *basename2 (path, strip_ext)
1776      char   *path;
1777      int strip_ext;             /* boolean */
1778 {
1779         char   *b, *e = 0;
1780
1781         b = path;
1782         for (b = path; *path; path++)
1783                 if (*path == '/')
1784                         b = path + 1;
1785                 else if (*path == '.')
1786                         e = path;
1787
1788         if (strip_ext && e && e > b)
1789                 *e = '\0';
1790         return b;
1791 }
1792
1793 void usage ()
1794 {
1795         FILE   *f = stdout;
1796
1797         if (!did_outfilename) {
1798                 snprintf (outfile_path, sizeof(outfile_path), outfile_template,
1799                          prefix, C_plus_plus ? "cc" : "c");
1800                 outfilename = outfile_path;
1801         }
1802
1803         fprintf (f, _("Usage: %s [OPTIONS] [FILE]...\n"), program_name);
1804         fprintf (f,
1805                  _
1806                  ("Generates programs that perform pattern-matching on text.\n"
1807                   "\n" "Table Compression:\n"
1808                   "  -Ca, --align      trade off larger tables for better memory alignment\n"
1809                   "  -Ce, --ecs        construct equivalence classes\n"
1810                   "  -Cf               do not compress tables; use -f representation\n"
1811                   "  -CF               do not compress tables; use -F representation\n"
1812                   "  -Cm, --meta-ecs   construct meta-equivalence classes\n"
1813                   "  -Cr, --read       use read() instead of stdio for scanner input\n"
1814                   "  -f, --full        generate fast, large scanner. Same as -Cfr\n"
1815                   "  -F, --fast        use alternate table representation. Same as -CFr\n"
1816                   "  -Cem              default compression (same as --ecs --meta-ecs)\n"
1817                   "\n" "Debugging:\n"
1818                   "  -d, --debug             enable debug mode in scanner\n"
1819                   "  -b, --backup            write backing-up information to %s\n"
1820                   "  -p, --perf-report       write performance report to stderr\n"
1821                   "  -s, --nodefault         suppress default rule to ECHO unmatched text\n"
1822                   "  -T, --trace             %s should run in trace mode\n"
1823                   "  -w, --nowarn            do not generate warnings\n"
1824                   "  -v, --verbose           write summary of scanner statistics to stdout\n"
1825                   "\n" "Files:\n"
1826                   "  -o, --outfile=FILE      specify output filename\n"
1827                   "  -S, --skel=FILE         specify skeleton file\n"
1828                   "  -t, --stdout            write scanner on stdout instead of %s\n"
1829                   "      --yyclass=NAME      name of C++ class\n"
1830                   "      --header-file=FILE   create a C header file in addition to the scanner\n"
1831                   "      --tables-file[=FILE] write tables to FILE\n" "\n"
1832                   "Scanner behavior:\n"
1833                   "  -7, --7bit              generate 7-bit scanner\n"
1834                   "  -8, --8bit              generate 8-bit scanner\n"
1835                   "  -B, --batch             generate batch scanner (opposite of -I)\n"
1836                   "  -i, --case-insensitive  ignore case in patterns\n"
1837                   "  -l, --lex-compat        maximal compatibility with original lex\n"
1838                   "  -X, --posix-compat      maximal compatibility with POSIX lex\n"
1839                   "  -I, --interactive       generate interactive scanner (opposite of -B)\n"
1840                   "      --yylineno          track line count in yylineno\n"
1841                   "\n" "Generated code:\n"
1842                   "  -+,  --c++               generate C++ scanner class\n"
1843                   "  -Dmacro[=defn]           #define macro defn  (default defn is '1')\n"
1844                   "  -L,  --noline            suppress #line directives in scanner\n"
1845                   "  -P,  --prefix=STRING     use STRING as prefix instead of \"yy\"\n"
1846                   "  -R,  --reentrant         generate a reentrant C scanner\n"
1847                   "       --bison-bridge      scanner for bison pure parser.\n"
1848                   "       --bison-locations   include yylloc support.\n"
1849                   "       --stdinit           initialize yyin/yyout to stdin/stdout\n"
1850           "       --noansi-definitions old-style function definitions\n"
1851           "       --noansi-prototypes  empty parameter list in prototypes\n"
1852                   "       --nounistd          do not include <unistd.h>\n"
1853                   "       --noFUNCTION        do not generate a particular FUNCTION\n"
1854                   "\n" "Miscellaneous:\n"
1855                   "  -c                      do-nothing POSIX option\n"
1856                   "  -n                      do-nothing POSIX option\n"
1857                   "  -?\n"
1858                   "  -h, --help              produce this help message\n"
1859                   "  -V, --version           report %s version\n"),
1860                  backing_name, program_name, outfile_path, program_name);
1861
1862 }