1180 lines
28 KiB
C
1180 lines
28 KiB
C
/* 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 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
|
|
static const 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 <sys/cdefs.h>
|
|
__FBSDID("$FreeBSD$");
|
|
|
|
|
|
#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 );
|
|
}
|