| /* flex - tool to generate fast lexical analyzers */ |
| |
| /* Copyright (c) 1990 The Regents of the University of California. */ |
| /* All rights reserved. */ |
| |
| /* This code is derived from software contributed to Berkeley by */ |
| /* Vern Paxson. */ |
| |
| /* The United States Government has rights in this work pursuant */ |
| /* to contract no. DE-AC03-76SF00098 between the United States */ |
| /* Department of Energy and the University of California. */ |
| |
| /* This file is part of flex. */ |
| |
| /* Redistribution and use in source and binary forms, with or without */ |
| /* modification, are permitted provided that the following conditions */ |
| /* are met: */ |
| |
| /* 1. Redistributions of source code must retain the above copyright */ |
| /* notice, this list of conditions and the following disclaimer. */ |
| /* 2. Redistributions in binary form must reproduce the above copyright */ |
| /* notice, this list of conditions and the following disclaimer in the */ |
| /* documentation and/or other materials provided with the distribution. */ |
| |
| /* Neither the name of the University nor the names of its contributors */ |
| /* may be used to endorse or promote products derived from this software */ |
| /* without specific prior written permission. */ |
| |
| /* THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR */ |
| /* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED */ |
| /* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR */ |
| /* PURPOSE. */ |
| |
| |
| #include "flexdef.h" |
| #include "version.h" |
| #include "options.h" |
| #include "tables.h" |
| |
| static char flex_version[] = FLEX_VERSION; |
| |
| /* declare functions that have forward references */ |
| |
| void flexinit PROTO ((int, char **)); |
| void readin PROTO ((void)); |
| void set_up_initial_allocations PROTO ((void)); |
| static char *basename2 PROTO ((char *path, int should_strip_ext)); |
| |
| |
| /* these globals are all defined and commented in flexdef.h */ |
| int printstats, syntaxerror, eofseen, ddebug, trace, nowarn, spprdflt; |
| int interactive, lex_compat, posix_compat, do_yylineno, |
| useecs, fulltbl, usemecs; |
| int fullspd, gen_line_dirs, performance_report, backing_up_report; |
| int C_plus_plus, long_align, use_read, yytext_is_array, do_yywrap, |
| csize; |
| int reentrant, bison_bridge_lval, bison_bridge_lloc; |
| int yymore_used, reject, real_reject, continued_action, in_rule; |
| int yymore_really_used, reject_really_used; |
| int datapos, dataline, linenum; |
| FILE *skelfile = NULL; |
| int skel_ind = 0; |
| char *action_array; |
| int action_size, defs1_offset, prolog_offset, action_offset, |
| action_index; |
| char *infilename = NULL, *outfilename = NULL, *headerfilename = NULL; |
| int did_outfilename; |
| char *prefix, *yyclass, *extra_type = NULL; |
| int do_stdinit, use_stdout; |
| int onestate[ONE_STACK_SIZE], onesym[ONE_STACK_SIZE]; |
| int onenext[ONE_STACK_SIZE], onedef[ONE_STACK_SIZE], onesp; |
| int maximum_mns, current_mns, current_max_rules; |
| int num_rules, num_eof_rules, default_rule, lastnfa; |
| int *firstst, *lastst, *finalst, *transchar, *trans1, *trans2; |
| int *accptnum, *assoc_rule, *state_type; |
| int *rule_type, *rule_linenum, *rule_useful; |
| int current_state_type; |
| int variable_trailing_context_rules; |
| int numtemps, numprots, protprev[MSP], protnext[MSP], prottbl[MSP]; |
| int protcomst[MSP], firstprot, lastprot, protsave[PROT_SAVE_SIZE]; |
| int numecs, nextecm[CSIZE + 1], ecgroup[CSIZE + 1], nummecs, |
| tecfwd[CSIZE + 1]; |
| int tecbck[CSIZE + 1]; |
| int lastsc, *scset, *scbol, *scxclu, *sceof; |
| int current_max_scs; |
| char **scname; |
| int current_max_dfa_size, current_max_xpairs; |
| int current_max_template_xpairs, current_max_dfas; |
| int lastdfa, *nxt, *chk, *tnxt; |
| int *base, *def, *nultrans, NUL_ec, tblend, firstfree, **dss, *dfasiz; |
| union dfaacc_union *dfaacc; |
| int *accsiz, *dhash, numas; |
| int numsnpairs, jambase, jamstate; |
| int lastccl, *cclmap, *ccllen, *cclng, cclreuse; |
| int current_maxccls, current_max_ccl_tbl_size; |
| Char *ccltbl; |
| char nmstr[MAXLINE]; |
| int sectnum, nummt, hshcol, dfaeql, numeps, eps2, num_reallocs; |
| int tmpuses, totnst, peakpairs, numuniq, numdup, hshsave; |
| int num_backing_up, bol_needed; |
| FILE *backing_up_file; |
| int end_of_buffer_state; |
| char **input_files; |
| int num_input_files; |
| jmp_buf flex_main_jmp_buf; |
| bool *rule_has_nl, *ccl_has_nl; |
| int nlch = '\n'; |
| bool ansi_func_defs, ansi_func_protos; |
| |
| bool tablesext, tablesverify, gentables; |
| char *tablesfilename=0,*tablesname=0; |
| struct yytbl_writer tableswr; |
| |
| /* Make sure program_name is initialized so we don't crash if writing |
| * out an error message before getting the program name from argv[0]. |
| */ |
| char *program_name = "flex"; |
| |
| #ifndef SHORT_FILE_NAMES |
| static char *outfile_template = "lex.%s.%s"; |
| static char *backing_name = "lex.backup"; |
| static char *tablesfile_template = "lex.%s.tables"; |
| #else |
| static char *outfile_template = "lex%s.%s"; |
| static char *backing_name = "lex.bck"; |
| static char *tablesfile_template = "lex%s.tbl"; |
| #endif |
| |
| #ifdef MS_DOS |
| extern unsigned _stklen = 16384; |
| #endif |
| |
| /* From scan.l */ |
| extern FILE* yyout; |
| |
| static char outfile_path[MAXLINE]; |
| static int outfile_created = 0; |
| static char *skelname = NULL; |
| static int _stdout_closed = 0; /* flag to prevent double-fclose() on stdout. */ |
| const char *escaped_qstart = "[[]]M4_YY_NOOP[M4_YY_NOOP[M4_YY_NOOP[[]]"; |
| const char *escaped_qend = "[[]]M4_YY_NOOP]M4_YY_NOOP]M4_YY_NOOP[[]]"; |
| |
| /* For debugging. The max number of filters to apply to skeleton. */ |
| static int preproc_level = 1000; |
| |
| int flex_main PROTO ((int argc, char *argv[])); |
| int main PROTO ((int argc, char *argv[])); |
| |
| int flex_main (argc, argv) |
| int argc; |
| char *argv[]; |
| { |
| int i, exit_status, child_status; |
| |
| /* Set a longjmp target. Yes, I know it's a hack, but it gets worse: The |
| * return value of setjmp, if non-zero, is the desired exit code PLUS ONE. |
| * For example, if you want 'main' to return with code '2', then call |
| * longjmp() with an argument of 3. This is because it is invalid to |
| * specify a value of 0 to longjmp. FLEX_EXIT(n) should be used instead of |
| * exit(n); |
| */ |
| exit_status = setjmp (flex_main_jmp_buf); |
| if (exit_status){ |
| if (stdout && !_stdout_closed && !ferror(stdout)){ |
| fflush(stdout); |
| fclose(stdout); |
| } |
| while (wait(&child_status) > 0){ |
| if (!WIFEXITED (child_status) |
| || WEXITSTATUS (child_status) != 0){ |
| /* report an error of a child |
| */ |
| if( exit_status <= 1 ) |
| exit_status = 2; |
| |
| } |
| } |
| return exit_status - 1; |
| } |
| |
| flexinit (argc, argv); |
| |
| readin (); |
| |
| skelout (); |
| /* %% [1.5] DFA */ |
| ntod (); |
| |
| for (i = 1; i <= num_rules; ++i) |
| if (!rule_useful[i] && i != default_rule) |
| line_warning (_("rule cannot be matched"), |
| rule_linenum[i]); |
| |
| if (spprdflt && !reject && rule_useful[default_rule]) |
| line_warning (_ |
| ("-s option given but default rule can be matched"), |
| rule_linenum[default_rule]); |
| |
| /* Generate the C state transition tables from the DFA. */ |
| make_tables (); |
| |
| /* Note, flexend does not return. It exits with its argument |
| * as status. |
| */ |
| flexend (0); |
| |
| return 0; /* keep compilers/lint happy */ |
| } |
| |
| /* Wrapper around flex_main, so flex_main can be built as a library. */ |
| int main (argc, argv) |
| int argc; |
| char *argv[]; |
| { |
| #if ENABLE_NLS |
| #if HAVE_LOCALE_H |
| setlocale (LC_MESSAGES, ""); |
| setlocale (LC_CTYPE, ""); |
| textdomain (PACKAGE); |
| bindtextdomain (PACKAGE, LOCALEDIR); |
| #endif |
| #endif |
| |
| return flex_main (argc, argv); |
| } |
| |
| /* check_options - check user-specified options */ |
| |
| void check_options () |
| { |
| int i; |
| const char * m4 = NULL; |
| |
| if (lex_compat) { |
| if (C_plus_plus) |
| flexerror (_("Can't use -+ with -l option")); |
| |
| if (fulltbl || fullspd) |
| flexerror (_("Can't use -f or -F with -l option")); |
| |
| if (reentrant || bison_bridge_lval) |
| flexerror (_ |
| ("Can't use --reentrant or --bison-bridge with -l option")); |
| |
| yytext_is_array = true; |
| do_yylineno = true; |
| use_read = false; |
| } |
| |
| |
| #if 0 |
| /* This makes no sense whatsoever. I'm removing it. */ |
| if (do_yylineno) |
| /* This should really be "maintain_backup_tables = true" */ |
| reject_really_used = true; |
| #endif |
| |
| if (csize == unspecified) { |
| if ((fulltbl || fullspd) && !useecs) |
| csize = DEFAULT_CSIZE; |
| else |
| csize = CSIZE; |
| } |
| |
| if (interactive == unspecified) { |
| if (fulltbl || fullspd) |
| interactive = false; |
| else |
| interactive = true; |
| } |
| |
| if (fulltbl || fullspd) { |
| if (usemecs) |
| flexerror (_ |
| ("-Cf/-CF and -Cm don't make sense together")); |
| |
| if (interactive) |
| flexerror (_("-Cf/-CF and -I are incompatible")); |
| |
| if (lex_compat) |
| flexerror (_ |
| ("-Cf/-CF are incompatible with lex-compatibility mode")); |
| |
| |
| if (fulltbl && fullspd) |
| flexerror (_ |
| ("-Cf and -CF are mutually exclusive")); |
| } |
| |
| if (C_plus_plus && fullspd) |
| flexerror (_("Can't use -+ with -CF option")); |
| |
| if (C_plus_plus && yytext_is_array) { |
| warn (_("%array incompatible with -+ option")); |
| yytext_is_array = false; |
| } |
| |
| if (C_plus_plus && (reentrant)) |
| flexerror (_("Options -+ and --reentrant are mutually exclusive.")); |
| |
| if (C_plus_plus && bison_bridge_lval) |
| flexerror (_("bison bridge not supported for the C++ scanner.")); |
| |
| |
| if (useecs) { /* Set up doubly-linked equivalence classes. */ |
| |
| /* We loop all the way up to csize, since ecgroup[csize] is |
| * the position used for NUL characters. |
| */ |
| ecgroup[1] = NIL; |
| |
| for (i = 2; i <= csize; ++i) { |
| ecgroup[i] = i - 1; |
| nextecm[i - 1] = i; |
| } |
| |
| nextecm[csize] = NIL; |
| } |
| |
| else { |
| /* Put everything in its own equivalence class. */ |
| for (i = 1; i <= csize; ++i) { |
| ecgroup[i] = i; |
| nextecm[i] = BAD_SUBSCRIPT; /* to catch errors */ |
| } |
| } |
| |
| if (!ansi_func_defs) |
| buf_m4_define( &m4defs_buf, "M4_YY_NO_ANSI_FUNC_DEFS", NULL); |
| |
| if (!ansi_func_protos) |
| buf_m4_define( &m4defs_buf, "M4_YY_NO_ANSI_FUNC_PROTOS", NULL); |
| |
| if (extra_type) |
| buf_m4_define( &m4defs_buf, "M4_EXTRA_TYPE_DEFS", extra_type); |
| |
| if (!use_stdout) { |
| FILE *prev_stdout; |
| |
| if (!did_outfilename) { |
| char *suffix; |
| |
| if (C_plus_plus) |
| suffix = "cc"; |
| else |
| suffix = "c"; |
| |
| snprintf (outfile_path, sizeof(outfile_path), outfile_template, |
| prefix, suffix); |
| |
| outfilename = outfile_path; |
| } |
| |
| prev_stdout = freopen (outfilename, "w+", stdout); |
| |
| if (prev_stdout == NULL) |
| lerrsf (_("could not create %s"), outfilename); |
| |
| outfile_created = 1; |
| } |
| |
| |
| /* Setup the filter chain. */ |
| output_chain = filter_create_int(NULL, filter_tee_header, headerfilename); |
| if ( !(m4 = getenv("M4"))) |
| m4 = M4; |
| filter_create_ext(output_chain, m4, "-P", 0); |
| filter_create_int(output_chain, filter_fix_linedirs, NULL); |
| |
| /* For debugging, only run the requested number of filters. */ |
| if (preproc_level > 0) { |
| filter_truncate(output_chain, preproc_level); |
| filter_apply_chain(output_chain); |
| } |
| yyout = stdout; |
| |
| |
| /* always generate the tablesverify flag. */ |
| buf_m4_define (&m4defs_buf, "M4_YY_TABLES_VERIFY", tablesverify ? "1" : "0"); |
| if (tablesext) |
| gentables = false; |
| |
| if (tablesverify) |
| /* force generation of C tables. */ |
| gentables = true; |
| |
| |
| if (tablesext) { |
| FILE *tablesout; |
| struct yytbl_hdr hdr; |
| char *pname = 0; |
| int nbytes = 0; |
| |
| buf_m4_define (&m4defs_buf, "M4_YY_TABLES_EXTERNAL", NULL); |
| |
| if (!tablesfilename) { |
| nbytes = strlen (prefix) + strlen (tablesfile_template) + 2; |
| tablesfilename = pname = (char *) calloc (nbytes, 1); |
| snprintf (pname, nbytes, tablesfile_template, prefix); |
| } |
| |
| if ((tablesout = fopen (tablesfilename, "w")) == NULL) |
| lerrsf (_("could not create %s"), tablesfilename); |
| if (pname) |
| free (pname); |
| tablesfilename = 0; |
| |
| yytbl_writer_init (&tableswr, tablesout); |
| |
| nbytes = strlen (prefix) + strlen ("tables") + 2; |
| tablesname = (char *) calloc (nbytes, 1); |
| snprintf (tablesname, nbytes, "%stables", prefix); |
| yytbl_hdr_init (&hdr, flex_version, tablesname); |
| |
| if (yytbl_hdr_fwrite (&tableswr, &hdr) <= 0) |
| flexerror (_("could not write tables header")); |
| } |
| |
| if (skelname && (skelfile = fopen (skelname, "r")) == NULL) |
| lerrsf (_("can't open skeleton file %s"), skelname); |
| |
| if (reentrant) { |
| buf_m4_define (&m4defs_buf, "M4_YY_REENTRANT", NULL); |
| if (yytext_is_array) |
| buf_m4_define (&m4defs_buf, "M4_YY_TEXT_IS_ARRAY", NULL); |
| } |
| |
| if ( bison_bridge_lval) |
| buf_m4_define (&m4defs_buf, "M4_YY_BISON_LVAL", NULL); |
| |
| if ( bison_bridge_lloc) |
| buf_m4_define (&m4defs_buf, "<M4_YY_BISON_LLOC>", NULL); |
| |
| buf_m4_define(&m4defs_buf, "M4_YY_PREFIX", prefix); |
| |
| if (did_outfilename) |
| line_directive_out (stdout, 0); |
| |
| if (do_yylineno) |
| buf_m4_define (&m4defs_buf, "M4_YY_USE_LINENO", NULL); |
| |
| /* Create the alignment type. */ |
| buf_strdefine (&userdef_buf, "YY_INT_ALIGNED", |
| long_align ? "long int" : "short int"); |
| |
| /* Define the start condition macros. */ |
| { |
| struct Buf tmpbuf; |
| buf_init(&tmpbuf, sizeof(char)); |
| for (i = 1; i <= lastsc; i++) { |
| char *str, *fmt = "#define %s %d\n"; |
| size_t strsz; |
| |
| str = (char*)flex_alloc(strsz = strlen(fmt) + strlen(scname[i]) + (int)(1 + log10(i)) + 2); |
| if (!str) |
| flexfatal(_("allocation of macro definition failed")); |
| snprintf(str, strsz, fmt, scname[i], i - 1); |
| buf_strappend(&tmpbuf, str); |
| free(str); |
| } |
| buf_m4_define(&m4defs_buf, "M4_YY_SC_DEFS", tmpbuf.elts); |
| buf_destroy(&tmpbuf); |
| } |
| |
| /* This is where we begin writing to the file. */ |
| |
| /* Dump the %top code. */ |
| if( top_buf.elts) |
| outn((char*) top_buf.elts); |
| |
| /* Dump the m4 definitions. */ |
| buf_print_strings(&m4defs_buf, stdout); |
| m4defs_buf.nelts = 0; /* memory leak here. */ |
| |
| /* Place a bogus line directive, it will be fixed in the filter. */ |
| outn("#line 0 \"M4_YY_OUTFILE_NAME\"\n"); |
| |
| /* Dump the user defined preproc directives. */ |
| if (userdef_buf.elts) |
| outn ((char *) (userdef_buf.elts)); |
| |
| skelout (); |
| /* %% [1.0] */ |
| } |
| |
| /* flexend - terminate flex |
| * |
| * note |
| * This routine does not return. |
| */ |
| |
| void flexend (exit_status) |
| int exit_status; |
| |
| { |
| static int called_before = -1; /* prevent infinite recursion. */ |
| int tblsiz; |
| |
| if (++called_before) |
| FLEX_EXIT (exit_status); |
| |
| if (skelfile != NULL) { |
| if (ferror (skelfile)) |
| lerrsf (_("input error reading skeleton file %s"), |
| skelname); |
| |
| else if (fclose (skelfile)) |
| lerrsf (_("error closing skeleton file %s"), |
| skelname); |
| } |
| |
| #if 0 |
| fprintf (header_out, |
| "#ifdef YY_HEADER_EXPORT_START_CONDITIONS\n"); |
| fprintf (header_out, |
| "/* Beware! Start conditions are not prefixed. */\n"); |
| |
| /* Special case for "INITIAL" */ |
| fprintf (header_out, |
| "#undef INITIAL\n#define INITIAL 0\n"); |
| for (i = 2; i <= lastsc; i++) |
| fprintf (header_out, "#define %s %d\n", scname[i], i - 1); |
| fprintf (header_out, |
| "#endif /* YY_HEADER_EXPORT_START_CONDITIONS */\n\n"); |
| |
| /* Kill ALL flex-related macros. This is so the user |
| * can #include more than one generated header file. */ |
| fprintf (header_out, "#ifndef YY_HEADER_NO_UNDEFS\n"); |
| fprintf (header_out, |
| "/* Undefine all internal macros, etc., that do no belong in the header. */\n\n"); |
| |
| { |
| const char * undef_list[] = { |
| |
| "BEGIN", |
| "ECHO", |
| "EOB_ACT_CONTINUE_SCAN", |
| "EOB_ACT_END_OF_FILE", |
| "EOB_ACT_LAST_MATCH", |
| "FLEX_SCANNER", |
| "FLEX_STD", |
| "REJECT", |
| "YYFARGS0", |
| "YYFARGS1", |
| "YYFARGS2", |
| "YYFARGS3", |
| "YYLMAX", |
| "YYSTATE", |
| "YY_AT_BOL", |
| "YY_BREAK", |
| "YY_BUFFER_EOF_PENDING", |
| "YY_BUFFER_NEW", |
| "YY_BUFFER_NORMAL", |
| "YY_BUF_SIZE", |
| "M4_YY_CALL_LAST_ARG", |
| "M4_YY_CALL_ONLY_ARG", |
| "YY_CURRENT_BUFFER", |
| "YY_DECL", |
| "M4_YY_DECL_LAST_ARG", |
| "M4_YY_DEF_LAST_ARG", |
| "M4_YY_DEF_ONLY_ARG", |
| "YY_DO_BEFORE_ACTION", |
| "YY_END_OF_BUFFER", |
| "YY_END_OF_BUFFER_CHAR", |
| "YY_EXIT_FAILURE", |
| "YY_EXTRA_TYPE", |
| "YY_FATAL_ERROR", |
| "YY_FLEX_DEFINED_ECHO", |
| "YY_FLEX_LEX_COMPAT", |
| "YY_FLEX_MAJOR_VERSION", |
| "YY_FLEX_MINOR_VERSION", |
| "YY_FLEX_SUBMINOR_VERSION", |
| "YY_FLUSH_BUFFER", |
| "YY_G", |
| "YY_INPUT", |
| "YY_INTERACTIVE", |
| "YY_INT_ALIGNED", |
| "YY_LAST_ARG", |
| "YY_LESS_LINENO", |
| "YY_LEX_ARGS", |
| "YY_LEX_DECLARATION", |
| "YY_LEX_PROTO", |
| "YY_MAIN", |
| "YY_MORE_ADJ", |
| "YY_NEED_STRLEN", |
| "YY_NEW_FILE", |
| "YY_NULL", |
| "YY_NUM_RULES", |
| "YY_ONLY_ARG", |
| "YY_PARAMS", |
| "YY_PROTO", |
| "M4_YY_PROTO_LAST_ARG", |
| "M4_YY_PROTO_ONLY_ARG void", |
| "YY_READ_BUF_SIZE", |
| "YY_REENTRANT", |
| "YY_RESTORE_YY_MORE_OFFSET", |
| "YY_RULE_SETUP", |
| "YY_SC_TO_UI", |
| "YY_SKIP_YYWRAP", |
| "YY_START", |
| "YY_START_STACK_INCR", |
| "YY_STATE_EOF", |
| "YY_STDINIT", |
| "YY_TRAILING_HEAD_MASK", |
| "YY_TRAILING_MASK", |
| "YY_USER_ACTION", |
| "YY_USE_CONST", |
| "YY_USE_PROTOS", |
| "unput", |
| "yyTABLES_NAME", |
| "yy_create_buffer", |
| "yy_delete_buffer", |
| "yy_flex_debug", |
| "yy_flush_buffer", |
| "yy_init_buffer", |
| "yy_load_buffer_state", |
| "yy_new_buffer", |
| "yy_scan_buffer", |
| "yy_scan_bytes", |
| "yy_scan_string", |
| "yy_set_bol", |
| "yy_set_interactive", |
| "yy_switch_to_buffer", |
| "yypush_buffer_state", |
| "yypop_buffer_state", |
| "yyensure_buffer_stack", |
| "yyalloc", |
| "yyconst", |
| "yyextra", |
| "yyfree", |
| "yyget_debug", |
| "yyget_extra", |
| "yyget_in", |
| "yyget_leng", |
| "yyget_lineno", |
| "yyget_lloc", |
| "yyget_lval", |
| "yyget_out", |
| "yyget_text", |
| "yyin", |
| "yyleng", |
| "yyless", |
| "yylex", |
| "yylex_destroy", |
| "yylex_init", |
| "yylex_init_extra", |
| "yylineno", |
| "yylloc", |
| "yylval", |
| "yymore", |
| "yyout", |
| "yyrealloc", |
| "yyrestart", |
| "yyset_debug", |
| "yyset_extra", |
| "yyset_in", |
| "yyset_lineno", |
| "yyset_lloc", |
| "yyset_lval", |
| "yyset_out", |
| "yytables_destroy", |
| "yytables_fload", |
| "yyterminate", |
| "yytext", |
| "yytext_ptr", |
| "yywrap", |
| |
| /* must be null-terminated */ |
| NULL}; |
| |
| |
| for (i=0; undef_list[i] != NULL; i++) |
| fprintf (header_out, "#undef %s\n", undef_list[i]); |
| } |
| |
| /* undef any of the auto-generated symbols. */ |
| for (i = 0; i < defs_buf.nelts; i++) { |
| |
| /* don't undef start conditions */ |
| if (sclookup (((char **) defs_buf.elts)[i]) > 0) |
| continue; |
| fprintf (header_out, "#undef %s\n", |
| ((char **) defs_buf.elts)[i]); |
| } |
| |
| fprintf (header_out, |
| "#endif /* !YY_HEADER_NO_UNDEFS */\n"); |
| fprintf (header_out, "\n"); |
| fprintf (header_out, "#undef %sIN_HEADER\n", prefix); |
| fprintf (header_out, "#endif /* %sHEADER_H */\n", prefix); |
| |
| if (ferror (header_out)) |
| lerrsf (_("error creating header file %s"), |
| headerfilename); |
| fflush (header_out); |
| fclose (header_out); |
| #endif |
| |
| if (exit_status != 0 && outfile_created) { |
| if (ferror (stdout)) |
| lerrsf (_("error writing output file %s"), |
| outfilename); |
| |
| else if ((_stdout_closed = 1) && fclose (stdout)) |
| lerrsf (_("error closing output file %s"), |
| outfilename); |
| |
| else if (unlink (outfilename)) |
| lerrsf (_("error deleting output file %s"), |
| outfilename); |
| } |
| |
| |
| if (backing_up_report && backing_up_file) { |
| if (num_backing_up == 0) |
| fprintf (backing_up_file, _("No backing up.\n")); |
| else if (fullspd || fulltbl) |
| fprintf (backing_up_file, |
| _ |
| ("%d backing up (non-accepting) states.\n"), |
| num_backing_up); |
| else |
| fprintf (backing_up_file, |
| _("Compressed tables always back up.\n")); |
| |
| if (ferror (backing_up_file)) |
| lerrsf (_("error writing backup file %s"), |
| backing_name); |
| |
| else if (fclose (backing_up_file)) |
| lerrsf (_("error closing backup file %s"), |
| backing_name); |
| } |
| |
| if (printstats) { |
| fprintf (stderr, _("%s version %s usage statistics:\n"), |
| program_name, flex_version); |
| |
| fprintf (stderr, _(" scanner options: -")); |
| |
| if (C_plus_plus) |
| putc ('+', stderr); |
| if (backing_up_report) |
| putc ('b', stderr); |
| if (ddebug) |
| putc ('d', stderr); |
| if (sf_case_ins()) |
| putc ('i', stderr); |
| if (lex_compat) |
| putc ('l', stderr); |
| if (posix_compat) |
| putc ('X', stderr); |
| if (performance_report > 0) |
| putc ('p', stderr); |
| if (performance_report > 1) |
| putc ('p', stderr); |
| if (spprdflt) |
| putc ('s', stderr); |
| if (reentrant) |
| fputs ("--reentrant", stderr); |
| if (bison_bridge_lval) |
| fputs ("--bison-bridge", stderr); |
| if (bison_bridge_lloc) |
| fputs ("--bison-locations", stderr); |
| if (use_stdout) |
| putc ('t', stderr); |
| if (printstats) |
| putc ('v', stderr); /* always true! */ |
| if (nowarn) |
| putc ('w', stderr); |
| if (interactive == false) |
| putc ('B', stderr); |
| if (interactive == true) |
| putc ('I', stderr); |
| if (!gen_line_dirs) |
| putc ('L', stderr); |
| if (trace) |
| putc ('T', stderr); |
| |
| if (csize == unspecified) |
| /* We encountered an error fairly early on, so csize |
| * never got specified. Define it now, to prevent |
| * bogus table sizes being written out below. |
| */ |
| csize = 256; |
| |
| if (csize == 128) |
| putc ('7', stderr); |
| else |
| putc ('8', stderr); |
| |
| fprintf (stderr, " -C"); |
| |
| if (long_align) |
| putc ('a', stderr); |
| if (fulltbl) |
| putc ('f', stderr); |
| if (fullspd) |
| putc ('F', stderr); |
| if (useecs) |
| putc ('e', stderr); |
| if (usemecs) |
| putc ('m', stderr); |
| if (use_read) |
| putc ('r', stderr); |
| |
| if (did_outfilename) |
| fprintf (stderr, " -o%s", outfilename); |
| |
| if (skelname) |
| fprintf (stderr, " -S%s", skelname); |
| |
| if (strcmp (prefix, "yy")) |
| fprintf (stderr, " -P%s", prefix); |
| |
| putc ('\n', stderr); |
| |
| fprintf (stderr, _(" %d/%d NFA states\n"), |
| lastnfa, current_mns); |
| fprintf (stderr, _(" %d/%d DFA states (%d words)\n"), |
| lastdfa, current_max_dfas, totnst); |
| fprintf (stderr, _(" %d rules\n"), |
| num_rules + num_eof_rules - |
| 1 /* - 1 for def. rule */ ); |
| |
| if (num_backing_up == 0) |
| fprintf (stderr, _(" No backing up\n")); |
| else if (fullspd || fulltbl) |
| fprintf (stderr, |
| _ |
| (" %d backing-up (non-accepting) states\n"), |
| num_backing_up); |
| else |
| fprintf (stderr, |
| _ |
| (" Compressed tables always back-up\n")); |
| |
| if (bol_needed) |
| fprintf (stderr, |
| _(" Beginning-of-line patterns used\n")); |
| |
| fprintf (stderr, _(" %d/%d start conditions\n"), lastsc, |
| current_max_scs); |
| fprintf (stderr, |
| _ |
| (" %d epsilon states, %d double epsilon states\n"), |
| numeps, eps2); |
| |
| if (lastccl == 0) |
| fprintf (stderr, _(" no character classes\n")); |
| else |
| fprintf (stderr, |
| _ |
| (" %d/%d character classes needed %d/%d words of storage, %d reused\n"), |
| lastccl, current_maxccls, |
| cclmap[lastccl] + ccllen[lastccl], |
| current_max_ccl_tbl_size, cclreuse); |
| |
| fprintf (stderr, _(" %d state/nextstate pairs created\n"), |
| numsnpairs); |
| fprintf (stderr, |
| _(" %d/%d unique/duplicate transitions\n"), |
| numuniq, numdup); |
| |
| if (fulltbl) { |
| tblsiz = lastdfa * numecs; |
| fprintf (stderr, _(" %d table entries\n"), |
| tblsiz); |
| } |
| |
| else { |
| tblsiz = 2 * (lastdfa + numtemps) + 2 * tblend; |
| |
| fprintf (stderr, |
| _(" %d/%d base-def entries created\n"), |
| lastdfa + numtemps, current_max_dfas); |
| fprintf (stderr, |
| _ |
| (" %d/%d (peak %d) nxt-chk entries created\n"), |
| tblend, current_max_xpairs, peakpairs); |
| fprintf (stderr, |
| _ |
| (" %d/%d (peak %d) template nxt-chk entries created\n"), |
| numtemps * nummecs, |
| current_max_template_xpairs, |
| numtemps * numecs); |
| fprintf (stderr, _(" %d empty table entries\n"), |
| nummt); |
| fprintf (stderr, _(" %d protos created\n"), |
| numprots); |
| fprintf (stderr, |
| _(" %d templates created, %d uses\n"), |
| numtemps, tmpuses); |
| } |
| |
| if (useecs) { |
| tblsiz = tblsiz + csize; |
| fprintf (stderr, |
| _ |
| (" %d/%d equivalence classes created\n"), |
| numecs, csize); |
| } |
| |
| if (usemecs) { |
| tblsiz = tblsiz + numecs; |
| fprintf (stderr, |
| _ |
| (" %d/%d meta-equivalence classes created\n"), |
| nummecs, csize); |
| } |
| |
| fprintf (stderr, |
| _ |
| (" %d (%d saved) hash collisions, %d DFAs equal\n"), |
| hshcol, hshsave, dfaeql); |
| fprintf (stderr, _(" %d sets of reallocations needed\n"), |
| num_reallocs); |
| fprintf (stderr, _(" %d total table entries needed\n"), |
| tblsiz); |
| } |
| |
| FLEX_EXIT (exit_status); |
| } |
| |
| |
| /* flexinit - initialize flex */ |
| |
| void flexinit (argc, argv) |
| int argc; |
| char **argv; |
| { |
| int i, sawcmpflag, rv, optind; |
| char *arg; |
| scanopt_t sopt; |
| |
| printstats = syntaxerror = trace = spprdflt = false; |
| lex_compat = posix_compat = C_plus_plus = backing_up_report = |
| ddebug = fulltbl = false; |
| fullspd = long_align = nowarn = yymore_used = continued_action = |
| false; |
| do_yylineno = yytext_is_array = in_rule = reject = do_stdinit = |
| false; |
| yymore_really_used = reject_really_used = unspecified; |
| interactive = csize = unspecified; |
| do_yywrap = gen_line_dirs = usemecs = useecs = true; |
| reentrant = bison_bridge_lval = bison_bridge_lloc = false; |
| performance_report = 0; |
| did_outfilename = 0; |
| prefix = "yy"; |
| yyclass = 0; |
| use_read = use_stdout = false; |
| tablesext = tablesverify = false; |
| gentables = true; |
| tablesfilename = tablesname = NULL; |
| ansi_func_defs = ansi_func_protos = true; |
| |
| sawcmpflag = false; |
| |
| /* Initialize dynamic array for holding the rule actions. */ |
| action_size = 2048; /* default size of action array in bytes */ |
| action_array = allocate_character_array (action_size); |
| defs1_offset = prolog_offset = action_offset = action_index = 0; |
| action_array[0] = '\0'; |
| |
| /* Initialize any buffers. */ |
| buf_init (&userdef_buf, sizeof (char)); /* one long string */ |
| buf_init (&defs_buf, sizeof (char *)); /* list of strings */ |
| buf_init (&yydmap_buf, sizeof (char)); /* one long string */ |
| buf_init (&top_buf, sizeof (char)); /* one long string */ |
| |
| { |
| const char * m4defs_init_str[] = {"m4_changequote\n", |
| "m4_changequote([[, ]])\n"}; |
| buf_init (&m4defs_buf, sizeof (char *)); |
| buf_append (&m4defs_buf, &m4defs_init_str, 2); |
| } |
| |
| sf_init (); |
| |
| /* initialize regex lib */ |
| flex_init_regex(); |
| |
| /* Enable C++ if program name ends with '+'. */ |
| program_name = basename2 (argv[0], 0); |
| |
| if (program_name[0] != '\0' && |
| program_name[strlen (program_name) - 1] == '+') |
| C_plus_plus = true; |
| |
| /* read flags */ |
| sopt = scanopt_init (flexopts, argc, argv, 0); |
| if (!sopt) { |
| /* This will only happen when flexopts array is altered. */ |
| fprintf (stderr, |
| _("Internal error. flexopts are malformed.\n")); |
| FLEX_EXIT (1); |
| } |
| |
| while ((rv = scanopt (sopt, &arg, &optind)) != 0) { |
| |
| if (rv < 0) { |
| /* Scanopt has already printed an option-specific error message. */ |
| fprintf (stderr, |
| _ |
| ("Try `%s --help' for more information.\n"), |
| program_name); |
| FLEX_EXIT (1); |
| } |
| |
| switch ((enum flexopt_flag_t) rv) { |
| case OPT_CPLUSPLUS: |
| C_plus_plus = true; |
| break; |
| |
| case OPT_BATCH: |
| interactive = false; |
| break; |
| |
| case OPT_BACKUP: |
| backing_up_report = true; |
| break; |
| |
| case OPT_DONOTHING: |
| break; |
| |
| case OPT_COMPRESSION: |
| if (!sawcmpflag) { |
| useecs = false; |
| usemecs = false; |
| fulltbl = false; |
| sawcmpflag = true; |
| } |
| |
| for (i = 0; arg && arg[i] != '\0'; i++) |
| switch (arg[i]) { |
| case 'a': |
| long_align = true; |
| break; |
| |
| case 'e': |
| useecs = true; |
| break; |
| |
| case 'F': |
| fullspd = true; |
| break; |
| |
| case 'f': |
| fulltbl = true; |
| break; |
| |
| case 'm': |
| usemecs = true; |
| break; |
| |
| case 'r': |
| use_read = true; |
| break; |
| |
| default: |
| lerrif (_ |
| ("unknown -C option '%c'"), |
| (int) arg[i]); |
| break; |
| } |
| break; |
| |
| case OPT_DEBUG: |
| ddebug = true; |
| break; |
| |
| case OPT_NO_DEBUG: |
| ddebug = false; |
| break; |
| |
| case OPT_FULL: |
| useecs = usemecs = false; |
| use_read = fulltbl = true; |
| break; |
| |
| case OPT_FAST: |
| useecs = usemecs = false; |
| use_read = fullspd = true; |
| break; |
| |
| case OPT_HELP: |
| usage (); |
| FLEX_EXIT (0); |
| |
| case OPT_INTERACTIVE: |
| interactive = true; |
| break; |
| |
| case OPT_CASE_INSENSITIVE: |
| sf_set_case_ins(true); |
| break; |
| |
| case OPT_LEX_COMPAT: |
| lex_compat = true; |
| break; |
| |
| case OPT_POSIX_COMPAT: |
| posix_compat = true; |
| break; |
| |
| case OPT_PREPROC_LEVEL: |
| preproc_level = strtol(arg,NULL,0); |
| break; |
| |
| case OPT_MAIN: |
| buf_strdefine (&userdef_buf, "YY_MAIN", "1"); |
| do_yywrap = false; |
| break; |
| |
| case OPT_NO_MAIN: |
| buf_strdefine (&userdef_buf, "YY_MAIN", "0"); |
| break; |
| |
| case OPT_NO_LINE: |
| gen_line_dirs = false; |
| break; |
| |
| case OPT_OUTFILE: |
| outfilename = arg; |
| did_outfilename = 1; |
| break; |
| |
| case OPT_PREFIX: |
| prefix = arg; |
| break; |
| |
| case OPT_PERF_REPORT: |
| ++performance_report; |
| break; |
| |
| case OPT_BISON_BRIDGE: |
| bison_bridge_lval = true; |
| break; |
| |
| case OPT_BISON_BRIDGE_LOCATIONS: |
| bison_bridge_lval = bison_bridge_lloc = true; |
| break; |
| |
| case OPT_REENTRANT: |
| reentrant = true; |
| break; |
| |
| case OPT_NO_REENTRANT: |
| reentrant = false; |
| break; |
| |
| case OPT_SKEL: |
| skelname = arg; |
| break; |
| |
| case OPT_DEFAULT: |
| spprdflt = false; |
| break; |
| |
| case OPT_NO_DEFAULT: |
| spprdflt = true; |
| break; |
| |
| case OPT_STDOUT: |
| use_stdout = true; |
| break; |
| |
| case OPT_NO_UNISTD_H: |
| //buf_strdefine (&userdef_buf, "YY_NO_UNISTD_H", "1"); |
| buf_m4_define( &m4defs_buf, "M4_YY_NO_UNISTD_H",0); |
| break; |
| |
| case OPT_TABLES_FILE: |
| tablesext = true; |
| tablesfilename = arg; |
| break; |
| |
| case OPT_TABLES_VERIFY: |
| tablesverify = true; |
| break; |
| |
| case OPT_TRACE: |
| trace = true; |
| break; |
| |
| case OPT_VERBOSE: |
| printstats = true; |
| break; |
| |
| case OPT_VERSION: |
| printf (_("%s %s\n"), program_name, flex_version); |
| FLEX_EXIT (0); |
| |
| case OPT_WARN: |
| nowarn = false; |
| break; |
| |
| case OPT_NO_WARN: |
| nowarn = true; |
| break; |
| |
| case OPT_7BIT: |
| csize = 128; |
| break; |
| |
| case OPT_8BIT: |
| csize = CSIZE; |
| break; |
| |
| case OPT_ALIGN: |
| long_align = true; |
| break; |
| |
| case OPT_NO_ALIGN: |
| long_align = false; |
| break; |
| |
| case OPT_ALWAYS_INTERACTIVE: |
| buf_m4_define (&m4defs_buf, "M4_YY_ALWAYS_INTERACTIVE", 0); |
| break; |
| |
| case OPT_NEVER_INTERACTIVE: |
| buf_m4_define( &m4defs_buf, "M4_YY_NEVER_INTERACTIVE", 0); |
| break; |
| |
| case OPT_ARRAY: |
| yytext_is_array = true; |
| break; |
| |
| case OPT_POINTER: |
| yytext_is_array = false; |
| break; |
| |
| case OPT_ECS: |
| useecs = true; |
| break; |
| |
| case OPT_NO_ECS: |
| useecs = false; |
| break; |
| |
| case OPT_HEADER_FILE: |
| headerfilename = arg; |
| break; |
| |
| case OPT_META_ECS: |
| usemecs = true; |
| break; |
| |
| case OPT_NO_META_ECS: |
| usemecs = false; |
| break; |
| |
| case OPT_PREPROCDEFINE: |
| { |
| /* arg is "symbol" or "symbol=definition". */ |
| char *def; |
| |
| for (def = arg; |
| *def != '\0' && *def != '='; ++def) ; |
| |
| buf_strappend (&userdef_buf, "#define "); |
| if (*def == '\0') { |
| buf_strappend (&userdef_buf, arg); |
| buf_strappend (&userdef_buf, |
| " 1\n"); |
| } |
| else { |
| buf_strnappend (&userdef_buf, arg, |
| def - arg); |
| buf_strappend (&userdef_buf, " "); |
| buf_strappend (&userdef_buf, |
| def + 1); |
| buf_strappend (&userdef_buf, "\n"); |
| } |
| } |
| break; |
| |
| case OPT_READ: |
| use_read = true; |
| break; |
| |
| case OPT_STACK: |
| //buf_strdefine (&userdef_buf, "YY_STACK_USED", "1"); |
| buf_m4_define( &m4defs_buf, "M4_YY_STACK_USED",0); |
| break; |
| |
| case OPT_STDINIT: |
| do_stdinit = true; |
| break; |
| |
| case OPT_NO_STDINIT: |
| do_stdinit = false; |
| break; |
| |
| case OPT_YYCLASS: |
| yyclass = arg; |
| break; |
| |
| case OPT_YYLINENO: |
| do_yylineno = true; |
| break; |
| |
| case OPT_NO_YYLINENO: |
| do_yylineno = false; |
| break; |
| |
| case OPT_YYWRAP: |
| do_yywrap = true; |
| break; |
| |
| case OPT_NO_YYWRAP: |
| do_yywrap = false; |
| break; |
| |
| case OPT_YYMORE: |
| yymore_really_used = true; |
| break; |
| |
| case OPT_NO_YYMORE: |
| yymore_really_used = false; |
| break; |
| |
| case OPT_REJECT: |
| reject_really_used = true; |
| break; |
| |
| case OPT_NO_REJECT: |
| reject_really_used = false; |
| break; |
| |
| case OPT_NO_ANSI_FUNC_DEFS: |
| ansi_func_defs = false; |
| break; |
| |
| case OPT_NO_ANSI_FUNC_PROTOS: |
| ansi_func_protos = false; |
| break; |
| |
| case OPT_NO_YY_PUSH_STATE: |
| //buf_strdefine (&userdef_buf, "YY_NO_PUSH_STATE", "1"); |
| buf_m4_define( &m4defs_buf, "M4_YY_NO_PUSH_STATE",0); |
| break; |
| case OPT_NO_YY_POP_STATE: |
| //buf_strdefine (&userdef_buf, "YY_NO_POP_STATE", "1"); |
| buf_m4_define( &m4defs_buf, "M4_YY_NO_POP_STATE",0); |
| break; |
| case OPT_NO_YY_TOP_STATE: |
| //buf_strdefine (&userdef_buf, "YY_NO_TOP_STATE", "1"); |
| buf_m4_define( &m4defs_buf, "M4_YY_NO_TOP_STATE",0); |
| break; |
| case OPT_NO_UNPUT: |
| //buf_strdefine (&userdef_buf, "YY_NO_UNPUT", "1"); |
| buf_m4_define( &m4defs_buf, "M4_YY_NO_UNPUT",0); |
| break; |
| case OPT_NO_YY_SCAN_BUFFER: |
| //buf_strdefine (&userdef_buf, "YY_NO_SCAN_BUFFER", "1"); |
| buf_m4_define( &m4defs_buf, "M4_YY_NO_SCAN_BUFFER",0); |
| break; |
| case OPT_NO_YY_SCAN_BYTES: |
| //buf_strdefine (&userdef_buf, "YY_NO_SCAN_BYTES", "1"); |
| buf_m4_define( &m4defs_buf, "M4_YY_NO_SCAN_BYTES",0); |
| break; |
| case OPT_NO_YY_SCAN_STRING: |
| //buf_strdefine (&userdef_buf, "YY_NO_SCAN_STRING", "1"); |
| buf_m4_define( &m4defs_buf, "M4_YY_NO_SCAN_STRING",0); |
| break; |
| case OPT_NO_YYGET_EXTRA: |
| //buf_strdefine (&userdef_buf, "YY_NO_GET_EXTRA", "1"); |
| buf_m4_define( &m4defs_buf, "M4_YY_NO_GET_EXTRA",0); |
| break; |
| case OPT_NO_YYSET_EXTRA: |
| //buf_strdefine (&userdef_buf, "YY_NO_SET_EXTRA", "1"); |
| buf_m4_define( &m4defs_buf, "M4_YY_NO_SET_EXTRA",0); |
| break; |
| case OPT_NO_YYGET_LENG: |
| //buf_strdefine (&userdef_buf, "YY_NO_GET_LENG", "1"); |
| buf_m4_define( &m4defs_buf, "M4_YY_NO_GET_LENG",0); |
| break; |
| case OPT_NO_YYGET_TEXT: |
| //buf_strdefine (&userdef_buf, "YY_NO_GET_TEXT", "1"); |
| buf_m4_define( &m4defs_buf, "M4_YY_NO_GET_TEXT",0); |
| break; |
| case OPT_NO_YYGET_LINENO: |
| //buf_strdefine (&userdef_buf, "YY_NO_GET_LINENO", "1"); |
| buf_m4_define( &m4defs_buf, "M4_YY_NO_GET_LINENO",0); |
| break; |
| case OPT_NO_YYSET_LINENO: |
| //buf_strdefine (&userdef_buf, "YY_NO_SET_LINENO", "1"); |
| buf_m4_define( &m4defs_buf, "M4_YY_NO_SET_LINENO",0); |
| break; |
| case OPT_NO_YYGET_IN: |
| //buf_strdefine (&userdef_buf, "YY_NO_GET_IN", "1"); |
| buf_m4_define( &m4defs_buf, "M4_YY_NO_GET_IN",0); |
| break; |
| case OPT_NO_YYSET_IN: |
| //buf_strdefine (&userdef_buf, "YY_NO_SET_IN", "1"); |
| buf_m4_define( &m4defs_buf, "M4_YY_NO_SET_IN",0); |
| break; |
| case OPT_NO_YYGET_OUT: |
| //buf_strdefine (&userdef_buf, "YY_NO_GET_OUT", "1"); |
| buf_m4_define( &m4defs_buf, "M4_YY_NO_GET_OUT",0); |
| break; |
| case OPT_NO_YYSET_OUT: |
| //buf_strdefine (&userdef_buf, "YY_NO_SET_OUT", "1"); |
| buf_m4_define( &m4defs_buf, "M4_YY_NO_SET_OUT",0); |
| break; |
| case OPT_NO_YYGET_LVAL: |
| //buf_strdefine (&userdef_buf, "YY_NO_GET_LVAL", "1"); |
| buf_m4_define( &m4defs_buf, "M4_YY_NO_GET_LVAL",0); |
| break; |
| case OPT_NO_YYSET_LVAL: |
| //buf_strdefine (&userdef_buf, "YY_NO_SET_LVAL", "1"); |
| buf_m4_define( &m4defs_buf, "M4_YY_NO_SET_LVAL",0); |
| break; |
| case OPT_NO_YYGET_LLOC: |
| //buf_strdefine (&userdef_buf, "YY_NO_GET_LLOC", "1"); |
| buf_m4_define( &m4defs_buf, "M4_YY_NO_GET_LLOC",0); |
| break; |
| case OPT_NO_YYSET_LLOC: |
| //buf_strdefine (&userdef_buf, "YY_NO_SET_LLOC", "1"); |
| buf_m4_define( &m4defs_buf, "M4_YY_NO_SET_LLOC",0); |
| break; |
| |
| } /* switch */ |
| } /* while scanopt() */ |
| |
| scanopt_destroy (sopt); |
| |
| num_input_files = argc - optind; |
| input_files = argv + optind; |
| set_input_file (num_input_files > 0 ? input_files[0] : NULL); |
| |
| lastccl = lastsc = lastdfa = lastnfa = 0; |
| num_rules = num_eof_rules = default_rule = 0; |
| numas = numsnpairs = tmpuses = 0; |
| numecs = numeps = eps2 = num_reallocs = hshcol = dfaeql = totnst = |
| 0; |
| numuniq = numdup = hshsave = eofseen = datapos = dataline = 0; |
| num_backing_up = onesp = numprots = 0; |
| variable_trailing_context_rules = bol_needed = false; |
| |
| linenum = sectnum = 1; |
| firstprot = NIL; |
| |
| /* Used in mkprot() so that the first proto goes in slot 1 |
| * of the proto queue. |
| */ |
| lastprot = 1; |
| |
| set_up_initial_allocations (); |
| } |
| |
| |
| /* readin - read in the rules section of the input file(s) */ |
| |
| void readin () |
| { |
| static char yy_stdinit[] = "FILE *yyin = stdin, *yyout = stdout;"; |
| static char yy_nostdinit[] = |
| "FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;"; |
| |
| line_directive_out ((FILE *) 0, 1); |
| |
| if (yyparse ()) { |
| pinpoint_message (_("fatal parse error")); |
| flexend (1); |
| } |
| |
| if (syntaxerror) |
| flexend (1); |
| |
| /* If the user explicitly requested posix compatibility by specifing the |
| * posix-compat option, then we check for conflicting options. However, if |
| * the POSIXLY_CORRECT variable is set, then we quietly make flex as |
| * posix-compatible as possible. This is the recommended behavior |
| * according to the GNU Coding Standards. |
| * |
| * Note: The posix option was added to flex to provide the posix behavior |
| * of the repeat operator in regular expressions, e.g., `ab{3}' |
| */ |
| if (posix_compat) { |
| /* TODO: This is where we try to make flex behave according to |
| * posiz, AND check for conflicting options. How far should we go |
| * with this? Should we disable all the neat-o flex features? |
| */ |
| /* Update: Estes says no, since other flex features don't violate posix. */ |
| } |
| |
| if (getenv ("POSIXLY_CORRECT")) { |
| posix_compat = true; |
| } |
| |
| if (backing_up_report) { |
| backing_up_file = fopen (backing_name, "w"); |
| if (backing_up_file == NULL) |
| lerrsf (_ |
| ("could not create backing-up info file %s"), |
| backing_name); |
| } |
| |
| else |
| backing_up_file = NULL; |
| |
| if (yymore_really_used == true) |
| yymore_used = true; |
| else if (yymore_really_used == false) |
| yymore_used = false; |
| |
| if (reject_really_used == true) |
| reject = true; |
| else if (reject_really_used == false) |
| reject = false; |
| |
| if (performance_report > 0) { |
| if (lex_compat) { |
| fprintf (stderr, |
| _ |
| ("-l AT&T lex compatibility option entails a large performance penalty\n")); |
| fprintf (stderr, |
| _ |
| (" and may be the actual source of other reported performance penalties\n")); |
| } |
| |
| else if (do_yylineno) { |
| fprintf (stderr, |
| _ |
| ("%%option yylineno entails a performance penalty ONLY on rules that can match newline characters\n")); |
| } |
| |
| if (performance_report > 1) { |
| if (interactive) |
| fprintf (stderr, |
| _ |
| ("-I (interactive) entails a minor performance penalty\n")); |
| |
| if (yymore_used) |
| fprintf (stderr, |
| _ |
| ("yymore() entails a minor performance penalty\n")); |
| } |
| |
| if (reject) |
| fprintf (stderr, |
| _ |
| ("REJECT entails a large performance penalty\n")); |
| |
| if (variable_trailing_context_rules) |
| fprintf (stderr, |
| _ |
| ("Variable trailing context rules entail a large performance penalty\n")); |
| } |
| |
| if (reject) |
| real_reject = true; |
| |
| if (variable_trailing_context_rules) |
| reject = true; |
| |
| if ((fulltbl || fullspd) && reject) { |
| if (real_reject) |
| flexerror (_ |
| ("REJECT cannot be used with -f or -F")); |
| else if (do_yylineno) |
| flexerror (_ |
| ("%option yylineno cannot be used with REJECT")); |
| else |
| flexerror (_ |
| ("variable trailing context rules cannot be used with -f or -F")); |
| } |
| |
| if (reject){ |
| out_m4_define( "M4_YY_USES_REJECT", NULL); |
| //outn ("\n#define YY_USES_REJECT"); |
| } |
| |
| if (!do_yywrap) { |
| if (!C_plus_plus) |
| if (reentrant) |
| outn ("\n#define yywrap(yyscanner) 1"); |
| else |
| outn ("\n#define yywrap() 1"); |
| outn ("#define YY_SKIP_YYWRAP"); |
| } |
| |
| if (ddebug) |
| outn ("\n#define FLEX_DEBUG"); |
| |
| OUT_BEGIN_CODE (); |
| if (csize == 256) |
| outn ("typedef unsigned char YY_CHAR;"); |
| else |
| outn ("typedef char YY_CHAR;"); |
| OUT_END_CODE (); |
| |
| if (C_plus_plus) { |
| outn ("#define yytext_ptr yytext"); |
| |
| if (interactive) |
| outn ("#define YY_INTERACTIVE"); |
| } |
| |
| else { |
| OUT_BEGIN_CODE (); |
| /* In reentrant scanner, stdinit is handled in flex.skl. */ |
| if (do_stdinit) { |
| if (reentrant){ |
| outn ("#ifdef VMS"); |
| outn ("#ifdef __VMS_POSIX"); |
| outn ("#define YY_STDINIT"); |
| outn ("#endif"); |
| outn ("#else"); |
| outn ("#define YY_STDINIT"); |
| outn ("#endif"); |
| } |
| |
| outn ("#ifdef VMS"); |
| outn ("#ifndef __VMS_POSIX"); |
| outn (yy_nostdinit); |
| outn ("#else"); |
| outn (yy_stdinit); |
| outn ("#endif"); |
| outn ("#else"); |
| outn (yy_stdinit); |
| outn ("#endif"); |
| } |
| |
| else { |
| if(!reentrant) |
| outn (yy_nostdinit); |
| } |
| OUT_END_CODE (); |
| } |
| |
| OUT_BEGIN_CODE (); |
| if (fullspd) |
| outn ("typedef yyconst struct yy_trans_info *yy_state_type;"); |
| else if (!C_plus_plus) |
| outn ("typedef int yy_state_type;"); |
| OUT_END_CODE (); |
| |
| if (lex_compat) |
| outn ("#define YY_FLEX_LEX_COMPAT"); |
| |
| if (!C_plus_plus && !reentrant) { |
| outn ("extern int yylineno;"); |
| OUT_BEGIN_CODE (); |
| outn ("int yylineno = 1;"); |
| OUT_END_CODE (); |
| } |
| |
| if (C_plus_plus) { |
| outn ("\n#include <FlexLexer.h>"); |
| |
| if (!do_yywrap) { |
| outn("\nint yyFlexLexer::yywrap() { return 1; }"); |
| } |
| |
| if (yyclass) { |
| outn ("int yyFlexLexer::yylex()"); |
| outn ("\t{"); |
| outn ("\tLexerError( \"yyFlexLexer::yylex invoked but %option yyclass used\" );"); |
| outn ("\treturn 0;"); |
| outn ("\t}"); |
| |
| out_str ("\n#define YY_DECL int %s::yylex()\n", |
| yyclass); |
| } |
| } |
| |
| else { |
| |
| /* Watch out: yytext_ptr is a variable when yytext is an array, |
| * but it's a macro when yytext is a pointer. |
| */ |
| if (yytext_is_array) { |
| if (!reentrant) |
| outn ("extern char yytext[];\n"); |
| } |
| else { |
| if (reentrant) { |
| outn ("#define yytext_ptr yytext_r"); |
| } |
| else { |
| outn ("extern char *yytext;"); |
| outn ("#define yytext_ptr yytext"); |
| } |
| } |
| |
| if (yyclass) |
| flexerror (_ |
| ("%option yyclass only meaningful for C++ scanners")); |
| } |
| |
| if (useecs) |
| numecs = cre8ecs (nextecm, ecgroup, csize); |
| else |
| numecs = csize; |
| |
| /* Now map the equivalence class for NUL to its expected place. */ |
| ecgroup[0] = ecgroup[csize]; |
| NUL_ec = ABS (ecgroup[0]); |
| |
| if (useecs) |
| ccl2ecl (); |
| } |
| |
| |
| /* set_up_initial_allocations - allocate memory for internal tables */ |
| |
| void set_up_initial_allocations () |
| { |
| maximum_mns = (long_align ? MAXIMUM_MNS_LONG : MAXIMUM_MNS); |
| current_mns = INITIAL_MNS; |
| firstst = allocate_integer_array (current_mns); |
| lastst = allocate_integer_array (current_mns); |
| finalst = allocate_integer_array (current_mns); |
| transchar = allocate_integer_array (current_mns); |
| trans1 = allocate_integer_array (current_mns); |
| trans2 = allocate_integer_array (current_mns); |
| accptnum = allocate_integer_array (current_mns); |
| assoc_rule = allocate_integer_array (current_mns); |
| state_type = allocate_integer_array (current_mns); |
| |
| current_max_rules = INITIAL_MAX_RULES; |
| rule_type = allocate_integer_array (current_max_rules); |
| rule_linenum = allocate_integer_array (current_max_rules); |
| rule_useful = allocate_integer_array (current_max_rules); |
| rule_has_nl = allocate_bool_array (current_max_rules); |
| |
| current_max_scs = INITIAL_MAX_SCS; |
| scset = allocate_integer_array (current_max_scs); |
| scbol = allocate_integer_array (current_max_scs); |
| scxclu = allocate_integer_array (current_max_scs); |
| sceof = allocate_integer_array (current_max_scs); |
| scname = allocate_char_ptr_array (current_max_scs); |
| |
| current_maxccls = INITIAL_MAX_CCLS; |
| cclmap = allocate_integer_array (current_maxccls); |
| ccllen = allocate_integer_array (current_maxccls); |
| cclng = allocate_integer_array (current_maxccls); |
| ccl_has_nl = allocate_bool_array (current_maxccls); |
| |
| current_max_ccl_tbl_size = INITIAL_MAX_CCL_TBL_SIZE; |
| ccltbl = allocate_Character_array (current_max_ccl_tbl_size); |
| |
| current_max_dfa_size = INITIAL_MAX_DFA_SIZE; |
| |
| current_max_xpairs = INITIAL_MAX_XPAIRS; |
| nxt = allocate_integer_array (current_max_xpairs); |
| chk = allocate_integer_array (current_max_xpairs); |
| |
| current_max_template_xpairs = INITIAL_MAX_TEMPLATE_XPAIRS; |
| tnxt = allocate_integer_array (current_max_template_xpairs); |
| |
| current_max_dfas = INITIAL_MAX_DFAS; |
| base = allocate_integer_array (current_max_dfas); |
| def = allocate_integer_array (current_max_dfas); |
| dfasiz = allocate_integer_array (current_max_dfas); |
| accsiz = allocate_integer_array (current_max_dfas); |
| dhash = allocate_integer_array (current_max_dfas); |
| dss = allocate_int_ptr_array (current_max_dfas); |
| dfaacc = allocate_dfaacc_union (current_max_dfas); |
| |
| nultrans = (int *) 0; |
| } |
| |
| |
| /* extracts basename from path, optionally stripping the extension "\.*" |
| * (same concept as /bin/sh `basename`, but different handling of extension). */ |
| static char *basename2 (path, strip_ext) |
| char *path; |
| int strip_ext; /* boolean */ |
| { |
| char *b, *e = 0; |
| |
| b = path; |
| for (b = path; *path; path++) |
| if (*path == '/') |
| b = path + 1; |
| else if (*path == '.') |
| e = path; |
| |
| if (strip_ext && e && e > b) |
| *e = '\0'; |
| return b; |
| } |
| |
| void usage () |
| { |
| FILE *f = stdout; |
| |
| if (!did_outfilename) { |
| snprintf (outfile_path, sizeof(outfile_path), outfile_template, |
| prefix, C_plus_plus ? "cc" : "c"); |
| outfilename = outfile_path; |
| } |
| |
| fprintf (f, _("Usage: %s [OPTIONS] [FILE]...\n"), program_name); |
| fprintf (f, |
| _ |
| ("Generates programs that perform pattern-matching on text.\n" |
| "\n" "Table Compression:\n" |
| " -Ca, --align trade off larger tables for better memory alignment\n" |
| " -Ce, --ecs construct equivalence classes\n" |
| " -Cf do not compress tables; use -f representation\n" |
| " -CF do not compress tables; use -F representation\n" |
| " -Cm, --meta-ecs construct meta-equivalence classes\n" |
| " -Cr, --read use read() instead of stdio for scanner input\n" |
| " -f, --full generate fast, large scanner. Same as -Cfr\n" |
| " -F, --fast use alternate table representation. Same as -CFr\n" |
| " -Cem default compression (same as --ecs --meta-ecs)\n" |
| "\n" "Debugging:\n" |
| " -d, --debug enable debug mode in scanner\n" |
| " -b, --backup write backing-up information to %s\n" |
| " -p, --perf-report write performance report to stderr\n" |
| " -s, --nodefault suppress default rule to ECHO unmatched text\n" |
| " -T, --trace %s should run in trace mode\n" |
| " -w, --nowarn do not generate warnings\n" |
| " -v, --verbose write summary of scanner statistics to stdout\n" |
| "\n" "Files:\n" |
| " -o, --outfile=FILE specify output filename\n" |
| " -S, --skel=FILE specify skeleton file\n" |
| " -t, --stdout write scanner on stdout instead of %s\n" |
| " --yyclass=NAME name of C++ class\n" |
| " --header-file=FILE create a C header file in addition to the scanner\n" |
| " --tables-file[=FILE] write tables to FILE\n" "\n" |
| "Scanner behavior:\n" |
| " -7, --7bit generate 7-bit scanner\n" |
| " -8, --8bit generate 8-bit scanner\n" |
| " -B, --batch generate batch scanner (opposite of -I)\n" |
| " -i, --case-insensitive ignore case in patterns\n" |
| " -l, --lex-compat maximal compatibility with original lex\n" |
| " -X, --posix-compat maximal compatibility with POSIX lex\n" |
| " -I, --interactive generate interactive scanner (opposite of -B)\n" |
| " --yylineno track line count in yylineno\n" |
| "\n" "Generated code:\n" |
| " -+, --c++ generate C++ scanner class\n" |
| " -Dmacro[=defn] #define macro defn (default defn is '1')\n" |
| " -L, --noline suppress #line directives in scanner\n" |
| " -P, --prefix=STRING use STRING as prefix instead of \"yy\"\n" |
| " -R, --reentrant generate a reentrant C scanner\n" |
| " --bison-bridge scanner for bison pure parser.\n" |
| " --bison-locations include yylloc support.\n" |
| " --stdinit initialize yyin/yyout to stdin/stdout\n" |
| " --noansi-definitions old-style function definitions\n" |
| " --noansi-prototypes empty parameter list in prototypes\n" |
| " --nounistd do not include <unistd.h>\n" |
| " --noFUNCTION do not generate a particular FUNCTION\n" |
| "\n" "Miscellaneous:\n" |
| " -c do-nothing POSIX option\n" |
| " -n do-nothing POSIX option\n" |
| " -?\n" |
| " -h, --help produce this help message\n" |
| " -V, --version report %s version\n"), |
| backing_name, program_name, outfile_path, program_name); |
| |
| } |