| version 1.11, 2004/02/03 21:20:17 |
version 1.12, 2015/11/19 19:43:40 |
|
|
| |
|
| /* gen - actual generation (writing) of flex scanners */ |
/* gen - actual generation (writing) of flex scanners */ |
| |
|
| /*- |
/* Copyright (c) 1990 The Regents of the University of California. */ |
| * Copyright (c) 1990 The Regents of the University of California. |
/* All rights reserved. */ |
| * All rights reserved. |
|
| * |
|
| * This code is derived from software contributed to Berkeley by |
|
| * Vern Paxson. |
|
| * |
|
| * The United States Government has rights in this work pursuant |
|
| * to contract no. DE-AC03-76SF00098 between the United States |
|
| * Department of Energy and the University of California. |
|
| * |
|
| * Redistribution and use in source and binary forms, with or without |
|
| * modification, are permitted provided that the following conditions |
|
| * are met: |
|
| * |
|
| * 1. Redistributions of source code must retain the above copyright |
|
| * notice, this list of conditions and the following disclaimer. |
|
| * 2. Redistributions in binary form must reproduce the above copyright |
|
| * notice, this list of conditions and the following disclaimer in the |
|
| * documentation and/or other materials provided with the distribution. |
|
| * |
|
| * Neither the name of the University nor the names of its contributors |
|
| * may be used to endorse or promote products derived from this software |
|
| * without specific prior written permission. |
|
| * |
|
| * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR |
|
| * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED |
|
| * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
|
| * PURPOSE. |
|
| */ |
|
| |
|
| /* $Header$ */ |
/* This code is derived from software contributed to Berkeley by */ |
| |
/* Vern Paxson. */ |
| |
|
| |
/* The United States Government has rights in this work pursuant */ |
| |
/* to contract no. DE-AC03-76SF00098 between the United States */ |
| |
/* Department of Energy and the University of California. */ |
| |
|
| |
/* This file is part of flex. */ |
| |
|
| |
/* Redistribution and use in source and binary forms, with or without */ |
| |
/* modification, are permitted provided that the following conditions */ |
| |
/* are met: */ |
| |
|
| |
/* 1. Redistributions of source code must retain the above copyright */ |
| |
/* notice, this list of conditions and the following disclaimer. */ |
| |
/* 2. Redistributions in binary form must reproduce the above copyright */ |
| |
/* notice, this list of conditions and the following disclaimer in the */ |
| |
/* documentation and/or other materials provided with the distribution. */ |
| |
|
| |
/* Neither the name of the University nor the names of its contributors */ |
| |
/* may be used to endorse or promote products derived from this software */ |
| |
/* without specific prior written permission. */ |
| |
|
| |
/* THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR */ |
| |
/* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED */ |
| |
/* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR */ |
| |
/* PURPOSE. */ |
| |
|
| #include "flexdef.h" |
#include "flexdef.h" |
| |
#include "tables.h" |
| |
|
| |
|
| /* declare functions that have forward references */ |
/* declare functions that have forward references */ |
| |
|
| void gen_next_state PROTO((int)); |
void gen_next_state PROTO ((int)); |
| void genecs PROTO((void)); |
void genecs PROTO ((void)); |
| void indent_put2s PROTO((char [], char [])); |
void indent_put2s PROTO ((const char *, const char *)); |
| void indent_puts PROTO((char [])); |
void indent_puts PROTO ((const char *)); |
| |
|
| |
|
| static int indent_level = 0; /* each level is 8 spaces */ |
static int indent_level = 0; /* each level is 8 spaces */ |
| |
|
| #define indent_up() (++indent_level) |
#define indent_up() (++indent_level) |
| #define indent_down() (--indent_level) |
#define indent_down() (--indent_level) |
|
|
| * to this is that the fast table representation generally uses the |
* to this is that the fast table representation generally uses the |
| * 0 elements of its arrays, too.) |
* 0 elements of its arrays, too.) |
| */ |
*/ |
| static char C_int_decl[] = "static yyconst int %s[%d] =\n { 0,\n"; |
|
| static char C_short_decl[] = "static yyconst short int %s[%d] =\n { 0,\n"; |
|
| static char C_long_decl[] = "static yyconst long int %s[%d] =\n { 0,\n"; |
|
| static char C_state_decl[] = |
|
| "static yyconst yy_state_type %s[%d] =\n { 0,\n"; |
|
| |
|
| |
static const char *get_int16_decl (void) |
| |
{ |
| |
return (gentables) |
| |
? "static yyconst flex_int16_t %s[%d] =\n { 0,\n" |
| |
: "static yyconst flex_int16_t * %s = 0;\n"; |
| |
} |
| |
|
| |
|
| |
static const char *get_int32_decl (void) |
| |
{ |
| |
return (gentables) |
| |
? "static yyconst flex_int32_t %s[%d] =\n { 0,\n" |
| |
: "static yyconst flex_int32_t * %s = 0;\n"; |
| |
} |
| |
|
| |
static const char *get_state_decl (void) |
| |
{ |
| |
return (gentables) |
| |
? "static yyconst yy_state_type %s[%d] =\n { 0,\n" |
| |
: "static yyconst yy_state_type * %s = 0;\n"; |
| |
} |
| |
|
| /* Indent to the current level. */ |
/* Indent to the current level. */ |
| |
|
| void do_indent() |
void do_indent () |
| { |
{ |
| int i = indent_level * 8; |
int i = indent_level * 8; |
| |
|
| while ( i >= 8 ) |
while (i >= 8) { |
| { |
outc ('\t'); |
| outc( '\t' ); |
|
| i -= 8; |
i -= 8; |
| } |
} |
| |
|
| while ( i > 0 ) |
while (i > 0) { |
| { |
outc (' '); |
| outc( ' ' ); |
|
| --i; |
--i; |
| |
} |
| |
} |
| |
|
| |
|
| |
/** Make the table for possible eol matches. |
| |
* @return the newly allocated rule_can_match_eol table |
| |
*/ |
| |
static struct yytbl_data *mkeoltbl (void) |
| |
{ |
| |
int i; |
| |
flex_int8_t *tdata = 0; |
| |
struct yytbl_data *tbl; |
| |
|
| |
tbl = (struct yytbl_data *) calloc (1, sizeof (struct yytbl_data)); |
| |
yytbl_data_init (tbl, YYTD_ID_RULE_CAN_MATCH_EOL); |
| |
tbl->td_flags = YYTD_DATA8; |
| |
tbl->td_lolen = num_rules + 1; |
| |
tbl->td_data = tdata = |
| |
(flex_int8_t *) calloc (tbl->td_lolen, sizeof (flex_int8_t)); |
| |
|
| |
for (i = 1; i <= num_rules; i++) |
| |
tdata[i] = rule_has_nl[i] ? 1 : 0; |
| |
|
| |
buf_prints (&yydmap_buf, |
| |
"\t{YYTD_ID_RULE_CAN_MATCH_EOL, (void**)&yy_rule_can_match_eol, sizeof(%s)},\n", |
| |
"flex_int32_t"); |
| |
return tbl; |
| |
} |
| |
|
| |
/* Generate the table for possible eol matches. */ |
| |
static void geneoltbl () |
| |
{ |
| |
int i; |
| |
|
| |
outn ("m4_ifdef( [[M4_YY_USE_LINENO]],[["); |
| |
outn ("/* Table of booleans, true if rule could match eol. */"); |
| |
out_str_dec (get_int32_decl (), "yy_rule_can_match_eol", |
| |
num_rules + 1); |
| |
|
| |
if (gentables) { |
| |
for (i = 1; i <= num_rules; i++) { |
| |
out_dec ("%d, ", rule_has_nl[i] ? 1 : 0); |
| |
/* format nicely, 20 numbers per line. */ |
| |
if ((i % 20) == 19) |
| |
out ("\n "); |
| } |
} |
| |
out (" };\n"); |
| } |
} |
| |
outn ("]])"); |
| |
} |
| |
|
| |
|
| /* Generate the code to keep backing-up information. */ |
/* Generate the code to keep backing-up information. */ |
| |
|
| void gen_backing_up() |
void gen_backing_up () |
| { |
{ |
| if ( reject || num_backing_up == 0 ) |
if (reject || num_backing_up == 0) |
| return; |
return; |
| |
|
| if ( fullspd ) |
if (fullspd) |
| indent_puts( "if ( yy_current_state[-1].yy_nxt )" ); |
indent_puts ("if ( yy_current_state[-1].yy_nxt )"); |
| else |
else |
| indent_puts( "if ( yy_accept[yy_current_state] )" ); |
indent_puts ("if ( yy_accept[yy_current_state] )"); |
| |
|
| indent_up(); |
indent_up (); |
| indent_puts( "{" ); |
indent_puts ("{"); |
| indent_puts( "yy_last_accepting_state = yy_current_state;" ); |
indent_puts ("YY_G(yy_last_accepting_state) = yy_current_state;"); |
| indent_puts( "yy_last_accepting_cpos = yy_cp;" ); |
indent_puts ("YY_G(yy_last_accepting_cpos) = yy_cp;"); |
| indent_puts( "}" ); |
indent_puts ("}"); |
| indent_down(); |
indent_down (); |
| } |
} |
| |
|
| |
|
| /* Generate the code to perform the backing up. */ |
/* Generate the code to perform the backing up. */ |
| |
|
| void gen_bu_action() |
void gen_bu_action () |
| { |
{ |
| if ( reject || num_backing_up == 0 ) |
if (reject || num_backing_up == 0) |
| return; |
return; |
| |
|
| set_indent( 3 ); |
set_indent (3); |
| |
|
| indent_puts( "case 0: /* must back up */" ); |
indent_puts ("case 0: /* must back up */"); |
| indent_puts( "/* undo the effects of YY_DO_BEFORE_ACTION */" ); |
indent_puts ("/* undo the effects of YY_DO_BEFORE_ACTION */"); |
| indent_puts( "*yy_cp = yy_hold_char;" ); |
indent_puts ("*yy_cp = YY_G(yy_hold_char);"); |
| |
|
| if ( fullspd || fulltbl ) |
if (fullspd || fulltbl) |
| indent_puts( "yy_cp = yy_last_accepting_cpos + 1;" ); |
indent_puts ("yy_cp = YY_G(yy_last_accepting_cpos) + 1;"); |
| else |
else |
| /* Backing-up info for compressed tables is taken \after/ |
/* Backing-up info for compressed tables is taken \after/ |
| * yy_cp has been incremented for the next state. |
* yy_cp has been incremented for the next state. |
| */ |
*/ |
| indent_puts( "yy_cp = yy_last_accepting_cpos;" ); |
indent_puts ("yy_cp = YY_G(yy_last_accepting_cpos);"); |
| |
|
| indent_puts( "yy_current_state = yy_last_accepting_state;" ); |
indent_puts ("yy_current_state = YY_G(yy_last_accepting_state);"); |
| indent_puts( "goto yy_find_action;" ); |
indent_puts ("goto yy_find_action;"); |
| outc( '\n' ); |
outc ('\n'); |
| |
|
| set_indent( 0 ); |
set_indent (0); |
| |
} |
| |
|
| |
/** mkctbl - make full speed compressed transition table |
| |
* This is an array of structs; each struct a pair of integers. |
| |
* You should call mkssltbl() immediately after this. |
| |
* Then, I think, mkecstbl(). Arrrg. |
| |
* @return the newly allocated trans table |
| |
*/ |
| |
|
| |
static struct yytbl_data *mkctbl (void) |
| |
{ |
| |
int i; |
| |
struct yytbl_data *tbl = 0; |
| |
flex_int32_t *tdata = 0, curr = 0; |
| |
int end_of_buffer_action = num_rules + 1; |
| |
|
| |
buf_prints (&yydmap_buf, |
| |
"\t{YYTD_ID_TRANSITION, (void**)&yy_transition, sizeof(%s)},\n", |
| |
((tblend + numecs + 1) >= INT16_MAX |
| |
|| long_align) ? "flex_int32_t" : "flex_int16_t"); |
| |
|
| |
tbl = (struct yytbl_data *) calloc (1, sizeof (struct yytbl_data)); |
| |
yytbl_data_init (tbl, YYTD_ID_TRANSITION); |
| |
tbl->td_flags = YYTD_DATA32 | YYTD_STRUCT; |
| |
tbl->td_hilen = 0; |
| |
tbl->td_lolen = tblend + numecs + 1; /* number of structs */ |
| |
|
| |
tbl->td_data = tdata = |
| |
(flex_int32_t *) calloc (tbl->td_lolen * 2, sizeof (flex_int32_t)); |
| |
|
| |
/* We want the transition to be represented as the offset to the |
| |
* next state, not the actual state number, which is what it currently |
| |
* is. The offset is base[nxt[i]] - (base of current state)]. That's |
| |
* just the difference between the starting points of the two involved |
| |
* states (to - from). |
| |
* |
| |
* First, though, we need to find some way to put in our end-of-buffer |
| |
* flags and states. We do this by making a state with absolutely no |
| |
* transitions. We put it at the end of the table. |
| |
*/ |
| |
|
| |
/* We need to have room in nxt/chk for two more slots: One for the |
| |
* action and one for the end-of-buffer transition. We now *assume* |
| |
* that we're guaranteed the only character we'll try to index this |
| |
* nxt/chk pair with is EOB, i.e., 0, so we don't have to make sure |
| |
* there's room for jam entries for other characters. |
| |
*/ |
| |
|
| |
while (tblend + 2 >= current_max_xpairs) |
| |
expand_nxt_chk (); |
| |
|
| |
while (lastdfa + 1 >= current_max_dfas) |
| |
increase_max_dfas (); |
| |
|
| |
base[lastdfa + 1] = tblend + 2; |
| |
nxt[tblend + 1] = end_of_buffer_action; |
| |
chk[tblend + 1] = numecs + 1; |
| |
chk[tblend + 2] = 1; /* anything but EOB */ |
| |
|
| |
/* So that "make test" won't show arb. differences. */ |
| |
nxt[tblend + 2] = 0; |
| |
|
| |
/* Make sure every state has an end-of-buffer transition and an |
| |
* action #. |
| |
*/ |
| |
for (i = 0; i <= lastdfa; ++i) { |
| |
int anum = dfaacc[i].dfaacc_state; |
| |
int offset = base[i]; |
| |
|
| |
chk[offset] = EOB_POSITION; |
| |
chk[offset - 1] = ACTION_POSITION; |
| |
nxt[offset - 1] = anum; /* action number */ |
| } |
} |
| |
|
| |
for (i = 0; i <= tblend; ++i) { |
| |
if (chk[i] == EOB_POSITION) { |
| |
tdata[curr++] = 0; |
| |
tdata[curr++] = base[lastdfa + 1] - i; |
| |
} |
| |
|
| |
else if (chk[i] == ACTION_POSITION) { |
| |
tdata[curr++] = 0; |
| |
tdata[curr++] = nxt[i]; |
| |
} |
| |
|
| |
else if (chk[i] > numecs || chk[i] == 0) { |
| |
tdata[curr++] = 0; |
| |
tdata[curr++] = 0; |
| |
} |
| |
else { /* verify, transition */ |
| |
|
| |
tdata[curr++] = chk[i]; |
| |
tdata[curr++] = base[nxt[i]] - (i - chk[i]); |
| |
} |
| |
} |
| |
|
| |
|
| |
/* Here's the final, end-of-buffer state. */ |
| |
tdata[curr++] = chk[tblend + 1]; |
| |
tdata[curr++] = nxt[tblend + 1]; |
| |
|
| |
tdata[curr++] = chk[tblend + 2]; |
| |
tdata[curr++] = nxt[tblend + 2]; |
| |
|
| |
return tbl; |
| |
} |
| |
|
| |
|
| |
/** Make start_state_list table. |
| |
* @return the newly allocated start_state_list table |
| |
*/ |
| |
static struct yytbl_data *mkssltbl (void) |
| |
{ |
| |
struct yytbl_data *tbl = 0; |
| |
flex_int32_t *tdata = 0; |
| |
flex_int32_t i; |
| |
|
| |
tbl = (struct yytbl_data *) calloc (1, sizeof (struct yytbl_data)); |
| |
yytbl_data_init (tbl, YYTD_ID_START_STATE_LIST); |
| |
tbl->td_flags = YYTD_DATA32 | YYTD_PTRANS; |
| |
tbl->td_hilen = 0; |
| |
tbl->td_lolen = lastsc * 2 + 1; |
| |
|
| |
tbl->td_data = tdata = |
| |
(flex_int32_t *) calloc (tbl->td_lolen, sizeof (flex_int32_t)); |
| |
|
| |
for (i = 0; i <= lastsc * 2; ++i) |
| |
tdata[i] = base[i]; |
| |
|
| |
buf_prints (&yydmap_buf, |
| |
"\t{YYTD_ID_START_STATE_LIST, (void**)&yy_start_state_list, sizeof(%s)},\n", |
| |
"struct yy_trans_info*"); |
| |
|
| |
return tbl; |
| |
} |
| |
|
| |
|
| |
|
| /* genctbl - generates full speed compressed transition table */ |
/* genctbl - generates full speed compressed transition table */ |
| |
|
| void genctbl() |
void genctbl () |
| { |
{ |
| int i; |
int i; |
| int end_of_buffer_action = num_rules + 1; |
int end_of_buffer_action = num_rules + 1; |
| |
|
| /* Table of verify for transition and offset to next state. */ |
/* Table of verify for transition and offset to next state. */ |
| out_dec( "static yyconst struct yy_trans_info yy_transition[%d] =\n", |
if (gentables) |
| tblend + numecs + 1 ); |
out_dec ("static yyconst struct yy_trans_info yy_transition[%d] =\n {\n", tblend + numecs + 1); |
| outn( " {" ); |
else |
| |
outn ("static yyconst struct yy_trans_info *yy_transition = 0;"); |
| |
|
| /* We want the transition to be represented as the offset to the |
/* We want the transition to be represented as the offset to the |
| * next state, not the actual state number, which is what it currently |
* next state, not the actual state number, which is what it currently |
|
|
| * there's room for jam entries for other characters. |
* there's room for jam entries for other characters. |
| */ |
*/ |
| |
|
| while ( tblend + 2 >= current_max_xpairs ) |
while (tblend + 2 >= current_max_xpairs) |
| expand_nxt_chk(); |
expand_nxt_chk (); |
| |
|
| while ( lastdfa + 1 >= current_max_dfas ) |
while (lastdfa + 1 >= current_max_dfas) |
| increase_max_dfas(); |
increase_max_dfas (); |
| |
|
| base[lastdfa + 1] = tblend + 2; |
base[lastdfa + 1] = tblend + 2; |
| nxt[tblend + 1] = end_of_buffer_action; |
nxt[tblend + 1] = end_of_buffer_action; |
| chk[tblend + 1] = numecs + 1; |
chk[tblend + 1] = numecs + 1; |
| chk[tblend + 2] = 1; /* anything but EOB */ |
chk[tblend + 2] = 1; /* anything but EOB */ |
| |
|
| /* So that "make test" won't show arb. differences. */ |
/* So that "make test" won't show arb. differences. */ |
| nxt[tblend + 2] = 0; |
nxt[tblend + 2] = 0; |
|
|
| /* Make sure every state has an end-of-buffer transition and an |
/* Make sure every state has an end-of-buffer transition and an |
| * action #. |
* action #. |
| */ |
*/ |
| for ( i = 0; i <= lastdfa; ++i ) |
for (i = 0; i <= lastdfa; ++i) { |
| { |
int anum = dfaacc[i].dfaacc_state; |
| int anum = dfaacc[i].dfaacc_state; |
int offset = base[i]; |
| int offset = base[i]; |
|
| |
|
| chk[offset] = EOB_POSITION; |
chk[offset] = EOB_POSITION; |
| chk[offset - 1] = ACTION_POSITION; |
chk[offset - 1] = ACTION_POSITION; |
| nxt[offset - 1] = anum; /* action number */ |
nxt[offset - 1] = anum; /* action number */ |
| } |
} |
| |
|
| for ( i = 0; i <= tblend; ++i ) |
for (i = 0; i <= tblend; ++i) { |
| { |
if (chk[i] == EOB_POSITION) |
| if ( chk[i] == EOB_POSITION ) |
transition_struct_out (0, base[lastdfa + 1] - i); |
| transition_struct_out( 0, base[lastdfa + 1] - i ); |
|
| |
|
| else if ( chk[i] == ACTION_POSITION ) |
else if (chk[i] == ACTION_POSITION) |
| transition_struct_out( 0, nxt[i] ); |
transition_struct_out (0, nxt[i]); |
| |
|
| else if ( chk[i] > numecs || chk[i] == 0 ) |
else if (chk[i] > numecs || chk[i] == 0) |
| transition_struct_out( 0, 0 ); /* unused slot */ |
transition_struct_out (0, 0); /* unused slot */ |
| |
|
| else /* verify, transition */ |
else /* verify, transition */ |
| transition_struct_out( chk[i], |
transition_struct_out (chk[i], |
| base[nxt[i]] - (i - chk[i]) ); |
base[nxt[i]] - (i - |
| } |
chk[i])); |
| |
} |
| |
|
| |
|
| /* Here's the final, end-of-buffer state. */ |
/* Here's the final, end-of-buffer state. */ |
| transition_struct_out( chk[tblend + 1], nxt[tblend + 1] ); |
transition_struct_out (chk[tblend + 1], nxt[tblend + 1]); |
| transition_struct_out( chk[tblend + 2], nxt[tblend + 2] ); |
transition_struct_out (chk[tblend + 2], nxt[tblend + 2]); |
| |
|
| outn( " };\n" ); |
if (gentables) |
| |
outn (" };\n"); |
| |
|
| /* Table of pointers to start states. */ |
/* Table of pointers to start states. */ |
| out_dec( |
if (gentables) |
| "static yyconst struct yy_trans_info *yy_start_state_list[%d] =\n", |
out_dec ("static yyconst struct yy_trans_info *yy_start_state_list[%d] =\n", lastsc * 2 + 1); |
| lastsc * 2 + 1 ); |
else |
| outn( " {" ); /* } so vi doesn't get confused */ |
outn ("static yyconst struct yy_trans_info **yy_start_state_list =0;"); |
| |
|
| for ( i = 0; i <= lastsc * 2; ++i ) |
if (gentables) { |
| out_dec( " &yy_transition[%d],\n", base[i] ); |
outn (" {"); |
| |
|
| dataend(); |
for (i = 0; i <= lastsc * 2; ++i) |
| |
out_dec (" &yy_transition[%d],\n", base[i]); |
| |
|
| if ( useecs ) |
dataend (); |
| genecs(); |
|
| } |
} |
| |
|
| |
if (useecs) |
| |
genecs (); |
| |
} |
| |
|
| |
|
| |
/* mkecstbl - Make equivalence-class tables. */ |
| |
|
| |
struct yytbl_data *mkecstbl (void) |
| |
{ |
| |
int i; |
| |
struct yytbl_data *tbl = 0; |
| |
flex_int32_t *tdata = 0; |
| |
|
| |
tbl = (struct yytbl_data *) calloc (1, sizeof (struct yytbl_data)); |
| |
yytbl_data_init (tbl, YYTD_ID_EC); |
| |
tbl->td_flags |= YYTD_DATA32; |
| |
tbl->td_hilen = 0; |
| |
tbl->td_lolen = csize; |
| |
|
| |
tbl->td_data = tdata = |
| |
(flex_int32_t *) calloc (tbl->td_lolen, sizeof (flex_int32_t)); |
| |
|
| |
for (i = 1; i < csize; ++i) { |
| |
ecgroup[i] = ABS (ecgroup[i]); |
| |
tdata[i] = ecgroup[i]; |
| |
} |
| |
|
| |
buf_prints (&yydmap_buf, |
| |
"\t{YYTD_ID_EC, (void**)&yy_ec, sizeof(%s)},\n", |
| |
"flex_int32_t"); |
| |
|
| |
return tbl; |
| |
} |
| |
|
| /* Generate equivalence-class tables. */ |
/* Generate equivalence-class tables. */ |
| |
|
| void genecs() |
void genecs () |
| { |
{ |
| int i, j; |
int i, j; |
| int numrows; |
int numrows; |
| |
|
| out_str_dec( C_int_decl, "yy_ec", csize ); |
out_str_dec (get_int32_decl (), "yy_ec", csize); |
| |
|
| for ( i = 1; i < csize; ++i ) |
for (i = 1; i < csize; ++i) { |
| { |
ecgroup[i] = ABS (ecgroup[i]); |
| if ( caseins && (i >= 'A') && (i <= 'Z') ) |
mkdata (ecgroup[i]); |
| ecgroup[i] = ecgroup[clower( i )]; |
} |
| |
|
| ecgroup[i] = ABS( ecgroup[i] ); |
dataend (); |
| mkdata( ecgroup[i] ); |
|
| } |
|
| |
|
| dataend(); |
if (trace) { |
| |
fputs (_("\n\nEquivalence Classes:\n\n"), stderr); |
| |
|
| if ( trace ) |
|
| { |
|
| fputs( _( "\n\nEquivalence Classes:\n\n" ), stderr ); |
|
| |
|
| numrows = csize / 8; |
numrows = csize / 8; |
| |
|
| for ( j = 0; j < numrows; ++j ) |
for (j = 0; j < numrows; ++j) { |
| { |
for (i = j; i < csize; i = i + numrows) { |
| for ( i = j; i < csize; i = i + numrows ) |
fprintf (stderr, "%4s = %-2d", |
| { |
readable_form (i), ecgroup[i]); |
| fprintf( stderr, "%4s = %-2d", |
|
| readable_form( i ), ecgroup[i] ); |
|
| |
|
| putc( ' ', stderr ); |
putc (' ', stderr); |
| } |
|
| |
|
| putc( '\n', stderr ); |
|
| } |
} |
| |
|
| |
putc ('\n', stderr); |
| } |
} |
| } |
} |
| |
} |
| |
|
| |
|
| /* Generate the code to find the action number. */ |
/* Generate the code to find the action number. */ |
| |
|
| void gen_find_action() |
void gen_find_action () |
| { |
{ |
| if ( fullspd ) |
if (fullspd) |
| indent_puts( "yy_act = yy_current_state[-1].yy_nxt;" ); |
indent_puts ("yy_act = yy_current_state[-1].yy_nxt;"); |
| |
|
| else if ( fulltbl ) |
else if (fulltbl) |
| indent_puts( "yy_act = yy_accept[yy_current_state];" ); |
indent_puts ("yy_act = yy_accept[yy_current_state];"); |
| |
|
| else if ( reject ) |
else if (reject) { |
| { |
indent_puts ("yy_current_state = *--YY_G(yy_state_ptr);"); |
| indent_puts( "yy_current_state = *--yy_state_ptr;" ); |
indent_puts ("YY_G(yy_lp) = yy_accept[yy_current_state];"); |
| indent_puts( "yy_lp = yy_accept[yy_current_state];" ); |
|
| |
|
| outn( |
outn ("find_rule: /* we branch to this label when backing up */"); |
| "find_rule: /* we branch to this label when backing up */" ); |
|
| |
|
| indent_puts( |
indent_puts |
| "for ( ; ; ) /* until we find what rule we matched */" ); |
("for ( ; ; ) /* until we find what rule we matched */"); |
| |
|
| indent_up(); |
indent_up (); |
| |
|
| indent_puts( "{" ); |
indent_puts ("{"); |
| |
|
| indent_puts( |
indent_puts |
| "if ( yy_lp && yy_lp < yy_accept[yy_current_state + 1] )" ); |
("if ( YY_G(yy_lp) && YY_G(yy_lp) < yy_accept[yy_current_state + 1] )"); |
| indent_up(); |
indent_up (); |
| indent_puts( "{" ); |
indent_puts ("{"); |
| indent_puts( "yy_act = yy_acclist[yy_lp];" ); |
indent_puts ("yy_act = yy_acclist[YY_G(yy_lp)];"); |
| |
|
| if ( variable_trailing_context_rules ) |
if (variable_trailing_context_rules) { |
| { |
indent_puts |
| indent_puts( "if ( yy_act & YY_TRAILING_HEAD_MASK ||" ); |
("if ( yy_act & YY_TRAILING_HEAD_MASK ||"); |
| indent_puts( " yy_looking_for_trail_begin )" ); |
indent_puts (" YY_G(yy_looking_for_trail_begin) )"); |
| indent_up(); |
indent_up (); |
| indent_puts( "{" ); |
indent_puts ("{"); |
| |
|
| indent_puts( |
indent_puts |
| "if ( yy_act == yy_looking_for_trail_begin )" ); |
("if ( yy_act == YY_G(yy_looking_for_trail_begin) )"); |
| indent_up(); |
indent_up (); |
| indent_puts( "{" ); |
indent_puts ("{"); |
| indent_puts( "yy_looking_for_trail_begin = 0;" ); |
indent_puts ("YY_G(yy_looking_for_trail_begin) = 0;"); |
| indent_puts( "yy_act &= ~YY_TRAILING_HEAD_MASK;" ); |
indent_puts ("yy_act &= ~YY_TRAILING_HEAD_MASK;"); |
| indent_puts( "break;" ); |
indent_puts ("break;"); |
| indent_puts( "}" ); |
indent_puts ("}"); |
| indent_down(); |
indent_down (); |
| |
|
| indent_puts( "}" ); |
indent_puts ("}"); |
| indent_down(); |
indent_down (); |
| |
|
| indent_puts( "else if ( yy_act & YY_TRAILING_MASK )" ); |
indent_puts |
| indent_up(); |
("else if ( yy_act & YY_TRAILING_MASK )"); |
| indent_puts( "{" ); |
indent_up (); |
| indent_puts( |
indent_puts ("{"); |
| "yy_looking_for_trail_begin = yy_act & ~YY_TRAILING_MASK;" ); |
indent_puts |
| indent_puts( |
("YY_G(yy_looking_for_trail_begin) = yy_act & ~YY_TRAILING_MASK;"); |
| "yy_looking_for_trail_begin |= YY_TRAILING_HEAD_MASK;" ); |
indent_puts |
| |
("YY_G(yy_looking_for_trail_begin) |= YY_TRAILING_HEAD_MASK;"); |
| |
|
| if ( real_reject ) |
if (real_reject) { |
| { |
|
| /* Remember matched text in case we back up |
/* Remember matched text in case we back up |
| * due to REJECT. |
* due to REJECT. |
| */ |
*/ |
| indent_puts( "yy_full_match = yy_cp;" ); |
indent_puts |
| indent_puts( "yy_full_state = yy_state_ptr;" ); |
("YY_G(yy_full_match) = yy_cp;"); |
| indent_puts( "yy_full_lp = yy_lp;" ); |
indent_puts |
| } |
("YY_G(yy_full_state) = YY_G(yy_state_ptr);"); |
| |
indent_puts ("YY_G(yy_full_lp) = YY_G(yy_lp);"); |
| |
} |
| |
|
| indent_puts( "}" ); |
indent_puts ("}"); |
| indent_down(); |
indent_down (); |
| |
|
| indent_puts( "else" ); |
indent_puts ("else"); |
| indent_up(); |
indent_up (); |
| indent_puts( "{" ); |
indent_puts ("{"); |
| indent_puts( "yy_full_match = yy_cp;" ); |
indent_puts ("YY_G(yy_full_match) = yy_cp;"); |
| indent_puts( "yy_full_state = yy_state_ptr;" ); |
indent_puts |
| indent_puts( "yy_full_lp = yy_lp;" ); |
("YY_G(yy_full_state) = YY_G(yy_state_ptr);"); |
| indent_puts( "break;" ); |
indent_puts ("YY_G(yy_full_lp) = YY_G(yy_lp);"); |
| indent_puts( "}" ); |
indent_puts ("break;"); |
| indent_down(); |
indent_puts ("}"); |
| |
indent_down (); |
| |
|
| indent_puts( "++yy_lp;" ); |
indent_puts ("++YY_G(yy_lp);"); |
| indent_puts( "goto find_rule;" ); |
indent_puts ("goto find_rule;"); |
| } |
} |
| |
|
| else |
else { |
| { |
|
| /* Remember matched text in case we back up due to |
/* Remember matched text in case we back up due to |
| * trailing context plus REJECT. |
* trailing context plus REJECT. |
| */ |
*/ |
| indent_up(); |
indent_up (); |
| indent_puts( "{" ); |
indent_puts ("{"); |
| indent_puts( "yy_full_match = yy_cp;" ); |
indent_puts ("YY_G(yy_full_match) = yy_cp;"); |
| indent_puts( "break;" ); |
indent_puts ("break;"); |
| indent_puts( "}" ); |
indent_puts ("}"); |
| indent_down(); |
indent_down (); |
| } |
} |
| |
|
| indent_puts( "}" ); |
indent_puts ("}"); |
| indent_down(); |
indent_down (); |
| |
|
| indent_puts( "--yy_cp;" ); |
indent_puts ("--yy_cp;"); |
| |
|
| /* We could consolidate the following two lines with those at |
/* We could consolidate the following two lines with those at |
| * the beginning, but at the cost of complaints that we're |
* the beginning, but at the cost of complaints that we're |
| * branching inside a loop. |
* branching inside a loop. |
| */ |
*/ |
| indent_puts( "yy_current_state = *--yy_state_ptr;" ); |
indent_puts ("yy_current_state = *--YY_G(yy_state_ptr);"); |
| indent_puts( "yy_lp = yy_accept[yy_current_state];" ); |
indent_puts ("YY_G(yy_lp) = yy_accept[yy_current_state];"); |
| |
|
| indent_puts( "}" ); |
indent_puts ("}"); |
| |
|
| indent_down(); |
indent_down (); |
| } |
} |
| |
|
| else |
else { /* compressed */ |
| { /* compressed */ |
indent_puts ("yy_act = yy_accept[yy_current_state];"); |
| indent_puts( "yy_act = yy_accept[yy_current_state];" ); |
|
| |
|
| if ( interactive && ! reject ) |
if (interactive && !reject) { |
| { |
|
| /* Do the guaranteed-needed backing up to figure out |
/* Do the guaranteed-needed backing up to figure out |
| * the match. |
* the match. |
| */ |
*/ |
| indent_puts( "if ( yy_act == 0 )" ); |
indent_puts ("if ( yy_act == 0 )"); |
| indent_up(); |
indent_up (); |
| indent_puts( "{ /* have to back up */" ); |
indent_puts ("{ /* have to back up */"); |
| indent_puts( "yy_cp = yy_last_accepting_cpos;" ); |
indent_puts |
| indent_puts( |
("yy_cp = YY_G(yy_last_accepting_cpos);"); |
| "yy_current_state = yy_last_accepting_state;" ); |
indent_puts |
| indent_puts( "yy_act = yy_accept[yy_current_state];" ); |
("yy_current_state = YY_G(yy_last_accepting_state);"); |
| indent_puts( "}" ); |
indent_puts |
| indent_down(); |
("yy_act = yy_accept[yy_current_state];"); |
| } |
indent_puts ("}"); |
| |
indent_down (); |
| } |
} |
| } |
} |
| |
} |
| |
|
| |
/* mkftbl - make the full table and return the struct . |
| |
* you should call mkecstbl() after this. |
| |
*/ |
| |
|
| |
struct yytbl_data *mkftbl (void) |
| |
{ |
| |
int i; |
| |
int end_of_buffer_action = num_rules + 1; |
| |
struct yytbl_data *tbl; |
| |
flex_int32_t *tdata = 0; |
| |
|
| |
tbl = (struct yytbl_data *) calloc (1, sizeof (struct yytbl_data)); |
| |
yytbl_data_init (tbl, YYTD_ID_ACCEPT); |
| |
tbl->td_flags |= YYTD_DATA32; |
| |
tbl->td_hilen = 0; /* it's a one-dimensional array */ |
| |
tbl->td_lolen = lastdfa + 1; |
| |
|
| |
tbl->td_data = tdata = |
| |
(flex_int32_t *) calloc (tbl->td_lolen, sizeof (flex_int32_t)); |
| |
|
| |
dfaacc[end_of_buffer_state].dfaacc_state = end_of_buffer_action; |
| |
|
| |
for (i = 1; i <= lastdfa; ++i) { |
| |
int anum = dfaacc[i].dfaacc_state; |
| |
|
| |
tdata[i] = anum; |
| |
|
| |
if (trace && anum) |
| |
fprintf (stderr, _("state # %d accepts: [%d]\n"), |
| |
i, anum); |
| |
} |
| |
|
| |
buf_prints (&yydmap_buf, |
| |
"\t{YYTD_ID_ACCEPT, (void**)&yy_accept, sizeof(%s)},\n", |
| |
long_align ? "flex_int32_t" : "flex_int16_t"); |
| |
return tbl; |
| |
} |
| |
|
| |
|
| /* genftbl - generate full transition table */ |
/* genftbl - generate full transition table */ |
| |
|
| void genftbl() |
void genftbl () |
| { |
{ |
| int i; |
int i; |
| int end_of_buffer_action = num_rules + 1; |
int end_of_buffer_action = num_rules + 1; |
| |
|
| out_str_dec( long_align ? C_long_decl : C_short_decl, |
out_str_dec (long_align ? get_int32_decl () : get_int16_decl (), |
| "yy_accept", lastdfa + 1 ); |
"yy_accept", lastdfa + 1); |
| |
|
| dfaacc[end_of_buffer_state].dfaacc_state = end_of_buffer_action; |
dfaacc[end_of_buffer_state].dfaacc_state = end_of_buffer_action; |
| |
|
| for ( i = 1; i <= lastdfa; ++i ) |
for (i = 1; i <= lastdfa; ++i) { |
| { |
|
| int anum = dfaacc[i].dfaacc_state; |
int anum = dfaacc[i].dfaacc_state; |
| |
|
| mkdata( anum ); |
mkdata (anum); |
| |
|
| if ( trace && anum ) |
if (trace && anum) |
| fprintf( stderr, _( "state # %d accepts: [%d]\n" ), |
fprintf (stderr, _("state # %d accepts: [%d]\n"), |
| i, anum ); |
i, anum); |
| } |
} |
| |
|
| dataend(); |
dataend (); |
| |
|
| if ( useecs ) |
if (useecs) |
| genecs(); |
genecs (); |
| |
|
| /* Don't have to dump the actual full table entries - they were |
/* Don't have to dump the actual full table entries - they were |
| * created on-the-fly. |
* created on-the-fly. |
| */ |
*/ |
| } |
} |
| |
|
| |
|
| /* Generate the code to find the next compressed-table state. */ |
/* Generate the code to find the next compressed-table state. */ |
| |
|
| void gen_next_compressed_state( char_map ) |
void gen_next_compressed_state (char_map) |
| char *char_map; |
char *char_map; |
| { |
{ |
| indent_put2s( "register YY_CHAR yy_c = %s;", char_map ); |
indent_put2s ("YY_CHAR yy_c = %s;", char_map); |
| |
|
| /* Save the backing-up info \before/ computing the next state |
/* Save the backing-up info \before/ computing the next state |
| * because we always compute one more state than needed - we |
* because we always compute one more state than needed - we |
| * always proceed until we reach a jam state |
* always proceed until we reach a jam state |
| */ |
*/ |
| gen_backing_up(); |
gen_backing_up (); |
| |
|
| indent_puts( |
indent_puts |
| "while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )" ); |
("while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )"); |
| indent_up(); |
indent_up (); |
| indent_puts( "{" ); |
indent_puts ("{"); |
| indent_puts( "yy_current_state = (int) yy_def[yy_current_state];" ); |
indent_puts ("yy_current_state = (int) yy_def[yy_current_state];"); |
| |
|
| if ( usemecs ) |
if (usemecs) { |
| { |
|
| /* We've arrange it so that templates are never chained |
/* We've arrange it so that templates are never chained |
| * to one another. This means we can afford to make a |
* to one another. This means we can afford to make a |
| * very simple test to see if we need to convert to |
* very simple test to see if we need to convert to |
|
|
| * about erroneously looking up the meta-equivalence |
* about erroneously looking up the meta-equivalence |
| * class twice |
* class twice |
| */ |
*/ |
| do_indent(); |
do_indent (); |
| |
|
| /* lastdfa + 2 is the beginning of the templates */ |
/* lastdfa + 2 is the beginning of the templates */ |
| out_dec( "if ( yy_current_state >= %d )\n", lastdfa + 2 ); |
out_dec ("if ( yy_current_state >= %d )\n", lastdfa + 2); |
| |
|
| indent_up(); |
indent_up (); |
| indent_puts( "yy_c = yy_meta[(unsigned int) yy_c];" ); |
indent_puts ("yy_c = yy_meta[(unsigned int) yy_c];"); |
| indent_down(); |
indent_down (); |
| } |
} |
| |
|
| indent_puts( "}" ); |
indent_puts ("}"); |
| indent_down(); |
indent_down (); |
| |
|
| indent_puts( |
indent_puts |
| "yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];" ); |
("yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];"); |
| } |
} |
| |
|
| |
|
| /* Generate the code to find the next match. */ |
/* Generate the code to find the next match. */ |
| |
|
| void gen_next_match() |
void gen_next_match () |
| { |
{ |
| /* NOTE - changes in here should be reflected in gen_next_state() and |
/* NOTE - changes in here should be reflected in gen_next_state() and |
| * gen_NUL_trans(). |
* gen_NUL_trans(). |
| */ |
*/ |
| char *char_map = useecs ? |
char *char_map = useecs ? |
| "yy_ec[YY_SC_TO_UI(*yy_cp)]" : |
"yy_ec[YY_SC_TO_UI(*yy_cp)] " : "YY_SC_TO_UI(*yy_cp)"; |
| "YY_SC_TO_UI(*yy_cp)"; |
|
| |
|
| char *char_map_2 = useecs ? |
char *char_map_2 = useecs ? |
| "yy_ec[YY_SC_TO_UI(*++yy_cp)]" : |
"yy_ec[YY_SC_TO_UI(*++yy_cp)] " : "YY_SC_TO_UI(*++yy_cp)"; |
| "YY_SC_TO_UI(*++yy_cp)"; |
|
| |
|
| if ( fulltbl ) |
if (fulltbl) { |
| { |
if (gentables) |
| indent_put2s( |
indent_put2s |
| "while ( (yy_current_state = yy_nxt[yy_current_state][%s]) > 0 )", |
("while ( (yy_current_state = yy_nxt[yy_current_state][ %s ]) > 0 )", |
| char_map ); |
char_map); |
| |
else |
| |
indent_put2s |
| |
("while ( (yy_current_state = yy_nxt[yy_current_state*YY_NXT_LOLEN + %s ]) > 0 )", |
| |
char_map); |
| |
|
| indent_up(); |
indent_up (); |
| |
|
| if ( num_backing_up > 0 ) |
if (num_backing_up > 0) { |
| { |
indent_puts ("{"); |
| indent_puts( "{" ); /* } for vi */ |
gen_backing_up (); |
| gen_backing_up(); |
outc ('\n'); |
| outc( '\n' ); |
} |
| } |
|
| |
|
| indent_puts( "++yy_cp;" ); |
indent_puts ("++yy_cp;"); |
| |
|
| if ( num_backing_up > 0 ) |
if (num_backing_up > 0) |
| /* { for vi */ |
|
| indent_puts( "}" ); |
|
| |
|
| indent_down(); |
indent_puts ("}"); |
| |
|
| outc( '\n' ); |
indent_down (); |
| indent_puts( "yy_current_state = -yy_current_state;" ); |
|
| } |
|
| |
|
| else if ( fullspd ) |
outc ('\n'); |
| { |
indent_puts ("yy_current_state = -yy_current_state;"); |
| indent_puts( "{" ); /* } for vi */ |
} |
| indent_puts( |
|
| "register yyconst struct yy_trans_info *yy_trans_info;\n" ); |
|
| indent_puts( "register YY_CHAR yy_c;\n" ); |
|
| indent_put2s( "for ( yy_c = %s;", char_map ); |
|
| indent_puts( |
|
| " (yy_trans_info = &yy_current_state[(unsigned int) yy_c])->" ); |
|
| indent_puts( "yy_verify == yy_c;" ); |
|
| indent_put2s( " yy_c = %s )", char_map_2 ); |
|
| |
|
| indent_up(); |
else if (fullspd) { |
| |
indent_puts ("{"); |
| |
indent_puts |
| |
("yyconst struct yy_trans_info *yy_trans_info;\n"); |
| |
indent_puts ("YY_CHAR yy_c;\n"); |
| |
indent_put2s ("for ( yy_c = %s;", char_map); |
| |
indent_puts |
| |
(" (yy_trans_info = &yy_current_state[(unsigned int) yy_c])->"); |
| |
indent_puts ("yy_verify == yy_c;"); |
| |
indent_put2s (" yy_c = %s )", char_map_2); |
| |
|
| if ( num_backing_up > 0 ) |
indent_up (); |
| indent_puts( "{" ); /* } for vi */ |
|
| |
|
| indent_puts( "yy_current_state += yy_trans_info->yy_nxt;" ); |
if (num_backing_up > 0) |
| |
indent_puts ("{"); |
| |
|
| if ( num_backing_up > 0 ) |
indent_puts ("yy_current_state += yy_trans_info->yy_nxt;"); |
| { |
|
| outc( '\n' ); |
|
| gen_backing_up(); /* { for vi */ |
|
| indent_puts( "}" ); |
|
| } |
|
| |
|
| indent_down(); /* { for vi */ |
if (num_backing_up > 0) { |
| indent_puts( "}" ); |
outc ('\n'); |
| |
gen_backing_up (); |
| |
indent_puts ("}"); |
| } |
} |
| |
|
| else |
indent_down (); |
| { /* compressed */ |
indent_puts ("}"); |
| indent_puts( "do" ); |
} |
| |
|
| indent_up(); |
else { /* compressed */ |
| indent_puts( "{" ); /* } for vi */ |
indent_puts ("do"); |
| |
|
| gen_next_state( false ); |
indent_up (); |
| |
indent_puts ("{"); |
| |
|
| indent_puts( "++yy_cp;" ); |
gen_next_state (false); |
| |
|
| /* { for vi */ |
indent_puts ("++yy_cp;"); |
| indent_puts( "}" ); |
|
| indent_down(); |
|
| |
|
| do_indent(); |
|
| |
|
| if ( interactive ) |
indent_puts ("}"); |
| out_dec( "while ( yy_base[yy_current_state] != %d );\n", |
indent_down (); |
| jambase ); |
|
| |
do_indent (); |
| |
|
| |
if (interactive) |
| |
out_dec ("while ( yy_base[yy_current_state] != %d );\n", jambase); |
| else |
else |
| out_dec( "while ( yy_current_state != %d );\n", |
out_dec ("while ( yy_current_state != %d );\n", |
| jamstate ); |
jamstate); |
| |
|
| if ( ! reject && ! interactive ) |
if (!reject && !interactive) { |
| { |
|
| /* Do the guaranteed-needed backing up to figure out |
/* Do the guaranteed-needed backing up to figure out |
| * the match. |
* the match. |
| */ |
*/ |
| indent_puts( "yy_cp = yy_last_accepting_cpos;" ); |
indent_puts |
| indent_puts( |
("yy_cp = YY_G(yy_last_accepting_cpos);"); |
| "yy_current_state = yy_last_accepting_state;" ); |
indent_puts |
| } |
("yy_current_state = YY_G(yy_last_accepting_state);"); |
| } |
} |
| } |
} |
| |
} |
| |
|
| |
|
| /* Generate the code to find the next state. */ |
/* Generate the code to find the next state. */ |
| |
|
| void gen_next_state( worry_about_NULs ) |
void gen_next_state (worry_about_NULs) |
| int worry_about_NULs; |
int worry_about_NULs; |
| { /* NOTE - changes in here should be reflected in gen_next_match() */ |
{ /* NOTE - changes in here should be reflected in gen_next_match() */ |
| char char_map[256]; |
char char_map[256]; |
| |
|
| if ( worry_about_NULs && ! nultrans ) |
if (worry_about_NULs && !nultrans) { |
| { |
if (useecs) |
| if ( useecs ) |
snprintf (char_map, sizeof(char_map), |
| (void) snprintf( char_map, sizeof char_map, |
"(*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : %d)", |
| "(*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : %d)", |
NUL_ec); |
| NUL_ec ); |
|
| else |
else |
| (void) snprintf( char_map, sizeof char_map, |
snprintf (char_map, sizeof(char_map), |
| "(*yy_cp ? YY_SC_TO_UI(*yy_cp) : %d)", NUL_ec ); |
"(*yy_cp ? YY_SC_TO_UI(*yy_cp) : %d)", |
| } |
NUL_ec); |
| |
} |
| |
|
| else |
else |
| strlcpy( char_map, useecs ? |
strlcpy (char_map, useecs ? |
| "yy_ec[YY_SC_TO_UI(*yy_cp)]" : "YY_SC_TO_UI(*yy_cp)", |
"yy_ec[YY_SC_TO_UI(*yy_cp)] " : "YY_SC_TO_UI(*yy_cp)", |
| sizeof char_map ); |
sizeof char_map ); |
| |
|
| if ( worry_about_NULs && nultrans ) |
if (worry_about_NULs && nultrans) { |
| { |
if (!fulltbl && !fullspd) |
| if ( ! fulltbl && ! fullspd ) |
|
| /* Compressed tables back up *before* they match. */ |
/* Compressed tables back up *before* they match. */ |
| gen_backing_up(); |
gen_backing_up (); |
| |
|
| indent_puts( "if ( *yy_cp )" ); |
indent_puts ("if ( *yy_cp )"); |
| indent_up(); |
indent_up (); |
| indent_puts( "{" ); /* } for vi */ |
indent_puts ("{"); |
| } |
} |
| |
|
| if ( fulltbl ) |
if (fulltbl) { |
| indent_put2s( |
if (gentables) |
| "yy_current_state = yy_nxt[yy_current_state][%s];", |
indent_put2s |
| char_map ); |
("yy_current_state = yy_nxt[yy_current_state][%s];", |
| |
char_map); |
| |
else |
| |
indent_put2s |
| |
("yy_current_state = yy_nxt[yy_current_state*YY_NXT_LOLEN + %s];", |
| |
char_map); |
| |
} |
| |
|
| else if ( fullspd ) |
else if (fullspd) |
| indent_put2s( |
indent_put2s |
| "yy_current_state += yy_current_state[%s].yy_nxt;", |
("yy_current_state += yy_current_state[%s].yy_nxt;", |
| char_map ); |
char_map); |
| |
|
| else |
else |
| gen_next_compressed_state( char_map ); |
gen_next_compressed_state (char_map); |
| |
|
| if ( worry_about_NULs && nultrans ) |
if (worry_about_NULs && nultrans) { |
| { |
|
| /* { for vi */ |
|
| indent_puts( "}" ); |
|
| indent_down(); |
|
| indent_puts( "else" ); |
|
| indent_up(); |
|
| indent_puts( |
|
| "yy_current_state = yy_NUL_trans[yy_current_state];" ); |
|
| indent_down(); |
|
| } |
|
| |
|
| if ( fullspd || fulltbl ) |
indent_puts ("}"); |
| gen_backing_up(); |
indent_down (); |
| |
indent_puts ("else"); |
| if ( reject ) |
indent_up (); |
| indent_puts( "*yy_state_ptr++ = yy_current_state;" ); |
indent_puts |
| |
("yy_current_state = yy_NUL_trans[yy_current_state];"); |
| |
indent_down (); |
| } |
} |
| |
|
| |
if (fullspd || fulltbl) |
| |
gen_backing_up (); |
| |
|
| |
if (reject) |
| |
indent_puts ("*YY_G(yy_state_ptr)++ = yy_current_state;"); |
| |
} |
| |
|
| |
|
| /* Generate the code to make a NUL transition. */ |
/* Generate the code to make a NUL transition. */ |
| |
|
| void gen_NUL_trans() |
void gen_NUL_trans () |
| { /* NOTE - changes in here should be reflected in gen_next_match() */ |
{ /* NOTE - changes in here should be reflected in gen_next_match() */ |
| /* Only generate a definition for "yy_cp" if we'll generate code |
/* Only generate a definition for "yy_cp" if we'll generate code |
| * that uses it. Otherwise lint and the like complain. |
* that uses it. Otherwise lint and the like complain. |
| */ |
*/ |
| int need_backing_up = (num_backing_up > 0 && ! reject); |
int need_backing_up = (num_backing_up > 0 && !reject); |
| |
|
| if ( need_backing_up && (! nultrans || fullspd || fulltbl) ) |
if (need_backing_up && (!nultrans || fullspd || fulltbl)) |
| /* We're going to need yy_cp lying around for the call |
/* We're going to need yy_cp lying around for the call |
| * below to gen_backing_up(). |
* below to gen_backing_up(). |
| */ |
*/ |
| indent_puts( "register char *yy_cp = yy_c_buf_p;" ); |
indent_puts ("char *yy_cp = YY_G(yy_c_buf_p);"); |
| |
|
| outc( '\n' ); |
outc ('\n'); |
| |
|
| if ( nultrans ) |
if (nultrans) { |
| { |
indent_puts |
| indent_puts( |
("yy_current_state = yy_NUL_trans[yy_current_state];"); |
| "yy_current_state = yy_NUL_trans[yy_current_state];" ); |
indent_puts ("yy_is_jam = (yy_current_state == 0);"); |
| indent_puts( "yy_is_jam = (yy_current_state == 0);" ); |
} |
| } |
|
| |
|
| else if ( fulltbl ) |
else if (fulltbl) { |
| { |
do_indent (); |
| do_indent(); |
if (gentables) |
| out_dec( "yy_current_state = yy_nxt[yy_current_state][%d];\n", |
out_dec ("yy_current_state = yy_nxt[yy_current_state][%d];\n", NUL_ec); |
| NUL_ec ); |
else |
| indent_puts( "yy_is_jam = (yy_current_state <= 0);" ); |
out_dec ("yy_current_state = yy_nxt[yy_current_state*YY_NXT_LOLEN + %d];\n", NUL_ec); |
| } |
indent_puts ("yy_is_jam = (yy_current_state <= 0);"); |
| |
} |
| |
|
| else if ( fullspd ) |
else if (fullspd) { |
| { |
do_indent (); |
| do_indent(); |
out_dec ("int yy_c = %d;\n", NUL_ec); |
| out_dec( "register int yy_c = %d;\n", NUL_ec ); |
|
| |
|
| indent_puts( |
indent_puts |
| "register yyconst struct yy_trans_info *yy_trans_info;\n" ); |
("yyconst struct yy_trans_info *yy_trans_info;\n"); |
| indent_puts( |
indent_puts |
| "yy_trans_info = &yy_current_state[(unsigned int) yy_c];" ); |
("yy_trans_info = &yy_current_state[(unsigned int) yy_c];"); |
| indent_puts( "yy_current_state += yy_trans_info->yy_nxt;" ); |
indent_puts ("yy_current_state += yy_trans_info->yy_nxt;"); |
| |
|
| indent_puts( |
indent_puts |
| "yy_is_jam = (yy_trans_info->yy_verify != yy_c);" ); |
("yy_is_jam = (yy_trans_info->yy_verify != yy_c);"); |
| } |
} |
| |
|
| else |
else { |
| { |
char NUL_ec_str[20]; |
| char NUL_ec_str[20]; |
|
| |
|
| (void) snprintf( NUL_ec_str, sizeof NUL_ec_str, "%d", NUL_ec ); |
snprintf (NUL_ec_str, sizeof(NUL_ec_str), "%d", NUL_ec); |
| gen_next_compressed_state( NUL_ec_str ); |
gen_next_compressed_state (NUL_ec_str); |
| |
|
| do_indent(); |
do_indent (); |
| out_dec( "yy_is_jam = (yy_current_state == %d);\n", jamstate ); |
out_dec ("yy_is_jam = (yy_current_state == %d);\n", |
| |
jamstate); |
| |
|
| if ( reject ) |
if (reject) { |
| { |
|
| /* Only stack this state if it's a transition we |
/* Only stack this state if it's a transition we |
| * actually make. If we stack it on a jam, then |
* actually make. If we stack it on a jam, then |
| * the state stack and yy_c_buf_p get out of sync. |
* the state stack and yy_c_buf_p get out of sync. |
| */ |
*/ |
| indent_puts( "if ( ! yy_is_jam )" ); |
indent_puts ("if ( ! yy_is_jam )"); |
| indent_up(); |
indent_up (); |
| indent_puts( "*yy_state_ptr++ = yy_current_state;" ); |
indent_puts |
| indent_down(); |
("*YY_G(yy_state_ptr)++ = yy_current_state;"); |
| } |
indent_down (); |
| } |
} |
| |
} |
| |
|
| /* If we've entered an accepting state, back up; note that |
/* If we've entered an accepting state, back up; note that |
| * compressed tables have *already* done such backing up, so |
* compressed tables have *already* done such backing up, so |
| * we needn't bother with it again. |
* we needn't bother with it again. |
| */ |
*/ |
| if ( need_backing_up && (fullspd || fulltbl) ) |
if (need_backing_up && (fullspd || fulltbl)) { |
| { |
outc ('\n'); |
| outc( '\n' ); |
indent_puts ("if ( ! yy_is_jam )"); |
| indent_puts( "if ( ! yy_is_jam )" ); |
indent_up (); |
| indent_up(); |
indent_puts ("{"); |
| indent_puts( "{" ); |
gen_backing_up (); |
| gen_backing_up(); |
indent_puts ("}"); |
| indent_puts( "}" ); |
indent_down (); |
| indent_down(); |
|
| } |
|
| } |
} |
| |
} |
| |
|
| |
|
| /* Generate the code to find the start state. */ |
/* Generate the code to find the start state. */ |
| |
|
| void gen_start_state() |
void gen_start_state () |
| { |
{ |
| if ( fullspd ) |
if (fullspd) { |
| { |
if (bol_needed) { |
| if ( bol_needed ) |
indent_puts |
| { |
("yy_current_state = yy_start_state_list[YY_G(yy_start) + YY_AT_BOL()];"); |
| indent_puts( |
|
| "yy_current_state = yy_start_state_list[yy_start + YY_AT_BOL()];" ); |
|
| } |
|
| else |
|
| indent_puts( |
|
| "yy_current_state = yy_start_state_list[yy_start];" ); |
|
| } |
} |
| |
else |
| |
indent_puts |
| |
("yy_current_state = yy_start_state_list[YY_G(yy_start)];"); |
| |
} |
| |
|
| else |
else { |
| { |
indent_puts ("yy_current_state = YY_G(yy_start);"); |
| indent_puts( "yy_current_state = yy_start;" ); |
|
| |
|
| if ( bol_needed ) |
if (bol_needed) |
| indent_puts( "yy_current_state += YY_AT_BOL();" ); |
indent_puts ("yy_current_state += YY_AT_BOL();"); |
| |
|
| if ( reject ) |
if (reject) { |
| { |
|
| /* Set up for storing up states. */ |
/* Set up for storing up states. */ |
| indent_puts( "yy_state_ptr = yy_state_buf;" ); |
outn ("m4_ifdef( [[M4_YY_USES_REJECT]],\n[["); |
| indent_puts( "*yy_state_ptr++ = yy_current_state;" ); |
indent_puts |
| } |
("YY_G(yy_state_ptr) = YY_G(yy_state_buf);"); |
| |
indent_puts |
| |
("*YY_G(yy_state_ptr)++ = yy_current_state;"); |
| |
outn ("]])"); |
| } |
} |
| } |
} |
| |
} |
| |
|
| |
|
| /* gentabs - generate data statements for the transition tables */ |
/* gentabs - generate data statements for the transition tables */ |
| |
|
| void gentabs() |
void gentabs () |
| { |
{ |
| int i, j, k, *accset, nacc, *acc_array, total_states; |
int i, j, k, *accset, nacc, *acc_array, total_states; |
| int end_of_buffer_action = num_rules + 1; |
int end_of_buffer_action = num_rules + 1; |
| |
struct yytbl_data *yyacc_tbl = 0, *yymeta_tbl = 0, *yybase_tbl = 0, |
| |
*yydef_tbl = 0, *yynxt_tbl = 0, *yychk_tbl = 0, *yyacclist_tbl=0; |
| |
flex_int32_t *yyacc_data = 0, *yybase_data = 0, *yydef_data = 0, |
| |
*yynxt_data = 0, *yychk_data = 0, *yyacclist_data=0; |
| |
flex_int32_t yybase_curr = 0, yyacclist_curr=0,yyacc_curr=0; |
| |
|
| acc_array = allocate_integer_array( current_max_dfas ); |
acc_array = allocate_integer_array (current_max_dfas); |
| nummt = 0; |
nummt = 0; |
| |
|
| /* The compressed table format jams by entering the "jam state", |
/* The compressed table format jams by entering the "jam state", |
|
|
| */ |
*/ |
| ++num_backing_up; |
++num_backing_up; |
| |
|
| if ( reject ) |
if (reject) { |
| { |
|
| /* Write out accepting list and pointer list. |
/* Write out accepting list and pointer list. |
| * |
|
| * First we generate the "yy_acclist" array. In the process, |
* First we generate the "yy_acclist" array. In the process, |
| * we compute the indices that will go into the "yy_accept" |
* we compute the indices that will go into the "yy_accept" |
| * array, and save the indices in the dfaacc array. |
* array, and save the indices in the dfaacc array. |
| */ |
*/ |
| int EOB_accepting_list[2]; |
int EOB_accepting_list[2]; |
| |
|
| /* Set up accepting structures for the End Of Buffer state. */ |
/* Set up accepting structures for the End Of Buffer state. */ |
| EOB_accepting_list[0] = 0; |
EOB_accepting_list[0] = 0; |
| EOB_accepting_list[1] = end_of_buffer_action; |
EOB_accepting_list[1] = end_of_buffer_action; |
| accsiz[end_of_buffer_state] = 1; |
accsiz[end_of_buffer_state] = 1; |
| dfaacc[end_of_buffer_state].dfaacc_set = EOB_accepting_list; |
dfaacc[end_of_buffer_state].dfaacc_set = |
| |
EOB_accepting_list; |
| |
|
| out_str_dec( long_align ? C_long_decl : C_short_decl, |
out_str_dec (long_align ? get_int32_decl () : |
| "yy_acclist", MAX( numas, 1 ) + 1 ); |
get_int16_decl (), "yy_acclist", MAX (numas, |
| |
1) + 1); |
| |
|
| |
buf_prints (&yydmap_buf, |
| |
"\t{YYTD_ID_ACCLIST, (void**)&yy_acclist, sizeof(%s)},\n", |
| |
long_align ? "flex_int32_t" : "flex_int16_t"); |
| |
|
| j = 1; /* index into "yy_acclist" array */ |
yyacclist_tbl = (struct yytbl_data*)calloc(1,sizeof(struct yytbl_data)); |
| |
yytbl_data_init (yyacclist_tbl, YYTD_ID_ACCLIST); |
| |
yyacclist_tbl->td_lolen = MAX(numas,1) + 1; |
| |
yyacclist_tbl->td_data = yyacclist_data = |
| |
(flex_int32_t *) calloc (yyacclist_tbl->td_lolen, sizeof (flex_int32_t)); |
| |
yyacclist_curr = 1; |
| |
|
| for ( i = 1; i <= lastdfa; ++i ) |
j = 1; /* index into "yy_acclist" array */ |
| { |
|
| |
for (i = 1; i <= lastdfa; ++i) { |
| acc_array[i] = j; |
acc_array[i] = j; |
| |
|
| if ( accsiz[i] != 0 ) |
if (accsiz[i] != 0) { |
| { |
|
| accset = dfaacc[i].dfaacc_set; |
accset = dfaacc[i].dfaacc_set; |
| nacc = accsiz[i]; |
nacc = accsiz[i]; |
| |
|
| if ( trace ) |
if (trace) |
| fprintf( stderr, |
fprintf (stderr, |
| _( "state # %d accepts: " ), |
_("state # %d accepts: "), |
| i ); |
i); |
| |
|
| for ( k = 1; k <= nacc; ++k ) |
for (k = 1; k <= nacc; ++k) { |
| { |
int accnum = accset[k]; |
| int accnum = accset[k]; |
|
| |
|
| ++j; |
++j; |
| |
|
| if ( variable_trailing_context_rules && |
if (variable_trailing_context_rules |
| ! (accnum & YY_TRAILING_HEAD_MASK) && |
&& !(accnum & |
| accnum > 0 && accnum <= num_rules && |
YY_TRAILING_HEAD_MASK) |
| rule_type[accnum] == RULE_VARIABLE ) |
&& accnum > 0 |
| { |
&& accnum <= num_rules |
| |
&& rule_type[accnum] == |
| |
RULE_VARIABLE) { |
| /* Special hack to flag |
/* Special hack to flag |
| * accepting number as part |
* accepting number as part |
| * of trailing context rule. |
* of trailing context rule. |
| */ |
*/ |
| accnum |= YY_TRAILING_MASK; |
accnum |= YY_TRAILING_MASK; |
| } |
} |
| |
|
| mkdata( accnum ); |
mkdata (accnum); |
| |
yyacclist_data[yyacclist_curr++] = accnum; |
| |
|
| if ( trace ) |
if (trace) { |
| { |
fprintf (stderr, "[%d]", |
| fprintf( stderr, "[%d]", |
accset[k]); |
| accset[k] ); |
|
| |
|
| if ( k < nacc ) |
if (k < nacc) |
| fputs( ", ", stderr ); |
fputs (", ", |
| |
stderr); |
| else |
else |
| putc( '\n', stderr ); |
putc ('\n', |
| } |
stderr); |
| } |
} |
| } |
} |
| } |
} |
| |
} |
| |
|
| /* add accepting number for the "jam" state */ |
/* add accepting number for the "jam" state */ |
| acc_array[i] = j; |
acc_array[i] = j; |
| |
|
| dataend(); |
dataend (); |
| } |
if (tablesext) { |
| |
yytbl_data_compress (yyacclist_tbl); |
| |
if (yytbl_data_fwrite (&tableswr, yyacclist_tbl) < 0) |
| |
flexerror (_("Could not write yyacclist_tbl")); |
| |
yytbl_data_destroy (yyacclist_tbl); |
| |
yyacclist_tbl = NULL; |
| |
} |
| |
} |
| |
|
| else |
else { |
| { |
dfaacc[end_of_buffer_state].dfaacc_state = |
| dfaacc[end_of_buffer_state].dfaacc_state = end_of_buffer_action; |
end_of_buffer_action; |
| |
|
| for ( i = 1; i <= lastdfa; ++i ) |
for (i = 1; i <= lastdfa; ++i) |
| acc_array[i] = dfaacc[i].dfaacc_state; |
acc_array[i] = dfaacc[i].dfaacc_state; |
| |
|
| /* add accepting number for jam state */ |
/* add accepting number for jam state */ |
| acc_array[i] = 0; |
acc_array[i] = 0; |
| } |
} |
| |
|
| |
/* Begin generating yy_accept */ |
| |
|
| /* Spit out "yy_accept" array. If we're doing "reject", it'll be |
/* Spit out "yy_accept" array. If we're doing "reject", it'll be |
| * pointers into the "yy_acclist" array. Otherwise it's actual |
* pointers into the "yy_acclist" array. Otherwise it's actual |
| * accepting numbers. In either case, we just dump the numbers. |
* accepting numbers. In either case, we just dump the numbers. |
|
|
| */ |
*/ |
| k = lastdfa + 2; |
k = lastdfa + 2; |
| |
|
| if ( reject ) |
if (reject) |
| /* We put a "cap" on the table associating lists of accepting |
/* We put a "cap" on the table associating lists of accepting |
| * numbers with state numbers. This is needed because we tell |
* numbers with state numbers. This is needed because we tell |
| * where the end of an accepting list is by looking at where |
* where the end of an accepting list is by looking at where |
|
|
| */ |
*/ |
| ++k; |
++k; |
| |
|
| out_str_dec( long_align ? C_long_decl : C_short_decl, "yy_accept", k ); |
out_str_dec (long_align ? get_int32_decl () : get_int16_decl (), |
| |
"yy_accept", k); |
| |
|
| for ( i = 1; i <= lastdfa; ++i ) |
buf_prints (&yydmap_buf, |
| { |
"\t{YYTD_ID_ACCEPT, (void**)&yy_accept, sizeof(%s)},\n", |
| mkdata( acc_array[i] ); |
long_align ? "flex_int32_t" : "flex_int16_t"); |
| |
|
| if ( ! reject && trace && acc_array[i] ) |
yyacc_tbl = |
| fprintf( stderr, _( "state # %d accepts: [%d]\n" ), |
(struct yytbl_data *) calloc (1, |
| i, acc_array[i] ); |
sizeof (struct yytbl_data)); |
| } |
yytbl_data_init (yyacc_tbl, YYTD_ID_ACCEPT); |
| |
yyacc_tbl->td_lolen = k; |
| |
yyacc_tbl->td_data = yyacc_data = |
| |
(flex_int32_t *) calloc (yyacc_tbl->td_lolen, sizeof (flex_int32_t)); |
| |
yyacc_curr=1; |
| |
|
| |
for (i = 1; i <= lastdfa; ++i) { |
| |
mkdata (acc_array[i]); |
| |
yyacc_data[yyacc_curr++] = acc_array[i]; |
| |
|
| |
if (!reject && trace && acc_array[i]) |
| |
fprintf (stderr, _("state # %d accepts: [%d]\n"), |
| |
i, acc_array[i]); |
| |
} |
| |
|
| /* Add entry for "jam" state. */ |
/* Add entry for "jam" state. */ |
| mkdata( acc_array[i] ); |
mkdata (acc_array[i]); |
| |
yyacc_data[yyacc_curr++] = acc_array[i]; |
| |
|
| if ( reject ) |
if (reject) { |
| /* Add "cap" for the list. */ |
/* Add "cap" for the list. */ |
| mkdata( acc_array[i] ); |
mkdata (acc_array[i]); |
| |
yyacc_data[yyacc_curr++] = acc_array[i]; |
| |
} |
| |
|
| dataend(); |
dataend (); |
| |
if (tablesext) { |
| |
yytbl_data_compress (yyacc_tbl); |
| |
if (yytbl_data_fwrite (&tableswr, yyacc_tbl) < 0) |
| |
flexerror (_("Could not write yyacc_tbl")); |
| |
yytbl_data_destroy (yyacc_tbl); |
| |
yyacc_tbl = NULL; |
| |
} |
| |
/* End generating yy_accept */ |
| |
|
| if ( useecs ) |
if (useecs) { |
| genecs(); |
|
| |
|
| if ( usemecs ) |
genecs (); |
| { |
if (tablesext) { |
| |
struct yytbl_data *tbl; |
| |
|
| |
tbl = mkecstbl (); |
| |
yytbl_data_compress (tbl); |
| |
if (yytbl_data_fwrite (&tableswr, tbl) < 0) |
| |
flexerror (_("Could not write ecstbl")); |
| |
yytbl_data_destroy (tbl); |
| |
tbl = 0; |
| |
} |
| |
} |
| |
|
| |
if (usemecs) { |
| |
/* Begin generating yy_meta */ |
| /* Write out meta-equivalence classes (used to index |
/* Write out meta-equivalence classes (used to index |
| * templates with). |
* templates with). |
| */ |
*/ |
| |
flex_int32_t *yymecs_data = 0; |
| |
yymeta_tbl = |
| |
(struct yytbl_data *) calloc (1, |
| |
sizeof (struct |
| |
yytbl_data)); |
| |
yytbl_data_init (yymeta_tbl, YYTD_ID_META); |
| |
yymeta_tbl->td_lolen = numecs + 1; |
| |
yymeta_tbl->td_data = yymecs_data = |
| |
(flex_int32_t *) calloc (yymeta_tbl->td_lolen, |
| |
sizeof (flex_int32_t)); |
| |
|
| if ( trace ) |
if (trace) |
| fputs( _( "\n\nMeta-Equivalence Classes:\n" ), |
fputs (_("\n\nMeta-Equivalence Classes:\n"), |
| stderr ); |
stderr); |
| |
|
| out_str_dec( C_int_decl, "yy_meta", numecs + 1 ); |
out_str_dec (get_int32_decl (), "yy_meta", numecs + 1); |
| |
buf_prints (&yydmap_buf, |
| |
"\t{YYTD_ID_META, (void**)&yy_meta, sizeof(%s)},\n", |
| |
"flex_int32_t"); |
| |
|
| for ( i = 1; i <= numecs; ++i ) |
for (i = 1; i <= numecs; ++i) { |
| { |
if (trace) |
| if ( trace ) |
fprintf (stderr, "%d = %d\n", |
| fprintf( stderr, "%d = %d\n", |
i, ABS (tecbck[i])); |
| i, ABS( tecbck[i] ) ); |
|
| |
|
| mkdata( ABS( tecbck[i] ) ); |
mkdata (ABS (tecbck[i])); |
| } |
yymecs_data[i] = ABS (tecbck[i]); |
| |
} |
| |
|
| dataend(); |
dataend (); |
| |
if (tablesext) { |
| |
yytbl_data_compress (yymeta_tbl); |
| |
if (yytbl_data_fwrite (&tableswr, yymeta_tbl) < 0) |
| |
flexerror (_ |
| |
("Could not write yymeta_tbl")); |
| |
yytbl_data_destroy (yymeta_tbl); |
| |
yymeta_tbl = NULL; |
| } |
} |
| |
/* End generating yy_meta */ |
| |
} |
| |
|
| total_states = lastdfa + numtemps; |
total_states = lastdfa + numtemps; |
| |
|
| out_str_dec( (tblend >= MAX_SHORT || long_align) ? |
/* Begin generating yy_base */ |
| C_long_decl : C_short_decl, |
out_str_dec ((tblend >= INT16_MAX || long_align) ? |
| "yy_base", total_states + 1 ); |
get_int32_decl () : get_int16_decl (), |
| |
"yy_base", total_states + 1); |
| |
|
| for ( i = 1; i <= lastdfa; ++i ) |
buf_prints (&yydmap_buf, |
| { |
"\t{YYTD_ID_BASE, (void**)&yy_base, sizeof(%s)},\n", |
| |
(tblend >= INT16_MAX |
| |
|| long_align) ? "flex_int32_t" : "flex_int16_t"); |
| |
yybase_tbl = |
| |
(struct yytbl_data *) calloc (1, |
| |
sizeof (struct yytbl_data)); |
| |
yytbl_data_init (yybase_tbl, YYTD_ID_BASE); |
| |
yybase_tbl->td_lolen = total_states + 1; |
| |
yybase_tbl->td_data = yybase_data = |
| |
(flex_int32_t *) calloc (yybase_tbl->td_lolen, |
| |
sizeof (flex_int32_t)); |
| |
yybase_curr = 1; |
| |
|
| |
for (i = 1; i <= lastdfa; ++i) { |
| int d = def[i]; |
int d = def[i]; |
| |
|
| if ( base[i] == JAMSTATE ) |
if (base[i] == JAMSTATE) |
| base[i] = jambase; |
base[i] = jambase; |
| |
|
| if ( d == JAMSTATE ) |
if (d == JAMSTATE) |
| def[i] = jamstate; |
def[i] = jamstate; |
| |
|
| else if ( d < 0 ) |
else if (d < 0) { |
| { |
|
| /* Template reference. */ |
/* Template reference. */ |
| ++tmpuses; |
++tmpuses; |
| def[i] = lastdfa - d + 1; |
def[i] = lastdfa - d + 1; |
| } |
|
| |
|
| mkdata( base[i] ); |
|
| } |
} |
| |
|
| |
mkdata (base[i]); |
| |
yybase_data[yybase_curr++] = base[i]; |
| |
} |
| |
|
| /* Generate jam state's base index. */ |
/* Generate jam state's base index. */ |
| mkdata( base[i] ); |
mkdata (base[i]); |
| |
yybase_data[yybase_curr++] = base[i]; |
| |
|
| for ( ++i /* skip jam state */; i <= total_states; ++i ) |
for (++i /* skip jam state */ ; i <= total_states; ++i) { |
| { |
mkdata (base[i]); |
| mkdata( base[i] ); |
yybase_data[yybase_curr++] = base[i]; |
| def[i] = jamstate; |
def[i] = jamstate; |
| } |
} |
| |
|
| dataend(); |
dataend (); |
| |
if (tablesext) { |
| |
yytbl_data_compress (yybase_tbl); |
| |
if (yytbl_data_fwrite (&tableswr, yybase_tbl) < 0) |
| |
flexerror (_("Could not write yybase_tbl")); |
| |
yytbl_data_destroy (yybase_tbl); |
| |
yybase_tbl = NULL; |
| |
} |
| |
/* End generating yy_base */ |
| |
|
| out_str_dec( (total_states >= MAX_SHORT || long_align) ? |
|
| C_long_decl : C_short_decl, |
|
| "yy_def", total_states + 1 ); |
|
| |
|
| for ( i = 1; i <= total_states; ++i ) |
/* Begin generating yy_def */ |
| mkdata( def[i] ); |
out_str_dec ((total_states >= INT16_MAX || long_align) ? |
| |
get_int32_decl () : get_int16_decl (), |
| |
"yy_def", total_states + 1); |
| |
|
| dataend(); |
buf_prints (&yydmap_buf, |
| |
"\t{YYTD_ID_DEF, (void**)&yy_def, sizeof(%s)},\n", |
| |
(total_states >= INT16_MAX |
| |
|| long_align) ? "flex_int32_t" : "flex_int16_t"); |
| |
|
| out_str_dec( (total_states >= MAX_SHORT || long_align) ? |
yydef_tbl = |
| C_long_decl : C_short_decl, |
(struct yytbl_data *) calloc (1, |
| "yy_nxt", tblend + 1 ); |
sizeof (struct yytbl_data)); |
| |
yytbl_data_init (yydef_tbl, YYTD_ID_DEF); |
| |
yydef_tbl->td_lolen = total_states + 1; |
| |
yydef_tbl->td_data = yydef_data = |
| |
(flex_int32_t *) calloc (yydef_tbl->td_lolen, sizeof (flex_int32_t)); |
| |
|
| for ( i = 1; i <= tblend; ++i ) |
for (i = 1; i <= total_states; ++i) { |
| { |
mkdata (def[i]); |
| |
yydef_data[i] = def[i]; |
| |
} |
| |
|
| |
dataend (); |
| |
if (tablesext) { |
| |
yytbl_data_compress (yydef_tbl); |
| |
if (yytbl_data_fwrite (&tableswr, yydef_tbl) < 0) |
| |
flexerror (_("Could not write yydef_tbl")); |
| |
yytbl_data_destroy (yydef_tbl); |
| |
yydef_tbl = NULL; |
| |
} |
| |
/* End generating yy_def */ |
| |
|
| |
|
| |
/* Begin generating yy_nxt */ |
| |
out_str_dec ((total_states >= INT16_MAX || long_align) ? |
| |
get_int32_decl () : get_int16_decl (), "yy_nxt", |
| |
tblend + 1); |
| |
|
| |
buf_prints (&yydmap_buf, |
| |
"\t{YYTD_ID_NXT, (void**)&yy_nxt, sizeof(%s)},\n", |
| |
(total_states >= INT16_MAX |
| |
|| long_align) ? "flex_int32_t" : "flex_int16_t"); |
| |
|
| |
yynxt_tbl = |
| |
(struct yytbl_data *) calloc (1, |
| |
sizeof (struct yytbl_data)); |
| |
yytbl_data_init (yynxt_tbl, YYTD_ID_NXT); |
| |
yynxt_tbl->td_lolen = tblend + 1; |
| |
yynxt_tbl->td_data = yynxt_data = |
| |
(flex_int32_t *) calloc (yynxt_tbl->td_lolen, sizeof (flex_int32_t)); |
| |
|
| |
for (i = 1; i <= tblend; ++i) { |
| /* Note, the order of the following test is important. |
/* Note, the order of the following test is important. |
| * If chk[i] is 0, then nxt[i] is undefined. |
* If chk[i] is 0, then nxt[i] is undefined. |
| */ |
*/ |
| if ( chk[i] == 0 || nxt[i] == 0 ) |
if (chk[i] == 0 || nxt[i] == 0) |
| nxt[i] = jamstate; /* new state is the JAM state */ |
nxt[i] = jamstate; /* new state is the JAM state */ |
| |
|
| mkdata( nxt[i] ); |
mkdata (nxt[i]); |
| } |
yynxt_data[i] = nxt[i]; |
| |
} |
| |
|
| dataend(); |
dataend (); |
| |
if (tablesext) { |
| |
yytbl_data_compress (yynxt_tbl); |
| |
if (yytbl_data_fwrite (&tableswr, yynxt_tbl) < 0) |
| |
flexerror (_("Could not write yynxt_tbl")); |
| |
yytbl_data_destroy (yynxt_tbl); |
| |
yynxt_tbl = NULL; |
| |
} |
| |
/* End generating yy_nxt */ |
| |
|
| out_str_dec( (total_states >= MAX_SHORT || long_align) ? |
/* Begin generating yy_chk */ |
| C_long_decl : C_short_decl, |
out_str_dec ((total_states >= INT16_MAX || long_align) ? |
| "yy_chk", tblend + 1 ); |
get_int32_decl () : get_int16_decl (), "yy_chk", |
| |
tblend + 1); |
| |
|
| for ( i = 1; i <= tblend; ++i ) |
buf_prints (&yydmap_buf, |
| { |
"\t{YYTD_ID_CHK, (void**)&yy_chk, sizeof(%s)},\n", |
| if ( chk[i] == 0 ) |
(total_states >= INT16_MAX |
| |
|| long_align) ? "flex_int32_t" : "flex_int16_t"); |
| |
|
| |
yychk_tbl = |
| |
(struct yytbl_data *) calloc (1, |
| |
sizeof (struct yytbl_data)); |
| |
yytbl_data_init (yychk_tbl, YYTD_ID_CHK); |
| |
yychk_tbl->td_lolen = tblend + 1; |
| |
yychk_tbl->td_data = yychk_data = |
| |
(flex_int32_t *) calloc (yychk_tbl->td_lolen, sizeof (flex_int32_t)); |
| |
|
| |
for (i = 1; i <= tblend; ++i) { |
| |
if (chk[i] == 0) |
| ++nummt; |
++nummt; |
| |
|
| mkdata( chk[i] ); |
mkdata (chk[i]); |
| } |
yychk_data[i] = chk[i]; |
| |
} |
| |
|
| dataend(); |
dataend (); |
| free(acc_array); |
if (tablesext) { |
| |
yytbl_data_compress (yychk_tbl); |
| |
if (yytbl_data_fwrite (&tableswr, yychk_tbl) < 0) |
| |
flexerror (_("Could not write yychk_tbl")); |
| |
yytbl_data_destroy (yychk_tbl); |
| |
yychk_tbl = NULL; |
| } |
} |
| |
/* End generating yy_chk */ |
| |
|
| |
flex_free ((void *) acc_array); |
| |
} |
| |
|
| |
|
| /* Write out a formatted string (with a secondary string argument) at the |
/* Write out a formatted string (with a secondary string argument) at the |
| * current indentation level, adding a final newline. |
* current indentation level, adding a final newline. |
| */ |
*/ |
| |
|
| void indent_put2s( fmt, arg ) |
void indent_put2s (fmt, arg) |
| char fmt[], arg[]; |
const char *fmt, *arg; |
| { |
{ |
| do_indent(); |
do_indent (); |
| out_str( fmt, arg ); |
out_str (fmt, arg); |
| outn( "" ); |
outn (""); |
| } |
} |
| |
|
| |
|
| /* Write out a string at the current indentation level, adding a final |
/* Write out a string at the current indentation level, adding a final |
| * newline. |
* newline. |
| */ |
*/ |
| |
|
| void indent_puts( str ) |
void indent_puts (str) |
| char str[]; |
const char *str; |
| { |
{ |
| do_indent(); |
do_indent (); |
| outn( str ); |
outn (str); |
| } |
} |
| |
|
| |
|
| /* make_tables - generate transition tables and finishes generating output file |
/* make_tables - generate transition tables and finishes generating output file |
| */ |
*/ |
| |
|
| void make_tables() |
void make_tables () |
| { |
{ |
| int i; |
int i; |
| int did_eof_rule = false; |
int did_eof_rule = false; |
| |
struct yytbl_data *yynultrans_tbl; |
| |
|
| skelout(); |
|
| |
|
| |
skelout (); /* %% [2.0] - break point in skel */ |
| |
|
| /* First, take care of YY_DO_BEFORE_ACTION depending on yymore |
/* First, take care of YY_DO_BEFORE_ACTION depending on yymore |
| * being used. |
* being used. |
| */ |
*/ |
| set_indent( 1 ); |
set_indent (1); |
| |
|
| if ( yymore_used && ! yytext_is_array ) |
if (yymore_used && !yytext_is_array) { |
| { |
indent_puts ("YY_G(yytext_ptr) -= YY_G(yy_more_len); \\"); |
| indent_puts( "yytext_ptr -= yy_more_len; \\" ); |
indent_puts |
| indent_puts( "yyleng = (int) (yy_cp - yytext_ptr); \\" ); |
("yyleng = (size_t) (yy_cp - YY_G(yytext_ptr)); \\"); |
| } |
} |
| |
|
| else |
else |
| indent_puts( "yyleng = (int) (yy_cp - yy_bp); \\" ); |
indent_puts ("yyleng = (size_t) (yy_cp - yy_bp); \\"); |
| |
|
| /* Now also deal with copying yytext_ptr to yytext if needed. */ |
/* Now also deal with copying yytext_ptr to yytext if needed. */ |
| skelout(); |
skelout (); /* %% [3.0] - break point in skel */ |
| if ( yytext_is_array ) |
if (yytext_is_array) { |
| { |
if (yymore_used) |
| if ( yymore_used ) |
indent_puts |
| indent_puts( |
("if ( yyleng + YY_G(yy_more_offset) >= YYLMAX ) \\"); |
| "if ( yyleng + yy_more_offset >= YYLMAX ) \\" ); |
|
| else |
else |
| indent_puts( "if ( yyleng >= YYLMAX ) \\" ); |
indent_puts ("if ( yyleng >= YYLMAX ) \\"); |
| |
|
| indent_up(); |
indent_up (); |
| indent_puts( |
indent_puts |
| "YY_FATAL_ERROR( \"token too large, exceeds YYLMAX\" ); \\" ); |
("YY_FATAL_ERROR( \"token too large, exceeds YYLMAX\" ); \\"); |
| indent_down(); |
indent_down (); |
| |
|
| if ( yymore_used ) |
if (yymore_used) { |
| { |
indent_puts |
| indent_puts( |
("yy_flex_strncpy( &yytext[YY_G(yy_more_offset)], YY_G(yytext_ptr), yyleng + 1 M4_YY_CALL_LAST_ARG); \\"); |
| "yy_flex_strncpy( &yytext[yy_more_offset], yytext_ptr, yyleng + 1 ); \\" ); |
indent_puts ("yyleng += YY_G(yy_more_offset); \\"); |
| indent_puts( "yyleng += yy_more_offset; \\" ); |
indent_puts |
| indent_puts( |
("YY_G(yy_prev_more_offset) = YY_G(yy_more_offset); \\"); |
| "yy_prev_more_offset = yy_more_offset; \\" ); |
indent_puts ("YY_G(yy_more_offset) = 0; \\"); |
| indent_puts( "yy_more_offset = 0; \\" ); |
|
| } |
|
| else |
|
| { |
|
| indent_puts( |
|
| "yy_flex_strncpy( yytext, yytext_ptr, yyleng + 1 ); \\" ); |
|
| } |
|
| } |
} |
| |
else { |
| |
indent_puts |
| |
("yy_flex_strncpy( yytext, YY_G(yytext_ptr), yyleng + 1 M4_YY_CALL_LAST_ARG); \\"); |
| |
} |
| |
} |
| |
|
| set_indent( 0 ); |
set_indent (0); |
| |
|
| skelout(); |
skelout (); /* %% [4.0] - break point in skel */ |
| |
|
| |
|
| out_dec( "#define YY_NUM_RULES %d\n", num_rules ); |
/* This is where we REALLY begin generating the tables. */ |
| out_dec( "#define YY_END_OF_BUFFER %d\n", num_rules + 1 ); |
|
| |
|
| if ( fullspd ) |
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 |
/* Need to define the transet type as a size large |
| * enough to hold the biggest offset. |
* enough to hold the biggest offset. |
| */ |
*/ |
| int total_table_size = tblend + numecs + 1; |
int total_table_size = tblend + numecs + 1; |
| char *trans_offset_type = |
char *trans_offset_type = |
| (total_table_size >= MAX_SHORT || long_align) ? |
(total_table_size >= INT16_MAX || long_align) ? |
| "long" : "short"; |
"flex_int32_t" : "flex_int16_t"; |
| |
|
| set_indent( 0 ); |
set_indent (0); |
| indent_puts( "struct yy_trans_info" ); |
indent_puts ("struct yy_trans_info"); |
| indent_up(); |
indent_up (); |
| indent_puts( "{" ); /* } for vi */ |
indent_puts ("{"); |
| |
|
| if ( long_align ) |
/* We require that yy_verify and yy_nxt must be of the same size int. */ |
| indent_puts( "long yy_verify;" ); |
indent_put2s ("%s yy_verify;", trans_offset_type); |
| else |
|
| indent_puts( "short yy_verify;" ); |
|
| |
|
| /* In cases where its sister yy_verify *is* a "yes, there is |
/* In cases where its sister yy_verify *is* a "yes, there is |
| * a transition", yy_nxt is the offset (in records) to the |
* a transition", yy_nxt is the offset (in records) to the |
|
|
| * for that state. |
* for that state. |
| */ |
*/ |
| |
|
| indent_put2s( "%s yy_nxt;", trans_offset_type ); |
indent_put2s ("%s yy_nxt;", trans_offset_type); |
| indent_puts( "};" ); |
indent_puts ("};"); |
| indent_down(); |
indent_down (); |
| |
} |
| |
else { |
| |
/* We generate a bogus 'struct yy_trans_info' data type |
| |
* so we can guarantee that it is always declared in the skel. |
| |
* This is so we can compile "sizeof(struct yy_trans_info)" |
| |
* in any scanner. |
| |
*/ |
| |
indent_puts |
| |
("/* This struct is not used in this scanner,"); |
| |
indent_puts (" but its presence is necessary. */"); |
| |
indent_puts ("struct yy_trans_info"); |
| |
indent_up (); |
| |
indent_puts ("{"); |
| |
indent_puts ("flex_int32_t yy_verify;"); |
| |
indent_puts ("flex_int32_t yy_nxt;"); |
| |
indent_puts ("};"); |
| |
indent_down (); |
| |
} |
| |
|
| |
if (fullspd) { |
| |
genctbl (); |
| |
if (tablesext) { |
| |
struct yytbl_data *tbl; |
| |
|
| |
tbl = mkctbl (); |
| |
yytbl_data_compress (tbl); |
| |
if (yytbl_data_fwrite (&tableswr, tbl) < 0) |
| |
flexerror (_("Could not write ftbl")); |
| |
yytbl_data_destroy (tbl); |
| |
|
| |
tbl = mkssltbl (); |
| |
yytbl_data_compress (tbl); |
| |
if (yytbl_data_fwrite (&tableswr, tbl) < 0) |
| |
flexerror (_("Could not write ssltbl")); |
| |
yytbl_data_destroy (tbl); |
| |
tbl = 0; |
| |
|
| |
if (useecs) { |
| |
tbl = mkecstbl (); |
| |
yytbl_data_compress (tbl); |
| |
if (yytbl_data_fwrite (&tableswr, tbl) < 0) |
| |
flexerror (_ |
| |
("Could not write ecstbl")); |
| |
yytbl_data_destroy (tbl); |
| |
tbl = 0; |
| |
} |
| } |
} |
| |
} |
| |
else if (fulltbl) { |
| |
genftbl (); |
| |
if (tablesext) { |
| |
struct yytbl_data *tbl; |
| |
|
| if ( fullspd ) |
tbl = mkftbl (); |
| genctbl(); |
yytbl_data_compress (tbl); |
| else if ( fulltbl ) |
if (yytbl_data_fwrite (&tableswr, tbl) < 0) |
| genftbl(); |
flexerror (_("Could not write ftbl")); |
| |
yytbl_data_destroy (tbl); |
| |
tbl = 0; |
| |
|
| |
if (useecs) { |
| |
tbl = mkecstbl (); |
| |
yytbl_data_compress (tbl); |
| |
if (yytbl_data_fwrite (&tableswr, tbl) < 0) |
| |
flexerror (_ |
| |
("Could not write ecstbl")); |
| |
yytbl_data_destroy (tbl); |
| |
tbl = 0; |
| |
} |
| |
} |
| |
} |
| else |
else |
| gentabs(); |
gentabs (); |
| |
|
| |
if (do_yylineno) { |
| |
|
| |
geneoltbl (); |
| |
|
| |
if (tablesext) { |
| |
struct yytbl_data *tbl; |
| |
|
| |
tbl = mkeoltbl (); |
| |
yytbl_data_compress (tbl); |
| |
if (yytbl_data_fwrite (&tableswr, tbl) < 0) |
| |
flexerror (_("Could not write eoltbl")); |
| |
yytbl_data_destroy (tbl); |
| |
tbl = 0; |
| |
} |
| |
} |
| |
|
| /* Definitions for backing up. We don't need them if REJECT |
/* Definitions for backing up. We don't need them if REJECT |
| * is being used because then we use an alternative backin-up |
* is being used because then we use an alternative backin-up |
| * technique instead. |
* technique instead. |
| */ |
*/ |
| if ( num_backing_up > 0 && ! reject ) |
if (num_backing_up > 0 && !reject) { |
| { |
if (!C_plus_plus && !reentrant) { |
| if ( ! C_plus_plus ) |
indent_puts |
| { |
("static yy_state_type yy_last_accepting_state;"); |
| indent_puts( |
indent_puts |
| "static yy_state_type yy_last_accepting_state;" ); |
("static char *yy_last_accepting_cpos;\n"); |
| indent_puts( |
|
| "static char *yy_last_accepting_cpos;\n" ); |
|
| } |
|
| } |
} |
| |
} |
| |
|
| if ( nultrans ) |
if (nultrans) { |
| { |
flex_int32_t *yynultrans_data = 0; |
| out_str_dec( C_state_decl, "yy_NUL_trans", lastdfa + 1 ); |
|
| |
|
| for ( i = 1; i <= lastdfa; ++i ) |
/* Begin generating yy_NUL_trans */ |
| { |
out_str_dec (get_state_decl (), "yy_NUL_trans", |
| if ( fullspd ) |
lastdfa + 1); |
| out_dec( " &yy_transition[%d],\n", base[i] ); |
buf_prints (&yydmap_buf, |
| else |
"\t{YYTD_ID_NUL_TRANS, (void**)&yy_NUL_trans, sizeof(%s)},\n", |
| mkdata( nultrans[i] ); |
(fullspd) ? "struct yy_trans_info*" : |
| } |
"flex_int32_t"); |
| |
|
| dataend(); |
yynultrans_tbl = |
| } |
(struct yytbl_data *) calloc (1, |
| |
sizeof (struct |
| |
yytbl_data)); |
| |
yytbl_data_init (yynultrans_tbl, YYTD_ID_NUL_TRANS); |
| |
if (fullspd) |
| |
yynultrans_tbl->td_flags |= YYTD_PTRANS; |
| |
yynultrans_tbl->td_lolen = lastdfa + 1; |
| |
yynultrans_tbl->td_data = yynultrans_data = |
| |
(flex_int32_t *) calloc (yynultrans_tbl->td_lolen, |
| |
sizeof (flex_int32_t)); |
| |
|
| if ( ddebug ) |
for (i = 1; i <= lastdfa; ++i) { |
| { /* Spit out table mapping rules to line numbers. */ |
if (fullspd) { |
| if ( ! C_plus_plus ) |
out_dec (" &yy_transition[%d],\n", |
| { |
base[i]); |
| indent_puts( "extern int yy_flex_debug;" ); |
yynultrans_data[i] = base[i]; |
| indent_puts( "int yy_flex_debug = 1;\n" ); |
|
| } |
} |
| |
else { |
| |
mkdata (nultrans[i]); |
| |
yynultrans_data[i] = nultrans[i]; |
| |
} |
| |
} |
| |
|
| out_str_dec( long_align ? C_long_decl : C_short_decl, |
dataend (); |
| "yy_rule_linenum", num_rules ); |
if (tablesext) { |
| for ( i = 1; i < num_rules; ++i ) |
yytbl_data_compress (yynultrans_tbl); |
| mkdata( rule_linenum[i] ); |
if (yytbl_data_fwrite (&tableswr, yynultrans_tbl) < |
| dataend(); |
0) |
| |
flexerror (_ |
| |
("Could not write yynultrans_tbl")); |
| |
yytbl_data_destroy (yynultrans_tbl); |
| |
yynultrans_tbl = NULL; |
| } |
} |
| |
/* End generating yy_NUL_trans */ |
| |
} |
| |
|
| if ( reject ) |
if (!C_plus_plus && !reentrant) { |
| { |
indent_puts ("extern int yy_flex_debug;"); |
| /* Declare state buffer variables. */ |
indent_put2s ("int yy_flex_debug = %s;\n", |
| if ( ! C_plus_plus ) |
ddebug ? "1" : "0"); |
| { |
} |
| 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 (ddebug) { /* Spit out table mapping rules to line numbers. */ |
| { |
out_str_dec (long_align ? get_int32_decl () : |
| if ( ! C_plus_plus ) |
get_int16_decl (), "yy_rule_linenum", |
| { |
num_rules); |
| outn( |
for (i = 1; i < num_rules; ++i) |
| "static int yy_looking_for_trail_begin = 0;" ); |
mkdata (rule_linenum[i]); |
| outn( "static int yy_full_lp;" ); |
dataend (); |
| outn( "static int *yy_full_state;" ); |
} |
| } |
|
| |
|
| out_hex( "#define YY_TRAILING_MASK 0x%x\n", |
if (reject) { |
| (unsigned int) YY_TRAILING_MASK ); |
outn ("m4_ifdef( [[M4_YY_USES_REJECT]],\n[["); |
| out_hex( "#define YY_TRAILING_HEAD_MASK 0x%x\n", |
/* Declare state buffer variables. */ |
| (unsigned int) YY_TRAILING_HEAD_MASK ); |
if (!C_plus_plus && !reentrant) { |
| } |
outn ("static yy_state_type *yy_state_buf=0, *yy_state_ptr=0;"); |
| |
outn ("static char *yy_full_match;"); |
| |
outn ("static int yy_lp;"); |
| |
} |
| |
|
| outn( "#define REJECT \\" ); |
if (variable_trailing_context_rules) { |
| outn( "{ \\" ); /* } for vi */ |
if (!C_plus_plus && !reentrant) { |
| outn( |
outn ("static int yy_looking_for_trail_begin = 0;"); |
| "*yy_cp = yy_hold_char; /* undo effects of setting up yytext */ \\" ); |
outn ("static int yy_full_lp;"); |
| outn( |
outn ("static int *yy_full_state;"); |
| "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; \\" ); |
out_hex ("#define YY_TRAILING_MASK 0x%x\n", |
| outn( "goto find_rule; \\" ); |
(unsigned int) YY_TRAILING_MASK); |
| /* { for vi */ |
out_hex ("#define YY_TRAILING_HEAD_MASK 0x%x\n", |
| outn( "}" ); |
(unsigned int) YY_TRAILING_HEAD_MASK); |
| } |
} |
| |
|
| else |
outn ("#define REJECT \\"); |
| { |
outn ("{ \\"); |
| outn( |
outn ("*yy_cp = YY_G(yy_hold_char); /* undo effects of setting up yytext */ \\"); |
| "/* The intent behind this definition is that it'll catch" ); |
outn ("yy_cp = YY_G(yy_full_match); /* restore poss. backed-over text */ \\"); |
| outn( " * any uses of REJECT which flex missed." ); |
|
| outn( " */" ); |
if (variable_trailing_context_rules) { |
| outn( "#define REJECT reject_used_but_not_detected" ); |
outn ("YY_G(yy_lp) = YY_G(yy_full_lp); /* restore orig. accepting pos. */ \\"); |
| |
outn ("YY_G(yy_state_ptr) = YY_G(yy_full_state); /* restore orig. state */ \\"); |
| |
outn ("yy_current_state = *YY_G(yy_state_ptr); /* restore curr. state */ \\"); |
| } |
} |
| |
|
| if ( yymore_used ) |
outn ("++YY_G(yy_lp); \\"); |
| { |
outn ("goto find_rule; \\"); |
| 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 ) |
outn ("}"); |
| { |
outn ("]])\n"); |
| indent_puts( |
} |
| "#define yymore() (yy_more_offset = yy_flex_strlen( yytext ))" ); |
|
| indent_puts( "#define YY_NEED_STRLEN" ); |
else { |
| indent_puts( "#define YY_MORE_ADJ 0" ); |
outn ("/* The intent behind this definition is that it'll catch"); |
| indent_puts( "#define YY_RESTORE_YY_MORE_OFFSET \\" ); |
outn (" * any uses of REJECT which flex missed."); |
| indent_up(); |
outn (" */"); |
| indent_puts( "{ \\" ); |
outn ("#define REJECT reject_used_but_not_detected"); |
| indent_puts( "yy_more_offset = yy_prev_more_offset; \\" ); |
} |
| indent_puts( "yyleng -= yy_more_offset; \\" ); |
|
| indent_puts( "}" ); |
if (yymore_used) { |
| indent_down(); |
if (!C_plus_plus) { |
| |
if (yytext_is_array) { |
| |
if (!reentrant){ |
| |
indent_puts ("static int yy_more_offset = 0;"); |
| |
indent_puts ("static int yy_prev_more_offset = 0;"); |
| |
} |
| } |
} |
| else |
else if (!reentrant) { |
| { |
indent_puts |
| indent_puts( "#define yymore() (yy_more_flag = 1)" ); |
("static int yy_more_flag = 0;"); |
| indent_puts( "#define YY_MORE_ADJ yy_more_len" ); |
indent_puts |
| indent_puts( "#define YY_RESTORE_YY_MORE_OFFSET" ); |
("static int yy_more_len = 0;"); |
| } |
} |
| } |
} |
| |
|
| else |
if (yytext_is_array) { |
| { |
indent_puts |
| indent_puts( "#define yymore() yymore_used_but_not_detected" ); |
("#define yymore() (YY_G(yy_more_offset) = yy_flex_strlen( yytext M4_YY_CALL_LAST_ARG))"); |
| indent_puts( "#define YY_MORE_ADJ 0" ); |
indent_puts ("#define YY_NEED_STRLEN"); |
| indent_puts( "#define YY_RESTORE_YY_MORE_OFFSET" ); |
indent_puts ("#define YY_MORE_ADJ 0"); |
| |
indent_puts |
| |
("#define YY_RESTORE_YY_MORE_OFFSET \\"); |
| |
indent_up (); |
| |
indent_puts ("{ \\"); |
| |
indent_puts |
| |
("YY_G(yy_more_offset) = YY_G(yy_prev_more_offset); \\"); |
| |
indent_puts ("yyleng -= YY_G(yy_more_offset); \\"); |
| |
indent_puts ("}"); |
| |
indent_down (); |
| } |
} |
| |
else { |
| |
indent_puts |
| |
("#define yymore() (YY_G(yy_more_flag) = 1)"); |
| |
indent_puts |
| |
("#define YY_MORE_ADJ YY_G(yy_more_len)"); |
| |
indent_puts ("#define YY_RESTORE_YY_MORE_OFFSET"); |
| |
} |
| |
} |
| |
|
| if ( ! C_plus_plus ) |
else { |
| { |
indent_puts |
| if ( yytext_is_array ) |
("#define yymore() yymore_used_but_not_detected"); |
| { |
indent_puts ("#define YY_MORE_ADJ 0"); |
| outn( "#ifndef YYLMAX" ); |
indent_puts ("#define YY_RESTORE_YY_MORE_OFFSET"); |
| outn( "#define YYLMAX 8192" ); |
} |
| outn( "#endif\n" ); |
|
| outn( "char yytext[YYLMAX];" ); |
|
| outn( "char *yytext_ptr;" ); |
|
| } |
|
| |
|
| else |
if (!C_plus_plus) { |
| outn( "char *yytext;" ); |
if (yytext_is_array) { |
| |
outn ("#ifndef YYLMAX"); |
| |
outn ("#define YYLMAX 8192"); |
| |
outn ("#endif\n"); |
| |
if (!reentrant){ |
| |
outn ("char yytext[YYLMAX];"); |
| |
outn ("char *yytext_ptr;"); |
| |
} |
| } |
} |
| |
|
| out( &action_array[defs1_offset] ); |
else { |
| |
if(! reentrant) |
| |
outn ("char *yytext;"); |
| |
} |
| |
} |
| |
|
| line_directive_out( stdout, 0 ); |
out (&action_array[defs1_offset]); |
| |
|
| skelout(); |
line_directive_out (stdout, 0); |
| |
|
| if ( ! C_plus_plus ) |
skelout (); /* %% [5.0] - break point in skel */ |
| { |
|
| 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 |
if (!C_plus_plus) { |
| { |
if (use_read) { |
| outn( |
outn ("\terrno=0; \\"); |
| "\tif ( yy_current_buffer->yy_is_interactive ) \\" ); |
outn ("\twhile ( (result = read( fileno(yyin), (char *) buf, max_size )) < 0 ) \\"); |
| outn( "\t\t{ \\" ); |
outn ("\t{ \\"); |
| outn( "\t\tint c = '*', n; \\" ); |
outn ("\t\tif( errno != EINTR) \\"); |
| outn( "\t\tfor ( n = 0; n < max_size && \\" ); |
outn ("\t\t{ \\"); |
| outn( "\t\t\t (c = getc( yyin )) != EOF && c != '\\n'; ++n ) \\" ); |
outn ("\t\t\tYY_FATAL_ERROR( \"input in flex scanner failed\" ); \\"); |
| outn( "\t\t\tbuf[n] = (char) c; \\" ); |
outn ("\t\t\tbreak; \\"); |
| outn( "\t\tif ( c == '\\n' ) \\" ); |
outn ("\t\t} \\"); |
| outn( "\t\t\tbuf[n++] = (char) c; \\" ); |
outn ("\t\terrno=0; \\"); |
| outn( "\t\tif ( c == EOF && ferror( yyin ) ) \\" ); |
outn ("\t\tclearerr(yyin); \\"); |
| outn( |
outn ("\t}\\"); |
| "\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(); |
else { |
| |
outn ("\tif ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \\"); |
| indent_puts( "#define YY_RULE_SETUP \\" ); |
outn ("\t\t{ \\"); |
| indent_up(); |
outn ("\t\tint c = '*'; \\"); |
| if ( bol_needed ) |
outn ("\t\tsize_t n; \\"); |
| { |
outn ("\t\tfor ( n = 0; n < max_size && \\"); |
| indent_puts( "if ( yyleng > 0 ) \\" ); |
outn ("\t\t\t (c = getc( yyin )) != EOF && c != '\\n'; ++n ) \\"); |
| indent_up(); |
outn ("\t\t\tbuf[n] = (char) c; \\"); |
| indent_puts( "yy_current_buffer->yy_at_bol = \\" ); |
outn ("\t\tif ( c == '\\n' ) \\"); |
| indent_puts( "\t\t(yytext[yyleng - 1] == '\\n'); \\" ); |
outn ("\t\t\tbuf[n++] = (char) c; \\"); |
| indent_down(); |
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 \\"); |
| |
outn ("\t\t{ \\"); |
| |
outn ("\t\terrno=0; \\"); |
| |
outn ("\t\twhile ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \\"); |
| |
outn ("\t\t\t{ \\"); |
| |
outn ("\t\t\tif( errno != EINTR) \\"); |
| |
outn ("\t\t\t\t{ \\"); |
| |
outn ("\t\t\t\tYY_FATAL_ERROR( \"input in flex scanner failed\" ); \\"); |
| |
outn ("\t\t\t\tbreak; \\"); |
| |
outn ("\t\t\t\t} \\"); |
| |
outn ("\t\t\terrno=0; \\"); |
| |
outn ("\t\t\tclearerr(yyin); \\"); |
| |
outn ("\t\t\t} \\"); |
| |
outn ("\t\t}\\"); |
| } |
} |
| indent_puts( "YY_USER_ACTION" ); |
} |
| indent_down(); |
|
| |
|
| skelout(); |
skelout (); /* %% [6.0] - break point in skel */ |
| |
|
| |
indent_puts ("#define YY_RULE_SETUP \\"); |
| |
indent_up (); |
| |
if (bol_needed) { |
| |
indent_puts ("if ( yyleng > 0 ) \\"); |
| |
indent_up (); |
| |
indent_puts ("YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \\"); |
| |
indent_puts ("\t\t(yytext[yyleng - 1] == '\\n'); \\"); |
| |
indent_down (); |
| |
} |
| |
indent_puts ("YY_USER_ACTION"); |
| |
indent_down (); |
| |
|
| |
skelout (); /* %% [7.0] - break point in skel */ |
| |
|
| /* Copy prolog to output file. */ |
/* Copy prolog to output file. */ |
| out( &action_array[prolog_offset] ); |
out (&action_array[prolog_offset]); |
| |
|
| line_directive_out( stdout, 0 ); |
line_directive_out (stdout, 0); |
| |
|
| skelout(); |
skelout (); /* %% [8.0] - break point in skel */ |
| |
|
| set_indent( 2 ); |
set_indent (2); |
| |
|
| if ( yymore_used && ! yytext_is_array ) |
if (yymore_used && !yytext_is_array) { |
| { |
indent_puts ("YY_G(yy_more_len) = 0;"); |
| indent_puts( "yy_more_len = 0;" ); |
indent_puts ("if ( YY_G(yy_more_flag) )"); |
| indent_puts( "if ( yy_more_flag )" ); |
indent_up (); |
| indent_up(); |
indent_puts ("{"); |
| indent_puts( "{" ); |
indent_puts |
| indent_puts( "yy_more_len = yy_c_buf_p - yytext_ptr;" ); |
("YY_G(yy_more_len) = YY_G(yy_c_buf_p) - YY_G(yytext_ptr);"); |
| indent_puts( "yy_more_flag = 0;" ); |
indent_puts ("YY_G(yy_more_flag) = 0;"); |
| indent_puts( "}" ); |
indent_puts ("}"); |
| indent_down(); |
indent_down (); |
| } |
} |
| |
|
| skelout(); |
skelout (); /* %% [9.0] - break point in skel */ |
| |
|
| gen_start_state(); |
gen_start_state (); |
| |
|
| /* Note, don't use any indentation. */ |
/* Note, don't use any indentation. */ |
| outn( "yy_match:" ); |
outn ("yy_match:"); |
| gen_next_match(); |
gen_next_match (); |
| |
|
| skelout(); |
skelout (); /* %% [10.0] - break point in skel */ |
| set_indent( 2 ); |
set_indent (2); |
| gen_find_action(); |
gen_find_action (); |
| |
|
| skelout(); |
skelout (); /* %% [11.0] - break point in skel */ |
| if ( do_yylineno ) |
outn ("m4_ifdef( [[M4_YY_USE_LINENO]],[["); |
| { |
indent_puts |
| indent_puts( "if ( yy_act != YY_END_OF_BUFFER )" ); |
("if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] )"); |
| indent_up(); |
indent_up (); |
| indent_puts( "{" ); |
indent_puts ("{"); |
| indent_puts( "int yyl;" ); |
indent_puts ("yy_size_t yyl;"); |
| indent_puts( "for ( yyl = 0; yyl < yyleng; ++yyl )" ); |
do_indent (); |
| indent_up(); |
out_str ("for ( yyl = %s; yyl < yyleng; ++yyl )\n", |
| indent_puts( "if ( yytext[yyl] == '\\n' )" ); |
yymore_used ? (yytext_is_array ? "YY_G(yy_prev_more_offset)" : |
| indent_up(); |
"YY_G(yy_more_len)") : "0"); |
| indent_puts( "++yylineno;" ); |
indent_up (); |
| indent_down(); |
indent_puts ("if ( yytext[yyl] == '\\n' )"); |
| indent_down(); |
indent_up (); |
| indent_puts( "}" ); |
indent_puts ("M4_YY_INCR_LINENO();"); |
| indent_down(); |
indent_down (); |
| } |
indent_down (); |
| |
indent_puts ("}"); |
| |
indent_down (); |
| |
outn ("]])"); |
| |
|
| skelout(); |
skelout (); /* %% [12.0] - break point in skel */ |
| if ( ddebug ) |
if (ddebug) { |
| { |
indent_puts ("if ( yy_flex_debug )"); |
| indent_puts( "if ( yy_flex_debug )" ); |
indent_up (); |
| indent_up(); |
|
| |
|
| indent_puts( "{" ); |
indent_puts ("{"); |
| indent_puts( "if ( yy_act == 0 )" ); |
indent_puts ("if ( yy_act == 0 )"); |
| indent_up(); |
indent_up (); |
| indent_puts( C_plus_plus ? |
indent_puts (C_plus_plus ? |
| "std::cerr << \"--scanner backing up\\n\";" : |
"std::cerr << \"--scanner backing up\\n\";" : |
| "fprintf( stderr, \"--scanner backing up\\n\" );" ); |
"fprintf( stderr, \"--scanner backing up\\n\" );"); |
| indent_down(); |
indent_down (); |
| |
|
| do_indent(); |
do_indent (); |
| out_dec( "else if ( yy_act < %d )\n", num_rules ); |
out_dec ("else if ( yy_act < %d )\n", num_rules); |
| indent_up(); |
indent_up (); |
| |
|
| if ( C_plus_plus ) |
if (C_plus_plus) { |
| { |
indent_puts |
| indent_puts( |
("std::cerr << \"--accepting rule at line \" << yy_rule_linenum[yy_act] <<"); |
| "std::cerr << \"--accepting rule at line \" << yy_rule_linenum[yy_act] <<" ); |
indent_puts |
| indent_puts( |
(" \"(\\\"\" << yytext << \"\\\")\\n\";"); |
| " \"(\\\"\" << yytext << \"\\\")\\n\";" ); |
} |
| } |
else { |
| else |
indent_puts |
| { |
("fprintf( stderr, \"--accepting rule at line %ld (\\\"%s\\\")\\n\","); |
| indent_puts( |
|
| "fprintf( stderr, \"--accepting rule at line %d (\\\"%s\\\")\\n\"," ); |
|
| |
|
| indent_puts( |
indent_puts |
| " yy_rule_linenum[yy_act], yytext );" ); |
(" (long)yy_rule_linenum[yy_act], yytext );"); |
| } |
} |
| |
|
| indent_down(); |
indent_down (); |
| |
|
| do_indent(); |
do_indent (); |
| out_dec( "else if ( yy_act == %d )\n", num_rules ); |
out_dec ("else if ( yy_act == %d )\n", num_rules); |
| indent_up(); |
indent_up (); |
| |
|
| if ( C_plus_plus ) |
if (C_plus_plus) { |
| { |
indent_puts |
| indent_puts( |
("std::cerr << \"--accepting default rule (\\\"\" << yytext << \"\\\")\\n\";"); |
| "std::cerr << \"--accepting default rule (\\\"\" << yytext << \"\\\")\\n\";" ); |
} |
| } |
else { |
| else |
indent_puts |
| { |
("fprintf( stderr, \"--accepting default rule (\\\"%s\\\")\\n\","); |
| indent_puts( |
indent_puts (" yytext );"); |
| "fprintf( stderr, \"--accepting default rule (\\\"%s\\\")\\n\"," ); |
} |
| indent_puts( " yytext );" ); |
|
| } |
|
| |
|
| indent_down(); |
indent_down (); |
| |
|
| do_indent(); |
do_indent (); |
| out_dec( "else if ( yy_act == %d )\n", num_rules + 1 ); |
out_dec ("else if ( yy_act == %d )\n", num_rules + 1); |
| indent_up(); |
indent_up (); |
| |
|
| indent_puts( C_plus_plus ? |
indent_puts (C_plus_plus ? |
| "std::cerr << \"--(end of buffer or a NUL)\\n\";" : |
"std::cerr << \"--(end of buffer or a NUL)\\n\";" : |
| "fprintf( stderr, \"--(end of buffer or a NUL)\\n\" );" ); |
"fprintf( stderr, \"--(end of buffer or a NUL)\\n\" );"); |
| |
|
| indent_down(); |
indent_down (); |
| |
|
| do_indent(); |
do_indent (); |
| outn( "else" ); |
outn ("else"); |
| indent_up(); |
indent_up (); |
| |
|
| if ( C_plus_plus ) |
if (C_plus_plus) { |
| { |
indent_puts |
| indent_puts( |
("std::cerr << \"--EOF (start condition \" << YY_START << \")\\n\";"); |
| "std::cerr << \"--EOF (start condition \" << YY_START << \")\\n\";" ); |
} |
| } |
else { |
| else |
indent_puts |
| { |
("fprintf( stderr, \"--EOF (start condition %d)\\n\", YY_START );"); |
| indent_puts( |
} |
| "fprintf( stderr, \"--EOF (start condition %d)\\n\", YY_START );" ); |
|
| } |
|
| |
|
| indent_down(); |
indent_down (); |
| |
|
| indent_puts( "}" ); |
indent_puts ("}"); |
| indent_down(); |
indent_down (); |
| } |
} |
| |
|
| /* Copy actions to output file. */ |
/* Copy actions to output file. */ |
| skelout(); |
skelout (); /* %% [13.0] - break point in skel */ |
| indent_up(); |
indent_up (); |
| gen_bu_action(); |
gen_bu_action (); |
| out( &action_array[action_offset] ); |
out (&action_array[action_offset]); |
| |
|
| line_directive_out( stdout, 0 ); |
line_directive_out (stdout, 0); |
| |
|
| /* generate cases for any missing EOF rules */ |
/* generate cases for any missing EOF rules */ |
| for ( i = 1; i <= lastsc; ++i ) |
for (i = 1; i <= lastsc; ++i) |
| if ( ! sceof[i] ) |
if (!sceof[i]) { |
| { |
do_indent (); |
| do_indent(); |
out_str ("case YY_STATE_EOF(%s):\n", scname[i]); |
| out_str( "case YY_STATE_EOF(%s):\n", scname[i] ); |
|
| did_eof_rule = true; |
did_eof_rule = true; |
| } |
|
| |
|
| if ( did_eof_rule ) |
|
| { |
|
| indent_up(); |
|
| indent_puts( "yyterminate();" ); |
|
| indent_down(); |
|
| } |
} |
| |
|
| |
if (did_eof_rule) { |
| |
indent_up (); |
| |
indent_puts ("yyterminate();"); |
| |
indent_down (); |
| |
} |
| |
|
| |
|
| /* Generate code for handling NUL's, if needed. */ |
/* Generate code for handling NUL's, if needed. */ |
| |
|
| /* First, deal with backing up and setting up yy_cp if the scanner |
/* First, deal with backing up and setting up yy_cp if the scanner |
| * finds that it should JAM on the NUL. |
* finds that it should JAM on the NUL. |
| */ |
*/ |
| skelout(); |
skelout (); /* %% [14.0] - break point in skel */ |
| set_indent( 4 ); |
set_indent (4); |
| |
|
| if ( fullspd || fulltbl ) |
if (fullspd || fulltbl) |
| indent_puts( "yy_cp = yy_c_buf_p;" ); |
indent_puts ("yy_cp = YY_G(yy_c_buf_p);"); |
| |
|
| else |
else { /* compressed table */ |
| { /* compressed table */ |
if (!reject && !interactive) { |
| if ( ! reject && ! interactive ) |
|
| { |
|
| /* Do the guaranteed-needed backing up to figure |
/* Do the guaranteed-needed backing up to figure |
| * out the match. |
* out the match. |
| */ |
*/ |
| indent_puts( "yy_cp = yy_last_accepting_cpos;" ); |
indent_puts |
| indent_puts( |
("yy_cp = YY_G(yy_last_accepting_cpos);"); |
| "yy_current_state = yy_last_accepting_state;" ); |
indent_puts |
| } |
("yy_current_state = YY_G(yy_last_accepting_state);"); |
| |
} |
| |
|
| else |
else |
| /* Still need to initialize yy_cp, though |
/* Still need to initialize yy_cp, though |
| * yy_current_state was set up by |
* yy_current_state was set up by |
| * yy_get_previous_state(). |
* yy_get_previous_state(). |
| */ |
*/ |
| indent_puts( "yy_cp = yy_c_buf_p;" ); |
indent_puts ("yy_cp = YY_G(yy_c_buf_p);"); |
| } |
} |
| |
|
| |
|
| /* Generate code for yy_get_previous_state(). */ |
/* Generate code for yy_get_previous_state(). */ |
| set_indent( 1 ); |
set_indent (1); |
| skelout(); |
skelout (); /* %% [15.0] - break point in skel */ |
| |
|
| gen_start_state(); |
gen_start_state (); |
| |
|
| set_indent( 2 ); |
set_indent (2); |
| skelout(); |
skelout (); /* %% [16.0] - break point in skel */ |
| gen_next_state( true ); |
gen_next_state (true); |
| |
|
| set_indent( 1 ); |
set_indent (1); |
| skelout(); |
skelout (); /* %% [17.0] - break point in skel */ |
| gen_NUL_trans(); |
gen_NUL_trans (); |
| |
|
| skelout(); |
skelout (); /* %% [18.0] - break point in skel */ |
| if ( do_yylineno ) |
skelout (); /* %% [19.0] - break point in skel */ |
| { /* 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(). */ |
/* Update BOL and yylineno inside of input(). */ |
| if ( bol_needed ) |
if (bol_needed) { |
| { |
indent_puts |
| indent_puts( "yy_current_buffer->yy_at_bol = (c == '\\n');" ); |
("YY_CURRENT_BUFFER_LVALUE->yy_at_bol = (c == '\\n');"); |
| if ( do_yylineno ) |
if (do_yylineno) { |
| { |
indent_puts |
| indent_puts( "if ( yy_current_buffer->yy_at_bol )" ); |
("if ( YY_CURRENT_BUFFER_LVALUE->yy_at_bol )"); |
| indent_up(); |
indent_up (); |
| indent_puts( "++yylineno;" ); |
indent_puts ("M4_YY_INCR_LINENO();"); |
| indent_down(); |
indent_down (); |
| } |
|
| } |
} |
| |
} |
| |
|
| else if ( do_yylineno ) |
else if (do_yylineno) { |
| { |
indent_puts ("if ( c == '\\n' )"); |
| indent_puts( "if ( c == '\\n' )" ); |
indent_up (); |
| indent_up(); |
indent_puts ("M4_YY_INCR_LINENO();"); |
| indent_puts( "++yylineno;" ); |
indent_down (); |
| indent_down(); |
} |
| } |
|
| |
|
| skelout(); |
skelout (); |
| |
|
| /* Copy remainder of input to output. */ |
/* Copy remainder of input to output. */ |
| |
|
| line_directive_out( stdout, 1 ); |
line_directive_out (stdout, 1); |
| |
|
| if ( sectnum == 3 ) |
if (sectnum == 3) { |
| (void) flexscan(); /* copy remainder of input to output */ |
OUT_BEGIN_CODE (); |
| |
(void) flexscan (); /* copy remainder of input to output */ |
| |
OUT_END_CODE (); |
| } |
} |
| |
} |
![[BACK]](/icons/back.gif){kind=icon}
Return to gen.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / usr.bin / lex