=================================================================== RCS file: /cvsrepo/anoncvs/cvs/src/usr.bin/lex/main.c,v retrieving revision 1.15 retrieving revision 1.16 diff -u -r1.15 -r1.16 --- src/usr.bin/lex/main.c 2015/10/10 05:47:54 1.15 +++ src/usr.bin/lex/main.c 2015/11/19 19:43:40 1.16 @@ -1,849 +1,1455 @@ -/* $OpenBSD: main.c,v 1.15 2015/10/10 05:47:54 deraadt Exp $ */ +/* $OpenBSD: main.c,v 1.16 2015/11/19 19:43:40 tedu 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. - * - * 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. - */ +/* Copyright (c) 1990 The Regents of the University of California. */ +/* All rights reserved. */ -/* $Header: /cvsrepo/anoncvs/cvs/src/usr.bin/lex/main.c,v 1.15 2015/10/10 05:47:54 deraadt Exp $ */ +/* 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)); +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)); -#ifdef NEED_ARGV_FIXUP -extern void argv_fixup PROTO((int *, char ***)); -#endif - /* these globals are all defined and commented in flexdef.h */ -int printstats, syntaxerror, eofseen, ddebug, trace, nowarn, spprdflt; -int interactive, caseins, lex_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 yymore_used, reject, real_reject, continued_action, in_rule; -int yymore_really_used, reject_really_used; -int datapos, dataline, linenum, out_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; -int did_outfilename; -char *prefix, *yyclass; -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 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; +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; +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"; +char *program_name = "flex"; #ifndef SHORT_FILE_NAMES -static const char outfile_template[] = "lex.%s.%s"; -static const char backing_name[] = "lex.backup"; +static const char *outfile_template = "lex.%s.%s"; +static const char *backing_name = "lex.backup"; +static const char *tablesfile_template = "lex.%s.tables"; #else -static const char outfile_template[] = "lex%s.%s"; -static const char backing_name[] = "lex.bck"; +static const char *outfile_template = "lex%s.%s"; +static const char *backing_name = "lex.bck"; +static const char *tablesfile_template = "lex%s.tbl"; #endif -#ifdef THINK_C -#include -#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 main( argc, argv ) -int argc; -char **argv; - { - int i; +int flex_main PROTO ((int argc, char *argv[])); +int main PROTO ((int argc, char *argv[])); - if (pledge("stdio rpath wpath cpath", NULL) == -1) - { - fprintf( stderr, _( "%s: pledge\n" ), - program_name); - exit(1); - } +int flex_main (argc, argv) + int argc; + char *argv[]; +{ + int i, exit_status, child_status; -#ifdef THINK_C - argc = ccommand( &argv ); -#endif -#ifdef NEED_ARGV_FIXUP - argv_fixup( &argc, &argv ); -#endif + /* 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; - flexinit( argc, argv ); + } + } + return exit_status - 1; + } - readin(); + flexinit (argc, argv); - ntod(); + readin (); - for ( i = 1; i <= num_rules; ++i ) - if ( ! rule_useful[i] && i != default_rule ) - line_warning( _( "rule cannot be matched" ), - rule_linenum[i] ); + skelout (); + /* %% [1.5] DFA */ + ntod (); - if ( spprdflt && ! reject && rule_useful[default_rule] ) - line_warning( - _( "-s option given but default rule can be matched" ), - rule_linenum[default_rule] ); + 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(); + make_tables (); /* Note, flexend does not return. It exits with its argument * as status. */ - flexend( 0 ); + flexend (0); - return 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 + + if (pledge("stdio rpath wpath cpath proc exec", NULL) == -1) + { + fprintf( stderr, _( "%s: pledge\n"), + program_name); + exit(1); } + return flex_main (argc, argv); +} /* check_options - check user-specified options */ -void check_options() - { - int i; +void check_options () +{ + int i; + const char * m4 = NULL; - if ( lex_compat ) - { - if ( C_plus_plus ) - flexerror( _( "Can't use -+ with -l option" ) ); + 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 (fulltbl || fullspd) + flexerror (_("Can't use -f or -F with -l option")); - /* Don't rely on detecting use of yymore() and REJECT, - * just assume they'll be used. - */ - yymore_really_used = reject_really_used = true; + 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 ( do_yylineno ) + +#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 ) + if (csize == unspecified) { + if ((fulltbl || fullspd) && !useecs) csize = DEFAULT_CSIZE; else csize = CSIZE; - } + } - if ( interactive == unspecified ) - { - if ( fulltbl || fullspd ) + 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 (fulltbl || fullspd) { + if (usemecs) + flexerror (_ + ("-Cf/-CF and -Cm don't make sense together")); - if ( interactive ) - flexerror( _( "-Cf/-CF and -I are incompatible" ) ); + if (interactive) + flexerror (_("-Cf/-CF and -I are incompatible")); - if ( lex_compat ) - flexerror( - _( "-Cf/-CF are incompatible with lex-compatibility mode" ) ); + if (lex_compat) + flexerror (_ + ("-Cf/-CF are incompatible with lex-compatibility mode")); - if ( do_yylineno ) - flexerror( - _( "-Cf/-CF and %option yylineno are incompatible" ) ); - if ( fulltbl && fullspd ) - flexerror( _( "-Cf and -CF are mutually exclusive" ) ); - } + 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 && fullspd) + flexerror (_("Can't use -+ with -CF option")); - if ( C_plus_plus && yytext_is_array ) - { - warn( _( "%array incompatible with -+ option" ) ); + if (C_plus_plus && yytext_is_array) { + warn (_("%array incompatible with -+ option")); yytext_is_array = false; - } + } - if ( useecs ) - { /* Set up doubly-linked equivalence classes. */ + 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 ) - { + for (i = 2; i <= csize; ++i) { ecgroup[i] = i - 1; nextecm[i - 1] = i; - } + } nextecm[csize] = NIL; - } + } - else - { + else { /* Put everything in its own equivalence class. */ - for ( i = 1; i <= csize; ++i ) - { + for (i = 1; i <= csize; ++i) { ecgroup[i] = i; nextecm[i] = BAD_SUBSCRIPT; /* to catch errors */ - } } + } - if ( ! use_stdout ) - { - FILE *prev_stdout; + if (!ansi_func_defs) + buf_m4_define( &m4defs_buf, "M4_YY_NO_ANSI_FUNC_DEFS", NULL); - if ( ! did_outfilename ) - { - char *suffix; + if (!ansi_func_protos) + buf_m4_define( &m4defs_buf, "M4_YY_NO_ANSI_FUNC_PROTOS", NULL); - if ( C_plus_plus ) + 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 ); + snprintf (outfile_path, sizeof(outfile_path), outfile_template, + prefix, suffix); outfilename = outfile_path; - } + } - prev_stdout = freopen( outfilename, "w", stdout ); + prev_stdout = freopen (outfilename, "w+", stdout); - if ( prev_stdout == NULL ) - lerrsf( _( "could not create %s" ), outfilename ); + if (prev_stdout == NULL) + lerrsf (_("could not create %s"), outfilename); outfile_created = 1; - } + } - if ( skelname && (skelfile = fopen( skelname, "r" )) == NULL ) - lerrsf( _( "can't open skeleton file %s" ), skelname ); - if ( strcmp( prefix, "yy" ) ) - { -#define GEN_PREFIX(name) out_str3( "#define yy%s %s%s\n", name, prefix, name ) - if ( C_plus_plus ) - GEN_PREFIX( "FlexLexer" ); - else - { - GEN_PREFIX( "_create_buffer" ); - GEN_PREFIX( "_delete_buffer" ); - GEN_PREFIX( "_scan_buffer" ); - GEN_PREFIX( "_scan_string" ); - GEN_PREFIX( "_scan_bytes" ); - GEN_PREFIX( "_flex_debug" ); - GEN_PREFIX( "_init_buffer" ); - GEN_PREFIX( "_flush_buffer" ); - GEN_PREFIX( "_load_buffer_state" ); - GEN_PREFIX( "_switch_to_buffer" ); - GEN_PREFIX( "in" ); - GEN_PREFIX( "leng" ); - GEN_PREFIX( "lex" ); - GEN_PREFIX( "out" ); - GEN_PREFIX( "restart" ); - GEN_PREFIX( "text" ); + /* 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); - if ( do_yylineno ) - GEN_PREFIX( "lineno" ); - } + /* 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; - if ( do_yywrap ) - GEN_PREFIX( "wrap" ); - outn( "" ); + /* 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 ( did_outfilename ) - line_directive_out( stdout, 0 ); + if ((tablesout = fopen (tablesfilename, "w")) == NULL) + lerrsf (_("could not create %s"), tablesfilename); + if (pname) + free (pname); + tablesfilename = 0; - skelout(); + 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*)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; +void flexend (exit_status) + int exit_status; - { - int tblsiz; - int unlink(); +{ + static int called_before = -1; /* prevent infinite recursion. */ + int tblsiz; - if ( skelfile != NULL ) - { - if ( ferror( skelfile ) ) - lerrsf( _( "input error reading skeleton file %s" ), - skelname ); + if (++called_before) + FLEX_EXIT (exit_status); - else if ( fclose( skelfile ) ) - lerrsf( _( "error closing skeleton file %s" ), - skelname ); - } + if (skelfile != NULL) { + if (ferror (skelfile)) + lerrsf (_("input error reading skeleton file %s"), + skelname); - if ( exit_status != 0 && outfile_created ) - { - if ( ferror( stdout ) ) - lerrsf( _( "error writing output file %s" ), - outfilename ); + else if (fclose (skelfile)) + lerrsf (_("error closing skeleton file %s"), + skelname); + } - else if ( fclose( stdout ) ) - lerrsf( _( "error closing output file %s" ), - outfilename ); +#if 0 + fprintf (header_out, + "#ifdef YY_HEADER_EXPORT_START_CONDITIONS\n"); + fprintf (header_out, + "/* Beware! Start conditions are not prefixed. */\n"); - else if ( unlink( outfilename ) ) - lerrsf( _( "error deleting output file %s" ), - outfilename ); + /* 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]); } - 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 ); + 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" ) ); + fprintf (backing_up_file, + _("Compressed tables always back up.\n")); - if ( ferror( backing_up_file ) ) - lerrsf( _( "error writing backup file %s" ), - backing_name ); + 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 ); - } + 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 ); + if (printstats) { + fprintf (stderr, _("%s version %s usage statistics:\n"), + program_name, flex_version); - fprintf( stderr, _( " scanner options: -" ) ); + fprintf (stderr, _(" scanner options: -")); - if ( C_plus_plus ) - putc( '+', stderr ); - if ( backing_up_report ) - putc( 'b', stderr ); - if ( ddebug ) - putc( 'd', stderr ); - if ( caseins ) - putc( 'i', stderr ); - if ( lex_compat ) - putc( 'l', stderr ); - if ( performance_report > 0 ) - putc( 'p', stderr ); - if ( performance_report > 1 ) - putc( 'p', stderr ); - if ( spprdflt ) - putc( 's', 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 (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 ) + 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 ); + if (csize == 128) + putc ('7', stderr); else - putc( '8', stderr ); + putc ('8', stderr); - fprintf( stderr, " -C" ); + 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 (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 (did_outfilename) + fprintf (stderr, " -o%s", outfilename); - if ( skelname ) - fprintf( stderr, " -S%s", skelname ); + if (skelname) + fprintf (stderr, " -S%s", skelname); - if ( strcmp( prefix, "yy" ) ) - fprintf( stderr, " -P%s", prefix ); + if (strcmp (prefix, "yy")) + fprintf (stderr, " -P%s", prefix); - putc( '\n', stderr ); + 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 */ ); + 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 ); + 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" ) ); + fprintf (stderr, + _ + (" Compressed tables always back-up\n")); - if ( bol_needed ) - fprintf( stderr, - _( " Beginning-of-line patterns used\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 ); + 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" ) ); + 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/%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 ); + fprintf (stderr, _(" %d state/nextstate pairs created\n"), + numsnpairs); + fprintf (stderr, + _(" %d/%d unique/duplicate transitions\n"), + numuniq, numdup); - if ( fulltbl ) - { + if (fulltbl) { tblsiz = lastdfa * numecs; - fprintf( stderr, _( " %d table entries\n" ), tblsiz ); - } + fprintf (stderr, _(" %d table entries\n"), + tblsiz); + } - else - { + 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 ); - } + 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 ) - { + if (useecs) { tblsiz = tblsiz + csize; - fprintf( stderr, - _( " %d/%d equivalence classes created\n" ), - numecs, csize ); - } + fprintf (stderr, + _ + (" %d/%d equivalence classes created\n"), + numecs, csize); + } - if ( usemecs ) - { + 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 ); + fprintf (stderr, + _ + (" %d/%d meta-equivalence classes created\n"), + nummecs, csize); } - exit( exit_status ); + 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; - char *arg; +void flexinit (argc, argv) + int argc; + char **argv; +{ + int i, sawcmpflag, rv, optind; + char *arg; + scanopt_t sopt; - printstats = syntaxerror = trace = spprdflt = caseins = false; - lex_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; + 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 ); + action_array = allocate_character_array (action_size); defs1_offset = prolog_offset = action_offset = action_index = 0; action_array[0] = '\0'; - program_name = argv[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 */ - if ( program_name[0] != '\0' && - program_name[strlen( program_name ) - 1] == '+' ) + { + 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 */ - for ( --argc, ++argv; argc ; --argc, ++argv ) - { - arg = argv[0]; + 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); + } - if ( arg[0] != '-' || arg[1] == '\0' ) + 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; - if ( arg[1] == '-' ) - { /* --option */ - if ( ! strcmp( arg, "--help" ) ) - arg = "-h"; + case OPT_BATCH: + interactive = false; + break; - else if ( ! strcmp( arg, "--version" ) ) - arg = "-V"; + case OPT_BACKUP: + backing_up_report = true; + break; - else if ( ! strcmp( arg, "--" ) ) - { /* end of options */ - --argc; - ++argv; - break; - } + case OPT_DONOTHING: + break; + + case OPT_COMPRESSION: + if (!sawcmpflag) { + useecs = false; + usemecs = false; + fulltbl = false; + sawcmpflag = true; } - for ( i = 1; arg[i] != '\0'; ++i ) - switch ( arg[i] ) - { - case '+': - C_plus_plus = true; + for (i = 0; arg && arg[i] != '\0'; i++) + switch (arg[i]) { + case 'a': + long_align = true; break; - case 'B': - interactive = false; + case 'e': + useecs = true; break; - case 'b': - backing_up_report = true; + case 'F': + fullspd = true; break; - case 'c': + case 'f': + fulltbl = true; break; - case 'C': - if ( i != 1 ) - flexerror( - _( "-C flag must be given separately" ) ); + case 'm': + usemecs = true; + break; - if ( ! sawcmpflag ) - { - useecs = false; - usemecs = false; - fulltbl = false; - sawcmpflag = true; - } + case 'r': + use_read = true; + break; - for ( ++i; arg[i] != '\0'; ++i ) - switch ( arg[i] ) - { - case 'a': - long_align = - true; - break; + default: + lerrif (_ + ("unknown -C option '%c'"), + (int) arg[i]); + break; + } + break; - case 'e': - useecs = true; - break; + case OPT_DEBUG: + ddebug = true; + break; - case 'F': - fullspd = true; - break; + case OPT_NO_DEBUG: + ddebug = false; + break; - case 'f': - fulltbl = true; - break; + case OPT_FULL: + useecs = usemecs = false; + use_read = fulltbl = true; + break; - case 'm': - usemecs = true; - break; + case OPT_FAST: + useecs = usemecs = false; + use_read = fullspd = true; + break; - case 'r': - use_read = true; - break; + case OPT_HELP: + usage (); + FLEX_EXIT (0); - default: - lerrif( - _( "unknown -C option '%c'" ), - (int) arg[i] ); - break; - } + case OPT_INTERACTIVE: + interactive = true; + break; - goto get_next_arg; + case OPT_CASE_INSENSITIVE: + sf_set_case_ins(true); + break; - case 'd': - ddebug = true; - break; + case OPT_LEX_COMPAT: + lex_compat = true; + break; - case 'f': - useecs = usemecs = false; - use_read = fulltbl = true; - break; + case OPT_POSIX_COMPAT: + posix_compat = true; + break; - case 'F': - useecs = usemecs = false; - use_read = fullspd = true; - break; + case OPT_PREPROC_LEVEL: + preproc_level = strtol(arg,NULL,0); + break; - case '?': - case 'h': - usage(); - exit( 0 ); + case OPT_MAIN: + buf_strdefine (&userdef_buf, "YY_MAIN", "1"); + do_yywrap = false; + break; - case 'I': - interactive = true; - break; + case OPT_NO_MAIN: + buf_strdefine (&userdef_buf, "YY_MAIN", "0"); + break; - case 'i': - caseins = true; - break; + case OPT_NO_LINE: + gen_line_dirs = false; + break; - case 'l': - lex_compat = true; - break; + case OPT_OUTFILE: + outfilename = arg; + did_outfilename = 1; + break; - case 'L': - gen_line_dirs = false; - break; + case OPT_PREFIX: + prefix = arg; + break; - case 'n': - /* Stupid do-nothing deprecated - * option. - */ - break; + case OPT_PERF_REPORT: + ++performance_report; + break; - case 'o': - if ( i != 1 ) - flexerror( - _( "-o flag must be given separately" ) ); + case OPT_BISON_BRIDGE: + bison_bridge_lval = true; + break; - outfilename = arg + i + 1; - did_outfilename = 1; - goto get_next_arg; + case OPT_BISON_BRIDGE_LOCATIONS: + bison_bridge_lval = bison_bridge_lloc = true; + break; - case 'P': - if ( i != 1 ) - flexerror( - _( "-P flag must be given separately" ) ); + case OPT_REENTRANT: + reentrant = true; + break; - prefix = arg + i + 1; - goto get_next_arg; + case OPT_NO_REENTRANT: + reentrant = false; + break; - case 'p': - ++performance_report; - break; + case OPT_SKEL: + skelname = arg; + break; - case 'S': - if ( i != 1 ) - flexerror( - _( "-S flag must be given separately" ) ); + case OPT_DEFAULT: + spprdflt = false; + break; - skelname = arg + i + 1; - goto get_next_arg; + case OPT_NO_DEFAULT: + spprdflt = true; + break; - case 's': - spprdflt = true; - break; + case OPT_STDOUT: + use_stdout = true; + break; - case 't': - 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 'T': - trace = true; - break; + case OPT_TABLES_FILE: + tablesext = true; + tablesfilename = arg; + break; - case 'v': - printstats = true; - break; + case OPT_TABLES_VERIFY: + tablesverify = true; + break; - case 'V': - printf( _( "%s version %s\n" ), - program_name, flex_version ); - exit( 0 ); + case OPT_TRACE: + trace = true; + break; - case 'w': - nowarn = true; - break; + case OPT_VERBOSE: + printstats = true; + break; - case '7': - csize = 128; - break; + case OPT_VERSION: + printf (_("%s %s\n"), program_name, flex_version); + FLEX_EXIT (0); - case '8': - csize = CSIZE; - break; + case OPT_WARN: + nowarn = false; + break; - default: - fprintf( stderr, - _( "%s: unknown flag '%c'. For usage, try\n\t%s --help\n" ), - program_name, (int) arg[i], - program_name ); - exit( 1 ); + 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; - /* Used by -C, -S, -o, and -P flags in lieu of a "continue 2" - * control. - */ - get_next_arg: ; - } + case OPT_READ: + use_read = true; + break; - num_input_files = argc; - input_files = argv; - set_input_file( num_input_files > 0 ? input_files[0] : NULL ); + 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; + 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; - out_linenum = linenum = sectnum = 1; + linenum = sectnum = 1; firstprot = NIL; /* Used in mkprot() so that the first proto goes in slot 1 @@ -851,334 +1457,410 @@ */ lastprot = 1; - set_up_initial_allocations(); - } + set_up_initial_allocations (); +} /* readin - read in the rules section of the input file(s) */ -void readin() - { +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 ); + line_directive_out ((FILE *) 0, 1); - if ( yyparse() ) - { - pinpoint_message( _( "fatal parse error" ) ); - flexend( 1 ); - } + if (yyparse ()) { + pinpoint_message (_("fatal parse error")); + flexend (1); + } - if ( syntaxerror ) - flexend( 1 ); + if (syntaxerror) + flexend (1); - 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 ); - } + /* 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 ) + if (yymore_really_used == true) yymore_used = true; - else if ( yymore_really_used == false ) + else if (yymore_really_used == false) yymore_used = false; - if ( reject_really_used == true ) + if (reject_really_used == true) reject = true; - else if ( reject_really_used == false ) + 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" ) ); - } + 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 large performance penalty\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 (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 (yymore_used) + fprintf (stderr, + _ + ("yymore() entails a minor performance penalty\n")); + } - if ( reject ) - fprintf( stderr, - _( "REJECT entails a large 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 (variable_trailing_context_rules) + fprintf (stderr, + _ + ("Variable trailing context rules entail a large performance penalty\n")); + } - if ( reject ) + if (reject) real_reject = true; - if ( variable_trailing_context_rules ) + 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 -f or -F" ) ); + 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" ) ); - } + flexerror (_ + ("variable trailing context rules cannot be used with -f or -F")); + } - if ( reject ) - outn( "\n#define YY_USES_REJECT" ); + if (reject){ + out_m4_define( "M4_YY_USES_REJECT", NULL); + //outn ("\n#define YY_USES_REJECT"); + } - if ( ! do_yywrap ) - { - outn( "\n#define yywrap() 1" ); - outn( "#define YY_SKIP_YYWRAP" ); - } + 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" ); + if (ddebug) + outn ("\n#define FLEX_DEBUG"); - if ( csize == 256 ) - outn( "typedef unsigned char YY_CHAR;" ); + OUT_BEGIN_CODE (); + if (csize == 256) + outn ("typedef unsigned char YY_CHAR;"); else - outn( "typedef char YY_CHAR;" ); + outn ("typedef char YY_CHAR;"); + OUT_END_CODE (); - if ( C_plus_plus ) - { - outn( "#define yytext_ptr yytext" ); + if (C_plus_plus) { + outn ("#define yytext_ptr yytext"); - if ( interactive ) - outn( "#define YY_INTERACTIVE" ); - } + if (interactive) + outn ("#define YY_INTERACTIVE"); + } - else - { - if ( do_stdinit ) - { - 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 { + 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"); + } - else - outn( yy_nostdinit ); + outn ("#ifdef VMS"); + outn ("#ifndef __VMS_POSIX"); + outn (yy_nostdinit); + outn ("#else"); + outn (yy_stdinit); + outn ("#endif"); + outn ("#else"); + outn (yy_stdinit); + outn ("#endif"); } - if ( fullspd ) - outn( "typedef yyconst struct yy_trans_info *yy_state_type;" ); - else if ( ! C_plus_plus ) - outn( "typedef int yy_state_type;" ); + else { + if(!reentrant) + outn (yy_nostdinit); + } + OUT_END_CODE (); + } - if ( ddebug ) - outn( "\n#define FLEX_DEBUG" ); + 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 (lex_compat) + outn ("#define YY_FLEX_LEX_COMPAT"); - if ( do_yylineno && ! C_plus_plus ) - { - outn( "extern int yylineno;" ); - outn( "int yylineno = 1;" ); + 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 "); + + if (!do_yywrap) { + outn("\nint yyFlexLexer::yywrap() { return 1; }"); } - if ( C_plus_plus ) - { - outn( "\n#include " ); + if (yyclass) { + outn ("int yyFlexLexer::yylex()"); + outn ("\t{"); + outn ("\tLexerError( \"yyFlexLexer::yylex invoked but %option yyclass used\" );"); + outn ("\treturn 0;"); + outn ("\t}"); - 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 ); - } + out_str ("\n#define YY_DECL int %s::yylex()\n", + yyclass); } + } - else - { - if ( yytext_is_array ) - outn( "extern char yytext[];\n" ); + else { - else - { - outn( "extern char *yytext;" ); - outn( "#define yytext_ptr yytext" ); + /* 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"); } - - if ( yyclass ) - flexerror( - _( "%option yyclass only meaningful for C++ scanners" ) ); + else { + outn ("extern char *yytext;"); + outn ("#define yytext_ptr yytext"); + } } - if ( useecs ) - numecs = cre8ecs( nextecm, ecgroup, csize ); + 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] ); + NUL_ec = ABS (ecgroup[0]); - if ( useecs ) - ccl2ecl(); - } + if (useecs) + ccl2ecl (); +} /* set_up_initial_allocations - allocate memory for internal tables */ -void set_up_initial_allocations() - { +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 ); + 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_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 ); + 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 ); + 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 ); + 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 ); + 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 ); + 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 ); + 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; - } +} -void usage() - { - FILE *f = stdout; +/* 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; - fprintf( f, -_( "%s [-bdfhilnpstvwBFILTV78+? -C[aefFmr] -ooutput -Pprefix -Sskeleton]\n" ), - program_name ); - fprintf( f, _( "\t[--help --version] [file ...]\n" ) ); + b = path; + for (b = path; *path; path++) + if (*path == '/') + b = path + 1; + else if (*path == '.') + e = path; - fprintf( f, _( "\t-b generate backing-up information to %s\n" ), - backing_name ); - fprintf( f, _( "\t-d turn on debug mode in generated scanner\n" ) ); - fprintf( f, _( "\t-f generate fast, large scanner\n" ) ); - fprintf( f, _( "\t-h produce this help message\n" ) ); - fprintf( f, _( "\t-i generate case-insensitive scanner\n" ) ); - fprintf( f, _( "\t-l maximal compatibility with original lex\n" ) ); - fprintf( f, _( "\t-n do-nothing POSIX option\n" ) ); - fprintf( f, _( "\t-p generate performance report to stderr\n" ) ); - fprintf( f, - _( "\t-s suppress default rule to ECHO unmatched text\n" ) ); + if (strip_ext && e && e > b) + *e = '\0'; + return b; +} - if ( ! did_outfilename ) - { - snprintf( outfile_path, sizeof outfile_path, outfile_template, - prefix, C_plus_plus ? "cc" : "c" ); +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, - _( "\t-t write generated scanner on stdout instead of %s\n" ), - outfilename ); + 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); - fprintf( f, - _( "\t-v write summary of scanner statistics to f\n" ) ); - fprintf( f, _( "\t-w do not generate warnings\n" ) ); - fprintf( f, _( "\t-B generate batch scanner (opposite of -I)\n" ) ); - fprintf( f, - _( "\t-F use alternative fast scanner representation\n" ) ); - fprintf( f, - _( "\t-I generate interactive scanner (opposite of -B)\n" ) ); - fprintf( f, _( "\t-L suppress #line directives in scanner\n" ) ); - fprintf( f, _( "\t-T %s should run in trace mode\n" ), program_name ); - fprintf( f, _( "\t-V report %s version\n" ), program_name ); - fprintf( f, _( "\t-7 generate 7-bit scanner\n" ) ); - fprintf( f, _( "\t-8 generate 8-bit scanner\n" ) ); - fprintf( f, _( "\t-+ generate C++ scanner class\n" ) ); - fprintf( f, _( "\t-? produce this help message\n" ) ); - fprintf( f, -_( "\t-C specify degree of table compression (default is -Cem):\n" ) ); - fprintf( f, -_( "\t\t-Ca trade off larger tables for better memory alignment\n" ) ); - fprintf( f, _( "\t\t-Ce construct equivalence classes\n" ) ); - fprintf( f, -_( "\t\t-Cf do not compress scanner tables; use -f representation\n" ) ); - fprintf( f, -_( "\t\t-CF do not compress scanner tables; use -F representation\n" ) ); - fprintf( f, _( "\t\t-Cm construct meta-equivalence classes\n" ) ); - fprintf( f, - _( "\t\t-Cr use read() instead of stdio for scanner input\n" ) ); - fprintf( f, _( "\t-o specify output filename\n" ) ); - fprintf( f, _( "\t-P specify scanner prefix other than \"yy\"\n" ) ); - fprintf( f, _( "\t-S specify skeleton file\n" ) ); - fprintf( f, _( "\t--help produce this help message\n" ) ); - fprintf( f, _( "\t--version report %s version\n" ), program_name ); - } +}