diff options
author | The Android Open Source Project <initial-contribution@android.com> | 2009-03-03 19:30:52 -0800 |
---|---|---|
committer | The Android Open Source Project <initial-contribution@android.com> | 2009-03-03 19:30:52 -0800 |
commit | 8e35f3cfc7fba1d1c829dc557ebad6409cbe16a2 (patch) | |
tree | 11425ea0b299d6fb89c6d3618a22d97d5bf68d0f /WebKitTools/android/flex-2.5.4a/main.c | |
parent | 648161bb0edfc3d43db63caed5cc5213bc6cb78f (diff) | |
download | external_webkit-8e35f3cfc7fba1d1c829dc557ebad6409cbe16a2.zip external_webkit-8e35f3cfc7fba1d1c829dc557ebad6409cbe16a2.tar.gz external_webkit-8e35f3cfc7fba1d1c829dc557ebad6409cbe16a2.tar.bz2 |
auto import from //depot/cupcake/@135843
Diffstat (limited to 'WebKitTools/android/flex-2.5.4a/main.c')
-rw-r--r-- | WebKitTools/android/flex-2.5.4a/main.c | 1177 |
1 files changed, 1177 insertions, 0 deletions
diff --git a/WebKitTools/android/flex-2.5.4a/main.c b/WebKitTools/android/flex-2.5.4a/main.c new file mode 100644 index 0000000..7873eec --- /dev/null +++ b/WebKitTools/android/flex-2.5.4a/main.c @@ -0,0 +1,1177 @@ +/* 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: (1) source distributions retain + * this entire copyright notice and comment, and (2) distributions including + * binaries display the following acknowledgement: ``This product includes + * software developed by the University of California, Berkeley and its + * contributors'' in the documentation or other materials provided with the + * distribution and in all advertising materials mentioning features or use + * of this software. 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. + */ + +#ifndef lint +char copyright[] = +"@(#) Copyright (c) 1990 The Regents of the University of California.\n\ + All rights reserved.\n"; +#endif /* not lint */ + +/* $Header: /home/daffy/u0/vern/flex/RCS/main.c,v 2.64 96/05/25 20:42:42 vern Exp $ */ + + +#include "flexdef.h" +#include "version.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)); + +#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; +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; + +/* Make sure program_name is initialized so we don't crash if writing + * out an error message before getting the program name from argv[0]. + */ +char *program_name = "flex"; + +#ifndef SHORT_FILE_NAMES +static char *outfile_template = "lex.%s.%s"; +static char *backing_name = "lex.backup"; +#else +static char *outfile_template = "lex%s.%s"; +static char *backing_name = "lex.bck"; +#endif + +#ifdef THINK_C +#include <console.h> +#endif + +#ifdef MS_DOS +extern unsigned _stklen = 16384; +#endif + +static char outfile_path[MAXLINE]; +static int outfile_created = 0; +static char *skelname = NULL; + + +int main( argc, argv ) +int argc; +char **argv; + { + int i; + +#ifdef THINK_C + argc = ccommand( &argv ); +#endif +#ifdef NEED_ARGV_FIXUP + argv_fixup( &argc, &argv ); +#endif + + flexinit( argc, argv ); + + readin(); + + 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 */ + } + + +/* 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" ) ); + + /* Don't rely on detecting use of yymore() and REJECT, + * just assume they'll be used. + */ + yymore_really_used = reject_really_used = true; + + yytext_is_array = true; + do_yylineno = true; + use_read = false; + } + + if ( do_yylineno ) + /* This should really be "maintain_backup_tables = true" */ + reject_really_used = true; + + 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 ( do_yylineno ) + flexerror( + _( "-Cf/-CF and %option yylineno are incompatible" ) ); + + if ( fulltbl && fullspd ) + flexerror( _( "-Cf and -CF are mutually exclusive" ) ); + } + + if ( C_plus_plus && fullspd ) + flexerror( _( "Can't use -+ with -CF option" ) ); + + if ( C_plus_plus && yytext_is_array ) + { + warn( _( "%array incompatible with -+ option" ) ); + yytext_is_array = false; + } + + if ( 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 ( ! use_stdout ) + { + FILE *prev_stdout; + + if ( ! did_outfilename ) + { + char *suffix; + + if ( C_plus_plus ) + suffix = "cc"; + else + suffix = "c"; + + sprintf( 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; + } + + 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" ); + + if ( do_yylineno ) + GEN_PREFIX( "lineno" ); + } + + if ( do_yywrap ) + GEN_PREFIX( "wrap" ); + + outn( "" ); + } + + if ( did_outfilename ) + line_directive_out( stdout, 0 ); + + skelout(); + } + + +/* flexend - terminate flex + * + * note + * This routine does not return. + */ + +void flexend( exit_status ) +int exit_status; + + { + int tblsiz; + int unlink(); + + 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 ( exit_status != 0 && outfile_created ) + { + if ( ferror( stdout ) ) + lerrsf( _( "error writing output file %s" ), + outfilename ); + + else if ( 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 ( 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 ( 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 ); + } + + exit( exit_status ); + } + + +/* flexinit - initialize flex */ + +void flexinit( argc, argv ) +int argc; +char **argv; + { + int i, sawcmpflag; + char *arg; + + 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; + yymore_really_used = reject_really_used = unspecified; + interactive = csize = unspecified; + do_yywrap = gen_line_dirs = usemecs = useecs = true; + performance_report = 0; + did_outfilename = 0; + prefix = "yy"; + yyclass = 0; + use_read = use_stdout = false; + + 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'; + + program_name = argv[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]; + + if ( arg[0] != '-' || arg[1] == '\0' ) + break; + + if ( arg[1] == '-' ) + { /* --option */ + if ( ! strcmp( arg, "--help" ) ) + arg = "-h"; + + else if ( ! strcmp( arg, "--version" ) ) + arg = "-V"; + + else if ( ! strcmp( arg, "--" ) ) + { /* end of options */ + --argc; + ++argv; + break; + } + } + + for ( i = 1; arg[i] != '\0'; ++i ) + switch ( arg[i] ) + { + case '+': + C_plus_plus = true; + break; + + case 'B': + interactive = false; + break; + + case 'b': + backing_up_report = true; + break; + + case 'c': + break; + + case 'C': + if ( i != 1 ) + flexerror( + _( "-C flag must be given separately" ) ); + + if ( ! sawcmpflag ) + { + useecs = false; + usemecs = false; + fulltbl = false; + sawcmpflag = true; + } + + for ( ++i; 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; + } + + goto get_next_arg; + + case 'd': + ddebug = true; + break; + + case 'f': + useecs = usemecs = false; + use_read = fulltbl = true; + break; + + case 'F': + useecs = usemecs = false; + use_read = fullspd = true; + break; + + case '?': + case 'h': + usage(); + exit( 0 ); + + case 'I': + interactive = true; + break; + + case 'i': + caseins = true; + break; + + case 'l': + lex_compat = true; + break; + + case 'L': + gen_line_dirs = false; + break; + + case 'n': + /* Stupid do-nothing deprecated + * option. + */ + break; + + case 'o': + if ( i != 1 ) + flexerror( + _( "-o flag must be given separately" ) ); + + outfilename = arg + i + 1; + did_outfilename = 1; + goto get_next_arg; + + case 'P': + if ( i != 1 ) + flexerror( + _( "-P flag must be given separately" ) ); + + prefix = arg + i + 1; + goto get_next_arg; + + case 'p': + ++performance_report; + break; + + case 'S': + if ( i != 1 ) + flexerror( + _( "-S flag must be given separately" ) ); + + skelname = arg + i + 1; + goto get_next_arg; + + case 's': + spprdflt = true; + break; + + case 't': + use_stdout = true; + break; + + case 'T': + trace = true; + break; + + case 'v': + printstats = true; + break; + + case 'V': + printf( _( "%s version %s\n" ), + program_name, flex_version ); + exit( 0 ); + + case 'w': + nowarn = true; + break; + + case '7': + csize = 128; + break; + + case '8': + csize = CSIZE; + 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 ); + } + + /* Used by -C, -S, -o, and -P flags in lieu of a "continue 2" + * control. + */ + get_next_arg: ; + } + + num_input_files = argc; + input_files = argv; + 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; + + out_linenum = 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 ( 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 large 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 ( 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 -f or -F" ) ); + else + flexerror( + _( "variable trailing context rules cannot be used with -f or -F" ) ); + } + + if ( reject ) + outn( "\n#define YY_USES_REJECT" ); + + if ( ! do_yywrap ) + { + outn( "\n#define yywrap() 1" ); + outn( "#define YY_SKIP_YYWRAP" ); + } + + if ( ddebug ) + outn( "\n#define FLEX_DEBUG" ); + + if ( csize == 256 ) + outn( "typedef unsigned char YY_CHAR;" ); + else + outn( "typedef char YY_CHAR;" ); + + if ( C_plus_plus ) + { + outn( "#define yytext_ptr yytext" ); + + 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 + outn( yy_nostdinit ); + } + + if ( fullspd ) + outn( "typedef yyconst struct yy_trans_info *yy_state_type;" ); + else if ( ! C_plus_plus ) + outn( "typedef int yy_state_type;" ); + + if ( ddebug ) + outn( "\n#define FLEX_DEBUG" ); + + 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 ) + { + outn( "\n#include <FlexLexer.h>" ); + + 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 + { + if ( yytext_is_array ) + outn( "extern char yytext[];\n" ); + + 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() + { + 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 ); + + 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 ); + + 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; + } + + +void usage() + { + FILE *f = stdout; + + fprintf( f, +_( "%s [-bcdfhilnpstvwBFILTV78+? -C[aefFmr] -ooutput -Pprefix -Sskeleton]\n" ), + program_name ); + fprintf( f, _( "\t[--help --version] [file ...]\n" ) ); + + fprintf( f, _( "\t-b generate backing-up information to %s\n" ), + backing_name ); + fprintf( f, _( "\t-c do-nothing POSIX option\n" ) ); + 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 ( ! did_outfilename ) + { + sprintf( 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, + _( "\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 ); + } |