void build_eof_action()
{
register int ii;
char action_text[MAXLINE];
for ( ii = 1; ii <= scon_stk_ptr; ++ii )
{
if ( sceof[scon_stk[ii]] )
format_pinpoint_message(
"multiple <<EOF>> rules for start condition %s",
scname[scon_stk[ii]] );
else
{
sceof[scon_stk[ii]] = true;
sprintf( action_text, "case YY_STATE_EOF(%s):\n",
scname[scon_stk[ii]] );
add_ind_action( 2, action_text );
}
}
line_directive_out( (FILE *) 0, 1 );
/* This isn't a normal rule after all - don't count it as
* such, so we don't have any holes in the rule numbering
* (which make generating "rule can never match" warnings
* more difficult.
*/
--num_rules;
++num_eof_rules;
}
void build_eof_action()
{
int i;
char action_text[MAXLINE];
for ( i = 1; i <= scon_stk_ptr; ++i )
{
if ( sceof[scon_stk[i]] )
format_pinpoint_message(
"multiple <<EOF>> rules for start condition %s",
scname[scon_stk[i]] );
else
{
sceof[scon_stk[i]] = true;
if (previous_continued_action /* && previous action was regular */)
add_action("YY_RULE_SETUP\n");
snprintf( action_text, sizeof(action_text), "case YY_STATE_EOF(%s):\n",
scname[scon_stk[i]] );
add_action( action_text );
}
}
line_directive_out( (FILE *) 0, 1 );
/* This isn't a normal rule after all - don't count it as
* such, so we don't have any holes in the rule numbering
* (which make generating "rule can never match" warnings
* more difficult.
*/
--num_rules;
++num_eof_rules;
}
void finish_rule(int mach, int variable_trail_rule, int headcnt, int trailcnt)
{
add_accept( mach, num_rules );
/* we did this in new_rule(), but it often gets the wrong
* number because we do it before we start parsing the current rule
*/
rule_linenum[num_rules] = linenum;
/* if this is a continued action, then the line-number has
* already been updated, giving us the wrong number
*/
if ( continued_action )
--rule_linenum[num_rules];
fprintf( temp_action_file, "case %d:\n", num_rules );
if ( variable_trail_rule )
{
rule_type[num_rules] = RULE_VARIABLE;
if ( performance_report )
fprintf( stderr, "Variable trailing context rule at line %d\n",
rule_linenum[num_rules] );
variable_trailing_context_rules = true;
}
else
{
rule_type[num_rules] = RULE_NORMAL;
if ( headcnt > 0 || trailcnt > 0 )
{
/* do trailing context magic to not match the trailing characters */
char *scanner_cp = "yy_c_buf_p = yy_cp";
char *scanner_bp = "yy_bp";
fprintf( temp_action_file,
"*yy_cp = yy_hold_char; /* undo effects of setting up yytext */\n" );
if ( headcnt > 0 )
fprintf( temp_action_file, "%s = %s + %d;\n",
scanner_cp, scanner_bp, headcnt );
else
fprintf( temp_action_file,
"%s -= %d;\n", scanner_cp, trailcnt );
fprintf( temp_action_file,
"YY_DO_BEFORE_ACTION; /* set up yytext again */\n" );
}
}
line_directive_out( temp_action_file );
}
void readin(void)
{
skelout();
if ( ddebug )
puts( "#define FLEX_DEBUG" );
if ( csize == 256 )
puts( "#define YY_CHAR unsigned char" );
else
puts( "#define YY_CHAR char" );
line_directive_out( stdout );
if ( yyparse() )
{
pinpoint_message( "fatal parse error" );
flexend( 1 );
}
if ( xlation )
{
numecs = ecs_from_xlation( ecgroup );
useecs = true;
}
else 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();
}
void build_eof_action()
{
register int i;
for ( i = 1; i <= actvp; ++i )
{
if ( sceof[actvsc[i]] )
format_pinpoint_message(
"multiple <<EOF>> rules for start condition %s",
scname[actvsc[i]] );
else
{
sceof[actvsc[i]] = true;
fprintf( temp_action_file, "case YY_STATE_EOF(%s):\n",
scname[actvsc[i]] );
}
}
line_directive_out( temp_action_file );
}
void readin(void)
{
static char yy_stdinit[] = "FILE *yyin = stdin, *yyout = stdout;";
static char yy_nostdinit[] =
"FILE *yyin = NULL, *yyout = NULL;";
line_directive_out( NULL, 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( yy_stdinit );
}
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();
}
void check_options(void)
{
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();
}
void check_options (void)
{
int i;
const char * m4 = NULL;
if (lex_compat) {
if (C_plus_plus)
flexerror (_("Can't use -+ with -l option"));
if (fulltbl || fullspd)
flexerror (_("Can't use -f or -F with -l option"));
if (reentrant || bison_bridge_lval)
flexerror (_
("Can't use --reentrant or --bison-bridge with -l option"));
yytext_is_array = true;
do_yylineno = true;
use_read = false;
}
#if 0
/* This makes no sense whatsoever. I'm removing it. */
if (do_yylineno)
/* This should really be "maintain_backup_tables = true" */
reject_really_used = true;
#endif
if (csize == unspecified) {
if ((fulltbl || fullspd) && !useecs)
csize = DEFAULT_CSIZE;
else
csize = CSIZE;
}
if (interactive == unspecified) {
if (fulltbl || fullspd)
interactive = false;
else
interactive = true;
}
if (fulltbl || fullspd) {
if (usemecs)
flexerror (_
("-Cf/-CF and -Cm don't make sense together"));
if (interactive)
flexerror (_("-Cf/-CF and -I are incompatible"));
if (lex_compat)
flexerror (_
("-Cf/-CF are incompatible with lex-compatibility mode"));
if (fulltbl && fullspd)
flexerror (_
("-Cf and -CF are mutually exclusive"));
}
if (C_plus_plus && fullspd)
flexerror (_("Can't use -+ with -CF option"));
if (C_plus_plus && yytext_is_array) {
lwarn (_("%array incompatible with -+ option"));
yytext_is_array = false;
}
if (C_plus_plus && (reentrant))
flexerror (_("Options -+ and --reentrant are mutually exclusive."));
if (C_plus_plus && bison_bridge_lval)
flexerror (_("bison bridge not supported for the C++ scanner."));
if (useecs) { /* Set up doubly-linked equivalence classes. */
/* We loop all the way up to csize, since ecgroup[csize] is
* the position used for NUL characters.
*/
ecgroup[1] = NIL;
for (i = 2; i <= csize; ++i) {
ecgroup[i] = i - 1;
nextecm[i - 1] = i;
}
nextecm[csize] = NIL;
}
else {
/* Put everything in its own equivalence class. */
for (i = 1; i <= csize; ++i) {
ecgroup[i] = i;
nextecm[i] = BAD_SUBSCRIPT; /* to catch errors */
}
}
if (extra_type)
buf_m4_define( &m4defs_buf, "M4_EXTRA_TYPE_DEFS", extra_type);
if (!use_stdout) {
FILE *prev_stdout;
if (!did_outfilename) {
char *suffix;
if (C_plus_plus)
suffix = "cc";
else
suffix = "c";
snprintf (outfile_path, sizeof(outfile_path), outfile_template,
prefix, suffix);
outfilename = outfile_path;
}
prev_stdout = freopen (outfilename, "w+", stdout);
if (prev_stdout == NULL)
lerr (_("could not create %s"), outfilename);
outfile_created = 1;
}
/* Setup the filter chain. */
output_chain = filter_create_int(NULL, filter_tee_header, headerfilename);
if ( !(m4 = getenv("M4"))) {
char *slash;
m4 = M4;
if ((slash = strrchr(M4, '/')) != NULL) {
m4 = slash+1;
/* break up $PATH */
const char *path = getenv("PATH");
if (!path) {
m4 = M4;
} else {
int m4_length = strlen(m4);
do {
size_t length = strlen(path);
struct stat sbuf;
const char *endOfDir = strchr(path, ':');
if (!endOfDir)
endOfDir = path+length;
{
char *m4_path = calloc(endOfDir-path + 1 + m4_length + 1, 1);
memcpy(m4_path, path, endOfDir-path);
m4_path[endOfDir-path] = '/';
memcpy(m4_path + (endOfDir-path) + 1, m4, m4_length + 1);
if (stat(m4_path, &sbuf) == 0 &&
(S_ISREG(sbuf.st_mode)) && sbuf.st_mode & S_IXUSR) {
m4 = m4_path;
break;
}
free(m4_path);
}
path = endOfDir+1;
} while (path[0]);
if (!path[0])
m4 = M4;
}
}
}
filter_create_ext(output_chain, m4, "-P", 0);
filter_create_int(output_chain, filter_fix_linedirs, NULL);
/* For debugging, only run the requested number of filters. */
if (preproc_level > 0) {
filter_truncate(output_chain, preproc_level);
filter_apply_chain(output_chain);
}
yyout = stdout;
/* always generate the tablesverify flag. */
buf_m4_define (&m4defs_buf, "M4_YY_TABLES_VERIFY", tablesverify ? "1" : "0");
if (tablesext)
gentables = false;
if (tablesverify)
/* force generation of C tables. */
gentables = true;
if (tablesext) {
FILE *tablesout;
struct yytbl_hdr hdr;
char *pname = 0;
size_t nbytes = 0;
buf_m4_define (&m4defs_buf, "M4_YY_TABLES_EXTERNAL", NULL);
if (!tablesfilename) {
nbytes = strlen (prefix) + strlen (tablesfile_template) + 2;
tablesfilename = pname = calloc(nbytes, 1);
snprintf (pname, nbytes, tablesfile_template, prefix);
}
if ((tablesout = fopen (tablesfilename, "w")) == NULL)
lerr (_("could not create %s"), tablesfilename);
free(pname);
tablesfilename = 0;
yytbl_writer_init (&tableswr, tablesout);
nbytes = strlen (prefix) + strlen ("tables") + 2;
tablesname = 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)
lerr (_("can't open skeleton file %s"), skelname);
if (reentrant) {
buf_m4_define (&m4defs_buf, "M4_YY_REENTRANT", NULL);
if (yytext_is_array)
buf_m4_define (&m4defs_buf, "M4_YY_TEXT_IS_ARRAY", NULL);
}
if ( bison_bridge_lval)
buf_m4_define (&m4defs_buf, "M4_YY_BISON_LVAL", NULL);
if ( bison_bridge_lloc)
buf_m4_define (&m4defs_buf, "<M4_YY_BISON_LLOC>", NULL);
if (strchr(prefix, '[') || strchr(prefix, ']'))
flexerror(_("Prefix cannot include '[' or ']'"));
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;
strsz = strlen(fmt) + strlen(scname[i]) + (size_t)(1 + ceil (log10(i))) + 2;
str = malloc(strsz);
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. */
if (gen_line_dirs)
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] */
}
void readin (void)
{
static char yy_stdinit[] = "FILE *yyin = stdin, *yyout = stdout;";
static char yy_nostdinit[] =
"FILE *yyin = NULL, *yyout = NULL;";
line_directive_out(NULL, 1);
if (yyparse ()) {
pinpoint_message (_("fatal parse error"));
flexend (1);
}
if (syntaxerror)
flexend (1);
/* If the user explicitly requested posix compatibility by specifing the
* posix-compat option, then we check for conflicting options. However, if
* the POSIXLY_CORRECT variable is set, then we quietly make flex as
* posix-compatible as possible. This is the recommended behavior
* according to the GNU Coding Standards.
*
* Note: The posix option was added to flex to provide the posix behavior
* of the repeat operator in regular expressions, e.g., `ab{3}'
*/
if (posix_compat) {
/* TODO: This is where we try to make flex behave according to
* posiz, AND check for conflicting options. How far should we go
* with this? Should we disable all the neat-o flex features?
*/
/* Update: Estes says no, since other flex features don't violate posix. */
}
if (getenv ("POSIXLY_CORRECT")) {
posix_compat = true;
}
if (backing_up_report) {
backing_up_file = fopen (backing_name, "w");
if (backing_up_file == NULL)
lerr (_
("could not create backing-up info file %s"),
backing_name);
}
else
backing_up_file = NULL;
if (yymore_really_used == true)
yymore_used = true;
else if (yymore_really_used == false)
yymore_used = false;
if (reject_really_used == true)
reject = true;
else if (reject_really_used == false)
reject = false;
if (performance_report > 0) {
if (lex_compat) {
fprintf (stderr,
_
("-l AT&T lex compatibility option entails a large performance penalty\n"));
fprintf (stderr,
_
(" and may be the actual source of other reported performance penalties\n"));
}
else if (do_yylineno) {
fprintf (stderr,
_
("%%option yylineno entails a performance penalty ONLY on rules that can match newline characters\n"));
}
if (performance_report > 1) {
if (interactive)
fprintf (stderr,
_
("-I (interactive) entails a minor performance penalty\n"));
if (yymore_used)
fprintf (stderr,
_
("yymore() entails a minor performance penalty\n"));
}
if (reject)
fprintf (stderr,
_
("REJECT entails a large performance penalty\n"));
if (variable_trailing_context_rules)
fprintf (stderr,
_
("Variable trailing context rules entail a large performance penalty\n"));
}
if (reject)
real_reject = true;
if (variable_trailing_context_rules)
reject = true;
if ((fulltbl || fullspd) && reject) {
if (real_reject)
flexerror (_
("REJECT cannot be used with -f or -F"));
else if (do_yylineno)
flexerror (_
("%option yylineno cannot be used with REJECT"));
else
flexerror (_
("variable trailing context rules cannot be used with -f or -F"));
}
if (reject){
out_m4_define( "M4_YY_USES_REJECT", NULL);
//outn ("\n#define YY_USES_REJECT");
}
if (!do_yywrap) {
if (!C_plus_plus) {
if (reentrant)
out_str ("\n#define %swrap(yyscanner) (/*CONSTCOND*/1)\n", prefix);
else
out_str ("\n#define %swrap() (/*CONSTCOND*/1)\n", prefix);
}
outn ("#define YY_SKIP_YYWRAP");
}
if (ddebug)
outn ("\n#define FLEX_DEBUG");
OUT_BEGIN_CODE ();
outn ("typedef flex_uint8_t YY_CHAR;");
OUT_END_CODE ();
if (C_plus_plus) {
outn ("#define yytext_ptr yytext");
if (interactive)
outn ("#define YY_INTERACTIVE");
}
else {
OUT_BEGIN_CODE ();
/* In reentrant scanner, stdinit is handled in flex.skl. */
if (do_stdinit) {
if (reentrant){
outn ("#ifdef VMS");
outn ("#ifdef __VMS_POSIX");
outn ("#define YY_STDINIT");
outn ("#endif");
outn ("#else");
outn ("#define YY_STDINIT");
outn ("#endif");
}
outn ("#ifdef VMS");
outn ("#ifndef __VMS_POSIX");
outn (yy_nostdinit);
outn ("#else");
outn (yy_stdinit);
outn ("#endif");
outn ("#else");
outn (yy_stdinit);
outn ("#endif");
}
else {
if(!reentrant)
outn (yy_nostdinit);
}
OUT_END_CODE ();
}
OUT_BEGIN_CODE ();
if (fullspd)
outn ("typedef const struct yy_trans_info *yy_state_type;");
else if (!C_plus_plus)
outn ("typedef int yy_state_type;");
OUT_END_CODE ();
if (lex_compat)
outn ("#define YY_FLEX_LEX_COMPAT");
if (!C_plus_plus && !reentrant) {
outn ("extern int yylineno;");
OUT_BEGIN_CODE ();
outn ("int yylineno = 1;");
OUT_END_CODE ();
}
if (C_plus_plus) {
outn ("\n#include <FlexLexer.h>");
if (!do_yywrap) {
outn("\nint yyFlexLexer::yywrap() { return 1; }");
}
if (yyclass) {
outn ("int yyFlexLexer::yylex()");
outn ("\t{");
outn ("\tLexerError( \"yyFlexLexer::yylex invoked but %option yyclass used\" );");
outn ("\treturn 0;");
outn ("\t}");
out_str ("\n#define YY_DECL int %s::yylex()\n",
yyclass);
}
}
else {
/* Watch out: yytext_ptr is a variable when yytext is an array,
* but it's a macro when yytext is a pointer.
*/
if (yytext_is_array) {
if (!reentrant)
outn ("extern char yytext[];\n");
}
else {
if (reentrant) {
outn ("#define yytext_ptr yytext_r");
}
else {
outn ("extern char *yytext;");
outn("#ifdef yytext_ptr");
outn("#undef yytext_ptr");
outn("#endif");
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 ();
}
/* finish_rule - finish up the processing for a rule
*
* An accepting number is added to the given machine. If variable_trail_rule
* is true then the rule has trailing context and both the head and trail
* are variable size. Otherwise if headcnt or trailcnt is non-zero then
* the machine recognizes a pattern with trailing context and headcnt is
* the number of characters in the matched part of the pattern, or zero
* if the matched part has variable length. trailcnt is the number of
* trailing context characters in the pattern, or zero if the trailing
* context has variable length.
*/
void
finish_rule(int mach, int variable_trail_rule, int headcnt, int trailcnt)
{
char action_text[MAXLINE];
add_accept(mach, num_rules);
/* We did this in new_rule(), but it often gets the wrong
* number because we do it before we start parsing the current rule.
*/
rule_linenum[num_rules] = linenum;
/* If this is a continued action, then the line-number has already
* been updated, giving us the wrong number.
*/
if (continued_action)
--rule_linenum[num_rules];
sprintf(action_text, "case %d:\n", num_rules);
add_ind_action(2, action_text);
if (variable_trail_rule) {
rule_type[num_rules] = RULE_VARIABLE;
if (performance_report > 0)
fprintf(stderr,
_("Variable trailing context rule at line %d\n"),
rule_linenum[num_rules]);
variable_trailing_context_rules = true;
}
else {
rule_type[num_rules] = RULE_NORMAL;
if (headcnt > 0 || trailcnt > 0) {
/* Do trailing context magic to not match the trailing
* characters.
*/
const char *scanner_cp = "yy_c_buf_p = yy_cp";
const char *scanner_bp = "yy_bp";
add_ind_action(3,
"*yy_cp = yy_hold_char;\t/* undo effects of setting up yytext */\n");
if (headcnt > 0) {
sprintf(action_text, "%s = %s + %d;\n",
scanner_cp, scanner_bp, headcnt);
add_ind_action(3, action_text);
}
else {
sprintf(action_text, "%s -= %d;\n",
scanner_cp, trailcnt);
add_ind_action(3, action_text);
}
add_ind_action(3,
"YY_DO_BEFORE_ACTION;\t/* set up yytext again */\n");
}
}
/* Okay, in the action code at this point yytext and yyleng have
* their proper final values for this rule, so here's the point
* to do any user action. But don't do it for continued actions,
* as that'll result in multiple YY_RULE_SETUP's.
*/
if (!continued_action)
add_ind_action(3, "YY_RULE_SETUP\n");
line_directive_out((FILE *) 0, 1);
}
void make_tables(void)
{
int i;
int did_eof_rule = false;
skelout();
/* First, take care of YY_DO_BEFORE_ACTION depending on yymore
* being used.
*/
set_indent( 1 );
if ( yymore_used && ! yytext_is_array )
{
indent_puts( "yytext_ptr -= yy_more_len; \\" );
indent_puts( "yyleng = (int) (yy_cp - yytext_ptr); \\" );
}
else
indent_puts( "yyleng = (int) (yy_cp - yy_bp); \\" );
/* Now also deal with copying yytext_ptr to yytext if needed. */
skelout();
if ( yytext_is_array )
{
if ( yymore_used )
indent_puts(
"if ( yyleng + yy_more_offset >= YYLMAX ) \\" );
else
indent_puts( "if ( yyleng >= YYLMAX ) \\" );
indent_up();
indent_puts(
"YY_FATAL_ERROR( \"token too large, exceeds YYLMAX\" ); \\" );
indent_down();
if ( yymore_used )
{
indent_puts(
"yy_flex_strncpy( &yytext[yy_more_offset], yytext_ptr, yyleng + 1 ); \\" );
indent_puts( "yyleng += yy_more_offset; \\" );
indent_puts(
"yy_prev_more_offset = yy_more_offset; \\" );
indent_puts( "yy_more_offset = 0; \\" );
}
else
{
indent_puts(
"yy_flex_strncpy( yytext, yytext_ptr, yyleng + 1 ); \\" );
}
}
set_indent( 0 );
skelout();
out_dec( "#define YY_NUM_RULES %d\n", num_rules );
out_dec( "#define YY_END_OF_BUFFER %d\n", num_rules + 1 );
if ( fullspd )
{
/* Need to define the transet type as a size large
* enough to hold the biggest offset.
*/
int total_table_size = tblend + numecs + 1;
char *trans_offset_type =
(total_table_size >= MAX_SHORT || long_align) ?
"long" : "short";
set_indent( 0 );
indent_puts( "struct yy_trans_info" );
indent_up();
indent_puts( "{" ); /* } for vi */
if ( long_align )
indent_puts( "long yy_verify;" );
else
indent_puts( "short yy_verify;" );
/* In cases where its sister yy_verify *is* a "yes, there is
* a transition", yy_nxt is the offset (in records) to the
* next state. In most cases where there is no transition,
* the value of yy_nxt is irrelevant. If yy_nxt is the -1th
* record of a state, though, then yy_nxt is the action number
* for that state.
*/
indent_put2s( "%s yy_nxt;", trans_offset_type );
indent_puts( "};" );
indent_down();
}
if ( fullspd )
genctbl();
else if ( fulltbl )
genftbl();
else
gentabs();
/* Definitions for backing up. We don't need them if REJECT
* is being used because then we use an alternative backin-up
* technique instead.
*/
if ( num_backing_up > 0 && ! reject )
{
if ( ! C_plus_plus )
{
indent_puts(
"static yy_state_type yy_last_accepting_state;" );
indent_puts(
"static char *yy_last_accepting_cpos;\n" );
}
}
if ( nultrans )
{
out_str_dec( C_state_decl, "yy_NUL_trans", lastdfa + 1 );
for ( i = 1; i <= lastdfa; ++i )
{
if ( fullspd )
out_dec( " &yy_transition[%d],\n", base[i] );
else
mkdata( nultrans[i] );
}
dataend();
}
if ( ddebug )
{ /* Spit out table mapping rules to line numbers. */
if ( ! C_plus_plus )
{
indent_puts( "extern int yy_flex_debug;" );
indent_puts( "int yy_flex_debug = 1;\n" );
}
out_str_dec( long_align ? C_long_decl : C_short_decl,
"yy_rule_linenum", num_rules );
for ( i = 1; i < num_rules; ++i )
mkdata( rule_linenum[i] );
dataend();
}
if ( reject )
{
/* Declare state buffer variables. */
if ( ! C_plus_plus )
{
outn(
"static yy_state_type yy_state_buf[YY_BUF_SIZE + 2], *yy_state_ptr;" );
outn( "static char *yy_full_match;" );
outn( "static int yy_lp;" );
}
if ( variable_trailing_context_rules )
{
if ( ! C_plus_plus )
{
outn(
"static int yy_looking_for_trail_begin = 0;" );
outn( "static int yy_full_lp;" );
outn( "static int *yy_full_state;" );
}
out_hex( "#define YY_TRAILING_MASK 0x%x\n",
(unsigned int) YY_TRAILING_MASK );
out_hex( "#define YY_TRAILING_HEAD_MASK 0x%x\n",
(unsigned int) YY_TRAILING_HEAD_MASK );
}
outn( "#define REJECT \\" );
outn( "{ \\" ); /* } for vi */
outn(
"*yy_cp = yy_hold_char; /* undo effects of setting up yytext */ \\" );
outn(
"yy_cp = yy_full_match; /* restore poss. backed-over text */ \\" );
if ( variable_trailing_context_rules )
{
outn(
"yy_lp = yy_full_lp; /* restore orig. accepting pos. */ \\" );
outn(
"yy_state_ptr = yy_full_state; /* restore orig. state */ \\" );
outn(
"yy_current_state = *yy_state_ptr; /* restore curr. state */ \\" );
}
outn( "++yy_lp; \\" );
outn( "goto find_rule; \\" );
/* { for vi */
outn( "}" );
}
else
{
outn(
"/* The intent behind this definition is that it'll catch" );
outn( " * any uses of REJECT which flex missed." );
outn( " */" );
outn( "#define REJECT reject_used_but_not_detected" );
}
if ( yymore_used )
{
if ( ! C_plus_plus )
{
if ( yytext_is_array )
{
indent_puts( "static int yy_more_offset = 0;" );
indent_puts(
"static int yy_prev_more_offset = 0;" );
}
else
{
indent_puts( "static int yy_more_flag = 0;" );
indent_puts( "static int yy_more_len = 0;" );
}
}
if ( yytext_is_array )
{
indent_puts(
"#define yymore() (yy_more_offset = yy_flex_strlen( yytext ))" );
indent_puts( "#define YY_NEED_STRLEN" );
indent_puts( "#define YY_MORE_ADJ 0" );
indent_puts( "#define YY_RESTORE_YY_MORE_OFFSET \\" );
indent_up();
indent_puts( "{ \\" );
indent_puts( "yy_more_offset = yy_prev_more_offset; \\" );
indent_puts( "yyleng -= yy_more_offset; \\" );
indent_puts( "}" );
indent_down();
}
else
{
indent_puts( "#define yymore() (yy_more_flag = 1)" );
indent_puts( "#define YY_MORE_ADJ yy_more_len" );
indent_puts( "#define YY_RESTORE_YY_MORE_OFFSET" );
}
}
else
{
indent_puts( "#define yymore() yymore_used_but_not_detected" );
indent_puts( "#define YY_MORE_ADJ 0" );
indent_puts( "#define YY_RESTORE_YY_MORE_OFFSET" );
}
if ( ! C_plus_plus )
{
if ( yytext_is_array )
{
outn( "#ifndef YYLMAX" );
outn( "#define YYLMAX 8192" );
outn( "#endif\n" );
outn( "char yytext[YYLMAX];" );
outn( "char *yytext_ptr;" );
}
else
outn( "char *yytext;" );
}
out( &action_array[defs1_offset] );
line_directive_out( stdout, 0 );
skelout();
if ( ! C_plus_plus )
{
if ( use_read )
{
outn(
"\tif ( (result = read( fileno(yyin), (char *) buf, max_size )) < 0 ) \\" );
outn(
"\t\tYY_FATAL_ERROR( \"input in flex scanner failed\" );" );
}
else
{
outn(
"\tif ( yy_current_buffer->yy_is_interactive ) \\" );
outn( "\t\t{ \\" );
outn( "\t\tint c = '*', n; \\" );
outn( "\t\tfor ( n = 0; n < max_size && \\" );
outn( "\t\t\t (c = getc( yyin )) != EOF && c != '\\n'; ++n ) \\" );
outn( "\t\t\tbuf[n] = (char) c; \\" );
outn( "\t\tif ( c == '\\n' ) \\" );
outn( "\t\t\tbuf[n++] = (char) c; \\" );
outn( "\t\tif ( c == EOF && ferror( yyin ) ) \\" );
outn(
"\t\t\tYY_FATAL_ERROR( \"input in flex scanner failed\" ); \\" );
outn( "\t\tresult = n; \\" );
outn( "\t\t} \\" );
outn(
"\telse if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \\" );
outn( "\t\t && ferror( yyin ) ) \\" );
outn(
"\t\tYY_FATAL_ERROR( \"input in flex scanner failed\" );" );
}
}
skelout();
indent_puts( "#define YY_RULE_SETUP \\" );
indent_up();
if ( bol_needed )
{
indent_puts( "if ( yyleng > 0 ) \\" );
indent_up();
indent_puts( "yy_current_buffer->yy_at_bol = \\" );
indent_puts( "\t\t(yytext[yyleng - 1] == '\\n'); \\" );
indent_down();
}
indent_puts( "YY_USER_ACTION" );
indent_down();
skelout();
/* Copy prolog to output file. */
out( &action_array[prolog_offset] );
line_directive_out( stdout, 0 );
skelout();
set_indent( 2 );
if ( yymore_used && ! yytext_is_array )
{
indent_puts( "yy_more_len = 0;" );
indent_puts( "if ( yy_more_flag )" );
indent_up();
indent_puts( "{" );
indent_puts( "yy_more_len = yy_c_buf_p - yytext_ptr;" );
indent_puts( "yy_more_flag = 0;" );
indent_puts( "}" );
indent_down();
}
skelout();
gen_start_state();
/* Note, don't use any indentation. */
outn( "yy_match:" );
gen_next_match();
skelout();
set_indent( 2 );
gen_find_action();
skelout();
if ( do_yylineno )
{
indent_puts( "if ( yy_act != YY_END_OF_BUFFER )" );
indent_up();
indent_puts( "{" );
indent_puts( "int yyl;" );
indent_puts( "for ( yyl = 0; yyl < yyleng; ++yyl )" );
indent_up();
indent_puts( "if ( yytext[yyl] == '\\n' )" );
indent_up();
indent_puts( "++yylineno;" );
indent_down();
indent_down();
indent_puts( "}" );
indent_down();
}
skelout();
if ( ddebug )
{
indent_puts( "if ( yy_flex_debug )" );
indent_up();
indent_puts( "{" );
indent_puts( "if ( yy_act == 0 )" );
indent_up();
indent_puts( C_plus_plus ?
"cerr << \"--scanner backing up\\n\";" :
"fprintf( stderr, \"--scanner backing up\\n\" );" );
indent_down();
do_indent();
out_dec( "else if ( yy_act < %d )\n", num_rules );
indent_up();
if ( C_plus_plus )
{
indent_puts(
"cerr << \"--accepting rule at line \" << yy_rule_linenum[yy_act] <<" );
indent_puts(
" \"(\\\"\" << yytext << \"\\\")\\n\";" );
}
else
{
indent_puts(
"fprintf( stderr, \"--accepting rule at line %d (\\\"%s\\\")\\n\"," );
indent_puts(
" yy_rule_linenum[yy_act], yytext );" );
}
indent_down();
do_indent();
out_dec( "else if ( yy_act == %d )\n", num_rules );
indent_up();
if ( C_plus_plus )
{
indent_puts(
"cerr << \"--accepting default rule (\\\"\" << yytext << \"\\\")\\n\";" );
}
else
{
indent_puts(
"fprintf( stderr, \"--accepting default rule (\\\"%s\\\")\\n\"," );
indent_puts( " yytext );" );
}
indent_down();
do_indent();
out_dec( "else if ( yy_act == %d )\n", num_rules + 1 );
indent_up();
indent_puts( C_plus_plus ?
"cerr << \"--(end of buffer or a NUL)\\n\";" :
"fprintf( stderr, \"--(end of buffer or a NUL)\\n\" );" );
indent_down();
do_indent();
outn( "else" );
indent_up();
if ( C_plus_plus )
{
indent_puts(
"cerr << \"--EOF (start condition \" << YY_START << \")\\n\";" );
}
else
{
indent_puts(
"fprintf( stderr, \"--EOF (start condition %d)\\n\", YY_START );" );
}
indent_down();
indent_puts( "}" );
indent_down();
}
/* Copy actions to output file. */
skelout();
indent_up();
gen_bu_action();
out( &action_array[action_offset] );
line_directive_out( stdout, 0 );
/* generate cases for any missing EOF rules */
for ( i = 1; i <= lastsc; ++i )
if ( ! sceof[i] )
{
do_indent();
out_str( "case YY_STATE_EOF(%s):\n", scname[i] );
did_eof_rule = true;
}
if ( did_eof_rule )
{
indent_up();
indent_puts( "yyterminate();" );
indent_down();
}
/* Generate code for handling NUL's, if needed. */
/* First, deal with backing up and setting up yy_cp if the scanner
* finds that it should JAM on the NUL.
*/
skelout();
set_indent( 4 );
if ( fullspd || fulltbl )
indent_puts( "yy_cp = yy_c_buf_p;" );
else
{ /* compressed table */
if ( ! reject && ! interactive )
{
/* Do the guaranteed-needed backing up to figure
* out the match.
*/
indent_puts( "yy_cp = yy_last_accepting_cpos;" );
indent_puts(
"yy_current_state = yy_last_accepting_state;" );
}
else
/* Still need to initialize yy_cp, though
* yy_current_state was set up by
* yy_get_previous_state().
*/
indent_puts( "yy_cp = yy_c_buf_p;" );
}
/* Generate code for yy_get_previous_state(). */
set_indent( 1 );
skelout();
gen_start_state();
set_indent( 2 );
skelout();
gen_next_state( true );
set_indent( 1 );
skelout();
gen_NUL_trans();
skelout();
if ( do_yylineno )
{ /* update yylineno inside of unput() */
indent_puts( "if ( c == '\\n' )" );
indent_up();
indent_puts( "--yylineno;" );
indent_down();
}
skelout();
/* Update BOL and yylineno inside of input(). */
if ( bol_needed )
{
indent_puts( "yy_current_buffer->yy_at_bol = (c == '\\n');" );
if ( do_yylineno )
{
indent_puts( "if ( yy_current_buffer->yy_at_bol )" );
indent_up();
indent_puts( "++yylineno;" );
indent_down();
}
}
else if ( do_yylineno )
{
indent_puts( "if ( c == '\\n' )" );
indent_up();
indent_puts( "++yylineno;" );
indent_down();
}
skelout();
/* Copy remainder of input to output. */
line_directive_out( stdout, 1 );
if ( sectnum == 3 )
(void) flexscan(); /* copy remainder of input to output */
}
