/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:8;tab-width:8;coding:utf-8 -*-│ │vi: set et ft=c ts=8 sw=8 fenc=utf-8 :vi│ └─────────────────────────────────────────────────────────────────────────────*/ /* clang-format off */ asm(".include \"third_party/lex/COPYING\""); /* $OpenBSD: main.c,v 1.27 2017/01/21 08:33:07 krw Exp $ */ /* 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 "libc/calls/calls.h" #include "libc/fmt/fmt.h" #include "libc/str/str.h" #include "libc/mem/mem.h" #include "libc/math.h" #include "libc/fmt/conv.h" #include "libc/log/log.h" #include "libc/runtime/gc.h" #include "libc/x/x.h" #include "libc/runtime/runtime.h" #include "libc/x/x.h" #include "libc/bits/safemacros.internal.h" #include "libc/bits/safemacros.internal.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; u_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"; static const char *outfile_template = "lex.%s.%s"; static const char *backing_name = "lex.backup"; static const char *tablesfile_template = "lex.%s.tables"; /* 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 pledge("stdio rpath wpath cpath proc exec", NULL); return flex_main(argc, argv); } /* check_options - check user-specified options */ void check_options() { int i; 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) { lexwarn(_("%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); filter_create_ext(output_chain, firstnonnull(getenv("M4"), gc(xasprintf("o/%s/third_party/m4/m4.com.dbg", nulltoempty(getenv("MODE"))))), "-P", "-g", 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); 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, "", 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 *) malloc(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 *def2; for (def2 = arg; *def2 != '\0' && *def2 != '='; ++def2); buf_strappend(&userdef_buf, "#define "); if (*def2 == '\0') { buf_strappend(&userdef_buf, arg); buf_strappend(&userdef_buf, " 1\n"); } else { buf_strnappend(&userdef_buf, arg, def2 - arg); buf_strappend(&userdef_buf, " "); buf_strappend(&userdef_buf, def2 + 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("#define YY_STDINIT"); } outn(yy_stdinit); } 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 \"third_party/lex/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 \n" " --noFUNCTION do not generate a particular FUNCTION\n" "\n" "Miscellaneous:\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); }