#include "flexdef.h"
-/* ccladd - add a single character to a ccl
- *
- * synopsis
- * int cclp;
- * int ch;
- * ccladd( cclp, ch );
- */
+/* ccladd - add a single character to a ccl */
void ccladd( cclp, ch )
int cclp;
int ch;
+ {
+ int ind, len, newpos, i;
- {
- int ind, len, newpos, i;
+ len = ccllen[cclp];
+ ind = cclmap[cclp];
- len = ccllen[cclp];
- ind = cclmap[cclp];
+ /* check to see if the character is already in the ccl */
- /* check to see if the character is already in the ccl */
+ for ( i = 0; i < len; ++i )
+ if ( ccltbl[ind + i] == ch )
+ return;
- for ( i = 0; i < len; ++i )
- if ( ccltbl[ind + i] == ch )
- return;
+ newpos = ind + len;
- newpos = ind + len;
+ if ( newpos >= current_max_ccl_tbl_size )
+ {
+ current_max_ccl_tbl_size += MAX_CCL_TBL_SIZE_INCREMENT;
- if ( newpos >= current_max_ccl_tbl_size )
- {
- current_max_ccl_tbl_size += MAX_CCL_TBL_SIZE_INCREMENT;
+ ++num_reallocs;
- ++num_reallocs;
+ ccltbl = reallocate_Character_array( ccltbl,
+ current_max_ccl_tbl_size );
+ }
- ccltbl = reallocate_Character_array( ccltbl, current_max_ccl_tbl_size );
+ ccllen[cclp] = len + 1;
+ ccltbl[newpos] = ch;
}
- ccllen[cclp] = len + 1;
- ccltbl[newpos] = ch;
- }
-
-/* cclinit - make an empty ccl
- *
- * synopsis
- * int cclinit();
- * new_ccl = cclinit();
- */
+/* cclinit - return an empty ccl */
int cclinit()
-
- {
- if ( ++lastccl >= current_maxccls )
{
- current_maxccls += MAX_CCLS_INCREMENT;
+ if ( ++lastccl >= current_maxccls )
+ {
+ current_maxccls += MAX_CCLS_INCREMENT;
- ++num_reallocs;
+ ++num_reallocs;
- cclmap = reallocate_integer_array( cclmap, current_maxccls );
- ccllen = reallocate_integer_array( ccllen, current_maxccls );
- cclng = reallocate_integer_array( cclng, current_maxccls );
- }
+ cclmap = reallocate_integer_array( cclmap, current_maxccls );
+ ccllen = reallocate_integer_array( ccllen, current_maxccls );
+ cclng = reallocate_integer_array( cclng, current_maxccls );
+ }
- if ( lastccl == 1 )
- /* we're making the first ccl */
- cclmap[lastccl] = 0;
+ if ( lastccl == 1 )
+ /* we're making the first ccl */
+ cclmap[lastccl] = 0;
- else
- /* the new pointer is just past the end of the last ccl. Since
- * the cclmap points to the \first/ character of a ccl, adding the
- * length of the ccl to the cclmap pointer will produce a cursor
- * to the first free space
- */
- cclmap[lastccl] = cclmap[lastccl - 1] + ccllen[lastccl - 1];
+ else
+ /* The new pointer is just past the end of the last ccl.
+ * Since the cclmap points to the \first/ character of a
+ * ccl, adding the length of the ccl to the cclmap pointer
+ * will produce a cursor to the first free space.
+ */
+ cclmap[lastccl] = cclmap[lastccl - 1] + ccllen[lastccl - 1];
- ccllen[lastccl] = 0;
- cclng[lastccl] = 0; /* ccl's start out life un-negated */
+ ccllen[lastccl] = 0;
+ cclng[lastccl] = 0; /* ccl's start out life un-negated */
- return ( lastccl );
- }
+ return lastccl;
+ }
-/* cclnegate - negate a ccl
- *
- * synopsis
- * int cclp;
- * cclnegate( ccl );
- */
+/* cclnegate - negate the given ccl */
void cclnegate( cclp )
int cclp;
-
- {
- cclng[cclp] = 1;
- }
+ {
+ cclng[cclp] = 1;
+ }
/* list_character_set - list the members of a set of characters in CCL form
*
- * synopsis
- * int cset[CSIZE];
- * FILE *file;
- * list_character_set( cset );
- *
- * writes to the given file a character-class representation of those
- * characters present in the given set. A character is present if it
- * has a non-zero value in the set array.
+ * Writes to the given file a character-class representation of those
+ * characters present in the given CCL. A character is present if it
+ * has a non-zero value in the cset array.
*/
void list_character_set( file, cset )
FILE *file;
int cset[];
+ {
+ char *readable_form();
+ register int i;
- {
- register int i;
- char *readable_form();
+ putc( '[', file );
- putc( '[', file );
+ for ( i = 0; i < csize; ++i )
+ {
+ if ( cset[i] )
+ {
+ register int start_char = i;
- for ( i = 0; i < csize; ++i )
- {
- if ( cset[i] )
- {
- register int start_char = i;
+ putc( ' ', file );
- putc( ' ', file );
+ fputs( readable_form( i ), file );
- fputs( readable_form( i ), file );
+ while ( ++i < csize && cset[i] )
+ ;
- while ( ++i < csize && cset[i] )
- ;
+ if ( i - 1 > start_char )
+ /* this was a run */
+ fprintf( file, "-%s", readable_form( i - 1 ) );
- if ( i - 1 > start_char )
- /* this was a run */
- fprintf( file, "-%s", readable_form( i - 1 ) );
+ putc( ' ', file );
+ }
+ }
- putc( ' ', file );
- }
+ putc( ']', file );
}
-
- putc( ']', file );
- }
/* check_for_backtracking - check a DFA state for backtracking
*
* synopsis
- * int ds, state[numecs];
- * check_for_backtracking( ds, state );
+ * void check_for_backtracking( int ds, int state[numecs] );
*
* ds is the number of the state to check and state[] is its out-transitions,
- * indexed by equivalence class, and state_rules[] is the set of rules
- * associated with this state
+ * indexed by equivalence class.
*/
void check_for_backtracking( ds, state )
int ds;
int state[];
+ {
+ if ( (reject && ! dfaacc[ds].dfaacc_set) || ! dfaacc[ds].dfaacc_state )
+ { /* state is non-accepting */
+ ++num_backtracking;
- {
- if ( (reject && ! dfaacc[ds].dfaacc_set) || ! dfaacc[ds].dfaacc_state )
- { /* state is non-accepting */
- ++num_backtracking;
-
- if ( backtrack_report )
- {
- fprintf( backtrack_file, "State #%d is non-accepting -\n", ds );
+ if ( backtrack_report )
+ {
+ fprintf( backtrack_file,
+ "State #%d is non-accepting -\n", ds );
- /* identify the state */
- dump_associated_rules( backtrack_file, ds );
+ /* identify the state */
+ dump_associated_rules( backtrack_file, ds );
- /* now identify it further using the out- and jam-transitions */
- dump_transitions( backtrack_file, state );
+ /* Now identify it further using the out- and
+ * jam-transitions.
+ */
+ dump_transitions( backtrack_file, state );
- putc( '\n', backtrack_file );
- }
+ putc( '\n', backtrack_file );
+ }
+ }
}
- }
/* check_trailing_context - check to see if NFA state set constitutes
* "dangerous" trailing context
*
* synopsis
- * int nfa_states[num_states+1], num_states;
- * int accset[nacc+1], nacc;
- * check_trailing_context( nfa_states, num_states, accset, nacc );
+ * void check_trailing_context( int nfa_states[num_states+1], int num_states,
+ * int accset[nacc+1], int nacc );
*
* NOTES
- * Trailing context is "dangerous" if both the head and the trailing
+ * Trailing context is "dangerous" if both the head and the trailing
* part are of variable size \and/ there's a DFA state which contains
* both an accepting state for the head part of the rule and NFA states
* which occur after the beginning of the trailing context.
+ *
* When such a rule is matched, it's impossible to tell if having been
- * in the DFA state indicates the beginning of the trailing context
- * or further-along scanning of the pattern. In these cases, a warning
+ * in the DFA state indicates the beginning of the trailing context or
+ * further-along scanning of the pattern. In these cases, a warning
* message is issued.
*
* nfa_states[1 .. num_states] is the list of NFA states in the DFA.
int *nfa_states, num_states;
int *accset;
register int nacc;
+ {
+ register int i, j;
- {
- register int i, j;
+ for ( i = 1; i <= num_states; ++i )
+ {
+ int ns = nfa_states[i];
+ register int type = state_type[ns];
+ register int ar = assoc_rule[ns];
- for ( i = 1; i <= num_states; ++i )
- {
- int ns = nfa_states[i];
- register int type = state_type[ns];
- register int ar = assoc_rule[ns];
-
- if ( type == STATE_NORMAL || rule_type[ar] != RULE_VARIABLE )
- { /* do nothing */
- }
-
- else if ( type == STATE_TRAILING_CONTEXT )
- {
- /* potential trouble. Scan set of accepting numbers for
- * the one marking the end of the "head". We assume that
- * this looping will be fairly cheap since it's rare that
- * an accepting number set is large.
- */
- for ( j = 1; j <= nacc; ++j )
- if ( accset[j] & YY_TRAILING_HEAD_MASK )
- {
- line_warning( "dangerous trailing context",
- rule_linenum[ar] );
- return;
- }
- }
+ if ( type == STATE_NORMAL || rule_type[ar] != RULE_VARIABLE )
+ { /* do nothing */
+ }
+
+ else if ( type == STATE_TRAILING_CONTEXT )
+ {
+ /* Potential trouble. Scan set of accepting numbers
+ * for the one marking the end of the "head". We
+ * assume that this looping will be fairly cheap
+ * since it's rare that an accepting number set
+ * is large.
+ */
+ for ( j = 1; j <= nacc; ++j )
+ if ( accset[j] & YY_TRAILING_HEAD_MASK )
+ {
+ line_warning(
+ "dangerous trailing context",
+ rule_linenum[ar] );
+ return;
+ }
+ }
+ }
}
- }
/* dump_associated_rules - list the rules associated with a DFA state
*
- * synopsis
- * int ds;
- * FILE *file;
- * dump_associated_rules( file, ds );
- *
- * goes through the set of NFA states associated with the DFA and
+ * Goes through the set of NFA states associated with the DFA and
* extracts the first MAX_ASSOC_RULES unique rules, sorts them,
- * and writes a report to the given file
+ * and writes a report to the given file.
*/
void dump_associated_rules( file, ds )
FILE *file;
int ds;
-
- {
- register int i, j;
- register int num_associated_rules = 0;
- int rule_set[MAX_ASSOC_RULES + 1];
- int *dset = dss[ds];
- int size = dfasiz[ds];
-
- for ( i = 1; i <= size; ++i )
{
- register int rule_num = rule_linenum[assoc_rule[dset[i]]];
+ register int i, j;
+ register int num_associated_rules = 0;
+ int rule_set[MAX_ASSOC_RULES + 1];
+ int *dset = dss[ds];
+ int size = dfasiz[ds];
- for ( j = 1; j <= num_associated_rules; ++j )
- if ( rule_num == rule_set[j] )
- break;
+ for ( i = 1; i <= size; ++i )
+ {
+ register int rule_num = rule_linenum[assoc_rule[dset[i]]];
- if ( j > num_associated_rules )
- { /* new rule */
- if ( num_associated_rules < MAX_ASSOC_RULES )
- rule_set[++num_associated_rules] = rule_num;
- }
- }
+ for ( j = 1; j <= num_associated_rules; ++j )
+ if ( rule_num == rule_set[j] )
+ break;
- bubble( rule_set, num_associated_rules );
+ if ( j > num_associated_rules )
+ { /* new rule */
+ if ( num_associated_rules < MAX_ASSOC_RULES )
+ rule_set[++num_associated_rules] = rule_num;
+ }
+ }
- fprintf( file, " associated rule line numbers:" );
+ bubble( rule_set, num_associated_rules );
- for ( i = 1; i <= num_associated_rules; ++i )
- {
- if ( i % 8 == 1 )
- putc( '\n', file );
-
- fprintf( file, "\t%d", rule_set[i] );
+ fprintf( file, " associated rule line numbers:" );
+
+ for ( i = 1; i <= num_associated_rules; ++i )
+ {
+ if ( i % 8 == 1 )
+ putc( '\n', file );
+
+ fprintf( file, "\t%d", rule_set[i] );
+ }
+
+ putc( '\n', file );
}
-
- putc( '\n', file );
- }
/* dump_transitions - list the transitions associated with a DFA state
*
* synopsis
- * int state[numecs];
- * FILE *file;
- * dump_transitions( file, state );
+ * dump_transitions( FILE *file, int state[numecs] );
*
- * goes through the set of out-transitions and lists them in human-readable
+ * Goes through the set of out-transitions and lists them in human-readable
* form (i.e., not as equivalence classes); also lists jam transitions
* (i.e., all those which are not out-transitions, plus EOF). The dump
* is done to the given file.
void dump_transitions( file, state )
FILE *file;
int state[];
+ {
+ register int i, ec;
+ int out_char_set[CSIZE];
- {
- register int i, ec;
- int out_char_set[CSIZE];
+ for ( i = 0; i < csize; ++i )
+ {
+ ec = abs( ecgroup[i] );
+ out_char_set[i] = state[ec];
+ }
- for ( i = 0; i < csize; ++i )
- {
- ec = abs( ecgroup[i] );
- out_char_set[i] = state[ec];
- }
-
- fprintf( file, " out-transitions: " );
+ fprintf( file, " out-transitions: " );
- list_character_set( file, out_char_set );
+ list_character_set( file, out_char_set );
- /* now invert the members of the set to get the jam transitions */
- for ( i = 0; i < csize; ++i )
- out_char_set[i] = ! out_char_set[i];
+ /* now invert the members of the set to get the jam transitions */
+ for ( i = 0; i < csize; ++i )
+ out_char_set[i] = ! out_char_set[i];
- fprintf( file, "\n jam-transitions: EOF " );
+ fprintf( file, "\n jam-transitions: EOF " );
- list_character_set( file, out_char_set );
+ list_character_set( file, out_char_set );
- putc( '\n', file );
- }
+ putc( '\n', file );
+ }
/* epsclosure - construct the epsilon closure of a set of ndfa states
*
* synopsis
- * int t[current_max_dfa_size], numstates, accset[num_rules + 1], nacc;
- * int hashval;
- * int *epsclosure();
- * t = epsclosure( t, &numstates, accset, &nacc, &hashval );
+ * int *epsclosure( int t[num_states], int *numstates_addr,
+ * int accset[num_rules+1], int *nacc_addr,
+ * int *hashval_addr );
*
* NOTES
- * the epsilon closure is the set of all states reachable by an arbitrary
- * number of epsilon transitions which themselves do not have epsilon
+ * The epsilon closure is the set of all states reachable by an arbitrary
+ * number of epsilon transitions, which themselves do not have epsilon
* transitions going out, unioned with the set of states which have non-null
* accepting numbers. t is an array of size numstates of nfa state numbers.
- * Upon return, t holds the epsilon closure and numstates is updated. accset
- * holds a list of the accepting numbers, and the size of accset is given
- * by nacc. t may be subjected to reallocation if it is not large enough
- * to hold the epsilon closure.
+ * Upon return, t holds the epsilon closure and *numstates_addr is updated.
+ * accset holds a list of the accepting numbers, and the size of accset is
+ * given by *nacc_addr. t may be subjected to reallocation if it is not
+ * large enough to hold the epsilon closure.
*
- * hashval is the hash value for the dfa corresponding to the state set
+ * hashval is the hash value for the dfa corresponding to the state set.
*/
int *epsclosure( t, ns_addr, accset, nacc_addr, hv_addr )
int *t, *ns_addr, accset[], *nacc_addr, *hv_addr;
-
- {
- register int stkpos, ns, tsp;
- int numstates = *ns_addr, nacc, hashval, transsym, nfaccnum;
- int stkend, nstate;
- static int did_stk_init = false, *stk;
+ {
+ register int stkpos, ns, tsp;
+ int numstates = *ns_addr, nacc, hashval, transsym, nfaccnum;
+ int stkend, nstate;
+ static int did_stk_init = false, *stk;
#define MARK_STATE(state) \
- trans1[state] = trans1[state] - MARKER_DIFFERENCE;
+trans1[state] = trans1[state] - MARKER_DIFFERENCE;
#define IS_MARKED(state) (trans1[state] < 0)
#define UNMARK_STATE(state) \
- trans1[state] = trans1[state] + MARKER_DIFFERENCE;
+trans1[state] = trans1[state] + MARKER_DIFFERENCE;
#define CHECK_ACCEPT(state) \
- { \
- nfaccnum = accptnum[state]; \
- if ( nfaccnum != NIL ) \
- accset[++nacc] = nfaccnum; \
- }
+{ \
+nfaccnum = accptnum[state]; \
+if ( nfaccnum != NIL ) \
+accset[++nacc] = nfaccnum; \
+}
#define DO_REALLOCATION \
- { \
- current_max_dfa_size += MAX_DFA_SIZE_INCREMENT; \
- ++num_reallocs; \
- t = reallocate_integer_array( t, current_max_dfa_size ); \
- stk = reallocate_integer_array( stk, current_max_dfa_size ); \
- } \
+{ \
+current_max_dfa_size += MAX_DFA_SIZE_INCREMENT; \
+++num_reallocs; \
+t = reallocate_integer_array( t, current_max_dfa_size ); \
+stk = reallocate_integer_array( stk, current_max_dfa_size ); \
+} \
#define PUT_ON_STACK(state) \
- { \
- if ( ++stkend >= current_max_dfa_size ) \
- DO_REALLOCATION \
- stk[stkend] = state; \
- MARK_STATE(state) \
- }
+{ \
+if ( ++stkend >= current_max_dfa_size ) \
+DO_REALLOCATION \
+stk[stkend] = state; \
+MARK_STATE(state) \
+}
#define ADD_STATE(state) \
- { \
- if ( ++numstates >= current_max_dfa_size ) \
- DO_REALLOCATION \
- t[numstates] = state; \
- hashval = hashval + state; \
- }
+{ \
+if ( ++numstates >= current_max_dfa_size ) \
+DO_REALLOCATION \
+t[numstates] = state; \
+hashval = hashval + state; \
+}
#define STACK_STATE(state) \
- { \
- PUT_ON_STACK(state) \
- CHECK_ACCEPT(state) \
- if ( nfaccnum != NIL || transchar[state] != SYM_EPSILON ) \
- ADD_STATE(state) \
- }
+{ \
+PUT_ON_STACK(state) \
+CHECK_ACCEPT(state) \
+if ( nfaccnum != NIL || transchar[state] != SYM_EPSILON ) \
+ADD_STATE(state) \
+}
- if ( ! did_stk_init )
- {
- stk = allocate_integer_array( current_max_dfa_size );
- did_stk_init = true;
- }
- nacc = stkend = hashval = 0;
-
- for ( nstate = 1; nstate <= numstates; ++nstate )
- {
- ns = t[nstate];
+ if ( ! did_stk_init )
+ {
+ stk = allocate_integer_array( current_max_dfa_size );
+ did_stk_init = true;
+ }
- /* the state could be marked if we've already pushed it onto
- * the stack
- */
- if ( ! IS_MARKED(ns) )
- PUT_ON_STACK(ns)
+ nacc = stkend = hashval = 0;
- CHECK_ACCEPT(ns)
- hashval = hashval + ns;
- }
+ for ( nstate = 1; nstate <= numstates; ++nstate )
+ {
+ ns = t[nstate];
- for ( stkpos = 1; stkpos <= stkend; ++stkpos )
- {
- ns = stk[stkpos];
- transsym = transchar[ns];
+ /* The state could be marked if we've already pushed it onto
+ * the stack.
+ */
+ if ( ! IS_MARKED(ns) )
+ PUT_ON_STACK(ns)
- if ( transsym == SYM_EPSILON )
- {
- tsp = trans1[ns] + MARKER_DIFFERENCE;
+ CHECK_ACCEPT(ns)
+ hashval = hashval + ns;
+ }
- if ( tsp != NO_TRANSITION )
+ for ( stkpos = 1; stkpos <= stkend; ++stkpos )
{
- if ( ! IS_MARKED(tsp) )
- STACK_STATE(tsp)
+ ns = stk[stkpos];
+ transsym = transchar[ns];
+
+ if ( transsym == SYM_EPSILON )
+ {
+ tsp = trans1[ns] + MARKER_DIFFERENCE;
- tsp = trans2[ns];
+ if ( tsp != NO_TRANSITION )
+ {
+ if ( ! IS_MARKED(tsp) )
+ STACK_STATE(tsp)
- if ( tsp != NO_TRANSITION )
- if ( ! IS_MARKED(tsp) )
- STACK_STATE(tsp)
+ tsp = trans2[ns];
+
+ if ( tsp != NO_TRANSITION && ! IS_MARKED(tsp) )
+ STACK_STATE(tsp)
+ }
+ }
}
- }
- }
- /* clear out "visit" markers */
+ /* Clear out "visit" markers. */
- for ( stkpos = 1; stkpos <= stkend; ++stkpos )
- {
- if ( IS_MARKED(stk[stkpos]) )
- {
- UNMARK_STATE(stk[stkpos])
- }
- else
- flexfatal( "consistency check failed in epsclosure()" );
- }
+ for ( stkpos = 1; stkpos <= stkend; ++stkpos )
+ {
+ if ( IS_MARKED(stk[stkpos]) )
+ UNMARK_STATE(stk[stkpos])
+ else
+ flexfatal( "consistency check failed in epsclosure()" );
+ }
- *ns_addr = numstates;
- *hv_addr = hashval;
- *nacc_addr = nacc;
+ *ns_addr = numstates;
+ *hv_addr = hashval;
+ *nacc_addr = nacc;
- return ( t );
- }
+ return t;
+ }
/* increase_max_dfas - increase the maximum number of DFAs */
void increase_max_dfas()
+ {
+ current_max_dfas += MAX_DFAS_INCREMENT;
- {
- current_max_dfas += MAX_DFAS_INCREMENT;
-
- ++num_reallocs;
+ ++num_reallocs;
- base = reallocate_integer_array( base, current_max_dfas );
- def = reallocate_integer_array( def, current_max_dfas );
- dfasiz = reallocate_integer_array( dfasiz, current_max_dfas );
- accsiz = reallocate_integer_array( accsiz, current_max_dfas );
- dhash = reallocate_integer_array( dhash, current_max_dfas );
- dss = reallocate_int_ptr_array( dss, current_max_dfas );
- dfaacc = reallocate_dfaacc_union( dfaacc, current_max_dfas );
+ base = reallocate_integer_array( base, current_max_dfas );
+ def = reallocate_integer_array( def, current_max_dfas );
+ dfasiz = reallocate_integer_array( dfasiz, current_max_dfas );
+ accsiz = reallocate_integer_array( accsiz, current_max_dfas );
+ dhash = reallocate_integer_array( dhash, current_max_dfas );
+ dss = reallocate_int_ptr_array( dss, current_max_dfas );
+ dfaacc = reallocate_dfaacc_union( dfaacc, current_max_dfas );
- if ( nultrans )
- nultrans = reallocate_integer_array( nultrans, current_max_dfas );
- }
+ if ( nultrans )
+ nultrans =
+ reallocate_integer_array( nultrans, current_max_dfas );
+ }
/* ntod - convert an ndfa to a dfa
*
- * synopsis
- * ntod();
- *
- * creates the dfa corresponding to the ndfa we've constructed. the
- * dfa starts out in state #1.
+ * Creates the dfa corresponding to the ndfa we've constructed. The
+ * dfa starts out in state #1.
*/
void ntod()
-
- {
- int *accset, ds, nacc, newds;
- int sym, hashval, numstates, dsize;
- int num_full_table_rows; /* used only for -f */
- int *nset, *dset;
- int targptr, totaltrans, i, comstate, comfreq, targ;
- int *epsclosure(), snstods(), symlist[CSIZE + 1];
- int num_start_states;
- int todo_head, todo_next;
-
- /* note that the following are indexed by *equivalence classes*
- * and not by characters. Since equivalence classes are indexed
- * beginning with 1, even if the scanner accepts NUL's, this
- * means that (since every character is potentially in its own
- * equivalence class) these arrays must have room for indices
- * from 1 to CSIZE, so their size must be CSIZE + 1.
- */
- int duplist[CSIZE + 1], state[CSIZE + 1];
- int targfreq[CSIZE + 1], targstate[CSIZE + 1];
-
- /* this is so find_table_space(...) will know where to start looking in
- * chk/nxt for unused records for space to put in the state
- */
- if ( fullspd )
- firstfree = 0;
-
- accset = allocate_integer_array( num_rules + 1 );
- nset = allocate_integer_array( current_max_dfa_size );
-
- /* the "todo" queue is represented by the head, which is the DFA
- * state currently being processed, and the "next", which is the
- * next DFA state number available (not in use). We depend on the
- * fact that snstods() returns DFA's \in increasing order/, and thus
- * need only know the bounds of the dfas to be processed.
- */
- todo_head = todo_next = 0;
-
- for ( i = 0; i <= csize; ++i )
{
- duplist[i] = NIL;
- symlist[i] = false;
- }
+ int *accset, ds, nacc, newds;
+ int sym, hashval, numstates, dsize;
+ int num_full_table_rows; /* used only for -f */
+ int *nset, *dset;
+ int targptr, totaltrans, i, comstate, comfreq, targ;
+ int *epsclosure(), snstods(), symlist[CSIZE + 1];
+ int num_start_states;
+ int todo_head, todo_next;
+
+ /* Note that the following are indexed by *equivalence classes*
+ * and not by characters. Since equivalence classes are indexed
+ * beginning with 1, even if the scanner accepts NUL's, this
+ * means that (since every character is potentially in its own
+ * equivalence class) these arrays must have room for indices
+ * from 1 to CSIZE, so their size must be CSIZE + 1.
+ */
+ int duplist[CSIZE + 1], state[CSIZE + 1];
+ int targfreq[CSIZE + 1], targstate[CSIZE + 1];
- for ( i = 0; i <= num_rules; ++i )
- accset[i] = NIL;
+ /* This is so find_table_space(...) will know where to start looking
+ * in chk/nxt for unused records for space to put in the state
+ */
+ if ( fullspd )
+ firstfree = 0;
- if ( trace )
- {
- dumpnfa( scset[1] );
- fputs( "\n\nDFA Dump:\n\n", stderr );
- }
+ accset = allocate_integer_array( num_rules + 1 );
+ nset = allocate_integer_array( current_max_dfa_size );
- inittbl();
-
- /* Check to see whether we should build a separate table for transitions
- * on NUL characters. We don't do this for full-speed (-F) scanners,
- * since for them we don't have a simple state number lying around with
- * which to index the table. We also don't bother doing it for scanners
- * unless (1) NUL is in its own equivalence class (indicated by a
- * positive value of ecgroup[NUL]), (2) NUL's equivalence class is
- * the last equivalence class, and (3) the number of equivalence classes
- * is the same as the number of characters. This latter case comes about
- * when useecs is false or when its true but every character still
- * manages to land in its own class (unlikely, but it's cheap to check
- * for). If all these things are true then the character code needed
- * to represent NUL's equivalence class for indexing the tables is
- * going to take one more bit than the number of characters, and therefore
- * we won't be assured of being able to fit it into a YY_CHAR variable.
- * This rules out storing the transitions in a compressed table, since
- * the code for interpreting them uses a YY_CHAR variable (perhaps it
- * should just use an integer, though; this is worth pondering ... ###).
- *
- * Finally, for full tables, we want the number of entries in the
- * table to be a power of two so the array references go fast (it
- * will just take a shift to compute the major index). If encoding
- * NUL's transitions in the table will spoil this, we give it its
- * own table (note that this will be the case if we're not using
- * equivalence classes).
- */
-
- /* note that the test for ecgroup[0] == numecs below accomplishes
- * both (1) and (2) above
- */
- if ( ! fullspd && ecgroup[0] == numecs )
- { /* NUL is alone in its equivalence class, which is the last one */
- int use_NUL_table = (numecs == csize);
-
- if ( fulltbl && ! use_NUL_table )
- { /* we still may want to use the table if numecs is a power of 2 */
- int power_of_two;
-
- for ( power_of_two = 1; power_of_two <= csize; power_of_two *= 2 )
- if ( numecs == power_of_two )
- {
- use_NUL_table = true;
- break;
- }
- }
-
- if ( use_NUL_table )
- nultrans = allocate_integer_array( current_max_dfas );
- /* from now on, nultrans != nil indicates that we're
- * saving null transitions for later, separate encoding
- */
- }
+ /* The "todo" queue is represented by the head, which is the DFA
+ * state currently being processed, and the "next", which is the
+ * next DFA state number available (not in use). We depend on the
+ * fact that snstods() returns DFA's \in increasing order/, and thus
+ * need only know the bounds of the dfas to be processed.
+ */
+ todo_head = todo_next = 0;
+ for ( i = 0; i <= csize; ++i )
+ {
+ duplist[i] = NIL;
+ symlist[i] = false;
+ }
- if ( fullspd )
- {
- for ( i = 0; i <= numecs; ++i )
- state[i] = 0;
- place_state( state, 0, 0 );
- }
+ for ( i = 0; i <= num_rules; ++i )
+ accset[i] = NIL;
- else if ( fulltbl )
- {
- if ( nultrans )
- /* we won't be including NUL's transitions in the table,
- * so build it for entries from 0 .. numecs - 1
- */
- num_full_table_rows = numecs;
+ if ( trace )
+ {
+ dumpnfa( scset[1] );
+ fputs( "\n\nDFA Dump:\n\n", stderr );
+ }
- else
- /* take into account the fact that we'll be including
- * the NUL entries in the transition table. Build it
- * from 0 .. numecs.
- */
- num_full_table_rows = numecs + 1;
-
- /* declare it "short" because it's a real long-shot that that
- * won't be large enough.
+ inittbl();
+
+ /* Check to see whether we should build a separate table for
+ * transitions on NUL characters. We don't do this for full-speed
+ * (-F) scanners, since for them we don't have a simple state
+ * number lying around with which to index the table. We also
+ * don't bother doing it for scanners unless (1) NUL is in its own
+ * equivalence class (indicated by a positive value of
+ * ecgroup[NUL]), (2) NUL's equivalence class is the last
+ * equivalence class, and (3) the number of equivalence classes is
+ * the same as the number of characters. This latter case comes
+ * about when useecs is false or when its true but every character
+ * still manages to land in its own class (unlikely, but it's
+ * cheap to check for). If all these things are true then the
+ * character code needed to represent NUL's equivalence class for
+ * indexing the tables is going to take one more bit than the
+ * number of characters, and therefore we won't be assured of
+ * being able to fit it into a YY_CHAR variable. This rules out
+ * storing the transitions in a compressed table, since the code
+ * for interpreting them uses a YY_CHAR variable (perhaps it
+ * should just use an integer, though; this is worth pondering ...
+ * ###).
+ *
+ * Finally, for full tables, we want the number of entries in the
+ * table to be a power of two so the array references go fast (it
+ * will just take a shift to compute the major index). If
+ * encoding NUL's transitions in the table will spoil this, we
+ * give it its own table (note that this will be the case if we're
+ * not using equivalence classes).
*/
- printf( "static short int yy_nxt[][%d] =\n {\n",
- /* '}' so vi doesn't get too confused */
- num_full_table_rows );
-
- /* generate 0 entries for state #0 */
- for ( i = 0; i < num_full_table_rows; ++i )
- mk2data( 0 );
- /* force ',' and dataflush() next call to mk2data */
- datapos = NUMDATAITEMS;
+ /* Note that the test for ecgroup[0] == numecs below accomplishes
+ * both (1) and (2) above
+ */
+ if ( ! fullspd && ecgroup[0] == numecs )
+ {
+ /* NUL is alone in its equivalence class, which is the
+ * last one.
+ */
+ int use_NUL_table = (numecs == csize);
- /* force extra blank line next dataflush() */
- dataline = NUMDATALINES;
- }
+ if ( fulltbl && ! use_NUL_table )
+ {
+ /* We still may want to use the table if numecs
+ * is a power of 2.
+ */
+ int power_of_two;
+
+ for ( power_of_two = 1; power_of_two <= csize;
+ power_of_two *= 2 )
+ if ( numecs == power_of_two )
+ {
+ use_NUL_table = true;
+ break;
+ }
+ }
- /* create the first states */
+ if ( use_NUL_table )
+ nultrans = allocate_integer_array( current_max_dfas );
- num_start_states = lastsc * 2;
+ /* From now on, nultrans != nil indicates that we're
+ * saving null transitions for later, separate encoding.
+ */
+ }
- for ( i = 1; i <= num_start_states; ++i )
- {
- numstates = 1;
- /* for each start condition, make one state for the case when
- * we're at the beginning of the line (the '^' operator) and
- * one for the case when we're not
- */
- if ( i % 2 == 1 )
- nset[numstates] = scset[(i / 2) + 1];
- else
- nset[numstates] = mkbranch( scbol[i / 2], scset[i / 2] );
+ if ( fullspd )
+ {
+ for ( i = 0; i <= numecs; ++i )
+ state[i] = 0;
+ place_state( state, 0, 0 );
+ }
- nset = epsclosure( nset, &numstates, accset, &nacc, &hashval );
+ else if ( fulltbl )
+ {
+ if ( nultrans )
+ /* We won't be including NUL's transitions in the
+ * table, so build it for entries from 0 .. numecs - 1.
+ */
+ num_full_table_rows = numecs;
- if ( snstods( nset, numstates, accset, nacc, hashval, &ds ) )
- {
- numas += nacc;
- totnst += numstates;
- ++todo_next;
+ else
+ /* Take into account the fact that we'll be including
+ * the NUL entries in the transition table. Build it
+ * from 0 .. numecs.
+ */
+ num_full_table_rows = numecs + 1;
+
+ /* Declare it "short" because it's a real long-shot that that
+ * won't be large enough.
+ */
+ printf( "static short int yy_nxt[][%d] =\n {\n",
+ /* '}' so vi doesn't get too confused */
+ num_full_table_rows );
+
+ /* Generate 0 entries for state #0. */
+ for ( i = 0; i < num_full_table_rows; ++i )
+ mk2data( 0 );
+
+ /* Force ',' and dataflush() next call to mk2data().*/
+ datapos = NUMDATAITEMS;
+
+ /* Force extra blank line next dataflush(). */
+ dataline = NUMDATALINES;
+ }
- if ( variable_trailing_context_rules && nacc > 0 )
- check_trailing_context( nset, numstates, accset, nacc );
- }
- }
+ /* Create the first states. */
- if ( ! fullspd )
- {
- if ( ! snstods( nset, 0, accset, 0, 0, &end_of_buffer_state ) )
- flexfatal( "could not create unique end-of-buffer state" );
+ num_start_states = lastsc * 2;
- ++numas;
- ++num_start_states;
- ++todo_next;
- }
+ for ( i = 1; i <= num_start_states; ++i )
+ {
+ numstates = 1;
+
+ /* For each start condition, make one state for the case when
+ * we're at the beginning of the line (the '^' operator) and
+ * one for the case when we're not.
+ */
+ if ( i % 2 == 1 )
+ nset[numstates] = scset[(i / 2) + 1];
+ else
+ nset[numstates] =
+ mkbranch( scbol[i / 2], scset[i / 2] );
- while ( todo_head < todo_next )
- {
- targptr = 0;
- totaltrans = 0;
+ nset = epsclosure( nset, &numstates, accset, &nacc, &hashval );
- for ( i = 1; i <= numecs; ++i )
- state[i] = 0;
-
- ds = ++todo_head;
+ if ( snstods( nset, numstates, accset, nacc, hashval, &ds ) )
+ {
+ numas += nacc;
+ totnst += numstates;
+ ++todo_next;
- dset = dss[ds];
- dsize = dfasiz[ds];
+ if ( variable_trailing_context_rules && nacc > 0 )
+ check_trailing_context( nset, numstates,
+ accset, nacc );
+ }
+ }
- if ( trace )
- fprintf( stderr, "state # %d:\n", ds );
+ if ( ! fullspd )
+ {
+ if ( ! snstods( nset, 0, accset, 0, 0, &end_of_buffer_state ) )
+ flexfatal(
+ "could not create unique end-of-buffer state" );
- sympartition( dset, dsize, symlist, duplist );
+ ++numas;
+ ++num_start_states;
+ ++todo_next;
+ }
- for ( sym = 1; sym <= numecs; ++sym )
- {
- if ( symlist[sym] )
+ while ( todo_head < todo_next )
{
- symlist[sym] = 0;
+ targptr = 0;
+ totaltrans = 0;
- if ( duplist[sym] == NIL )
- { /* symbol has unique out-transitions */
- numstates = symfollowset( dset, dsize, sym, nset );
- nset = epsclosure( nset, &numstates, accset,
- &nacc, &hashval );
+ for ( i = 1; i <= numecs; ++i )
+ state[i] = 0;
- if ( snstods( nset, numstates, accset,
- nacc, hashval, &newds ) )
- {
- totnst = totnst + numstates;
- ++todo_next;
- numas += nacc;
+ ds = ++todo_head;
- if ( variable_trailing_context_rules && nacc > 0 )
- check_trailing_context( nset, numstates,
- accset, nacc );
- }
+ dset = dss[ds];
+ dsize = dfasiz[ds];
- state[sym] = newds;
+ if ( trace )
+ fprintf( stderr, "state # %d:\n", ds );
- if ( trace )
- fprintf( stderr, "\t%d\t%d\n", sym, newds );
+ sympartition( dset, dsize, symlist, duplist );
- targfreq[++targptr] = 1;
- targstate[targptr] = newds;
- ++numuniq;
- }
+ for ( sym = 1; sym <= numecs; ++sym )
+ {
+ if ( symlist[sym] )
+ {
+ symlist[sym] = 0;
+
+ if ( duplist[sym] == NIL )
+ {
+ /* Symbol has unique out-transitions. */
+ numstates = symfollowset( dset, dsize,
+ sym, nset );
+ nset = epsclosure( nset, &numstates,
+ accset, &nacc, &hashval );
+
+ if ( snstods( nset, numstates, accset,
+ nacc, hashval, &newds ) )
+ {
+ totnst = totnst + numstates;
+ ++todo_next;
+ numas += nacc;
+
+ if (
+ variable_trailing_context_rules &&
+ nacc > 0 )
+ check_trailing_context(
+ nset, numstates,
+ accset, nacc );
+ }
+
+ state[sym] = newds;
+
+ if ( trace )
+ fprintf( stderr, "\t%d\t%d\n",
+ sym, newds );
+
+ targfreq[++targptr] = 1;
+ targstate[targptr] = newds;
+ ++numuniq;
+ }
+
+ else
+ {
+ /* sym's equivalence class has the same
+ * transitions as duplist(sym)'s
+ * equivalence class.
+ */
+ targ = state[duplist[sym]];
+ state[sym] = targ;
+
+ if ( trace )
+ fprintf( stderr, "\t%d\t%d\n",
+ sym, targ );
+
+ /* Update frequency count for
+ * destination state.
+ */
+
+ i = 0;
+ while ( targstate[++i] != targ )
+ ;
+
+ ++targfreq[i];
+ ++numdup;
+ }
+
+ ++totaltrans;
+ duplist[sym] = NIL;
+ }
+ }
- else
- {
- /* sym's equivalence class has the same transitions
- * as duplist(sym)'s equivalence class
- */
- targ = state[duplist[sym]];
- state[sym] = targ;
+ numsnpairs = numsnpairs + totaltrans;
+
+ if ( caseins && ! useecs )
+ {
+ register int j;
- if ( trace )
- fprintf( stderr, "\t%d\t%d\n", sym, targ );
+ for ( i = 'A', j = 'a'; i <= 'Z'; ++i, ++j )
+ state[i] = state[j];
+ }
- /* update frequency count for destination state */
+ if ( ds > num_start_states )
+ check_for_backtracking( ds, state );
- i = 0;
- while ( targstate[++i] != targ )
- ;
+ if ( nultrans )
+ {
+ nultrans[ds] = state[NUL_ec];
+ state[NUL_ec] = 0; /* remove transition */
+ }
- ++targfreq[i];
- ++numdup;
- }
+ if ( fulltbl )
+ {
+ /* Supply array's 0-element. */
+ if ( ds == end_of_buffer_state )
+ mk2data( -end_of_buffer_state );
+ else
+ mk2data( end_of_buffer_state );
+
+ for ( i = 1; i < num_full_table_rows; ++i )
+ /* Jams are marked by negative of state
+ * number.
+ */
+ mk2data( state[i] ? state[i] : -ds );
+
+ /* Force ',' and dataflush() next call to mk2data().*/
+ datapos = NUMDATAITEMS;
+
+ /* Force extra blank line next dataflush(). */
+ dataline = NUMDATALINES;
+ }
- ++totaltrans;
- duplist[sym] = NIL;
- }
- }
+ else if ( fullspd )
+ place_state( state, ds, totaltrans );
- numsnpairs = numsnpairs + totaltrans;
+ else if ( ds == end_of_buffer_state )
+ /* Special case this state to make sure it does what
+ * it's supposed to, i.e., jam on end-of-buffer.
+ */
+ stack1( ds, 0, 0, JAMSTATE );
- if ( caseins && ! useecs )
- {
- register int j;
+ else /* normal, compressed state */
+ {
+ /* Determine which destination state is the most
+ * common, and how many transitions to it there are.
+ */
- for ( i = 'A', j = 'a'; i <= 'Z'; ++i, ++j )
- state[i] = state[j];
- }
+ comfreq = 0;
+ comstate = 0;
- if ( ds > num_start_states )
- check_for_backtracking( ds, state );
+ for ( i = 1; i <= targptr; ++i )
+ if ( targfreq[i] > comfreq )
+ {
+ comfreq = targfreq[i];
+ comstate = targstate[i];
+ }
- if ( nultrans )
- {
- nultrans[ds] = state[NUL_ec];
- state[NUL_ec] = 0; /* remove transition */
- }
+ bldtbl( state, ds, totaltrans, comstate, comfreq );
+ }
+ }
if ( fulltbl )
- {
- /* supply array's 0-element */
- if ( ds == end_of_buffer_state )
- mk2data( -end_of_buffer_state );
- else
- mk2data( end_of_buffer_state );
-
- for ( i = 1; i < num_full_table_rows; ++i )
- /* jams are marked by negative of state number */
- mk2data( state[i] ? state[i] : -ds );
-
- /* force ',' and dataflush() next call to mk2data */
- datapos = NUMDATAITEMS;
-
- /* force extra blank line next dataflush() */
- dataline = NUMDATALINES;
- }
-
- else if ( fullspd )
- place_state( state, ds, totaltrans );
-
- else if ( ds == end_of_buffer_state )
- /* special case this state to make sure it does what it's
- * supposed to, i.e., jam on end-of-buffer
- */
- stack1( ds, 0, 0, JAMSTATE );
-
- else /* normal, compressed state */
- {
- /* determine which destination state is the most common, and
- * how many transitions to it there are
- */
-
- comfreq = 0;
- comstate = 0;
-
- for ( i = 1; i <= targptr; ++i )
- if ( targfreq[i] > comfreq )
- {
- comfreq = targfreq[i];
- comstate = targstate[i];
- }
-
- bldtbl( state, ds, totaltrans, comstate, comfreq );
- }
- }
-
- if ( fulltbl )
- dataend();
+ dataend();
- else if ( ! fullspd )
- {
- cmptmps(); /* create compressed template entries */
+ else if ( ! fullspd )
+ {
+ cmptmps(); /* create compressed template entries */
- /* create tables for all the states with only one out-transition */
- while ( onesp > 0 )
- {
- mk1tbl( onestate[onesp], onesym[onesp], onenext[onesp],
- onedef[onesp] );
- --onesp;
- }
+ /* Create tables for all the states with only one
+ * out-transition.
+ */
+ while ( onesp > 0 )
+ {
+ mk1tbl( onestate[onesp], onesym[onesp], onenext[onesp],
+ onedef[onesp] );
+ --onesp;
+ }
- mkdeftbl();
+ mkdeftbl();
+ }
}
- }
/* snstods - converts a set of ndfa states into a dfa state
*
* synopsis
- * int sns[numstates], numstates, newds, accset[num_rules + 1], nacc, hashval;
- * int snstods();
- * is_new_state = snstods( sns, numstates, accset, nacc, hashval, &newds );
+ * is_new_state = snstods( int sns[numstates], int numstates,
+ * int accset[num_rules+1], int nacc,
+ * int hashval, int *newds_addr );
*
- * on return, the dfa state number is in newds.
+ * On return, the dfa state number is in newds.
*/
int snstods( sns, numstates, accset, nacc, hashval, newds_addr )
int sns[], numstates, accset[], nacc, hashval, *newds_addr;
+ {
+ int didsort = 0;
+ register int i, j;
+ int newds, *oldsns;
- {
- int didsort = 0;
- register int i, j;
- int newds, *oldsns;
+ for ( i = 1; i <= lastdfa; ++i )
+ if ( hashval == dhash[i] )
+ {
+ if ( numstates == dfasiz[i] )
+ {
+ oldsns = dss[i];
+
+ if ( ! didsort )
+ {
+ /* We sort the states in sns so we
+ * can compare it to oldsns quickly.
+ * We use bubble because there probably
+ * aren't very many states.
+ */
+ bubble( sns, numstates );
+ didsort = 1;
+ }
+
+ for ( j = 1; j <= numstates; ++j )
+ if ( sns[j] != oldsns[j] )
+ break;
+
+ if ( j > numstates )
+ {
+ ++dfaeql;
+ *newds_addr = i;
+ return 0;
+ }
+
+ ++hshcol;
+ }
+
+ else
+ ++hshsave;
+ }
- for ( i = 1; i <= lastdfa; ++i )
- if ( hashval == dhash[i] )
- {
- if ( numstates == dfasiz[i] )
- {
- oldsns = dss[i];
-
- if ( ! didsort )
- {
- /* we sort the states in sns so we can compare it to
- * oldsns quickly. we use bubble because there probably
- * aren't very many states
- */
- bubble( sns, numstates );
- didsort = 1;
- }
-
- for ( j = 1; j <= numstates; ++j )
- if ( sns[j] != oldsns[j] )
- break;
-
- if ( j > numstates )
- {
- ++dfaeql;
- *newds_addr = i;
- return ( 0 );
- }
-
- ++hshcol;
- }
+ /* Make a new dfa. */
- else
- ++hshsave;
- }
+ if ( ++lastdfa >= current_max_dfas )
+ increase_max_dfas();
- /* make a new dfa */
+ newds = lastdfa;
- if ( ++lastdfa >= current_max_dfas )
- increase_max_dfas();
+ dss[newds] = allocate_integer_array( numstates + 1 );
- newds = lastdfa;
+ /* If we haven't already sorted the states in sns, we do so now,
+ * so that future comparisons with it can be made quickly.
+ */
- dss[newds] = allocate_integer_array( numstates + 1 );
+ if ( ! didsort )
+ bubble( sns, numstates );
- /* if we haven't already sorted the states in sns, we do so now, so that
- * future comparisons with it can be made quickly
- */
+ for ( i = 1; i <= numstates; ++i )
+ dss[newds][i] = sns[i];
- if ( ! didsort )
- bubble( sns, numstates );
+ dfasiz[newds] = numstates;
+ dhash[newds] = hashval;
- for ( i = 1; i <= numstates; ++i )
- dss[newds][i] = sns[i];
+ if ( nacc == 0 )
+ {
+ if ( reject )
+ dfaacc[newds].dfaacc_set = (int *) 0;
+ else
+ dfaacc[newds].dfaacc_state = 0;
- dfasiz[newds] = numstates;
- dhash[newds] = hashval;
+ accsiz[newds] = 0;
+ }
- if ( nacc == 0 )
- {
- if ( reject )
- dfaacc[newds].dfaacc_set = (int *) 0;
- else
- dfaacc[newds].dfaacc_state = 0;
+ else if ( reject )
+ {
+ /* We sort the accepting set in increasing order so the
+ * disambiguating rule that the first rule listed is considered
+ * match in the event of ties will work. We use a bubble
+ * sort since the list is probably quite small.
+ */
- accsiz[newds] = 0;
- }
+ bubble( accset, nacc );
- else if ( reject )
- {
- /* we sort the accepting set in increasing order so the disambiguating
- * rule that the first rule listed is considered match in the event of
- * ties will work. We use a bubble sort since the list is probably
- * quite small.
- */
+ dfaacc[newds].dfaacc_set = allocate_integer_array( nacc + 1 );
- bubble( accset, nacc );
+ /* Save the accepting set for later */
+ for ( i = 1; i <= nacc; ++i )
+ {
+ dfaacc[newds].dfaacc_set[i] = accset[i];
- dfaacc[newds].dfaacc_set = allocate_integer_array( nacc + 1 );
+ if ( accset[i] <= num_rules )
+ /* Who knows, perhaps a REJECT can yield
+ * this rule.
+ */
+ rule_useful[accset[i]] = true;
+ }
- /* save the accepting set for later */
- for ( i = 1; i <= nacc; ++i )
- {
- dfaacc[newds].dfaacc_set[i] = accset[i];
+ accsiz[newds] = nacc;
+ }
- if ( accset[i] <= num_rules )
- /* Who knows, perhaps a REJECT can yield this rule */
- rule_useful[accset[i]] = true;
- }
+ else
+ {
+ /* Find lowest numbered rule so the disambiguating rule
+ * will work.
+ */
+ j = num_rules + 1;
- accsiz[newds] = nacc;
- }
+ for ( i = 1; i <= nacc; ++i )
+ if ( accset[i] < j )
+ j = accset[i];
- else
- { /* find lowest numbered rule so the disambiguating rule will work */
- j = num_rules + 1;
+ dfaacc[newds].dfaacc_state = j;
- for ( i = 1; i <= nacc; ++i )
- if ( accset[i] < j )
- j = accset[i];
+ if ( j <= num_rules )
+ rule_useful[j] = true;
+ }
- dfaacc[newds].dfaacc_state = j;
+ *newds_addr = newds;
- if ( j <= num_rules )
- rule_useful[j] = true;
+ return 1;
}
- *newds_addr = newds;
-
- return ( 1 );
- }
-
/* symfollowset - follow the symbol transitions one step
*
* synopsis
- * int ds[current_max_dfa_size], dsize, transsym;
- * int nset[current_max_dfa_size], numstates;
- * numstates = symfollowset( ds, dsize, transsym, nset );
+ * numstates = symfollowset( int ds[current_max_dfa_size], int dsize,
+ * int transsym, int nset[current_max_dfa_size] );
*/
int symfollowset( ds, dsize, transsym, nset )
int ds[], dsize, transsym, nset[];
+ {
+ int ns, tsp, sym, i, j, lenccl, ch, numstates, ccllist;
+
+ numstates = 0;
+
+ for ( i = 1; i <= dsize; ++i )
+ { /* for each nfa state ns in the state set of ds */
+ ns = ds[i];
+ sym = transchar[ns];
+ tsp = trans1[ns];
+
+ if ( sym < 0 )
+ { /* it's a character class */
+ sym = -sym;
+ ccllist = cclmap[sym];
+ lenccl = ccllen[sym];
+
+ if ( cclng[sym] )
+ {
+ for ( j = 0; j < lenccl; ++j )
+ {
+ /* Loop through negated character
+ * class.
+ */
+ ch = ccltbl[ccllist + j];
+
+ if ( ch == 0 )
+ ch = NUL_ec;
+
+ if ( ch > transsym )
+ /* Transsym isn't in negated
+ * ccl.
+ */
+ break;
+
+ else if ( ch == transsym )
+ /* next 2 */ goto bottom;
+ }
+
+ /* Didn't find transsym in ccl. */
+ nset[++numstates] = tsp;
+ }
+
+ else
+ for ( j = 0; j < lenccl; ++j )
+ {
+ ch = ccltbl[ccllist + j];
+
+ if ( ch == 0 )
+ ch = NUL_ec;
+
+ if ( ch > transsym )
+ break;
+ else if ( ch == transsym )
+ {
+ nset[++numstates] = tsp;
+ break;
+ }
+ }
+ }
- {
- int ns, tsp, sym, i, j, lenccl, ch, numstates;
- int ccllist;
-
- numstates = 0;
-
- for ( i = 1; i <= dsize; ++i )
- { /* for each nfa state ns in the state set of ds */
- ns = ds[i];
- sym = transchar[ns];
- tsp = trans1[ns];
-
- if ( sym < 0 )
- { /* it's a character class */
- sym = -sym;
- ccllist = cclmap[sym];
- lenccl = ccllen[sym];
-
- if ( cclng[sym] )
- {
- for ( j = 0; j < lenccl; ++j )
- { /* loop through negated character class */
- ch = ccltbl[ccllist + j];
-
- if ( ch == 0 )
- ch = NUL_ec;
-
- if ( ch > transsym )
- break; /* transsym isn't in negated ccl */
-
- else if ( ch == transsym )
- /* next 2 */ goto bottom;
- }
-
- /* didn't find transsym in ccl */
- nset[++numstates] = tsp;
- }
-
- else
- for ( j = 0; j < lenccl; ++j )
- {
- ch = ccltbl[ccllist + j];
-
- if ( ch == 0 )
- ch = NUL_ec;
-
- if ( ch > transsym )
- break;
+ else if ( sym >= 'A' && sym <= 'Z' && caseins )
+ flexfatal( "consistency check failed in symfollowset" );
- else if ( ch == transsym )
- {
- nset[++numstates] = tsp;
- break;
+ else if ( sym == SYM_EPSILON )
+ { /* do nothing */
}
- }
- }
- else if ( sym >= 'A' && sym <= 'Z' && caseins )
- flexfatal( "consistency check failed in symfollowset" );
-
- else if ( sym == SYM_EPSILON )
- { /* do nothing */
- }
+ else if ( abs( ecgroup[sym] ) == transsym )
+ nset[++numstates] = tsp;
- else if ( abs( ecgroup[sym] ) == transsym )
- nset[++numstates] = tsp;
+ bottom: ;
+ }
-bottom:
- ;
+ return numstates;
}
- return ( numstates );
- }
-
/* sympartition - partition characters with same out-transitions
*
* synopsis
- * integer ds[current_max_dfa_size], numstates, duplist[numecs];
- * symlist[numecs];
- * sympartition( ds, numstates, symlist, duplist );
+ * sympartition( int ds[current_max_dfa_size], int numstates,
+ * int symlist[numecs], int duplist[numecs] );
*/
void sympartition( ds, numstates, symlist, duplist )
int ds[], numstates;
int symlist[], duplist[];
+ {
+ int tch, i, j, k, ns, dupfwd[CSIZE + 1], lenccl, cclp, ich;
- {
- int tch, i, j, k, ns, dupfwd[CSIZE + 1], lenccl, cclp, ich;
-
- /* partitioning is done by creating equivalence classes for those
- * characters which have out-transitions from the given state. Thus
- * we are really creating equivalence classes of equivalence classes.
- */
-
- for ( i = 1; i <= numecs; ++i )
- { /* initialize equivalence class list */
- duplist[i] = i - 1;
- dupfwd[i] = i + 1;
- }
+ /* Partitioning is done by creating equivalence classes for those
+ * characters which have out-transitions from the given state. Thus
+ * we are really creating equivalence classes of equivalence classes.
+ */
- duplist[1] = NIL;
- dupfwd[numecs] = NIL;
+ for ( i = 1; i <= numecs; ++i )
+ { /* initialize equivalence class list */
+ duplist[i] = i - 1;
+ dupfwd[i] = i + 1;
+ }
- for ( i = 1; i <= numstates; ++i )
- {
- ns = ds[i];
- tch = transchar[ns];
+ duplist[1] = NIL;
+ dupfwd[numecs] = NIL;
- if ( tch != SYM_EPSILON )
- {
- if ( tch < -lastccl || tch >= csize )
+ for ( i = 1; i <= numstates; ++i )
{
- if ( tch >= csize && tch <= CSIZE )
- flexerror( "scanner requires -8 flag" );
+ ns = ds[i];
+ tch = transchar[ns];
- else
- flexfatal(
+ if ( tch != SYM_EPSILON )
+ {
+ if ( tch < -lastccl || tch >= csize )
+ {
+ if ( tch >= csize && tch <= CSIZE )
+ flexerror( "scanner requires -8 flag" );
+
+ else
+ flexfatal(
"bad transition character detected in sympartition()" );
- }
+ }
- if ( tch >= 0 )
- { /* character transition */
- /* abs() needed for fake %t ec's */
- int ec = abs( ecgroup[tch] );
+ if ( tch >= 0 )
+ { /* character transition */
+ /* abs() needed for fake %t ec's */
+ int ec = abs( ecgroup[tch] );
- mkechar( ec, dupfwd, duplist );
- symlist[ec] = 1;
- }
+ mkechar( ec, dupfwd, duplist );
+ symlist[ec] = 1;
+ }
- else
- { /* character class */
- tch = -tch;
+ else
+ { /* character class */
+ tch = -tch;
- lenccl = ccllen[tch];
- cclp = cclmap[tch];
- mkeccl( ccltbl + cclp, lenccl, dupfwd, duplist, numecs,
- NUL_ec );
+ lenccl = ccllen[tch];
+ cclp = cclmap[tch];
+ mkeccl( ccltbl + cclp, lenccl, dupfwd,
+ duplist, numecs, NUL_ec );
- if ( cclng[tch] )
- {
- j = 0;
+ if ( cclng[tch] )
+ {
+ j = 0;
- for ( k = 0; k < lenccl; ++k )
- {
- ich = ccltbl[cclp + k];
+ for ( k = 0; k < lenccl; ++k )
+ {
+ ich = ccltbl[cclp + k];
- if ( ich == 0 )
- ich = NUL_ec;
+ if ( ich == 0 )
+ ich = NUL_ec;
- for ( ++j; j < ich; ++j )
- symlist[j] = 1;
- }
+ for ( ++j; j < ich; ++j )
+ symlist[j] = 1;
+ }
- for ( ++j; j <= numecs; ++j )
- symlist[j] = 1;
- }
+ for ( ++j; j <= numecs; ++j )
+ symlist[j] = 1;
+ }
- else
- for ( k = 0; k < lenccl; ++k )
- {
- ich = ccltbl[cclp + k];
+ else
+ for ( k = 0; k < lenccl; ++k )
+ {
+ ich = ccltbl[cclp + k];
- if ( ich == 0 )
- ich = NUL_ec;
+ if ( ich == 0 )
+ ich = NUL_ec;
- symlist[ich] = 1;
+ symlist[ich] = 1;
+ }
+ }
}
}
- }
}
- }
#include "flexdef.h"
-/* ccl2ecl - convert character classes to set of equivalence classes
- *
- * synopsis
- * ccl2ecl();
- */
+/* ccl2ecl - convert character classes to set of equivalence classes */
void ccl2ecl()
-
- {
- int i, ich, newlen, cclp, ccls, cclmec;
-
- for ( i = 1; i <= lastccl; ++i )
{
- /* we loop through each character class, and for each character
- * in the class, add the character's equivalence class to the
- * new "character" class we are creating. Thus when we are all
- * done, character classes will really consist of collections
- * of equivalence classes
- */
-
- newlen = 0;
- cclp = cclmap[i];
+ int i, ich, newlen, cclp, ccls, cclmec;
- for ( ccls = 0; ccls < ccllen[i]; ++ccls )
- {
- ich = ccltbl[cclp + ccls];
- cclmec = ecgroup[ich];
-
- if ( cclmec > 0 )
+ for ( i = 1; i <= lastccl; ++i )
{
- ccltbl[cclp + newlen] = cclmec;
- ++newlen;
+ /* We loop through each character class, and for each character
+ * in the class, add the character's equivalence class to the
+ * new "character" class we are creating. Thus when we are all
+ * done, character classes will really consist of collections
+ * of equivalence classes
+ */
+
+ newlen = 0;
+ cclp = cclmap[i];
+
+ for ( ccls = 0; ccls < ccllen[i]; ++ccls )
+ {
+ ich = ccltbl[cclp + ccls];
+ cclmec = ecgroup[ich];
+
+ if ( cclmec > 0 )
+ {
+ ccltbl[cclp + newlen] = cclmec;
+ ++newlen;
+ }
+ }
+
+ ccllen[i] = newlen;
}
- }
-
- ccllen[i] = newlen;
}
- }
/* cre8ecs - associate equivalence class numbers with class members
*
- * synopsis
- * int cre8ecs();
- * number of classes = cre8ecs( fwd, bck, num );
- *
- * fwd is the forward linked-list of equivalence class members. bck
- * is the backward linked-list, and num is the number of class members.
+ * fwd is the forward linked-list of equivalence class members. bck
+ * is the backward linked-list, and num is the number of class members.
*
- * Returned is the number of classes.
+ * Returned is the number of classes.
*/
int cre8ecs( fwd, bck, num )
int fwd[], bck[], num;
+ {
+ int i, j, numcl;
- {
- int i, j, numcl;
-
- numcl = 0;
-
- /* create equivalence class numbers. From now on, abs( bck(x) )
- * is the equivalence class number for object x. If bck(x)
- * is positive, then x is the representative of its equivalence
- * class.
- */
- for ( i = 1; i <= num; ++i )
- if ( bck[i] == NIL )
- {
- bck[i] = ++numcl;
- for ( j = fwd[i]; j != NIL; j = fwd[j] )
- bck[j] = -numcl;
- }
+ numcl = 0;
- return ( numcl );
- }
+ /* Create equivalence class numbers. From now on, abs( bck(x) )
+ * is the equivalence class number for object x. If bck(x)
+ * is positive, then x is the representative of its equivalence
+ * class.
+ */
+ for ( i = 1; i <= num; ++i )
+ if ( bck[i] == NIL )
+ {
+ bck[i] = ++numcl;
+ for ( j = fwd[i]; j != NIL; j = fwd[j] )
+ bck[j] = -numcl;
+ }
+
+ return numcl;
+ }
/* mkeccl - update equivalence classes based on character class xtions
* synopsis
* Char ccls[];
* int lenccl, fwd[llsiz], bck[llsiz], llsiz, NUL_mapping;
- * mkeccl( ccls, lenccl, fwd, bck, llsiz, NUL_mapping );
+ * void mkeccl( Char ccls[], int lenccl, int fwd[llsiz], int bck[llsiz],
+ * int llsiz, int NUL_mapping );
*
- * where ccls contains the elements of the character class, lenccl is the
+ * ccls contains the elements of the character class, lenccl is the
* number of elements in the ccl, fwd is the forward link-list of equivalent
- * characters, bck is the backward link-list, and llsiz size of the link-list
+ * characters, bck is the backward link-list, and llsiz size of the link-list.
*
* NUL_mapping is the value which NUL (0) should be mapped to.
*/
void mkeccl( ccls, lenccl, fwd, bck, llsiz, NUL_mapping )
Char ccls[];
int lenccl, fwd[], bck[], llsiz, NUL_mapping;
+ {
+ int cclp, oldec, newec;
+ int cclm, i, j;
+ static unsigned char cclflags[CSIZE]; /* initialized to all '\0' */
- {
- int cclp, oldec, newec;
- int cclm, i, j;
- static unsigned char cclflags[CSIZE]; /* initialized to all '\0' */
+ /* Note that it doesn't matter whether or not the character class is
+ * negated. The same results will be obtained in either case.
+ */
- /* note that it doesn't matter whether or not the character class is
- * negated. The same results will be obtained in either case.
- */
+ cclp = 0;
- cclp = 0;
+ while ( cclp < lenccl )
+ {
+ cclm = ccls[cclp];
- while ( cclp < lenccl )
- {
- cclm = ccls[cclp];
+ if ( NUL_mapping && cclm == 0 )
+ cclm = NUL_mapping;
- if ( NUL_mapping && cclm == 0 )
- cclm = NUL_mapping;
+ oldec = bck[cclm];
+ newec = cclm;
- oldec = bck[cclm];
- newec = cclm;
+ j = cclp + 1;
- j = cclp + 1;
+ for ( i = fwd[cclm]; i != NIL && i <= llsiz; i = fwd[i] )
+ { /* look for the symbol in the character class */
+ for ( ; j < lenccl; ++j )
+ {
+ register int ccl_char;
- for ( i = fwd[cclm]; i != NIL && i <= llsiz; i = fwd[i] )
- { /* look for the symbol in the character class */
- for ( ; j < lenccl; ++j )
- {
- register int ccl_char;
-
- if ( NUL_mapping && ccls[j] == 0 )
- ccl_char = NUL_mapping;
- else
- ccl_char = ccls[j];
-
- if ( ccl_char > i )
- break;
-
- if ( ccl_char == i && ! cclflags[j] )
- {
- /* we found an old companion of cclm in the ccl.
- * link it into the new equivalence class and flag it as
- * having been processed
- */
-
- bck[i] = newec;
- fwd[newec] = i;
- newec = i;
- cclflags[j] = 1; /* set flag so we don't reprocess */
-
- /* get next equivalence class member */
- /* continue 2 */
- goto next_pt;
- }
- }
+ if ( NUL_mapping && ccls[j] == 0 )
+ ccl_char = NUL_mapping;
+ else
+ ccl_char = ccls[j];
+
+ if ( ccl_char > i )
+ break;
+
+ if ( ccl_char == i && ! cclflags[j] )
+ {
+ /* We found an old companion of cclm
+ * in the ccl. Link it into the new
+ * equivalence class and flag it as
+ * having been processed.
+ */
+
+ bck[i] = newec;
+ fwd[newec] = i;
+ newec = i;
+ /* Set flag so we don't reprocess. */
+ cclflags[j] = 1;
+
+ /* Get next equivalence class member. */
+ /* continue 2 */
+ goto next_pt;
+ }
+ }
+
+ /* Symbol isn't in character class. Put it in the old
+ * equivalence class.
+ */
- /* symbol isn't in character class. Put it in the old equivalence
- * class
- */
+ bck[i] = oldec;
- bck[i] = oldec;
+ if ( oldec != NIL )
+ fwd[oldec] = i;
- if ( oldec != NIL )
- fwd[oldec] = i;
+ oldec = i;
- oldec = i;
-next_pt:
- ;
- }
+ next_pt: ;
+ }
- if ( bck[cclm] != NIL || oldec != bck[cclm] )
- {
- bck[cclm] = NIL;
- fwd[oldec] = NIL;
- }
+ if ( bck[cclm] != NIL || oldec != bck[cclm] )
+ {
+ bck[cclm] = NIL;
+ fwd[oldec] = NIL;
+ }
- fwd[newec] = NIL;
+ fwd[newec] = NIL;
- /* find next ccl member to process */
+ /* Find next ccl member to process. */
- for ( ++cclp; cclflags[cclp] && cclp < lenccl; ++cclp )
- {
- /* reset "doesn't need processing" flag */
- cclflags[cclp] = 0;
- }
+ for ( ++cclp; cclflags[cclp] && cclp < lenccl; ++cclp )
+ {
+ /* Reset "doesn't need processing" flag. */
+ cclflags[cclp] = 0;
+ }
+ }
}
- }
-/* mkechar - create equivalence class for single character
- *
- * synopsis
- * int tch, fwd[], bck[];
- * mkechar( tch, fwd, bck );
- */
+/* mkechar - create equivalence class for single character */
void mkechar( tch, fwd, bck )
int tch, fwd[], bck[];
+ {
+ /* If until now the character has been a proper subset of
+ * an equivalence class, break it away to create a new ec
+ */
- {
- /* if until now the character has been a proper subset of
- * an equivalence class, break it away to create a new ec
- */
-
- if ( fwd[tch] != NIL )
- bck[fwd[tch]] = bck[tch];
+ if ( fwd[tch] != NIL )
+ bck[fwd[tch]] = bck[tch];
- if ( bck[tch] != NIL )
- fwd[bck[tch]] = fwd[tch];
+ if ( bck[tch] != NIL )
+ fwd[bck[tch]] = fwd[tch];
- fwd[tch] = NIL;
- bck[tch] = NIL;
- }
+ fwd[tch] = NIL;
+ bck[tch] = NIL;
+ }
/* A lexical scanner generated by flex */
-/* scanner skeleton version:
+/* Scanner skeleton version:
* $Header$
*/
#include <stdlib.h>
#include <osfcn.h>
-/* use prototypes in function declarations */
+/* Use prototypes in function declarations. */
#define YY_USE_PROTOS
-/* the "const" storage-class-modifier is valid */
+/* The "const" storage-class-modifier is valid. */
#define YY_USE_CONST
#else /* ! __cplusplus */
#define YY_PROTO(proto) proto
#else
#define YY_PROTO(proto) ()
-/* we can't get here if it's an ANSI C compiler, or a C++ compiler,
+/* We can't get here if it's an ANSI C compiler, or a C++ compiler,
* so it's got to be a K&R compiler, and therefore there's no standard
- * place from which to include these definitions
+ * place from which to include these definitions.
*/
char *malloc();
int free();
#endif
-/* amount of stuff to slurp up with each read */
+/* Amount of stuff to slurp up with each read. */
#ifndef YY_READ_BUF_SIZE
#define YY_READ_BUF_SIZE 8192
#endif
-/* returned upon end-of-file */
+/* Returned upon end-of-file. */
#define YY_END_TOK 0
-/* copy whatever the last rule matched to the standard output */
+/* Copy whatever the last rule matched to the standard output. */
-/* cast to (char *) is because for 8-bit chars, yytext is (unsigned char *) */
+/* Cast to (char *) is because for 8-bit chars, yytext is (unsigned char *) */
/* this used to be an fputs(), but since the string might contain NUL's,
- * we now use fwrite()
+ * we now use fwrite().
*/
#define ECHO (void) fwrite( (char *) yytext, yyleng, 1, yyout )
-/* gets input and stuffs it into "buf". number of characters read, or YY_NULL,
+/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
* is returned in "result".
*/
#define YY_INPUT(buf,result,max_size) \
if ( (result = read( fileno(yyin), (char *) buf, max_size )) < 0 ) \
- YY_FATAL_ERROR( "read() in flex scanner failed" );
+ YY_FATAL_ERROR( "read() in flex scanner failed" );
#define YY_NULL 0
-/* no semi-colon after return; correct usage is to write "yyterminate();" -
+/* No semi-colon after return; correct usage is to write "yyterminate();" -
* we don't want an extra ';' after the "return" because that will cause
* some compilers to complain about unreachable statements.
*/
#define yyterminate() return YY_NULL
-/* report a fatal error */
+/* Report a fatal error. */
/* The funky do-while is used to turn this macro definition into
* a single C statement (which needs a semi-colon terminator).
} \
while ( 0 )
-/* default yywrap function - always treat EOF as an EOF */
+/* Default yywrap function - always treat EOF as an EOF. */
#define yywrap() 1
-/* enter a start condition. This macro really ought to take a parameter,
+/* Enter a start condition. This macro really ought to take a parameter,
* but we do it the disgusting crufty way forced on us by the ()-less
- * definition of BEGIN
+ * definition of BEGIN.
*/
#define BEGIN yy_start = 1 + 2 *
-/* action number for EOF rule of a given start state */
+/* Action number for EOF rule of a given start state. */
#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
-/* special action meaning "start processing a new file" */
+/* Special action meaning "start processing a new file". */
#define YY_NEW_FILE \
do \
{ \
} \
while ( 0 )
-/* default declaration of generated scanner - a define so the user can
- * easily add parameters
+/* Default declaration of generated scanner - a define so the user can
+ * easily add parameters.
*/
#define YY_DECL int yylex YY_PROTO(( void ))
-/* code executed at the end of each rule */
+/* Code executed at the end of each rule. */
#define YY_BREAK break;
#define YY_END_OF_BUFFER_CHAR 0
%% section 1 definitions and declarations of yytext/yytext_ptr go here
-/* done after the current pattern has been matched and before the
- * corresponding action - sets up yytext
+/* Done after the current pattern has been matched and before the
+ * corresponding action - sets up yytext.
*/
#define YY_DO_BEFORE_ACTION \
yytext_ptr = yy_bp; \
#define EOB_ACT_END_OF_FILE 1
#define EOB_ACT_LAST_MATCH 2
-/* return all but the first 'n' matched characters back to the input stream */
+/* Return all but the first 'n' matched characters back to the input stream. */
#define yyless(n) \
do \
{ \
- /* undo effects of setting up yytext */ \
+ /* Undo effects of setting up yytext. */ \
*yy_cp = yy_hold_char; \
yy_c_buf_p = yy_cp = yy_bp + n; \
YY_DO_BEFORE_ACTION; /* set up yytext again */ \
struct yy_buffer_state
- {
- FILE *yy_input_file;
+ {
+ FILE *yy_input_file;
- YY_CHAR *yy_ch_buf; /* input buffer */
- YY_CHAR *yy_buf_pos; /* current position in input buffer */
+ YY_CHAR *yy_ch_buf; /* input buffer */
+ YY_CHAR *yy_buf_pos; /* current position in input buffer */
- /* size of input buffer in bytes, not including room for EOB characters */
- int yy_buf_size;
+ /* Size of input buffer in bytes, not including room for EOB
+ * characters.
+ */
+ int yy_buf_size;
- /* number of characters read into yy_ch_buf, not including EOB characters */
- int yy_n_chars;
+ /* Number of characters read into yy_ch_buf, not including EOB
+ * characters.
+ */
+ int yy_n_chars;
- int yy_eof_status; /* whether we've seen an EOF on this buffer */
+ /* Whether we've seen an EOF on this buffer. */
+ int yy_eof_status;
#define EOF_NOT_SEEN 0
- /* "pending" happens when the EOF has been seen but there's still
- * some text process
- */
+ /* "Pending" happens when the EOF has been seen but there's still
+ * some text to process.
+ */
#define EOF_PENDING 1
#define EOF_DONE 2
- };
+ };
static YY_BUFFER_STATE yy_current_buffer = 0;
-/* we provide macros for accessing buffer states in case in the
+/* We provide macros for accessing buffer states in case in the
* future we want to put the buffer states in a more general
- * "scanner state"
+ * "scanner state".
*/
#define YY_CURRENT_BUFFER yy_current_buffer
-/* yy_hold_char holds the character lost when yytext is formed */
+/* yy_hold_char holds the character lost when yytext is formed. */
static YY_CHAR yy_hold_char;
static int yy_n_chars; /* number of characters read into yy_ch_buf */
%% data tables for the DFA go here
-/* these variables are all declared out here so that section 3 code can
- * manipulate them
+/* These variables are all declared out here so that section 3 code can
+ * manipulate them.
*/
-/* points to current character in buffer */
+/* Points to current character in buffer. */
static YY_CHAR *yy_c_buf_p = (YY_CHAR *) 0;
static int yy_init = 1; /* whether we need to initialize */
static int yy_start = 0; /* start state number */
-/* flag which is used to allow yywrap()'s to do buffer switches
+/* Flag which is used to allow yywrap()'s to do buffer switches
* instead of setting up a fresh yyin. A bit of a hack ...
*/
static int yy_did_buffer_switch_on_eof;
#endif
YY_DECL
- {
- register yy_state_type yy_current_state;
- register YY_CHAR *yy_cp, *yy_bp;
- register int yy_act;
+ {
+ register yy_state_type yy_current_state;
+ register YY_CHAR *yy_cp, *yy_bp;
+ register int yy_act;
%% user's declarations go here
- if ( yy_init )
- {
+ if ( yy_init )
+ {
#ifdef YY_USER_INIT
- YY_USER_INIT;
+ YY_USER_INIT;
#endif
- if ( ! yy_start )
- yy_start = 1; /* first start state */
+ if ( ! yy_start )
+ yy_start = 1; /* first start state */
- if ( ! yyin )
- yyin = stdin;
+ if ( ! yyin )
+ yyin = stdin;
- if ( ! yyout )
- yyout = stdout;
+ if ( ! yyout )
+ yyout = stdout;
- if ( yy_current_buffer )
- yy_init_buffer( yy_current_buffer, yyin );
- else
- yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
+ if ( yy_current_buffer )
+ yy_init_buffer( yy_current_buffer, yyin );
+ else
+ yy_current_buffer =
+ yy_create_buffer( yyin, YY_BUF_SIZE );
- yy_load_buffer_state();
+ yy_load_buffer_state();
- yy_init = 0;
- }
+ yy_init = 0;
+ }
- while ( 1 ) /* loops until end-of-file is reached */
- {
+ while ( 1 ) /* loops until end-of-file is reached */
+ {
%% yymore()-related code goes here
- yy_cp = yy_c_buf_p;
+ yy_cp = yy_c_buf_p;
- /* support of yytext */
- *yy_cp = yy_hold_char;
+ /* Support of yytext. */
+ *yy_cp = yy_hold_char;
- /* yy_bp points to the position in yy_ch_buf of the start of the
- * current run.
- */
- yy_bp = yy_cp;
+ /* yy_bp points to the position in yy_ch_buf of the start of
+ * the current run.
+ */
+ yy_bp = yy_cp;
%% code to set up and find next match goes here
yy_find_action:
%% code to find the action number goes here
- YY_DO_BEFORE_ACTION;
+ YY_DO_BEFORE_ACTION;
#ifdef YY_USER_ACTION
- if ( yy_act != YY_END_OF_BUFFER )
- {
- YY_USER_ACTION;
- }
+ if ( yy_act != YY_END_OF_BUFFER )
+ {
+ YY_USER_ACTION;
+ }
#endif
-do_action: /* this label is used only to access EOF actions */
+do_action: /* This label is used only to access EOF actions. */
%% debug code goes here
- switch ( yy_act )
- {
+ switch ( yy_act )
+ { /* beginning of action switch */
%% actions go here
- case YY_END_OF_BUFFER:
+ case YY_END_OF_BUFFER:
{
- /* amount of text matched not including the EOB char */
+ /* Amount of text matched not including the EOB char. */
int yy_amount_of_matched_text = yy_cp - yytext_ptr - 1;
- /* undo the effects of YY_DO_BEFORE_ACTION */
+ /* Undo the effects of YY_DO_BEFORE_ACTION. */
*yy_cp = yy_hold_char;
- /* note that here we test for yy_c_buf_p "<=" to the position
+ /* Note that here we test for yy_c_buf_p "<=" to the position
* of the first EOB in the buffer, since yy_c_buf_p will
* already have been incremented past the NUL character
- * (since all states make transitions on EOB to the end-
- * of-buffer state). Contrast this with the test in yyinput().
+ * (since all states make transitions on EOB to the
+ * end-of-buffer state). Contrast this with the test
+ * in yyinput().
*/
if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
- /* this was really a NUL */
- {
- yy_state_type yy_next_state;
+ { /* This was really a NUL. */
+ yy_state_type yy_next_state;
- yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
+ yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
- yy_current_state = yy_get_previous_state();
+ yy_current_state = yy_get_previous_state();
- /* okay, we're now positioned to make the
- * NUL transition. We couldn't have
- * yy_get_previous_state() go ahead and do it
- * for us because it doesn't know how to deal
- * with the possibility of jamming (and we
- * don't want to build jamming into it because
- * then it will run more slowly)
- */
+ /* Okay, we're now positioned to make the NUL
+ * transition. We couldn't have
+ * yy_get_previous_state() go ahead and do it
+ * for us because it doesn't know how to deal
+ * with the possibility of jamming (and we don't
+ * want to build jamming into it because then it
+ * will run more slowly).
+ */
- yy_next_state = yy_try_NUL_trans( yy_current_state );
+ yy_next_state = yy_try_NUL_trans( yy_current_state );
- yy_bp = yytext_ptr + YY_MORE_ADJ;
+ yy_bp = yytext_ptr + YY_MORE_ADJ;
- if ( yy_next_state )
- {
- /* consume the NUL */
- yy_cp = ++yy_c_buf_p;
- yy_current_state = yy_next_state;
- goto yy_match;
- }
+ if ( yy_next_state )
+ {
+ /* Consume the NUL. */
+ yy_cp = ++yy_c_buf_p;
+ yy_current_state = yy_next_state;
+ goto yy_match;
+ }
- else
- {
+ else
+ {
%% code to do backtracking for compressed tables and set up yy_cp goes here
- goto yy_find_action;
+ goto yy_find_action;
+ }
}
- }
else switch ( yy_get_next_buffer() )
- {
- case EOB_ACT_END_OF_FILE:
{
- yy_did_buffer_switch_on_eof = 0;
-
- if ( yywrap() )
- {
- /* note: because we've taken care in
- * yy_get_next_buffer() to have set up yytext,
- * we can now set up yy_c_buf_p so that if some
- * total hoser (like flex itself) wants
- * to call the scanner after we return the
- * YY_NULL, it'll still work - another YY_NULL
- * will get returned.
- */
- yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
-
- yy_act = YY_STATE_EOF((yy_start - 1) / 2);
- goto do_action;
- }
-
- else
- {
- if ( ! yy_did_buffer_switch_on_eof )
- YY_NEW_FILE;
- }
+ case EOB_ACT_END_OF_FILE:
+ {
+ yy_did_buffer_switch_on_eof = 0;
+
+ if ( yywrap() )
+ {
+ /* Note: because we've taken care in
+ * yy_get_next_buffer() to have set up
+ * yytext, we can now set up
+ * yy_c_buf_p so that if some total
+ * hoser (like flex itself) wants to
+ * call the scanner after we return the
+ * YY_NULL, it'll still work - another
+ * YY_NULL will get returned.
+ */
+ yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
+
+ yy_act = YY_STATE_EOF(
+ (yy_start - 1) / 2);
+ goto do_action;
+ }
+
+ else
+ {
+ if ( ! yy_did_buffer_switch_on_eof )
+ YY_NEW_FILE;
+ }
+ break;
+ }
+
+ case EOB_ACT_CONTINUE_SCAN:
+ yy_c_buf_p =
+ yytext_ptr + yy_amount_of_matched_text;
+
+ yy_current_state = yy_get_previous_state();
+
+ yy_cp = yy_c_buf_p;
+ yy_bp = yytext_ptr + YY_MORE_ADJ;
+ goto yy_match;
+
+ case EOB_ACT_LAST_MATCH:
+ yy_c_buf_p =
+ &yy_current_buffer->yy_ch_buf[yy_n_chars];
+
+ yy_current_state = yy_get_previous_state();
+
+ yy_cp = yy_c_buf_p;
+ yy_bp = yytext_ptr + YY_MORE_ADJ;
+ goto yy_find_action;
}
- break;
-
- case EOB_ACT_CONTINUE_SCAN:
- yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
-
- yy_current_state = yy_get_previous_state();
-
- yy_cp = yy_c_buf_p;
- yy_bp = yytext_ptr + YY_MORE_ADJ;
- goto yy_match;
-
- case EOB_ACT_LAST_MATCH:
- yy_c_buf_p =
- &yy_current_buffer->yy_ch_buf[yy_n_chars];
-
- yy_current_state = yy_get_previous_state();
-
- yy_cp = yy_c_buf_p;
- yy_bp = yytext_ptr + YY_MORE_ADJ;
- goto yy_find_action;
- }
break;
}
- default:
+ default:
#ifdef FLEX_DEBUG
printf( "action # %d\n", yy_act );
#endif
YY_FATAL_ERROR(
"fatal flex scanner internal error--no action found" );
- }
- }
- }
+ } /* end of action switch */
+ } /* end of scanning one token */
+ } /* end of yylex */
/* yy_get_next_buffer - try to read in a new buffer
*
- * synopsis
- * int yy_get_next_buffer();
- *
- * returns a code representing an action
- * EOB_ACT_LAST_MATCH -
- * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
- * EOB_ACT_END_OF_FILE - end of file
+ * Returns a code representing an action:
+ * EOB_ACT_LAST_MATCH -
+ * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
+ * EOB_ACT_END_OF_FILE - end of file
*/
static int yy_get_next_buffer()
+ {
+ register YY_CHAR *dest = yy_current_buffer->yy_ch_buf;
+ register YY_CHAR *source = yytext_ptr - 1; /* copy prev. char, too */
+ register int number_to_move, i;
+ int ret_val;
- {
- register YY_CHAR *dest = yy_current_buffer->yy_ch_buf;
- register YY_CHAR *source = yytext_ptr - 1; /* copy prev. char, too */
- register int number_to_move, i;
- int ret_val;
-
- if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
- YY_FATAL_ERROR(
+ if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
+ YY_FATAL_ERROR(
"fatal flex scanner internal error--end of buffer missed" );
- /* try to read more data */
+ /* Try to read more data. */
- /* first move last chars to start of buffer */
- number_to_move = yy_c_buf_p - yytext_ptr;
+ /* First move last chars to start of buffer. */
+ number_to_move = yy_c_buf_p - yytext_ptr;
- for ( i = 0; i < number_to_move; ++i )
- *(dest++) = *(source++);
+ for ( i = 0; i < number_to_move; ++i )
+ *(dest++) = *(source++);
- if ( yy_current_buffer->yy_eof_status != EOF_NOT_SEEN )
- /* don't do the read, it's not guaranteed to return an EOF,
- * just force an EOF
- */
- yy_n_chars = 0;
+ if ( yy_current_buffer->yy_eof_status != EOF_NOT_SEEN )
+ /* don't do the read, it's not guaranteed to return an EOF,
+ * just force an EOF
+ */
+ yy_n_chars = 0;
- else
- {
- int num_to_read = yy_current_buffer->yy_buf_size - number_to_move - 1;
+ else
+ {
+ int num_to_read =
+ yy_current_buffer->yy_buf_size - number_to_move - 1;
- if ( num_to_read > YY_READ_BUF_SIZE )
- num_to_read = YY_READ_BUF_SIZE;
+ if ( num_to_read > YY_READ_BUF_SIZE )
+ num_to_read = YY_READ_BUF_SIZE;
- else if ( num_to_read <= 0 )
- YY_FATAL_ERROR( "fatal error - scanner input buffer overflow" );
+ else if ( num_to_read <= 0 )
+ YY_FATAL_ERROR(
+ "fatal error - scanner input buffer overflow" );
- /* read in more data */
- YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
- yy_n_chars, num_to_read );
- }
+ /* Read in more data. */
+ YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
+ yy_n_chars, num_to_read );
+ }
- if ( yy_n_chars == 0 )
- {
- if ( number_to_move - YY_MORE_ADJ == 1 )
- {
- ret_val = EOB_ACT_END_OF_FILE;
- yy_current_buffer->yy_eof_status = EOF_DONE;
- }
+ if ( yy_n_chars == 0 )
+ {
+ if ( number_to_move - YY_MORE_ADJ == 1 )
+ {
+ ret_val = EOB_ACT_END_OF_FILE;
+ yy_current_buffer->yy_eof_status = EOF_DONE;
+ }
- else
- {
- ret_val = EOB_ACT_LAST_MATCH;
- yy_current_buffer->yy_eof_status = EOF_PENDING;
- }
- }
+ else
+ {
+ ret_val = EOB_ACT_LAST_MATCH;
+ yy_current_buffer->yy_eof_status = EOF_PENDING;
+ }
+ }
- else
- ret_val = EOB_ACT_CONTINUE_SCAN;
+ else
+ ret_val = EOB_ACT_CONTINUE_SCAN;
- yy_n_chars += number_to_move;
- yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
- yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
+ yy_n_chars += number_to_move;
+ yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
+ yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
- /* yytext begins at the second character in yy_ch_buf; the first
- * character is the one which preceded it before reading in the latest
- * buffer; it needs to be kept around in case it's a newline, so
- * yy_get_previous_state() will have with '^' rules active
- */
+ /* yytext begins at the second character in yy_ch_buf; the first
+ * character is the one which preceded it before reading in the latest
+ * buffer; it needs to be kept around in case it's a newline, so
+ * yy_get_previous_state() will have with '^' rules active.
+ */
- yytext_ptr = &yy_current_buffer->yy_ch_buf[1];
+ yytext_ptr = &yy_current_buffer->yy_ch_buf[1];
- return ret_val;
- }
+ return ret_val;
+ }
-/* yy_get_previous_state - get the state just before the EOB char was reached
- *
- * synopsis
- * yy_state_type yy_get_previous_state();
- */
+/* yy_get_previous_state - get the state just before the EOB char was reached */
static yy_state_type yy_get_previous_state()
-
- {
- register yy_state_type yy_current_state;
- register YY_CHAR *yy_cp;
+ {
+ register yy_state_type yy_current_state;
+ register YY_CHAR *yy_cp;
%% code to get the start state into yy_current_state goes here
- for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
- {
+ for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
+ {
%% code to find the next state goes here
- }
+ }
- return yy_current_state;
- }
+ return yy_current_state;
+ }
/* yy_try_NUL_trans - try to make a transition on the NUL character
*
* synopsis
- * next_state = yy_try_NUL_trans( current_state );
+ * next_state = yy_try_NUL_trans( current_state );
*/
#ifdef YY_USE_PROTOS
static yy_state_type yy_try_NUL_trans( yy_current_state )
register yy_state_type yy_current_state;
#endif
-
- {
- register int yy_is_jam;
+ {
+ register int yy_is_jam;
%% code to find the next state, and perhaps do backtracking, goes here
- return yy_is_jam ? 0 : yy_current_state;
- }
+ return yy_is_jam ? 0 : yy_current_state;
+ }
#ifdef YY_USE_PROTOS
YY_CHAR c;
register YY_CHAR *yy_bp;
#endif
+ {
+ register YY_CHAR *yy_cp = yy_c_buf_p;
- {
- register YY_CHAR *yy_cp = yy_c_buf_p;
-
- /* undo effects of setting up yytext */
- *yy_cp = yy_hold_char;
-
- if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
- { /* need to shift things up to make room */
- register int number_to_move = yy_n_chars + 2; /* +2 for EOB chars */
- register YY_CHAR *dest =
- &yy_current_buffer->yy_ch_buf[yy_current_buffer->yy_buf_size + 2];
- register YY_CHAR *source =
- &yy_current_buffer->yy_ch_buf[number_to_move];
-
- while ( source > yy_current_buffer->yy_ch_buf )
- *--dest = *--source;
-
- yy_cp += dest - source;
- yy_bp += dest - source;
- yy_n_chars = yy_current_buffer->yy_buf_size;
+ /* undo effects of setting up yytext */
+ *yy_cp = yy_hold_char;
if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
- YY_FATAL_ERROR( "flex scanner push-back overflow" );
- }
+ { /* need to shift things up to make room */
+ /* +2 for EOB chars. */
+ register int number_to_move = yy_n_chars + 2;
+ register YY_CHAR *dest = &yy_current_buffer->yy_ch_buf[
+ yy_current_buffer->yy_buf_size + 2];
+ register YY_CHAR *source =
+ &yy_current_buffer->yy_ch_buf[number_to_move];
+
+ while ( source > yy_current_buffer->yy_ch_buf )
+ *--dest = *--source;
+
+ yy_cp += dest - source;
+ yy_bp += dest - source;
+ yy_n_chars = yy_current_buffer->yy_buf_size;
+
+ if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
+ YY_FATAL_ERROR( "flex scanner push-back overflow" );
+ }
- if ( yy_cp > yy_bp && yy_cp[-1] == '\n' )
- yy_cp[-2] = '\n';
+ if ( yy_cp > yy_bp && yy_cp[-1] == '\n' )
+ yy_cp[-2] = '\n';
- *--yy_cp = c;
+ *--yy_cp = c;
- /* note: the formal parameter *must* be called "yy_bp" for this
- * macro to now work correctly
- */
- YY_DO_BEFORE_ACTION; /* set up yytext again */
- }
+ /* Note: the formal parameter *must* be called "yy_bp" for this
+ * macro to now work correctly.
+ */
+ YY_DO_BEFORE_ACTION; /* set up yytext again */
+ }
#ifdef __cplusplus
#else
static int input()
#endif
-
- {
- int c;
- YY_CHAR *yy_cp = yy_c_buf_p;
-
- *yy_cp = yy_hold_char;
-
- if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
{
- /* yy_c_buf_p now points to the character we want to return.
- * If this occurs *before* the EOB characters, then it's a
- * valid NUL; if not, then we've hit the end of the buffer.
- */
- if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
- /* this was really a NUL */
- *yy_c_buf_p = '\0';
+ int c;
+ YY_CHAR *yy_cp = yy_c_buf_p;
- else
- { /* need more input */
- yytext_ptr = yy_c_buf_p;
- ++yy_c_buf_p;
+ *yy_cp = yy_hold_char;
- switch ( yy_get_next_buffer() )
+ if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
{
- case EOB_ACT_END_OF_FILE:
- {
- if ( yywrap() )
- {
- yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
- return EOF;
- }
-
- YY_NEW_FILE;
-
+ /* yy_c_buf_p now points to the character we want to return.
+ * If this occurs *before* the EOB characters, then it's a
+ * valid NUL; if not, then we've hit the end of the buffer.
+ */
+ if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
+ /* This was really a NUL. */
+ *yy_c_buf_p = '\0';
+
+ else
+ { /* need more input */
+ yytext_ptr = yy_c_buf_p;
+ ++yy_c_buf_p;
+
+ switch ( yy_get_next_buffer() )
+ {
+ case EOB_ACT_END_OF_FILE:
+ {
+ if ( yywrap() )
+ {
+ yy_c_buf_p =
+ yytext_ptr + YY_MORE_ADJ;
+ return EOF;
+ }
+
+ YY_NEW_FILE;
#ifdef __cplusplus
- return yyinput();
+ return yyinput();
#else
- return input();
+ return input();
#endif
- }
+ }
- case EOB_ACT_CONTINUE_SCAN:
- yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
- break;
+ case EOB_ACT_CONTINUE_SCAN:
+ yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
+ break;
- case EOB_ACT_LAST_MATCH:
+ case EOB_ACT_LAST_MATCH:
#ifdef __cplusplus
- YY_FATAL_ERROR( "unexpected last match in yyinput()" );
+ YY_FATAL_ERROR(
+ "unexpected last match in yyinput()" );
#else
- YY_FATAL_ERROR( "unexpected last match in input()" );
+ YY_FATAL_ERROR(
+ "unexpected last match in input()" );
#endif
+ }
+ }
}
- }
- }
- c = *yy_c_buf_p;
- yy_hold_char = *++yy_c_buf_p;
+ c = *yy_c_buf_p;
+ yy_hold_char = *++yy_c_buf_p;
- return c;
- }
+ return c;
+ }
#ifdef YY_USE_PROTOS
void yyrestart( input_file )
FILE *input_file;
#endif
-
- {
- yy_init_buffer( yy_current_buffer, input_file );
- yy_load_buffer_state();
- }
+ {
+ yy_init_buffer( yy_current_buffer, input_file );
+ yy_load_buffer_state();
+ }
#ifdef YY_USE_PROTOS
void yy_switch_to_buffer( new_buffer )
YY_BUFFER_STATE new_buffer;
#endif
-
- {
- if ( yy_current_buffer == new_buffer )
- return;
-
- if ( yy_current_buffer )
{
- /* flush out information for old buffer */
- *yy_c_buf_p = yy_hold_char;
- yy_current_buffer->yy_buf_pos = yy_c_buf_p;
- yy_current_buffer->yy_n_chars = yy_n_chars;
- }
+ if ( yy_current_buffer == new_buffer )
+ return;
+
+ if ( yy_current_buffer )
+ {
+ /* Flush out information for old buffer. */
+ *yy_c_buf_p = yy_hold_char;
+ yy_current_buffer->yy_buf_pos = yy_c_buf_p;
+ yy_current_buffer->yy_n_chars = yy_n_chars;
+ }
- yy_current_buffer = new_buffer;
- yy_load_buffer_state();
+ yy_current_buffer = new_buffer;
+ yy_load_buffer_state();
- /* we don't actually know whether we did this switch during
- * EOF (yywrap()) processing, but the only time this flag
- * is looked at is after yywrap() is called, so it's safe
- * to go ahead and always set it.
- */
- yy_did_buffer_switch_on_eof = 1;
- }
+ /* We don't actually know whether we did this switch during
+ * EOF (yywrap()) processing, but the only time this flag
+ * is looked at is after yywrap() is called, so it's safe
+ * to go ahead and always set it.
+ */
+ yy_did_buffer_switch_on_eof = 1;
+ }
#ifdef YY_USE_PROTOS
#else
void yy_load_buffer_state()
#endif
-
- {
- yy_n_chars = yy_current_buffer->yy_n_chars;
- yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
- yyin = yy_current_buffer->yy_input_file;
- yy_hold_char = *yy_c_buf_p;
- }
+ {
+ yy_n_chars = yy_current_buffer->yy_n_chars;
+ yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
+ yyin = yy_current_buffer->yy_input_file;
+ yy_hold_char = *yy_c_buf_p;
+ }
#ifdef YY_USE_PROTOS
FILE *file;
int size;
#endif
+ {
+ YY_BUFFER_STATE b;
- {
- YY_BUFFER_STATE b;
-
- b = (YY_BUFFER_STATE) malloc( sizeof( struct yy_buffer_state ) );
+ b = (YY_BUFFER_STATE) malloc( sizeof( struct yy_buffer_state ) );
- if ( ! b )
- YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
+ if ( ! b )
+ YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
- b->yy_buf_size = size;
+ b->yy_buf_size = size;
- /* yy_ch_buf has to be 2 characters longer than the size given because
- * we need to put in 2 end-of-buffer characters.
- */
- b->yy_ch_buf = (YY_CHAR *) malloc( (unsigned) (b->yy_buf_size + 2) );
+ /* yy_ch_buf has to be 2 characters longer than the size given because
+ * we need to put in 2 end-of-buffer characters.
+ */
+ b->yy_ch_buf = (YY_CHAR *) malloc( (unsigned) (b->yy_buf_size + 2) );
- if ( ! b->yy_ch_buf )
- YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
+ if ( ! b->yy_ch_buf )
+ YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
- yy_init_buffer( b, file );
+ yy_init_buffer( b, file );
- return b;
- }
+ return b;
+ }
#ifdef YY_USE_PROTOS
void yy_delete_buffer( b )
YY_BUFFER_STATE b;
#endif
+ {
+ if ( b == yy_current_buffer )
+ yy_current_buffer = (YY_BUFFER_STATE) 0;
- {
- if ( b == yy_current_buffer )
- yy_current_buffer = (YY_BUFFER_STATE) 0;
-
- free( (char *) b->yy_ch_buf );
- free( (char *) b );
- }
+ free( (char *) b->yy_ch_buf );
+ free( (char *) b );
+ }
#ifdef YY_USE_PROTOS
YY_BUFFER_STATE b;
FILE *file;
#endif
+ {
+ b->yy_input_file = file;
- {
- b->yy_input_file = file;
-
- /* we put in the '\n' and start reading from [1] so that an
- * initial match-at-newline will be true.
- */
+ /* We put in the '\n' and start reading from [1] so that an
+ * initial match-at-newline will be true.
+ */
- b->yy_ch_buf[0] = '\n';
- b->yy_n_chars = 1;
+ b->yy_ch_buf[0] = '\n';
+ b->yy_n_chars = 1;
- /* we always need two end-of-buffer characters. The first causes
- * a transition to the end-of-buffer state. The second causes
- * a jam in that state.
- */
- b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
- b->yy_ch_buf[2] = YY_END_OF_BUFFER_CHAR;
+ /* We always need two end-of-buffer characters. The first causes
+ * a transition to the end-of-buffer state. The second causes
+ * a jam in that state.
+ */
+ b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
+ b->yy_ch_buf[2] = YY_END_OF_BUFFER_CHAR;
- b->yy_buf_pos = &b->yy_ch_buf[1];
+ b->yy_buf_pos = &b->yy_ch_buf[1];
- b->yy_eof_status = EOF_NOT_SEEN;
- }
+ b->yy_eof_status = EOF_NOT_SEEN;
+ }
#include <stdio.h>
#endif
-/* always be prepared to generate an 8-bit scanner */
+/* Always be prepared to generate an 8-bit scanner. */
#define FLEX_8_BIT_CHARS
#ifdef FLEX_8_BIT_CHARS
#define CSIZE 128
#endif
-/* size of input alphabet - should be size of ASCII set */
+/* Size of input alphabet - should be size of ASCII set. */
#ifndef DEFAULT_CSIZE
#define DEFAULT_CSIZE 128
#endif
#endif
-/* maximum line length we'll have to deal with */
+/* Maximum line length we'll have to deal with. */
#define MAXLINE BUFSIZ
-/* maximum size of file name */
+/* Maximum size of file name. */
#define FILENAMESIZE 1024
#ifndef min
#define false 0
-/* special chk[] values marking the slots taking by end-of-buffer and action
- * numbers
+/* Special chk[] values marking the slots taking by end-of-buffer and action
+ * numbers.
*/
#define EOB_POSITION -1
#define ACTION_POSITION -2
-/* number of data items per line for -f output */
+/* Number of data items per line for -f output. */
#define NUMDATAITEMS 10
-/* number of lines of data in -f output before inserting a blank line for
+/* Number of lines of data in -f output before inserting a blank line for
* readability.
*/
#define NUMDATALINES 10
-/* transition_struct_out() definitions */
+/* Transition_struct_out() definitions. */
#define TRANS_STRUCT_PRINT_LENGTH 15
-/* returns true if an nfa state has an epsilon out-transition slot
+/* Returns true if an nfa state has an epsilon out-transition slot
* that can be used. This definition is currently not used.
*/
#define FREE_EPSILON(state) \
trans2[state] == NO_TRANSITION && \
finalst[state] != state)
-/* returns true if an nfa state has an epsilon out-transition character
+/* Returns true if an nfa state has an epsilon out-transition character
* and both slots are free
*/
#define SUPER_FREE_EPSILON(state) \
(transchar[state] == SYM_EPSILON && \
trans1[state] == NO_TRANSITION) \
-/* maximum number of NFA states that can comprise a DFA state. It's real
+/* Maximum number of NFA states that can comprise a DFA state. It's real
* big because if there's a lot of rules, the initial state will have a
* huge epsilon closure.
*/
#define MAX_DFA_SIZE_INCREMENT 750
-/* a note on the following masks. They are used to mark accepting numbers
+/* A note on the following masks. They are used to mark accepting numbers
* as being special. As such, they implicitly limit the number of accepting
* numbers (i.e., rules) because if there are too many rules the rule numbers
* will overload the mask bits. Fortunately, this limit is \large/ (0x2000 ==
* new_rule() to ensure that this limit is not reached.
*/
-/* mask to mark a trailing context accepting number */
+/* Mask to mark a trailing context accepting number. */
#define YY_TRAILING_MASK 0x2000
-/* mask to mark the accepting number of the "head" of a trailing context rule */
+/* Mask to mark the accepting number of the "head" of a trailing context
+ * rule.
+ */
#define YY_TRAILING_HEAD_MASK 0x4000
-/* maximum number of rules, as outlined in the above note */
+/* Maximum number of rules, as outlined in the above note. */
#define MAX_RULE (YY_TRAILING_MASK - 1)
/* NIL must be 0. If not, its special meaning when making equivalence classes
- * (it marks the representative of a given e.c.) will be unidentifiable
+ * (it marks the representative of a given e.c.) will be unidentifiable.
*/
#define NIL 0
#define INITIAL_MAX_CCLS 100 /* max number of unique character classes */
#define MAX_CCLS_INCREMENT 100
-/* size of table holding members of character classes */
+/* Size of table holding members of character classes. */
#define INITIAL_MAX_CCL_TBL_SIZE 500
#define MAX_CCL_TBL_SIZE_INCREMENT 250
#define JAMSTATE -32766 /* marks a reference to the state that always jams */
-/* enough so that if it's subtracted from an NFA state number, the result
- * is guaranteed to be negative
+/* Enough so that if it's subtracted from an NFA state number, the result
+ * is guaranteed to be negative.
*/
#define MARKER_DIFFERENCE 32000
#define MAXIMUM_MNS 31999
-/* maximum number of nxt/chk pairs for non-templates */
+/* Maximum number of nxt/chk pairs for non-templates. */
#define INITIAL_MAX_XPAIRS 2000
#define MAX_XPAIRS_INCREMENT 2000
-/* maximum number of nxt/chk pairs needed for templates */
+/* Maximum number of nxt/chk pairs needed for templates. */
#define INITIAL_MAX_TEMPLATE_XPAIRS 2500
#define MAX_TEMPLATE_XPAIRS_INCREMENT 2500
#define ONE_STACK_SIZE 500 /* stack of states with only one out-transition */
#define SAME_TRANS -1 /* transition is the same as "default" entry for state */
-/* the following percentages are used to tune table compression:
+/* The following percentages are used to tune table compression:
- * the percentage the number of out-transitions a state must be of the
+ * The percentage the number of out-transitions a state must be of the
* number of equivalence classes in order to be considered for table
- * compaction by using protos
+ * compaction by using protos.
*/
#define PROTO_SIZE_PERCENTAGE 15
-/* the percentage the number of homogeneous out-transitions of a state
+/* The percentage the number of homogeneous out-transitions of a state
* must be of the number of total out-transitions of the state in order
* that the state's transition table is first compared with a potential
* template of the most common out-transition instead of with the first
- * proto in the proto queue
+ * proto in the proto queue.
*/
#define CHECK_COM_PERCENTAGE 50
-/* the percentage the number of differences between a state's transition
+/* The percentage the number of differences between a state's transition
* table and the proto it was first compared with must be of the total
* number of out-transitions of the state in order to keep the first
- * proto as a good match and not search any further
+ * proto as a good match and not search any further.
*/
#define FIRST_MATCH_DIFF_PERCENTAGE 10
-/* the percentage the number of differences between a state's transition
+/* The percentage the number of differences between a state's transition
* table and the most similar proto must be of the state's total number
- * of out-transitions to use the proto as an acceptable close match
+ * of out-transitions to use the proto as an acceptable close match.
*/
#define ACCEPTABLE_DIFF_PERCENTAGE 50
-/* the percentage the number of homogeneous out-transitions of a state
+/* The percentage the number of homogeneous out-transitions of a state
* must be of the number of total out-transitions of the state in order
- * to consider making a template from the state
+ * to consider making a template from the state.
*/
#define TEMPLATE_SAME_PERCENTAGE 60
-/* the percentage the number of differences between a state's transition
+/* The percentage the number of differences between a state's transition
* table and the most similar proto must be of the state's total number
- * of out-transitions to create a new proto from the state
+ * of out-transitions to create a new proto from the state.
*/
#define NEW_PROTO_DIFF_PERCENTAGE 20
-/* the percentage the total number of out-transitions of a state must be
+/* The percentage the total number of out-transitions of a state must be
* of the number of equivalence classes in order to consider trying to
* fit the transition table into "holes" inside the nxt/chk table.
*/
#define INTERIOR_FIT_PERCENTAGE 15
-/* size of region set aside to cache the complete transition table of
- * protos on the proto queue to enable quick comparisons
+/* Size of region set aside to cache the complete transition table of
+ * protos on the proto queue to enable quick comparisons.
*/
#define PROT_SAVE_SIZE 2000
#define MSP 50 /* maximum number of saved protos (protos on the proto queue) */
-/* maximum number of out-transitions a state can have that we'll rummage
+/* Maximum number of out-transitions a state can have that we'll rummage
* around through the interior of the internal fast table looking for a
- * spot for it
+ * spot for it.
*/
#define MAX_XTIONS_FULL_INTERIOR_FIT 4
-/* maximum number of rules which will be reported as being associated
- * with a DFA state
+/* Maximum number of rules which will be reported as being associated
+ * with a DFA state.
*/
#define MAX_ASSOC_RULES 100
-/* number that, if used to subscript an array, has a good chance of producing
- * an error; should be small enough to fit into a short
+/* Number that, if used to subscript an array, has a good chance of producing
+ * an error; should be small enough to fit into a short.
*/
#define BAD_SUBSCRIPT -32767
-/* absolute value of largest number that can be stored in a short, with a
+/* Absolute value of largest number that can be stored in a short, with a
* bit of slop thrown in for general paranoia.
*/
#define MAX_SHORT 32766
/* Declarations for global variables. */
-/* variables for symbol tables:
+/* Variables for symbol tables:
* sctbl - start-condition symbol table
* ndtbl - name-definition symbol table
* ccltab - character class text symbol table
*/
struct hash_entry
- {
- struct hash_entry *prev, *next;
- char *name;
- char *str_val;
- int int_val;
- } ;
+ {
+ struct hash_entry *prev, *next;
+ char *name;
+ char *str_val;
+ int int_val;
+ } ;
typedef struct hash_entry *hash_table[];
extern struct hash_entry *ccltab[CCL_HASH_SIZE];
-/* variables for flags:
+/* Variables for flags:
* printstats - if true (-v), dump statistics
* syntaxerror - true if a syntax error has been found
* eofseen - true if we've seen an eof in the input file
extern int yymore_really_used, reject_really_used;
-/* variables used in the flex input routines:
+/* Variables used in the flex input routines:
* datapos - characters on current output line
* dataline - number of contiguous lines of data in current data
- * statement. Used to generate readable -f output
+ * statement. Used to generate readable -f output
* linenum - current input line number
* skelfile - the skeleton file
* skel - compiled-in skeleton array
* prolog - pointer to where the prolog starts in action_array
* action_offset - index where the non-prolog starts in action_array
* action_index - index where the next action should go, with respect
- * to "action"
+ * to "action"
* action - pointer to where non-prolog starts; equal to
- * &action_array[action_offset]
+ * &action_array[action_offset]
*/
extern int datapos, dataline, linenum;
extern int action_size, action_offset, action_index;
-/* variables for stack of states having only one out-transition:
+/* Variables for stack of states having only one out-transition:
* onestate - state number
* onesym - transition symbol
* onenext - target state
extern int onenext[ONE_STACK_SIZE], onedef[ONE_STACK_SIZE], onesp;
-/* variables for nfa machine data:
+/* Variables for nfa machine data:
* current_mns - current maximum on number of NFA states
* num_rules - number of the last accepting state; also is number of
- * rules created so far
+ * rules created so far
* num_eof_rules - number of <<EOF>> rules
* default_rule - number of the default rule
* current_max_rules - current maximum number of rules
* accptnum - accepting number
* assoc_rule - rule associated with this NFA state (or 0 if none)
* state_type - a STATE_xxx type identifying whether the state is part
- * of a normal rule, the leading state in a trailing context
- * rule (i.e., the state which marks the transition from
- * recognizing the text-to-be-matched to the beginning of
- * the trailing context), or a subsequent state in a trailing
- * context rule
+ * of a normal rule, the leading state in a trailing context
+ * rule (i.e., the state which marks the transition from
+ * recognizing the text-to-be-matched to the beginning of
+ * the trailing context), or a subsequent state in a trailing
+ * context rule
* rule_type - a RULE_xxx type identifying whether this a ho-hum
- * normal rule or one which has variable head & trailing
- * context
+ * normal rule or one which has variable head & trailing
+ * context
* rule_linenum - line number associated with rule
* rule_useful - true if we've determined that the rule can be matched
*/
extern int *accptnum, *assoc_rule, *state_type;
extern int *rule_type, *rule_linenum, *rule_useful;
-/* different types of states; values are useful as masks, as well, for
- * routines like check_trailing_context()
+/* Different types of states; values are useful as masks, as well, for
+ * routines like check_trailing_context().
*/
#define STATE_NORMAL 0x1
#define STATE_TRAILING_CONTEXT 0x2
-/* global holding current type of state we're making */
+/* Global holding current type of state we're making. */
extern int current_state_type;
-/* different types of rules */
+/* Different types of rules. */
#define RULE_NORMAL 0
#define RULE_VARIABLE 1
-/* true if the input rules include a rule with both variable-length head
- * and trailing context, false otherwise
+/* True if the input rules include a rule with both variable-length head
+ * and trailing context, false otherwise.
*/
extern int variable_trailing_context_rules;
-/* variables for protos:
+/* Variables for protos:
* numtemps - number of templates created
* numprots - number of protos created
* protprev - backlink to a more-recently used proto
extern int protcomst[MSP], firstprot, lastprot, protsave[PROT_SAVE_SIZE];
-/* variables for managing equivalence classes:
+/* Variables for managing equivalence classes:
* numecs - number of equivalence classes
* nextecm - forward link of Equivalence Class members
* ecgroup - class number or backward link of EC members
* tecbck - backward link of MEC's
*/
-/* reserve enough room in the equivalence class arrays so that we
+/* Reserve enough room in the equivalence class arrays so that we
* can use the CSIZE'th element to hold equivalence class information
* for the NUL character. Later we'll move this information into
* the 0th element.
*/
extern int numecs, nextecm[CSIZE + 1], ecgroup[CSIZE + 1], nummecs;
-/* meta-equivalence classes are indexed starting at 1, so it's possible
+/* Meta-equivalence classes are indexed starting at 1, so it's possible
* that they will require positions from 1 .. CSIZE, i.e., CSIZE + 1
* slots total (since the arrays are 0-based). nextecm[] and ecgroup[]
* don't require the extra position since they're indexed from 1 .. CSIZE - 1.
extern int tecfwd[CSIZE + 1], tecbck[CSIZE + 1];
-/* variables for start conditions:
+/* Variables for start conditions:
* lastsc - last start condition created
* current_max_scs - current limit on number of start conditions
* scset - set of rules active in start condition
* sceof - true if start condition has EOF rule
* scname - start condition name
* actvsc - stack of active start conditions for the current rule;
- * a negative entry means that the start condition is *not*
- * active for the current rule. Start conditions may appear
- * multiple times on the stack; the entry for it closest
- * to the top of the stack (i.e., actvsc[actvp]) is the
- * one to use. Others are present from "<sc>{" scoping
- * constructs.
+ * a negative entry means that the start condition is *not*
+ * active for the current rule. Start conditions may appear
+ * multiple times on the stack; the entry for it closest
+ * to the top of the stack (i.e., actvsc[actvp]) is the
+ * one to use. Others are present from "<sc>{" scoping
+ * constructs.
*/
extern int lastsc, current_max_scs, *scset, *scbol, *scxclu, *sceof, *actvsc;
extern char **scname;
-/* variables for dfa machine data:
+/* Variables for dfa machine data:
* current_max_dfa_size - current maximum number of NFA states in DFA
* current_max_xpairs - current maximum number of non-template xtion pairs
* current_max_template_xpairs - current maximum number of template pairs
* accsiz - size of accepting set for each dfa state
* dhash - dfa state hash value
* numas - number of DFA accepting states created; note that this
- * is not necessarily the same value as num_rules, which is the analogous
- * value for the NFA
+ * is not necessarily the same value as num_rules, which is the analogous
+ * value for the NFA
* numsnpairs - number of state/nextstate transition pairs
* jambase - position in base/def where the default jam table starts
* jamstate - state number corresponding to "jam" state
extern int lastdfa, lasttemp, *nxt, *chk, *tnxt;
extern int *base, *def, *nultrans, NUL_ec, tblend, firstfree, **dss, *dfasiz;
extern union dfaacc_union
- {
- int *dfaacc_set;
- int dfaacc_state;
- } *dfaacc;
+ {
+ int *dfaacc_set;
+ int dfaacc_state;
+ } *dfaacc;
extern int *accsiz, *dhash, numas;
extern int numsnpairs, jambase, jamstate;
extern int end_of_buffer_state;
-/* variables for ccl information:
+/* Variables for ccl information:
* lastccl - ccl index of the last created ccl
* current_maxccls - current limit on the maximum number of unique ccl's
* cclmap - maps a ccl index to its set pointer
extern Char *ccltbl;
-/* variables for miscellaneous information:
+/* Variables for miscellaneous information:
* starttime - real-time when we started
* endtime - real-time when we ended
* nmstr - last NAME scanned by the scanner
* numeps - number of epsilon NFA states created
* eps2 - number of epsilon states which have 2 out-transitions
* num_reallocs - number of times it was necessary to realloc() a group
- * of arrays
+ * of arrays
* tmpuses - number of DFA states that chain to templates
* totnst - total number of NFA states used to make DFA states
* peakpairs - peak number of transition pairs we had to store internally
(Char *) reallocate_array( (void *) array, size, sizeof( Char ) )
-/* used to communicate between scanner and parser. The type should really
+/* Used to communicate between scanner and parser. The type should really
* be YYSTYPE, but we can't easily get our hands on it.
*/
extern int yylval;
-/* external functions that are cross-referenced among the flex source files */
+/* External functions that are cross-referenced among the flex source files. */
/* from file ccl.c */
-extern void ccladd PROTO((int, int)); /* Add a single character to a ccl */
+extern void ccladd PROTO((int, int)); /* add a single character to a ccl */
extern int cclinit PROTO((void)); /* make an empty ccl */
extern void cclnegate PROTO((int)); /* negate a ccl */
-/* list the members of a set of characters in CCL form */
+/* List the members of a set of characters in CCL form. */
extern void list_character_set PROTO((FILE*, int[]));
/* from file dfa.c */
-/* increase the maximum number of dfas */
+/* Increase the maximum number of dfas. */
extern void increase_max_dfas PROTO((void));
extern void ntod PROTO((void)); /* convert a ndfa to a dfa */
/* from file ecs.c */
-/* convert character classes to set of equivalence classes */
+/* Convert character classes to set of equivalence classes. */
extern void ccl2ecl PROTO((void));
-/* associate equivalence class numbers with class members */
+/* Associate equivalence class numbers with class members. */
extern int cre8ecs PROTO((int[], int[], int));
-/* update equivalence classes based on character class transitions */
+/* Update equivalence classes based on character class transitions. */
extern void mkeccl PROTO((Char[], int, int[], int[], int, int));
-/* create equivalence class for single character */
+/* Create equivalence class for single character. */
extern void mkechar PROTO((int, int[], int[]));
/* Add the given text to the stored actions. */
extern void add_action PROTO(( char *new_text ));
-/* true if a string is all lower case */
+/* True if a string is all lower case. */
extern int all_lower PROTO((register Char *));
-/* true if a string is all upper case */
+/* True if a string is all upper case. */
extern int all_upper PROTO((register Char *));
-/* bubble sort an integer array */
+/* Bubble sort an integer array. */
extern void bubble PROTO((int [], int));
-/* shell sort a character array */
+/* Shell sort a character array. */
extern void cshell PROTO((Char [], int, int));
-/* finish up a block of data declarations */
+/* Finish up a block of data declarations. */
extern void dataend PROTO((void));
-/* report an error message and terminate */
+/* Report an error message and terminate. */
extern void flexerror PROTO((char[]));
-/* report a fatal error message and terminate */
+/* Report a fatal error message and terminate. */
extern void flexfatal PROTO((char[]));
-/* report an error message formatted with one integer argument */
+/* Report an error message formatted with one integer argument. */
extern void lerrif PROTO((char[], int));
-/* report an error message formatted with one string argument */
+/* Report an error message formatted with one string argument. */
extern void lerrsf PROTO((char[], char[]));
-/* spit out a "# line" statement */
+/* Spit out a "# line" statement. */
extern void line_directive_out PROTO((FILE*));
-/* mark the current position in the action array as the end of the prolog */
+/* Mark the current position in the action array as the end of the prolog. */
extern void mark_prolog PROTO(());
-/* generate a data statment for a two-dimensional array */
+/* Generate a data statment for a two-dimensional array. */
extern void mk2data PROTO((int));
extern void mkdata PROTO((int)); /* generate a data statement */
-/* return the integer represented by a string of digits */
+/* Return the integer represented by a string of digits. */
extern int myctoi PROTO((Char []));
-/* write out one section of the skeleton file */
+/* Write out one section of the skeleton file. */
extern void skelout PROTO((void));
-/* output a yy_trans_info structure */
+/* Output a yy_trans_info structure. */
extern void transition_struct_out PROTO((int, int));
-/* set a region of memory to 0 */
+/* Set a region of memory to 0. */
extern void zero_out PROTO((char *, int));
/* from file nfa.c */
-/* add an accepting state to a machine */
+/* Add an accepting state to a machine. */
extern void add_accept PROTO((int, int));
-/* make a given number of copies of a singleton machine */
+/* Make a given number of copies of a singleton machine. */
extern int copysingl PROTO((int, int));
-/* debugging routine to write out an nfa */
+/* Debugging routine to write out an nfa. */
extern void dumpnfa PROTO((int));
-/* finish up the processing for a rule */
+/* Finish up the processing for a rule. */
extern void finish_rule PROTO((int, int, int, int));
-/* connect two machines together */
+/* Connect two machines together. */
extern int link_machines PROTO((int, int));
-/* mark each "beginning" state in a machine as being a "normal" (i.e.,
- * not trailing context associated) state
+/* Mark each "beginning" state in a machine as being a "normal" (i.e.,
+ * not trailing context associated) state.
*/
extern void mark_beginning_as_normal PROTO((register int));
-/* make a machine that branches to two machines */
+/* Make a machine that branches to two machines. */
extern int mkbranch PROTO((int, int));
extern int mkclos PROTO((int)); /* convert a machine into a closure */
extern int mkopt PROTO((int)); /* make a machine optional */
-/* make a machine that matches either one of two machines */
+/* Make a machine that matches either one of two machines. */
extern int mkor PROTO((int, int));
-/* convert a machine into a positive closure */
+/* Convert a machine into a positive closure. */
extern int mkposcl PROTO((int));
extern int mkrep PROTO((int, int, int)); /* make a replicated machine */
-/* create a state with a transition on a given symbol */
+/* Create a state with a transition on a given symbol. */
extern int mkstate PROTO((int));
extern void new_rule PROTO((void)); /* initialize for a new rule */
/* from file parse.y */
-/* write out a message formatted with one string, pinpointing its location */
+/* Write out a message formatted with one string, pinpointing its location. */
extern void format_pinpoint_message PROTO((char[], char[]));
-/* write out a message, pinpointing its location */
+/* Write out a message, pinpointing its location. */
extern void pinpoint_message PROTO((char[]));
-/* write out a warning, pinpointing it at the given line */
+/* Write out a warning, pinpointing it at the given line. */
void line_warning PROTO(( char[], int ));
-/* write out a message, pinpointing it at the given line */
+/* Write out a message, pinpointing it at the given line. */
void line_pinpoint PROTO(( char[], int ));
-/* report a formatted syntax error */
+/* Report a formatted syntax error. */
extern void format_synerr PROTO((char [], char[]));
extern void synerr PROTO((char [])); /* report a syntax error */
extern void warn PROTO((char [])); /* report a warning */
/* from file scan.l */
-/* the Flex-generated scanner for flex */
+/* The Flex-generated scanner for flex. */
extern int flexscan PROTO((void));
-/* open the given file (if NULL, stdin) for scanning */
+/* Open the given file (if NULL, stdin) for scanning. */
extern void set_input_file PROTO((char*));
-/* wrapup a file in the lexical analyzer */
+/* Wrapup a file in the lexical analyzer. */
extern int yywrap PROTO((void));
/* from file sym.c */
-/* save the text of a character class */
+/* Save the text of a character class. */
extern void cclinstal PROTO ((Char [], int));
-/* lookup the number associated with character class */
+/* Lookup the number associated with character class. */
extern int ccllookup PROTO((Char []));
extern void ndinstal PROTO((char[], Char[])); /* install a name definition */
-/* increase maximum number of SC's */
+/* Increase maximum number of SC's. */
extern void scextend PROTO((void));
extern void scinstal PROTO((char[], int)); /* make a start condition */
-/* lookup the number associated with a start condition */
+/* Lookup the number associated with a start condition. */
extern int sclookup PROTO((char[]));
/* from file tblcmp.c */
-/* build table entries for dfa state */
+/* Build table entries for dfa state. */
extern void bldtbl PROTO((int[], int, int, int, int));
extern void cmptmps PROTO((void)); /* compress template table entries */
extern void inittbl PROTO((void)); /* initialize transition tables */
-/* make the default, "jam" table entries */
+/* Make the default, "jam" table entries. */
extern void mkdeftbl PROTO((void));
-/* create table entries for a state (or state fragment) which has
- * only one out-transition */
+/* Create table entries for a state (or state fragment) which has
+ * only one out-transition.
+ */
extern void mk1tbl PROTO((int, int, int, int));
-/* place a state into full speed transition table */
+/* Place a state into full speed transition table. */
extern void place_state PROTO((int*, int, int));
-/* save states with only one out-transition to be processed later */
+/* Save states with only one out-transition to be processed later. */
extern void stack1 PROTO((int, int, int, int));
extern int yylex PROTO((void));
-/* The Unix kernel calls used here */
+/* The Unix system calls used here. */
extern int read PROTO((int, char*, int));
extern int unlink PROTO((char*));
void indent_puts PROTO((char []));
-static int indent_level = 0; /* each level is 4 spaces */
+static int indent_level = 0; /* each level is 8 spaces */
#define indent_up() (++indent_level)
#define indent_down() (--indent_level)
#define set_indent(indent_val) indent_level = indent_val
-/* *everything* is done in terms of arrays starting at 1, so provide
- * a null entry for the zero element of all C arrays
+/* *Everything* is done in terms of arrays starting at 1, so provide
+ * a null entry for the zero element of all C arrays.
*/
static char C_short_decl[] = "static const short int %s[%d] =\n { 0,\n";
static char C_long_decl[] = "static const long int %s[%d] =\n { 0,\n";
"static const yy_state_type %s[%d] =\n { 0,\n";
-/* indent to the current level */
+/* Indent to the current level. */
void do_indent()
+ {
+ register int i = indent_level * 8;
- {
- register int i = indent_level * 4;
+ while ( i >= 8 )
+ {
+ putchar( '\t' );
+ i -= 8;
+ }
- while ( i >= 8 )
- {
- putchar( '\t' );
- i -= 8;
- }
-
- while ( i > 0 )
- {
- putchar( ' ' );
- --i;
+ while ( i > 0 )
+ {
+ putchar( ' ' );
+ --i;
+ }
}
- }
-/* generate the code to keep backtracking information */
+/* Generate the code to keep backtracking information. */
void gen_backtracking()
+ {
+ if ( reject || num_backtracking == 0 )
+ return;
- {
- if ( reject || num_backtracking == 0 )
- return;
-
- if ( fullspd )
- indent_puts( "if ( yy_current_state[-1].yy_nxt )" );
- else
- indent_puts( "if ( yy_accept[yy_current_state] )" );
+ if ( fullspd )
+ indent_puts( "if ( yy_current_state[-1].yy_nxt )" );
+ else
+ indent_puts( "if ( yy_accept[yy_current_state] )" );
- indent_up();
- indent_puts( "{" );
- indent_puts( "yy_last_accepting_state = yy_current_state;" );
- indent_puts( "yy_last_accepting_cpos = yy_cp;" );
- indent_puts( "}" );
- indent_down();
- }
+ indent_up();
+ indent_puts( "{" );
+ indent_puts( "yy_last_accepting_state = yy_current_state;" );
+ indent_puts( "yy_last_accepting_cpos = yy_cp;" );
+ indent_puts( "}" );
+ indent_down();
+ }
-/* generate the code to perform the backtrack */
+/* Generate the code to perform the backtrack. */
void gen_bt_action()
+ {
+ if ( reject || num_backtracking == 0 )
+ return;
- {
- if ( reject || num_backtracking == 0 )
- return;
-
- set_indent( 3 );
+ set_indent( 3 );
- indent_puts( "case 0: /* must backtrack */" );
- indent_puts( "/* undo the effects of YY_DO_BEFORE_ACTION */" );
- indent_puts( "*yy_cp = yy_hold_char;" );
+ indent_puts( "case 0: /* must backtrack */" );
+ indent_puts( "/* undo the effects of YY_DO_BEFORE_ACTION */" );
+ indent_puts( "*yy_cp = yy_hold_char;" );
- if ( fullspd || fulltbl )
- indent_puts( "yy_cp = yy_last_accepting_cpos + 1;" );
- else
- /* backtracking info for compressed tables is taken \after/
- * yy_cp has been incremented for the next state
- */
- indent_puts( "yy_cp = yy_last_accepting_cpos;" );
+ if ( fullspd || fulltbl )
+ indent_puts( "yy_cp = yy_last_accepting_cpos + 1;" );
+ else
+ /* Backtracking info for compressed tables is taken \after/
+ * yy_cp has been incremented for the next state.
+ */
+ indent_puts( "yy_cp = yy_last_accepting_cpos;" );
- indent_puts( "yy_current_state = yy_last_accepting_state;" );
- indent_puts( "goto yy_find_action;" );
- putchar( '\n' );
+ indent_puts( "yy_current_state = yy_last_accepting_state;" );
+ indent_puts( "goto yy_find_action;" );
+ putchar( '\n' );
- set_indent( 0 );
- }
+ set_indent( 0 );
+ }
-/* genctbl - generates full speed compressed transition table
- *
- * synopsis
- * genctbl();
- */
+/* genctbl - generates full speed compressed transition table */
void genctbl()
-
- {
- register int i;
- int end_of_buffer_action = num_rules + 1;
-
- /* table of verify for transition and offset to next state */
- printf( "static const struct yy_trans_info yy_transition[%d] =\n",
- tblend + numecs + 1 );
- printf( " {\n" );
-
- /* 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[chk[i]]. 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.
- */
- /* at this point, we're guaranteed that there's enough room in nxt[]
- * and chk[] to hold tblend + numecs entries. We need just two 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.
- */
-
- base[lastdfa + 1] = tblend + 2;
- nxt[tblend + 1] = end_of_buffer_action;
- chk[tblend + 1] = numecs + 1;
- chk[tblend + 2] = 1; /* anything but EOB */
- nxt[tblend + 2] = 0; /* so that "make test" won't show arb. differences */
-
- /* make sure every state has a end-of-buffer transition and an action # */
- for ( i = 0; i <= lastdfa; ++i )
{
- register int anum = dfaacc[i].dfaacc_state;
+ register int i;
+ int end_of_buffer_action = num_rules + 1;
+
+ /* Table of verify for transition and offset to next state. */
+ printf( "static const struct yy_trans_info yy_transition[%d] =\n",
+ tblend + numecs + 1 );
+ printf( " {\n" );
+
+ /* 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[chk[i]]. 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.
+ */
- chk[base[i]] = EOB_POSITION;
- chk[base[i] - 1] = ACTION_POSITION;
- nxt[base[i] - 1] = anum; /* action number */
- }
+ /* At this point, we're guaranteed that there's enough room in nxt[]
+ * and chk[] to hold tblend + numecs entries. We need just two 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.
+ */
- for ( i = 0; i <= tblend; ++i )
- {
- if ( chk[i] == EOB_POSITION )
- transition_struct_out( 0, base[lastdfa + 1] - i );
+ base[lastdfa + 1] = tblend + 2;
+ nxt[tblend + 1] = end_of_buffer_action;
+ chk[tblend + 1] = numecs + 1;
+ chk[tblend + 2] = 1; /* anything but EOB */
- else if ( chk[i] == ACTION_POSITION )
- transition_struct_out( 0, nxt[i] );
+ /* So that "make test" won't show arb. differences. */
+ nxt[tblend + 2] = 0;
- else if ( chk[i] > numecs || chk[i] == 0 )
- transition_struct_out( 0, 0 ); /* unused slot */
+ /* Make sure every state has a end-of-buffer transition and an
+ * action #.
+ */
+ for ( i = 0; i <= lastdfa; ++i )
+ {
+ register int anum = dfaacc[i].dfaacc_state;
- else /* verify, transition */
- transition_struct_out( chk[i], base[nxt[i]] - (i - chk[i]) );
- }
+ chk[base[i]] = EOB_POSITION;
+ chk[base[i] - 1] = ACTION_POSITION;
+ nxt[base[i] - 1] = anum; /* action number */
+ }
+ for ( i = 0; i <= tblend; ++i )
+ {
+ if ( chk[i] == EOB_POSITION )
+ transition_struct_out( 0, base[lastdfa + 1] - i );
- /* here's the final, end-of-buffer state */
- transition_struct_out( chk[tblend + 1], nxt[tblend + 1] );
- transition_struct_out( chk[tblend + 2], nxt[tblend + 2] );
+ else if ( chk[i] == ACTION_POSITION )
+ transition_struct_out( 0, nxt[i] );
- printf( " };\n" );
- printf( "\n" );
+ else if ( chk[i] > numecs || chk[i] == 0 )
+ transition_struct_out( 0, 0 ); /* unused slot */
- /* table of pointers to start states */
- printf( "static const struct yy_trans_info *yy_start_state_list[%d] =\n",
- lastsc * 2 + 1 );
- printf( " {\n" );
+ else /* verify, transition */
+ transition_struct_out( chk[i],
+ base[nxt[i]] - (i - chk[i]) );
+ }
- for ( i = 0; i <= lastsc * 2; ++i )
- printf( " &yy_transition[%d],\n", base[i] );
- dataend();
+ /* Here's the final, end-of-buffer state. */
+ transition_struct_out( chk[tblend + 1], nxt[tblend + 1] );
+ transition_struct_out( chk[tblend + 2], nxt[tblend + 2] );
- if ( useecs )
- genecs();
- }
+ printf( " };\n" );
+ printf( "\n" );
+ /* Table of pointers to start states. */
+ printf(
+ "static const struct yy_trans_info *yy_start_state_list[%d] =\n",
+ lastsc * 2 + 1 );
+ printf( " {\n" ); /* } so vi doesn't get confused */
-/* generate equivalence-class tables */
+ for ( i = 0; i <= lastsc * 2; ++i )
+ printf( " &yy_transition[%d],\n", base[i] );
-void genecs()
+ dataend();
+
+ if ( useecs )
+ genecs();
+ }
- {
- register int i, j;
- static char C_char_decl[] = "static const %s %s[%d] =\n { 0,\n";
- int numrows;
- Char clower();
- if ( numecs < csize )
- printf( C_char_decl, "YY_CHAR", "yy_ec", csize );
- else
- printf( C_char_decl, "short", "yy_ec", csize );
+/* Generate equivalence-class tables. */
- for ( i = 1; i < csize; ++i )
+void genecs()
{
- if ( caseins && (i >= 'A') && (i <= 'Z') )
- ecgroup[i] = ecgroup[clower( i )];
+ Char clower();
+ static char C_char_decl[] = "static const %s %s[%d] =\n { 0,\n";
+ /* } so vi doesn't get confused */
+ register int i, j;
+ int numrows;
+
+ if ( numecs < csize )
+ printf( C_char_decl, "YY_CHAR", "yy_ec", csize );
+ else
+ printf( C_char_decl, "short", "yy_ec", csize );
- ecgroup[i] = abs( ecgroup[i] );
- mkdata( ecgroup[i] );
- }
+ for ( i = 1; i < csize; ++i )
+ {
+ if ( caseins && (i >= 'A') && (i <= 'Z') )
+ ecgroup[i] = ecgroup[clower( i )];
- dataend();
+ ecgroup[i] = abs( ecgroup[i] );
+ mkdata( ecgroup[i] );
+ }
- if ( trace )
- {
- char *readable_form();
+ dataend();
- fputs( "\n\nEquivalence Classes:\n\n", stderr );
+ if ( trace )
+ {
+ char *readable_form();
- numrows = csize / 8;
+ fputs( "\n\nEquivalence Classes:\n\n", stderr );
- for ( j = 0; j < numrows; ++j )
- {
- for ( i = j; i < csize; i = i + numrows )
- {
- fprintf( stderr, "%4s = %-2d", readable_form( i ), ecgroup[i] );
+ numrows = csize / 8;
- putc( ' ', stderr );
- }
+ for ( j = 0; j < numrows; ++j )
+ {
+ for ( i = j; i < csize; i = i + numrows )
+ {
+ fprintf( stderr, "%4s = %-2d",
+ readable_form( i ), ecgroup[i] );
+
+ 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()
+ {
+ if ( fullspd )
+ indent_puts( "yy_act = yy_current_state[-1].yy_nxt;" );
- {
- if ( fullspd )
- indent_puts( "yy_act = yy_current_state[-1].yy_nxt;" );
+ else if ( fulltbl )
+ indent_puts( "yy_act = yy_accept[yy_current_state];" );
- else if ( fulltbl )
- indent_puts( "yy_act = yy_accept[yy_current_state];" );
+ else if ( reject )
+ {
+ indent_puts( "yy_current_state = *--yy_state_ptr;" );
+ indent_puts( "yy_lp = yy_accept[yy_current_state];" );
- else if ( reject )
- {
- indent_puts( "yy_current_state = *--yy_state_ptr;" );
- indent_puts( "yy_lp = yy_accept[yy_current_state];" );
+ puts(
+ "find_rule: /* we branch to this label when backtracking */" );
- puts( "find_rule: /* we branch to this label when backtracking */" );
+ indent_puts(
+ "for ( ; ; ) /* until we find what rule we matched */" );
- indent_puts( "for ( ; ; ) /* until we find what rule we matched */" );
+ indent_up();
- indent_up();
+ indent_puts( "{" );
- indent_puts( "{" );
+ indent_puts(
+ "if ( yy_lp && yy_lp < yy_accept[yy_current_state + 1] )" );
+ indent_up();
+ indent_puts( "{" );
+ indent_puts( "yy_act = yy_acclist[yy_lp];" );
- indent_puts( "if ( yy_lp && yy_lp < yy_accept[yy_current_state + 1] )" );
- indent_up();
- indent_puts( "{" );
- indent_puts( "yy_act = yy_acclist[yy_lp];" );
-
- if ( variable_trailing_context_rules )
- {
- indent_puts( "if ( yy_act & YY_TRAILING_HEAD_MASK ||" );
- indent_puts( " yy_looking_for_trail_begin )" );
- indent_up();
- indent_puts( "{" );
-
- indent_puts( "if ( yy_act == yy_looking_for_trail_begin )" );
- indent_up();
- indent_puts( "{" );
- indent_puts( "yy_looking_for_trail_begin = 0;" );
- indent_puts( "yy_act &= ~YY_TRAILING_HEAD_MASK;" );
- indent_puts( "break;" );
- indent_puts( "}" );
- indent_down();
-
- indent_puts( "}" );
- indent_down();
-
- indent_puts( "else if ( yy_act & YY_TRAILING_MASK )" );
- indent_up();
- indent_puts( "{" );
- indent_puts(
+ if ( variable_trailing_context_rules )
+ {
+ indent_puts( "if ( yy_act & YY_TRAILING_HEAD_MASK ||" );
+ indent_puts( " yy_looking_for_trail_begin )" );
+ indent_up();
+ indent_puts( "{" );
+
+ indent_puts(
+ "if ( yy_act == yy_looking_for_trail_begin )" );
+ indent_up();
+ indent_puts( "{" );
+ indent_puts( "yy_looking_for_trail_begin = 0;" );
+ indent_puts( "yy_act &= ~YY_TRAILING_HEAD_MASK;" );
+ indent_puts( "break;" );
+ indent_puts( "}" );
+ indent_down();
+
+ indent_puts( "}" );
+ indent_down();
+
+ indent_puts( "else if ( yy_act & YY_TRAILING_MASK )" );
+ indent_up();
+ indent_puts( "{" );
+ indent_puts(
"yy_looking_for_trail_begin = yy_act & ~YY_TRAILING_MASK;" );
- indent_puts(
+ indent_puts(
"yy_looking_for_trail_begin |= YY_TRAILING_HEAD_MASK;" );
- if ( real_reject )
+ if ( real_reject )
+ {
+ /* Remember matched text in case we back up
+ * due to REJECT.
+ */
+ indent_puts( "yy_full_match = yy_cp;" );
+ indent_puts( "yy_full_state = yy_state_ptr;" );
+ indent_puts( "yy_full_lp = yy_lp;" );
+ }
+
+ indent_puts( "}" );
+ indent_down();
+
+ indent_puts( "else" );
+ indent_up();
+ indent_puts( "{" );
+ indent_puts( "yy_full_match = yy_cp;" );
+ indent_puts( "yy_full_state = yy_state_ptr;" );
+ indent_puts( "yy_full_lp = yy_lp;" );
+ indent_puts( "break;" );
+ indent_puts( "}" );
+ indent_down();
+
+ indent_puts( "++yy_lp;" );
+ indent_puts( "goto find_rule;" );
+ }
+
+ else
{
- /* remember matched text in case we back up due to REJECT */
+ /* Remember matched text in case we back up due to trailing
+ * context plus REJECT.
+ */
+ indent_up();
+ indent_puts( "{" );
indent_puts( "yy_full_match = yy_cp;" );
- indent_puts( "yy_full_state = yy_state_ptr;" );
- indent_puts( "yy_full_lp = yy_lp;" );
+ indent_puts( "break;" );
+ indent_puts( "}" );
+ indent_down();
}
- indent_puts( "}" );
- indent_down();
+ indent_puts( "}" );
+ indent_down();
- indent_puts( "else" );
- indent_up();
- indent_puts( "{" );
- indent_puts( "yy_full_match = yy_cp;" );
- indent_puts( "yy_full_state = yy_state_ptr;" );
- indent_puts( "yy_full_lp = yy_lp;" );
- indent_puts( "break;" );
- indent_puts( "}" );
- indent_down();
+ indent_puts( "--yy_cp;" );
- indent_puts( "++yy_lp;" );
- indent_puts( "goto find_rule;" );
- }
+ /* We could consolidate the following two lines with those at
+ * the beginning, but at the cost of complaints that we're
+ * branching inside a loop.
+ */
+ indent_puts( "yy_current_state = *--yy_state_ptr;" );
+ indent_puts( "yy_lp = yy_accept[yy_current_state];" );
- else
- {
- /* remember matched text in case we back up due to trailing context
- * plus REJECT
- */
- indent_up();
- indent_puts( "{" );
- indent_puts( "yy_full_match = yy_cp;" );
- indent_puts( "break;" );
- indent_puts( "}" );
- indent_down();
- }
+ indent_puts( "}" );
- indent_puts( "}" );
- indent_down();
-
- indent_puts( "--yy_cp;" );
-
- /* we could consolidate the following two lines with those at
- * the beginning, but at the cost of complaints that we're
- * branching inside a loop
- */
- indent_puts( "yy_current_state = *--yy_state_ptr;" );
- indent_puts( "yy_lp = yy_accept[yy_current_state];" );
-
- indent_puts( "}" );
+ indent_down();
+ }
- indent_down();
+ else
+ /* compressed */
+ indent_puts( "yy_act = yy_accept[yy_current_state];" );
}
- else
- /* compressed */
- indent_puts( "yy_act = yy_accept[yy_current_state];" );
- }
-
-/* genftbl - generates full transition table
- *
- * synopsis
- * genftbl();
- */
+/* genftbl - generates full transition table */
void genftbl()
+ {
+ register int i;
+ int end_of_buffer_action = num_rules + 1;
- {
- register int i;
- int end_of_buffer_action = num_rules + 1;
-
- printf( C_short_decl, "yy_accept", lastdfa + 1 );
-
+ printf( C_short_decl, "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 )
- {
- register int anum = dfaacc[i].dfaacc_state;
+ for ( i = 1; i <= lastdfa; ++i )
+ {
+ register int anum = dfaacc[i].dfaacc_state;
- mkdata( anum );
+ mkdata( anum );
- if ( trace && anum )
- fprintf( stderr, "state # %d accepts: [%d]\n", i, anum );
- }
+ if ( trace && anum )
+ fprintf( stderr, "state # %d accepts: [%d]\n",
+ i, anum );
+ }
- dataend();
+ dataend();
- if ( useecs )
- genecs();
+ if ( useecs )
+ genecs();
- /* don't have to dump the actual full table entries - they were created
- * on-the-fly
- */
- }
+ /* Don't have to dump the actual full table entries - they were
+ * 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 )
char *char_map;
-
- {
- indent_put2s( "register YY_CHAR yy_c = %s;", char_map );
-
- /* save the backtracking info \before/ computing the next state
- * because we always compute one more state than needed - we
- * always proceed until we reach a jam state
- */
- gen_backtracking();
-
- indent_puts(
- "while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )" );
- indent_up();
- indent_puts( "{" );
- indent_puts( "yy_current_state = yy_def[yy_current_state];" );
-
- if ( usemecs )
{
- /* we've arrange it so that templates are never chained
- * to one another. This means we can afford make a
- * very simple test to see if we need to convert to
- * yy_c's meta-equivalence class without worrying
- * about erroneously looking up the meta-equivalence
- * class twice
+ indent_put2s( "register YY_CHAR yy_c = %s;", char_map );
+
+ /* Save the backtracking info \before/ computing the next state
+ * because we always compute one more state than needed - we
+ * always proceed until we reach a jam state
*/
- do_indent();
- /* lastdfa + 2 is the beginning of the templates */
- printf( "if ( yy_current_state >= %d )\n", lastdfa + 2 );
+ gen_backtracking();
+ indent_puts(
+"while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )" );
indent_up();
- indent_puts( "yy_c = yy_meta[(unsigned int) yy_c];" );
- indent_down();
- }
+ indent_puts( "{" );
+ indent_puts( "yy_current_state = yy_def[yy_current_state];" );
- indent_puts( "}" );
- indent_down();
+ if ( usemecs )
+ {
+ /* We've arrange it so that templates are never chained
+ * to one another. This means we can afford make a
+ * very simple test to see if we need to convert to
+ * yy_c's meta-equivalence class without worrying
+ * about erroneously looking up the meta-equivalence
+ * class twice
+ */
+ do_indent();
+
+ /* lastdfa + 2 is the beginning of the templates */
+ printf( "if ( yy_current_state >= %d )\n", lastdfa + 2 );
+
+ indent_up();
+ indent_puts( "yy_c = yy_meta[(unsigned int) yy_c];" );
+ indent_down();
+ }
- indent_puts(
+ indent_puts( "}" );
+ indent_down();
+
+ indent_puts(
"yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];" );
- }
+ }
-/* generate the code to find the next match */
+/* Generate the code to find the next match. */
void gen_next_match()
-
- {
- /* NOTE - changes in here should be reflected in gen_next_state() and
- * gen_NUL_trans()
- */
- char *char_map = useecs ? "yy_ec[*yy_cp]" : "*yy_cp";
- char *char_map_2 = useecs ? "yy_ec[*++yy_cp]" : "*++yy_cp";
-
- if ( fulltbl )
{
- indent_put2s(
- "while ( (yy_current_state = yy_nxt[yy_current_state][%s]) > 0 )",
- char_map );
+ /* NOTE - changes in here should be reflected in gen_next_state() and
+ * gen_NUL_trans().
+ */
+ char *char_map = useecs ? "yy_ec[*yy_cp]" : "*yy_cp";
+ char *char_map_2 = useecs ? "yy_ec[*++yy_cp]" : "*++yy_cp";
- indent_up();
+ if ( fulltbl )
+ {
+ indent_put2s(
+ "while ( (yy_current_state = yy_nxt[yy_current_state][%s]) > 0 )",
+ char_map );
- if ( num_backtracking > 0 )
- {
- indent_puts( "{" );
- gen_backtracking();
- putchar( '\n' );
- }
+ indent_up();
- indent_puts( "++yy_cp;" );
+ if ( num_backtracking > 0 )
+ {
+ indent_puts( "{" ); /* } for vi */
+ gen_backtracking();
+ putchar( '\n' );
+ }
- if ( num_backtracking > 0 )
- indent_puts( "}" );
+ indent_puts( "++yy_cp;" );
- indent_down();
+ if ( num_backtracking > 0 )
+ /* { for vi */
+ indent_puts( "}" );
- putchar( '\n' );
- indent_puts( "yy_current_state = -yy_current_state;" );
- }
+ indent_down();
- else if ( fullspd )
- {
- indent_puts( "{" );
- indent_puts( "register const 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(
+ putchar( '\n' );
+ indent_puts( "yy_current_state = -yy_current_state;" );
+ }
+
+ else if ( fullspd )
+ {
+ indent_puts( "{" ); /* } for vi */
+ indent_puts(
+ "register const 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[yy_c])->yy_verify == yy_c;" );
- indent_put2s( " yy_c = %s )", char_map_2 );
+ indent_put2s( " yy_c = %s )", char_map_2 );
- indent_up();
+ indent_up();
- if ( num_backtracking > 0 )
- indent_puts( "{" );
+ if ( num_backtracking > 0 )
+ indent_puts( "{" ); /* } for vi */
- indent_puts( "yy_current_state += yy_trans_info->yy_nxt;" );
+ indent_puts( "yy_current_state += yy_trans_info->yy_nxt;" );
- if ( num_backtracking > 0 )
- {
- putchar( '\n' );
- gen_backtracking();
- indent_puts( "}" );
- }
+ if ( num_backtracking > 0 )
+ {
+ putchar( '\n' );
+ gen_backtracking(); /* { for vi */
+ indent_puts( "}" );
+ }
- indent_down();
- indent_puts( "}" );
- }
+ indent_down(); /* { for vi */
+ indent_puts( "}" );
+ }
- else
- { /* compressed */
- indent_puts( "do" );
+ else
+ { /* compressed */
+ indent_puts( "do" );
- indent_up();
- indent_puts( "{" );
+ indent_up();
+ indent_puts( "{" ); /* } for vi */
- gen_next_state( false );
+ gen_next_state( false );
- indent_puts( "++yy_cp;" );
+ indent_puts( "++yy_cp;" );
- indent_puts( "}" );
- indent_down();
+ /* { for vi */
+ indent_puts( "}" );
+ indent_down();
- do_indent();
+ do_indent();
- if ( interactive )
- printf( "while ( yy_base[yy_current_state] != %d );\n", jambase );
- else
- printf( "while ( yy_current_state != %d );\n", jamstate );
-
- if ( ! reject && ! interactive )
- {
- /* do the guaranteed-needed backtrack to figure out the match */
- indent_puts( "yy_cp = yy_last_accepting_cpos;" );
- indent_puts( "yy_current_state = yy_last_accepting_state;" );
- }
+ if ( interactive )
+ printf( "while ( yy_base[yy_current_state] != %d );\n",
+ jambase );
+ else
+ printf( "while ( yy_current_state != %d );\n",
+ jamstate );
+
+ if ( ! reject && ! interactive )
+ {
+ /* Do the guaranteed-needed backtrack to figure out
+ * the match.
+ */
+ indent_puts( "yy_cp = yy_last_accepting_cpos;" );
+ indent_puts(
+ "yy_current_state = 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 )
int worry_about_NULs;
+ { /* NOTE - changes in here should be reflected in get_next_match() */
+ char char_map[256];
- { /* NOTE - changes in here should be reflected in get_next_match() */
- char char_map[256];
+ if ( worry_about_NULs && ! nultrans )
+ {
+ if ( useecs )
+ (void) sprintf( char_map,
+ "(*yy_cp ? yy_ec[*yy_cp] : %d)", NUL_ec );
+ else
+ (void) sprintf( char_map,
+ "(*yy_cp ? *yy_cp : %d)", NUL_ec );
+ }
- if ( worry_about_NULs && ! nultrans )
- {
- if ( useecs )
- (void) sprintf( char_map, "(*yy_cp ? yy_ec[*yy_cp] : %d)", NUL_ec );
else
- (void) sprintf( char_map, "(*yy_cp ? *yy_cp : %d)", NUL_ec );
- }
-
- else
- (void) strcpy( char_map, useecs ? "yy_ec[*yy_cp]" : "*yy_cp" );
-
- if ( worry_about_NULs && nultrans )
- {
- if ( ! fulltbl && ! fullspd )
- /* compressed tables backtrack *before* they match */
- gen_backtracking();
-
- indent_puts( "if ( *yy_cp )" );
- indent_up();
- indent_puts( "{" );
- }
-
- if ( fulltbl )
- indent_put2s( "yy_current_state = yy_nxt[yy_current_state][%s];",
- char_map );
-
- else if ( fullspd )
- indent_put2s( "yy_current_state += yy_current_state[%s].yy_nxt;",
- char_map );
-
- else
- gen_next_compressed_state( char_map );
-
- if ( worry_about_NULs && nultrans )
- {
- 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 )
- gen_backtracking();
-
- if ( reject )
- indent_puts( "*yy_state_ptr++ = yy_current_state;" );
- }
+ (void) strcpy( char_map, useecs ? "yy_ec[*yy_cp]" : "*yy_cp" );
+ if ( worry_about_NULs && nultrans )
+ {
+ if ( ! fulltbl && ! fullspd )
+ /* Compressed tables backtrack *before* they match. */
+ gen_backtracking();
-/* generate the code to make a NUL transition */
+ indent_puts( "if ( *yy_cp )" );
+ indent_up();
+ indent_puts( "{" ); /* } for vi */
+ }
-void gen_NUL_trans()
+ if ( fulltbl )
+ indent_put2s(
+ "yy_current_state = yy_nxt[yy_current_state][%s];",
+ char_map );
- { /* NOTE - changes in here should be reflected in get_next_match() */
- int need_backtracking = (num_backtracking > 0 && ! reject);
+ else if ( fullspd )
+ indent_put2s(
+ "yy_current_state += yy_current_state[%s].yy_nxt;",
+ char_map );
- if ( need_backtracking )
- /* we'll need yy_cp lying around for the gen_backtracking() */
- indent_puts( "register YY_CHAR *yy_cp = yy_c_buf_p;" );
+ else
+ gen_next_compressed_state( char_map );
- putchar( '\n' );
+ 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 ( nultrans )
- {
- indent_puts( "yy_current_state = yy_NUL_trans[yy_current_state];" );
- indent_puts( "yy_is_jam = (yy_current_state == 0);" );
- }
+ if ( fullspd || fulltbl )
+ gen_backtracking();
- else if ( fulltbl )
- {
- do_indent();
- printf( "yy_current_state = yy_nxt[yy_current_state][%d];\n",
- NUL_ec );
- indent_puts( "yy_is_jam = (yy_current_state <= 0);" );
+ if ( reject )
+ indent_puts( "*yy_state_ptr++ = yy_current_state;" );
}
- else if ( fullspd )
- {
- do_indent();
- printf( "register int yy_c = %d;\n", NUL_ec );
- indent_puts(
- "register const struct yy_trans_info *yy_trans_info;\n" );
- indent_puts( "yy_trans_info = &yy_current_state[yy_c];" );
- indent_puts( "yy_current_state += yy_trans_info->yy_nxt;" );
+/* Generate the code to make a NUL transition. */
- indent_puts( "yy_is_jam = (yy_trans_info->yy_verify != yy_c);" );
- }
+void gen_NUL_trans()
+ { /* NOTE - changes in here should be reflected in get_next_match() */
+ int need_backtracking = (num_backtracking > 0 && ! reject);
- else
- {
- char NUL_ec_str[20];
+ if ( need_backtracking )
+ /* We'll need yy_cp lying around for the gen_backtracking(). */
+ indent_puts( "register YY_CHAR *yy_cp = yy_c_buf_p;" );
- (void) sprintf( NUL_ec_str, "%d", NUL_ec );
- gen_next_compressed_state( NUL_ec_str );
+ putchar( '\n' );
- if ( reject )
- indent_puts( "*yy_state_ptr++ = yy_current_state;" );
+ if ( nultrans )
+ {
+ indent_puts(
+ "yy_current_state = yy_NUL_trans[yy_current_state];" );
+ indent_puts( "yy_is_jam = (yy_current_state == 0);" );
+ }
- do_indent();
+ else if ( fulltbl )
+ {
+ do_indent();
+ printf( "yy_current_state = yy_nxt[yy_current_state][%d];\n",
+ NUL_ec );
+ indent_puts( "yy_is_jam = (yy_current_state <= 0);" );
+ }
- printf( "yy_is_jam = (yy_current_state == %d);\n", jamstate );
- }
+ else if ( fullspd )
+ {
+ do_indent();
+ printf( "register int yy_c = %d;\n", NUL_ec );
- /* if we've entered an accepting state, backtrack; note that
- * compressed tables have *already* done such backtracking, so
- * we needn't bother with it again
- */
- if ( need_backtracking && (fullspd || fulltbl) )
- {
- putchar( '\n' );
- indent_puts( "if ( ! yy_is_jam )" );
- indent_up();
- indent_puts( "{" );
- gen_backtracking();
- indent_puts( "}" );
- indent_down();
- }
- }
+ indent_puts(
+ "register const struct yy_trans_info *yy_trans_info;\n" );
+ indent_puts( "yy_trans_info = &yy_current_state[yy_c];" );
+ indent_puts( "yy_current_state += yy_trans_info->yy_nxt;" );
+ indent_puts(
+ "yy_is_jam = (yy_trans_info->yy_verify != yy_c);" );
+ }
-/* generate the code to find the start state */
+ else
+ {
+ char NUL_ec_str[20];
-void gen_start_state()
+ (void) sprintf( NUL_ec_str, "%d", NUL_ec );
+ gen_next_compressed_state( NUL_ec_str );
- {
- if ( fullspd )
- indent_put2s( "yy_current_state = yy_start_state_list[yy_start%s];",
- bol_needed ? " + (yy_bp[-1] == '\\n' ? 1 : 0)" : "" );
+ if ( reject )
+ indent_puts( "*yy_state_ptr++ = yy_current_state;" );
- else
- {
- indent_puts( "yy_current_state = yy_start;" );
+ do_indent();
- if ( bol_needed )
- {
- indent_puts( "if ( yy_bp[-1] == '\\n' )" );
- indent_up();
- indent_puts( "++yy_current_state;" );
- indent_down();
- }
+ printf( "yy_is_jam = (yy_current_state == %d);\n", jamstate );
+ }
- if ( reject )
- {
- /* set up for storing up states */
- indent_puts( "yy_state_ptr = yy_state_buf;" );
- indent_puts( "*yy_state_ptr++ = yy_current_state;" );
- }
+ /* If we've entered an accepting state, backtrack; note that
+ * compressed tables have *already* done such backtracking, so
+ * we needn't bother with it again.
+ */
+ if ( need_backtracking && (fullspd || fulltbl) )
+ {
+ putchar( '\n' );
+ indent_puts( "if ( ! yy_is_jam )" );
+ indent_up();
+ indent_puts( "{" );
+ gen_backtracking();
+ indent_puts( "}" );
+ indent_down();
+ }
}
- }
-/* gentabs - generate data statements for the transition tables
- *
- * synopsis
- * gentabs();
- */
+/* Generate the code to find the start state. */
-void gentabs()
+void gen_start_state()
+ {
+ if ( fullspd )
+ indent_put2s(
+ "yy_current_state = yy_start_state_list[yy_start%s];",
+ bol_needed ? " + (yy_bp[-1] == '\\n' ? 1 : 0)" : "" );
+
+ else
+ {
+ indent_puts( "yy_current_state = yy_start;" );
- {
- int i, j, k, *accset, nacc, *acc_array, total_states;
- int end_of_buffer_action = num_rules + 1;
+ if ( bol_needed )
+ {
+ indent_puts( "if ( yy_bp[-1] == '\\n' )" );
+ indent_up();
+ indent_puts( "++yy_current_state;" );
+ indent_down();
+ }
- /* *everything* is done in terms of arrays starting at 1, so provide
- * a null entry for the zero element of all C arrays
- */
- static char C_char_decl[] =
- "static const YY_CHAR %s[%d] =\n { 0,\n";
+ if ( reject )
+ {
+ /* Set up for storing up states. */
+ indent_puts( "yy_state_ptr = yy_state_buf;" );
+ indent_puts( "*yy_state_ptr++ = yy_current_state;" );
+ }
+ }
+ }
- acc_array = allocate_integer_array( current_max_dfas );
- nummt = 0;
- /* the compressed table format jams by entering the "jam state",
- * losing information about the previous state in the process.
- * In order to recover the previous state, we effectively need
- * to keep backtracking information.
- */
- ++num_backtracking;
+/* gentabs - generate data statements for the transition tables */
- if ( reject )
+void gentabs()
{
- /* write out accepting list and pointer list
- *
- * first we generate the "yy_acclist" array. In the process, we compute
- * the indices that will go into the "yy_accept" array, and save the
- * indices in the dfaacc array
- */
- int EOB_accepting_list[2];
+ int i, j, k, *accset, nacc, *acc_array, total_states;
+ int end_of_buffer_action = num_rules + 1;
- /* set up accepting structures for the End Of Buffer state */
- EOB_accepting_list[0] = 0;
- EOB_accepting_list[1] = end_of_buffer_action;
- accsiz[end_of_buffer_state] = 1;
- dfaacc[end_of_buffer_state].dfaacc_set = EOB_accepting_list;
-
- printf( C_short_decl, "yy_acclist", max( numas, 1 ) + 1 );
+ /* *Everything* is done in terms of arrays starting at 1, so provide
+ * a null entry for the zero element of all C arrays.
+ */
+ static char C_char_decl[] =
+ "static const YY_CHAR %s[%d] =\n { 0,\n"; /* } for vi */
- j = 1; /* index into "yy_acclist" array */
+ acc_array = allocate_integer_array( current_max_dfas );
+ nummt = 0;
- for ( i = 1; i <= lastdfa; ++i )
- {
- acc_array[i] = j;
+ /* The compressed table format jams by entering the "jam state",
+ * losing information about the previous state in the process.
+ * In order to recover the previous state, we effectively need
+ * to keep backtracking information.
+ */
+ ++num_backtracking;
- if ( accsiz[i] != 0 )
+ if ( reject )
{
- accset = dfaacc[i].dfaacc_set;
- nacc = accsiz[i];
+ /* Write out accepting list and pointer list.
+ *
+ * First we generate the "yy_acclist" array. In the process,
+ * we compute the indices that will go into the "yy_accept"
+ * array, and save the indices in the dfaacc array.
+ */
+ int EOB_accepting_list[2];
- if ( trace )
- fprintf( stderr, "state # %d accepts: ", i );
+ /* Set up accepting structures for the End Of Buffer state. */
+ EOB_accepting_list[0] = 0;
+ EOB_accepting_list[1] = end_of_buffer_action;
+ accsiz[end_of_buffer_state] = 1;
+ dfaacc[end_of_buffer_state].dfaacc_set = EOB_accepting_list;
- for ( k = 1; k <= nacc; ++k )
- {
- int accnum = accset[k];
+ printf( C_short_decl, "yy_acclist", max( numas, 1 ) + 1 );
- ++j;
+ j = 1; /* index into "yy_acclist" array */
- if ( variable_trailing_context_rules &&
- ! (accnum & YY_TRAILING_HEAD_MASK) &&
- accnum > 0 && accnum <= num_rules &&
- rule_type[accnum] == RULE_VARIABLE )
+ for ( i = 1; i <= lastdfa; ++i )
{
- /* special hack to flag accepting number as part
- * of trailing context rule
- */
- accnum |= YY_TRAILING_MASK;
+ acc_array[i] = j;
+
+ if ( accsiz[i] != 0 )
+ {
+ accset = dfaacc[i].dfaacc_set;
+ nacc = accsiz[i];
+
+ if ( trace )
+ fprintf( stderr,
+ "state # %d accepts: ", i );
+
+ for ( k = 1; k <= nacc; ++k )
+ {
+ int accnum = accset[k];
+
+ ++j;
+
+ if ( variable_trailing_context_rules &&
+ ! (accnum & YY_TRAILING_HEAD_MASK) &&
+ accnum > 0 && accnum <= num_rules &&
+ rule_type[accnum] == RULE_VARIABLE )
+ {
+ /* Special hack to flag
+ * accepting number as part
+ * of trailing context rule.
+ */
+ accnum |= YY_TRAILING_MASK;
+ }
+
+ mkdata( accnum );
+
+ if ( trace )
+ {
+ fprintf( stderr, "[%d]",
+ accset[k] );
+
+ if ( k < nacc )
+ fputs( ", ", stderr );
+ else
+ putc( '\n', stderr );
+ }
+ }
+ }
}
- mkdata( accnum );
+ /* add accepting number for the "jam" state */
+ acc_array[i] = j;
- if ( trace )
- {
- fprintf( stderr, "[%d]", accset[k] );
-
- if ( k < nacc )
- fputs( ", ", stderr );
- else
- putc( '\n', stderr );
- }
- }
+ dataend();
}
- }
-
- /* add accepting number for the "jam" state */
- acc_array[i] = j;
- dataend();
- }
+ else
+ {
+ dfaacc[end_of_buffer_state].dfaacc_state = end_of_buffer_action;
- else
- {
- dfaacc[end_of_buffer_state].dfaacc_state = end_of_buffer_action;
+ for ( i = 1; i <= lastdfa; ++i )
+ acc_array[i] = dfaacc[i].dfaacc_state;
- for ( i = 1; i <= lastdfa; ++i )
- acc_array[i] = dfaacc[i].dfaacc_state;
+ /* add accepting number for jam state */
+ acc_array[i] = 0;
+ }
- /* add accepting number for jam state */
- acc_array[i] = 0;
- }
+ /* Spit out "yy_accept" array. If we're doing "reject", it'll be
+ * pointers into the "yy_acclist" array. Otherwise it's actual
+ * accepting numbers. In either case, we just dump the numbers.
+ */
- /* spit out "yy_accept" array. If we're doing "reject", it'll be pointers
- * into the "yy_acclist" array. Otherwise it's actual accepting numbers.
- * In either case, we just dump the numbers.
- */
-
- /* "lastdfa + 2" is the size of "yy_accept"; includes room for C arrays
- * beginning at 0 and for "jam" state
- */
- k = lastdfa + 2;
-
- if ( reject )
- /* we put a "cap" on the table associating lists of accepting
- * numbers with state numbers. This is needed because we tell
- * where the end of an accepting list is by looking at where
- * the list for the next state starts.
+ /* "lastdfa + 2" is the size of "yy_accept"; includes room for C arrays
+ * beginning at 0 and for "jam" state.
*/
- ++k;
+ k = lastdfa + 2;
- printf( C_short_decl, "yy_accept", k );
+ if ( reject )
+ /* We put a "cap" on the table associating lists of accepting
+ * numbers with state numbers. This is needed because we tell
+ * where the end of an accepting list is by looking at where
+ * the list for the next state starts.
+ */
+ ++k;
- for ( i = 1; i <= lastdfa; ++i )
- {
- mkdata( acc_array[i] );
+ printf( C_short_decl, "yy_accept", k );
- if ( ! reject && trace && acc_array[i] )
- fprintf( stderr, "state # %d accepts: [%d]\n", i, acc_array[i] );
- }
+ for ( i = 1; i <= lastdfa; ++i )
+ {
+ mkdata( acc_array[i] );
- /* add entry for "jam" state */
- mkdata( acc_array[i] );
+ if ( ! reject && trace && acc_array[i] )
+ fprintf( stderr, "state # %d accepts: [%d]\n",
+ i, acc_array[i] );
+ }
- if ( reject )
- /* add "cap" for the list */
+ /* Add entry for "jam" state. */
mkdata( acc_array[i] );
- dataend();
+ if ( reject )
+ /* Add "cap" for the list. */
+ mkdata( acc_array[i] );
- if ( useecs )
- genecs();
+ dataend();
- if ( usemecs )
- {
- /* write out meta-equivalence classes (used to index templates with) */
+ if ( useecs )
+ genecs();
- if ( trace )
- fputs( "\n\nMeta-Equivalence Classes:\n", stderr );
+ if ( usemecs )
+ {
+ /* Write out meta-equivalence classes (used to index
+ * templates with).
+ */
- printf( C_char_decl, "yy_meta", numecs + 1 );
+ if ( trace )
+ fputs( "\n\nMeta-Equivalence Classes:\n", stderr );
- for ( i = 1; i <= numecs; ++i )
- {
- if ( trace )
- fprintf( stderr, "%d = %d\n", i, abs( tecbck[i] ) );
+ printf( C_char_decl, "yy_meta", numecs + 1 );
- mkdata( abs( tecbck[i] ) );
- }
+ for ( i = 1; i <= numecs; ++i )
+ {
+ if ( trace )
+ fprintf( stderr, "%d = %d\n",
+ i, abs( tecbck[i] ) );
- dataend();
- }
+ mkdata( abs( tecbck[i] ) );
+ }
- total_states = lastdfa + numtemps;
+ dataend();
+ }
- printf( total_states > MAX_SHORT ? C_long_decl : C_short_decl,
- "yy_base", total_states + 1 );
+ total_states = lastdfa + numtemps;
- for ( i = 1; i <= lastdfa; ++i )
- {
- register int d = def[i];
+ printf( total_states > MAX_SHORT ? C_long_decl : C_short_decl,
+ "yy_base", total_states + 1 );
- if ( base[i] == JAMSTATE )
- base[i] = jambase;
+ for ( i = 1; i <= lastdfa; ++i )
+ {
+ register int d = def[i];
- if ( d == JAMSTATE )
- def[i] = jamstate;
+ if ( base[i] == JAMSTATE )
+ base[i] = jambase;
- else if ( d < 0 )
- {
- /* template reference */
- ++tmpuses;
- def[i] = lastdfa - d + 1;
- }
+ if ( d == JAMSTATE )
+ def[i] = jamstate;
- mkdata( base[i] );
- }
+ else if ( d < 0 )
+ {
+ /* Template reference. */
+ ++tmpuses;
+ def[i] = lastdfa - d + 1;
+ }
- /* generate jam state's base index */
- mkdata( base[i] );
+ mkdata( base[i] );
+ }
- for ( ++i /* skip jam state */; i <= total_states; ++i )
- {
+ /* Generate jam state's base index. */
mkdata( base[i] );
- def[i] = jamstate;
- }
- dataend();
+ for ( ++i /* skip jam state */; i <= total_states; ++i )
+ {
+ mkdata( base[i] );
+ def[i] = jamstate;
+ }
- printf( tblend > MAX_SHORT ? C_long_decl : C_short_decl,
- "yy_def", total_states + 1 );
+ dataend();
- for ( i = 1; i <= total_states; ++i )
- mkdata( def[i] );
+ printf( tblend > MAX_SHORT ? C_long_decl : C_short_decl,
+ "yy_def", total_states + 1 );
- dataend();
+ for ( i = 1; i <= total_states; ++i )
+ mkdata( def[i] );
- printf( lastdfa > MAX_SHORT ? C_long_decl : C_short_decl,
- "yy_nxt", tblend + 1 );
+ dataend();
- for ( i = 1; i <= tblend; ++i )
- {
- if ( nxt[i] == 0 || chk[i] == 0 )
- nxt[i] = jamstate; /* new state is the JAM state */
+ printf( lastdfa > MAX_SHORT ? C_long_decl : C_short_decl,
+ "yy_nxt", tblend + 1 );
- mkdata( nxt[i] );
- }
+ for ( i = 1; i <= tblend; ++i )
+ {
+ if ( nxt[i] == 0 || chk[i] == 0 )
+ nxt[i] = jamstate; /* new state is the JAM state */
- dataend();
+ mkdata( nxt[i] );
+ }
- printf( lastdfa > MAX_SHORT ? C_long_decl : C_short_decl,
- "yy_chk", tblend + 1 );
+ dataend();
- for ( i = 1; i <= tblend; ++i )
- {
- if ( chk[i] == 0 )
- ++nummt;
+ printf( lastdfa > MAX_SHORT ? C_long_decl : C_short_decl,
+ "yy_chk", tblend + 1 );
- mkdata( chk[i] );
- }
+ for ( i = 1; i <= tblend; ++i )
+ {
+ if ( chk[i] == 0 )
+ ++nummt;
+
+ mkdata( chk[i] );
+ }
- dataend();
- }
+ dataend();
+ }
-/* write out a formatted string (with a secondary string argument) at the
- * current indentation level, adding a final newline
+/* Write out a formatted string (with a secondary string argument) at the
+ * current indentation level, adding a final newline.
*/
void indent_put2s( fmt, arg )
char fmt[], arg[];
-
- {
- do_indent();
- printf( fmt, arg );
- putchar( '\n' );
- }
+ {
+ do_indent();
+ printf( fmt, arg );
+ putchar( '\n' );
+ }
-/* write out a string at the current indentation level, adding a final
- * newline
+/* Write out a string at the current indentation level, adding a final
+ * newline.
*/
void indent_puts( str )
char str[];
-
- {
- do_indent();
- puts( str );
- }
+ {
+ do_indent();
+ puts( str );
+ }
-/* make_tables - generate transition tables
- *
- * synopsis
- * make_tables();
- *
- * Generates transition tables and finishes generating output file
+/* make_tables - generate transition tables and finishes generating output file
*/
void make_tables()
+ {
+ register int i;
+ int did_eof_rule = false;
- {
- register int i;
- int did_eof_rule = false;
-
- skelout();
+ skelout();
- /* first, take care of YY_DO_BEFORE_ACTION depending on yymore being used */
- set_indent( 2 );
+ /* First, take care of YY_DO_BEFORE_ACTION depending on yymore
+ * being used.
+ */
+ set_indent( 2 );
- if ( yymore_used )
- {
- indent_puts( "yytext_ptr -= yy_more_len; \\" );
- indent_puts( "yyleng = yy_cp - yytext_ptr; \\" );
- }
+ if ( yymore_used )
+ {
+ indent_puts( "yytext_ptr -= yy_more_len; \\" );
+ indent_puts( "yyleng = yy_cp - yytext_ptr; \\" );
+ }
- else
- indent_puts( "yyleng = yy_cp - yy_bp; \\" );
+ else
+ indent_puts( "yyleng = yy_cp - yy_bp; \\" );
- /* now also deal with copying yytext_ptr to yytext if needed */
- skelout();
- if ( yytext_is_array )
- {
- indent_puts( "if ( yyleng >= YYLMAX ) \\" );
- indent_up();
- indent_puts(
+ /* Now also deal with copying yytext_ptr to yytext if needed. */
+ skelout();
+ if ( yytext_is_array )
+ {
+ indent_puts( "if ( yyleng >= YYLMAX ) \\" );
+ indent_up();
+ indent_puts(
"YY_FATAL_ERROR( \"token too large, exceeds YYLMAX\" ); \\" );
- indent_down();
- indent_puts( "strcpy( yytext, (char *) yytext_ptr ); \\" );
- }
+ indent_down();
+ indent_puts( "strcpy( yytext, (char *) yytext_ptr ); \\" );
+ }
- set_indent( 0 );
-
- skelout();
+ set_indent( 0 );
+ skelout();
- printf( "#define YY_END_OF_BUFFER %d\n", num_rules + 1 );
- if ( fullspd )
- { /* need to define the transet type as a size large
- * enough to hold the biggest offset
- */
- int total_table_size = tblend + numecs + 1;
- char *trans_offset_type =
- total_table_size > MAX_SHORT ? "long" : "short";
+ printf( "#define YY_END_OF_BUFFER %d\n", num_rules + 1 );
- set_indent( 0 );
- indent_puts( "struct yy_trans_info" );
- indent_up();
- indent_puts( "{" );
- indent_puts( "short yy_verify;" );
-
- /* in cases where its sister yy_verify *is* a "yes, there is a
- * transition", yy_nxt is the offset (in records) to the next state.
- * In most cases where there is no transition, the value of yy_nxt
- * is irrelevant. If yy_nxt is the -1th record of a state, though,
- * then yy_nxt is the action number for that state
- */
-
- indent_put2s( "%s yy_nxt;", trans_offset_type );
- indent_puts( "};" );
- indent_down();
+ if ( fullspd )
+ {
+ /* Need to define the transet type as a size large
+ * enough to hold the biggest offset.
+ */
+ int total_table_size = tblend + numecs + 1;
+ char *trans_offset_type =
+ total_table_size > MAX_SHORT ? "long" : "short";
+
+ set_indent( 0 );
+ indent_puts( "struct yy_trans_info" );
+ indent_up();
+ indent_puts( "{" ); /* } for vi */
+ indent_puts( "short yy_verify;" );
+
+ /* In cases where its sister yy_verify *is* a "yes, there is
+ * a transition", yy_nxt is the offset (in records) to the
+ * next state. In most cases where there is no transition,
+ * the value of yy_nxt is irrelevant. If yy_nxt is the -1th
+ * record of a state, though, then yy_nxt is the action number
+ * for that state.
+ */
+
+ indent_put2s( "%s yy_nxt;", trans_offset_type );
+ indent_puts( "};" );
+ indent_down();
+
+ indent_puts(
+ "typedef const struct yy_trans_info *yy_state_type;" );
+ }
- indent_puts( "typedef const struct yy_trans_info *yy_state_type;" );
- }
-
- else
- indent_puts( "typedef int yy_state_type;" );
+ else
+ indent_puts( "typedef int yy_state_type;" );
- if ( fullspd )
- genctbl();
+ if ( fullspd )
+ genctbl();
+ else if ( fulltbl )
+ genftbl();
+ else
+ gentabs();
- else if ( fulltbl )
- genftbl();
+ if ( num_backtracking > 0 )
+ {
+ indent_puts( "static yy_state_type yy_last_accepting_state;" );
+ indent_puts( "static YY_CHAR *yy_last_accepting_cpos;\n" );
+ }
- else
- gentabs();
+ if ( nultrans )
+ {
+ printf( C_state_decl, "yy_NUL_trans", lastdfa + 1 );
- if ( num_backtracking > 0 )
- {
- indent_puts( "static yy_state_type yy_last_accepting_state;" );
- indent_puts( "static YY_CHAR *yy_last_accepting_cpos;\n" );
- }
+ for ( i = 1; i <= lastdfa; ++i )
+ {
+ if ( fullspd )
+ {
+ if ( nultrans )
+ printf( " &yy_transition[%d],\n",
+ base[i] );
+ else
+ printf( " 0,\n" );
+ }
- if ( nultrans )
- {
- printf( C_state_decl, "yy_NUL_trans", lastdfa + 1 );
+ else
+ mkdata( nultrans[i] );
+ }
- for ( i = 1; i <= lastdfa; ++i )
- {
- if ( fullspd )
- {
- if ( nultrans )
- printf( " &yy_transition[%d],\n", base[i] );
- else
- printf( " 0,\n" );
+ dataend();
}
-
- else
- mkdata( nultrans[i] );
- }
-
- dataend();
- }
- if ( ddebug )
- { /* spit out table mapping rules to line numbers */
- indent_puts( "extern int yy_flex_debug;" );
- indent_puts( "int yy_flex_debug = 1;\n" );
+ if ( ddebug )
+ { /* Spit out table mapping rules to line numbers. */
+ indent_puts( "extern int yy_flex_debug;" );
+ indent_puts( "int yy_flex_debug = 1;\n" );
- printf( C_short_decl, "yy_rule_linenum", num_rules );
- for ( i = 1; i < num_rules; ++i )
- mkdata( rule_linenum[i] );
- dataend();
- }
+ printf( C_short_decl, "yy_rule_linenum", num_rules );
+ for ( i = 1; i < num_rules; ++i )
+ mkdata( rule_linenum[i] );
+ dataend();
+ }
- if ( reject )
- {
- /* declare state buffer variables */
- puts(
+ if ( reject )
+ {
+ /* Declare state buffer variables. */
+ puts(
"static yy_state_type yy_state_buf[YY_BUF_SIZE + 2], *yy_state_ptr;" );
- puts( "static YY_CHAR *yy_full_match;" );
- puts( "static int yy_lp;" );
-
- if ( variable_trailing_context_rules )
- {
- puts( "static int yy_looking_for_trail_begin = 0;" );
- puts( "static int yy_full_lp;" );
- puts( "static int *yy_full_state;" );
- printf( "#define YY_TRAILING_MASK 0x%x\n",
- (unsigned int) YY_TRAILING_MASK );
- printf( "#define YY_TRAILING_HEAD_MASK 0x%x\n",
- (unsigned int) YY_TRAILING_HEAD_MASK );
- }
-
- puts( "#define REJECT \\" );
- puts( "{ \\" );
- puts(
+ puts( "static YY_CHAR *yy_full_match;" );
+ puts( "static int yy_lp;" );
+
+ if ( variable_trailing_context_rules )
+ {
+ puts( "static int yy_looking_for_trail_begin = 0;" );
+ puts( "static int yy_full_lp;" );
+ puts( "static int *yy_full_state;" );
+ printf( "#define YY_TRAILING_MASK 0x%x\n",
+ (unsigned int) YY_TRAILING_MASK );
+ printf( "#define YY_TRAILING_HEAD_MASK 0x%x\n",
+ (unsigned int) YY_TRAILING_HEAD_MASK );
+ }
+
+ puts( "#define REJECT \\" );
+ puts( "{ \\" ); /* } for vi */
+ puts(
"*yy_cp = yy_hold_char; /* undo effects of setting up yytext */ \\" );
- puts(
- "yy_cp = yy_full_match; /* restore poss. backed-over text */ \\" );
+ puts(
+ "yy_cp = yy_full_match; /* restore poss. backed-over text */ \\" );
- if ( variable_trailing_context_rules )
- {
- puts( "yy_lp = yy_full_lp; /* restore orig. accepting pos. */ \\" );
- puts(
+ if ( variable_trailing_context_rules )
+ {
+ puts(
+ "yy_lp = yy_full_lp; /* restore orig. accepting pos. */ \\" );
+ puts(
"yy_state_ptr = yy_full_state; /* restore orig. state */ \\" );
- puts(
- "yy_current_state = *yy_state_ptr; /* restore curr. state */ \\" );
- }
-
- puts( "++yy_lp; \\" );
- puts( "goto find_rule; \\" );
- puts( "}" );
- }
-
- else
- {
- puts( "/* the intent behind this definition is that it'll catch" );
- puts( " * any uses of REJECT which flex missed" );
- puts( " */" );
- puts( "#define REJECT reject_used_but_not_detected" );
- }
-
- if ( yymore_used )
- {
- indent_puts( "static int yy_more_flag = 0;" );
- indent_puts( "static int yy_doing_yy_more = 0;" );
- indent_puts( "static int yy_more_len = 0;" );
- indent_puts(
- "#define yymore() do { yy_more_flag = 1; } while ( 0 )" );
- indent_puts(
- "#define YY_MORE_ADJ (yy_doing_yy_more ? yy_more_len : 0)" );
- }
+ puts(
+ "yy_current_state = *yy_state_ptr; /* restore curr. state */ \\" );
+ }
- else
- {
- indent_puts( "#define yymore() yymore_used_but_not_detected" );
- indent_puts( "#define YY_MORE_ADJ 0" );
- }
+ puts( "++yy_lp; \\" );
+ puts( "goto find_rule; \\" );
+ /* { for vi */
+ puts( "}" );
+ }
- skelout();
+ else
+ {
+ puts(
+ "/* The intent behind this definition is that it'll catch" );
+ puts( " * any uses of REJECT which flex missed." );
+ puts( " */" );
+ puts( "#define REJECT reject_used_but_not_detected" );
+ }
- /* copy prolog to output file */
- fputs( prolog, stdout );
+ if ( yymore_used )
+ {
+ indent_puts( "static int yy_more_flag = 0;" );
+ indent_puts( "static int yy_doing_yy_more = 0;" );
+ indent_puts( "static int yy_more_len = 0;" );
+ indent_puts(
+ "#define yymore() do { yy_more_flag = 1; } while ( 0 )" );
+ indent_puts(
+ "#define YY_MORE_ADJ (yy_doing_yy_more ? yy_more_len : 0)" );
+ }
- skelout();
+ else
+ {
+ indent_puts( "#define yymore() yymore_used_but_not_detected" );
+ indent_puts( "#define YY_MORE_ADJ 0" );
+ }
- set_indent( 2 );
+ skelout();
- if ( yymore_used )
- {
- indent_puts( "yy_more_len = 0;" );
- indent_puts( "yy_doing_yy_more = yy_more_flag;" );
- indent_puts( "if ( yy_doing_yy_more )" );
- indent_up();
- indent_puts( "{" );
- indent_puts( "yy_more_len = yyleng;" );
- indent_puts( "yy_more_flag = 0;" );
- indent_puts( "}" );
- indent_down();
- }
+ /* Copy prolog to output file. */
+ fputs( prolog, stdout );
- skelout();
+ skelout();
- gen_start_state();
+ set_indent( 2 );
- /* note, don't use any indentation */
- puts( "yy_match:" );
- gen_next_match();
+ if ( yymore_used )
+ {
+ indent_puts( "yy_more_len = 0;" );
+ indent_puts( "yy_doing_yy_more = yy_more_flag;" );
+ indent_puts( "if ( yy_doing_yy_more )" );
+ indent_up();
+ indent_puts( "{" );
+ indent_puts( "yy_more_len = yyleng;" );
+ indent_puts( "yy_more_flag = 0;" );
+ indent_puts( "}" );
+ indent_down();
+ }
- skelout();
- set_indent( 2 );
- gen_find_action();
+ skelout();
- skelout();
- if ( ddebug )
- {
- indent_puts( "if ( yy_flex_debug )" );
- indent_up();
+ gen_start_state();
- indent_puts( "{" );
- indent_puts( "if ( yy_act == 0 )" );
- indent_up();
- indent_puts( "fprintf( stderr, \"--scanner backtracking\\n\" );" );
- indent_down();
+ /* Note, don't use any indentation. */
+ puts( "yy_match:" );
+ gen_next_match();
- do_indent();
- printf( "else if ( yy_act < %d )\n", num_rules );
- indent_up();
- indent_puts(
- "fprintf( stderr, \"--accepting rule at line %d (\\\"%s\\\")\\n\"," );
- indent_puts( " yy_rule_linenum[yy_act], yytext );" );
- indent_down();
+ skelout();
+ set_indent( 2 );
+ gen_find_action();
- do_indent();
- printf( "else if ( yy_act == %d )\n", num_rules );
- indent_up();
- indent_puts(
+ skelout();
+ if ( ddebug )
+ {
+ indent_puts( "if ( yy_flex_debug )" );
+ indent_up();
+
+ indent_puts( "{" );
+ indent_puts( "if ( yy_act == 0 )" );
+ indent_up();
+ indent_puts(
+ "fprintf( stderr, \"--scanner backtracking\\n\" );" );
+ indent_down();
+
+ do_indent();
+ printf( "else if ( yy_act < %d )\n", num_rules );
+ indent_up();
+ indent_puts(
+ "fprintf(
+ stderr, \"--accepting rule at line %d (\\\"%s\\\")\\n\"," );
+ indent_puts( " yy_rule_linenum[yy_act], yytext );" );
+ indent_down();
+
+ do_indent();
+ printf( "else if ( yy_act == %d )\n", num_rules );
+ indent_up();
+ indent_puts(
"fprintf( stderr, \"--accepting default rule (\\\"%s\\\")\\n\"," );
- indent_puts( " yytext );" );
- indent_down();
+ indent_puts( " yytext );" );
+ indent_down();
+
+ do_indent();
+ printf( "else if ( yy_act == %d )\n", num_rules + 1 );
+ indent_up();
+ indent_puts(
+ "fprintf( stderr, \"--(end of buffer or a NUL)\\n\" );" );
+ indent_down();
+
+ do_indent();
+ printf( "else\n" );
+ indent_up();
+ indent_puts( "fprintf( stderr, \"--EOF\\n\" );" );
+ indent_down();
+
+ indent_puts( "}" );
+ indent_down();
+ }
- do_indent();
- printf( "else if ( yy_act == %d )\n", num_rules + 1 );
+ /* Copy actions to output file. */
+ skelout();
indent_up();
- indent_puts( "fprintf( stderr, \"--(end of buffer or a NUL)\\n\" );" );
- indent_down();
+ gen_bt_action();
+ fputs( action, stdout );
- do_indent();
- printf( "else\n" );
- indent_up();
- indent_puts( "fprintf( stderr, \"--EOF\\n\" );" );
- indent_down();
+ /* generate cases for any missing EOF rules */
+ for ( i = 1; i <= lastsc; ++i )
+ if ( ! sceof[i] )
+ {
+ do_indent();
+ printf( "case YY_STATE_EOF(%s):\n", scname[i] );
+ did_eof_rule = true;
+ }
- indent_puts( "}" );
- indent_down();
- }
+ if ( did_eof_rule )
+ {
+ indent_up();
+ indent_puts( "yyterminate();" );
+ indent_down();
+ }
- /* copy actions to output file */
- skelout();
- indent_up();
- gen_bt_action();
- fputs( action, stdout );
-
- /* generate cases for any missing EOF rules */
- for ( i = 1; i <= lastsc; ++i )
- if ( ! sceof[i] )
- {
- do_indent();
- printf( "case YY_STATE_EOF(%s):\n", scname[i] );
- did_eof_rule = true;
- }
-
- if ( did_eof_rule )
- {
- indent_up();
- indent_puts( "yyterminate();" );
- indent_down();
- }
+ /* Generate code for handling NUL's, if needed. */
- /* generate code for handling NUL's, if needed */
-
- /* first, deal with backtracking and setting up yy_cp if the scanner
- * finds that it should JAM on the NUL
- */
- skelout();
- set_indent( 7 );
-
- if ( fullspd || fulltbl )
- indent_puts( "yy_cp = yy_c_buf_p;" );
-
- else
- { /* compressed table */
- if ( ! reject && ! interactive )
- {
- /* do the guaranteed-needed backtrack to figure out the match */
- indent_puts( "yy_cp = yy_last_accepting_cpos;" );
- indent_puts( "yy_current_state = yy_last_accepting_state;" );
- }
- }
+ /* First, deal with backtracking and setting up yy_cp if the scanner
+ * finds that it should JAM on the NUL>
+ */
+ skelout();
+ set_indent( 7 );
+ if ( fullspd || fulltbl )
+ indent_puts( "yy_cp = yy_c_buf_p;" );
+
+ else
+ { /* compressed table */
+ if ( ! reject && ! interactive )
+ {
+ /* Do the guaranteed-needed backtrack to figure
+ * out the match.
+ */
+ indent_puts( "yy_cp = yy_last_accepting_cpos;" );
+ indent_puts(
+ "yy_current_state = yy_last_accepting_state;" );
+ }
+ }
- /* generate code for yy_get_previous_state() */
- set_indent( 1 );
- skelout();
- if ( bol_needed )
- indent_puts( "register YY_CHAR *yy_bp = yytext_ptr;\n" );
+ /* Generate code for yy_get_previous_state(). */
+ set_indent( 1 );
+ skelout();
- gen_start_state();
+ if ( bol_needed )
+ indent_puts( "register YY_CHAR *yy_bp = yytext_ptr;\n" );
+
+ gen_start_state();
- set_indent( 2 );
- skelout();
- gen_next_state( true );
+ set_indent( 2 );
+ skelout();
+ gen_next_state( true );
- set_indent( 1 );
- skelout();
- gen_NUL_trans();
+ set_indent( 1 );
+ skelout();
+ gen_NUL_trans();
- skelout();
+ skelout();
- /* copy remainder of input to output */
+ /* Copy remainder of input to output. */
- line_directive_out( stdout );
- (void) flexscan(); /* copy remainder of input to output */
- }
+ line_directive_out( stdout );
+ (void) flexscan(); /* copy remainder of input to output */
+ }
int main( argc, argv )
int argc;
char *argv[];
-
- {
- return yylex();
- }
+ {
+ return yylex();
+ }
#else
static char *outfile = "lexyy.c";
#endif
+
static int outfile_created = 0;
static int use_stdout;
static char *skelname = NULL;
int main( argc, argv )
int argc;
char **argv;
+ {
+ int i;
- {
- int i;
-
- flexinit( argc, argv );
+ flexinit( argc, argv );
- readin();
+ readin();
- if ( syntaxerror )
- flexend( 1 );
+ if ( syntaxerror )
+ flexend( 1 );
- if ( yymore_really_used == REALLY_USED )
- yymore_used = true;
- else if ( yymore_really_used == REALLY_NOT_USED )
- yymore_used = false;
+ if ( yymore_really_used == REALLY_USED )
+ yymore_used = true;
+ else if ( yymore_really_used == REALLY_NOT_USED )
+ yymore_used = false;
- if ( reject_really_used == REALLY_USED )
- reject = true;
- else if ( reject_really_used == REALLY_NOT_USED )
- reject = false;
+ if ( reject_really_used == REALLY_USED )
+ reject = true;
+ else if ( reject_really_used == REALLY_NOT_USED )
+ reject = false;
- if ( performance_report > 0 )
- {
- if ( performance_report > 1 )
- {
- if ( interactive )
- fprintf( stderr,
- "-I (interactive) entails a minor performance penalty\n" );
+ if ( performance_report > 0 )
+ {
+ if ( performance_report > 1 )
+ {
+ if ( interactive )
+ fprintf( stderr,
+ "-I (interactive) entails a minor performance penalty\n" );
- if ( yymore_used )
- fprintf( stderr,
- "yymore() entails a minor performance penalty\n" );
- }
+ if ( yymore_used )
+ fprintf( stderr,
+ "yymore() entails a minor performance penalty\n" );
+ }
- if ( reject )
- fprintf( stderr, "REJECT entails a large performance penalty\n" );
+ if ( reject )
+ fprintf( stderr,
+ "REJECT entails a large performance penalty\n" );
- if ( variable_trailing_context_rules )
- fprintf( stderr,
+ if ( variable_trailing_context_rules )
+ fprintf( stderr,
"Variable trailing context rules entail a large performance penalty\n" );
- }
+ }
- if ( reject )
- real_reject = true;
+ if ( reject )
+ real_reject = true;
- if ( variable_trailing_context_rules )
- reject = true;
+ if ( variable_trailing_context_rules )
+ reject = true;
- if ( (fulltbl || fullspd) && reject )
- {
- if ( real_reject )
- flexerror( "REJECT cannot be used with -f or -F" );
- else
- flexerror(
+ if ( (fulltbl || fullspd) && reject )
+ {
+ if ( real_reject )
+ flexerror( "REJECT cannot be used with -f or -F" );
+ else
+ flexerror(
"variable trailing context rules cannot be used with -f or -F" );
- }
+ }
- ntod();
+ ntod();
- for ( i = 1; i <= num_rules; ++i )
- if ( ! rule_useful[i] && i != default_rule )
- line_warning( "rule cannot be matched", rule_linenum[i] );
+ for ( i = 1; i <= num_rules; ++i )
+ if ( ! rule_useful[i] && i != default_rule )
+ line_warning( "rule cannot be matched",
+ rule_linenum[i] );
- if ( spprdflt && ! reject && rule_useful[default_rule] )
- line_warning( "-s option given but default rule can be matched",
- rule_linenum[default_rule] );
+ if ( spprdflt && ! reject && rule_useful[default_rule] )
+ line_warning( "-s option given but default rule can be matched",
+ rule_linenum[default_rule] );
- /* generate the C state transition tables from the DFA */
- make_tables();
+ /* Generate the C state transition tables from the DFA. */
+ make_tables();
- /* note, flexend does not return. It exits with its argument as status. */
- flexend( 0 );
+ /* Note, flexend does not return. It exits with its argument
+ * as status.
+ */
+ flexend( 0 );
- return 0; /* keep compilers/lint happy */
- }
+ return 0; /* keep compilers/lint happy */
+ }
/* flexend - terminate flex
- *
- * synopsis
- * int status;
- * flexend( status );
- *
- * status is exit status.
*
* note
* This routine does not return.
*/
-void flexend( status )
-int status;
-
- {
- int tblsiz;
- char *flex_gettime();
-
- if ( skelfile != NULL )
- {
- if ( ferror( skelfile ) )
- flexfatal( "error occurred when reading skeleton file" );
-
- else if ( fclose( skelfile ) )
- flexfatal( "error occurred when closing skeleton file" );
- }
+void flexend( exit_status )
+int exit_status;
- if ( status != 0 && outfile_created )
{
- if ( ferror( stdout ) )
- flexfatal( "error occurred when writing output file" );
+ int tblsiz;
+ char *flex_gettime();
- else if ( fclose( stdout ) )
- flexfatal( "error occurred when closing output file" );
-
- else if ( unlink( outfile ) )
- flexfatal( "error occurred when deleting output file" );
- }
+ if ( skelfile != NULL )
+ {
+ if ( ferror( skelfile ) )
+ flexfatal(
+ "error occurred when reading skeleton file" );
- if ( backtrack_report && backtrack_file )
- {
- if ( num_backtracking == 0 )
- fprintf( backtrack_file, "No backtracking.\n" );
- else if ( fullspd || fulltbl )
- fprintf( backtrack_file,
- "%d backtracking (non-accepting) states.\n",
- num_backtracking );
- else
- fprintf( backtrack_file, "Compressed tables always backtrack.\n" );
+ else if ( fclose( skelfile ) )
+ flexfatal(
+ "error occurred when closing skeleton file" );
+ }
- if ( ferror( backtrack_file ) )
- flexfatal( "error occurred when writing backtracking file" );
+ if ( exit_status != 0 && outfile_created )
+ {
+ if ( ferror( stdout ) )
+ flexfatal( "error occurred when writing output file" );
- else if ( fclose( backtrack_file ) )
- flexfatal( "error occurred when closing backtracking file" );
- }
+ else if ( fclose( stdout ) )
+ flexfatal( "error occurred when closing output file" );
- if ( printstats )
- {
- fprintf( stderr, "%s version %s usage statistics:\n", program_name,
- flex_version );
-
- if ( starttime )
- {
- endtime = flex_gettime();
- fprintf( stderr, " started at %s, finished at %s\n",
- starttime, endtime );
- }
+ else if ( unlink( outfile ) )
+ flexfatal( "error occurred when deleting output file" );
+ }
- fprintf( stderr, " scanner options: -" );
+ if ( backtrack_report && backtrack_file )
+ {
+ if ( num_backtracking == 0 )
+ fprintf( backtrack_file, "No backtracking.\n" );
+ else if ( fullspd || fulltbl )
+ fprintf( backtrack_file,
+ "%d backtracking (non-accepting) states.\n",
+ num_backtracking );
+ else
+ fprintf( backtrack_file,
+ "Compressed tables always backtrack.\n" );
+
+ if ( ferror( backtrack_file ) )
+ flexfatal(
+ "error occurred when writing backtracking file" );
+
+ else if ( fclose( backtrack_file ) )
+ flexfatal(
+ "error occurred when closing backtracking file" );
+ }
- if ( backtrack_report )
- putc( 'b', stderr );
- if ( ddebug )
- putc( 'd', stderr );
- if ( caseins )
- putc( 'i', stderr );
- if ( performance_report > 0 )
- putc( 'p', stderr );
- if ( performance_report > 1 )
- putc( 'p', stderr );
- if ( spprdflt )
- putc( 's', stderr );
- if ( use_stdout )
- putc( 't', stderr );
if ( printstats )
- putc( 'v', stderr ); /* always true! */
- if ( nowarn )
- putc( 'w', stderr );
- if ( ! interactive )
- putc( 'B', stderr );
- if ( interactive )
- putc( 'I', stderr );
- if ( ! gen_line_dirs )
- putc( 'L', stderr );
- if ( trace )
- putc( 'T', stderr );
- if ( csize == 128 )
- putc( '7', stderr );
- else
- putc( '8', stderr );
+ {
+ fprintf( stderr, "%s version %s usage statistics:\n",
+ program_name, flex_version );
- fprintf( stderr, " -C" );
+ if ( starttime )
+ {
+ endtime = flex_gettime();
+ fprintf( stderr, " started at %s, finished at %s\n",
+ starttime, endtime );
+ }
- if ( fulltbl )
- putc( 'f', stderr );
- if ( fullspd )
- putc( 'F', stderr );
- if ( useecs )
- putc( 'e', stderr );
- if ( usemecs )
- putc( 'm', stderr );
-
- if ( skelname )
- fprintf( stderr, " -S%s", skelname );
-
- putc( '\n', stderr );
-
- fprintf( stderr, " %d/%d NFA states\n", lastnfa, current_mns );
- fprintf( stderr, " %d/%d DFA states (%d words)\n", lastdfa,
- current_max_dfas, totnst );
- fprintf( stderr, " %d rules\n",
- num_rules + num_eof_rules - 1 /* - 1 for def. rule */ );
-
- if ( num_backtracking == 0 )
- fprintf( stderr, " No backtracking\n" );
- else if ( fullspd || fulltbl )
- fprintf( stderr, " %d backtracking (non-accepting) states\n",
- num_backtracking );
- else
- fprintf( stderr, " compressed tables always backtrack\n" );
+ fprintf( stderr, " scanner options: -" );
+
+ if ( backtrack_report )
+ putc( 'b', stderr );
+ if ( ddebug )
+ putc( 'd', stderr );
+ if ( caseins )
+ putc( 'i', stderr );
+ if ( performance_report > 0 )
+ putc( 'p', stderr );
+ if ( performance_report > 1 )
+ putc( 'p', stderr );
+ if ( spprdflt )
+ putc( 's', stderr );
+ if ( use_stdout )
+ putc( 't', stderr );
+ if ( printstats )
+ putc( 'v', stderr ); /* always true! */
+ if ( nowarn )
+ putc( 'w', stderr );
+ if ( ! interactive )
+ putc( 'B', stderr );
+ if ( interactive )
+ putc( 'I', stderr );
+ if ( ! gen_line_dirs )
+ putc( 'L', stderr );
+ if ( trace )
+ putc( 'T', stderr );
+ if ( csize == 128 )
+ putc( '7', stderr );
+ else
+ putc( '8', stderr );
+
+ fprintf( stderr, " -C" );
+
+ if ( fulltbl )
+ putc( 'f', stderr );
+ if ( fullspd )
+ putc( 'F', stderr );
+ if ( useecs )
+ putc( 'e', stderr );
+ if ( usemecs )
+ putc( 'm', stderr );
+
+ if ( skelname )
+ fprintf( stderr, " -S%s", skelname );
+
+ putc( '\n', stderr );
+
+ fprintf( stderr, " %d/%d NFA states\n", lastnfa, current_mns );
+ fprintf( stderr, " %d/%d DFA states (%d words)\n", lastdfa,
+ current_max_dfas, totnst );
+ fprintf( stderr, " %d rules\n",
+ num_rules + num_eof_rules - 1 /* - 1 for def. rule */ );
+
+ if ( num_backtracking == 0 )
+ fprintf( stderr, " No backtracking\n" );
+ else if ( fullspd || fulltbl )
+ fprintf( stderr,
+ " %d backtracking (non-accepting) states\n",
+ num_backtracking );
+ else
+ fprintf( stderr,
+ " compressed tables always backtrack\n" );
+
+ if ( bol_needed )
+ fprintf( stderr,
+ " Beginning-of-line patterns used\n" );
+
+ fprintf( stderr, " %d/%d start conditions\n", lastsc,
+ current_max_scs );
+ fprintf( stderr,
+ " %d epsilon states, %d double epsilon states\n",
+ numeps, eps2 );
- if ( bol_needed )
- fprintf( stderr, " Beginning-of-line patterns used\n" );
+ if ( lastccl == 0 )
+ fprintf( stderr, " no character classes\n" );
+ else
+ fprintf( stderr,
+ " %d/%d character classes needed %d/%d words of storage, %d reused\n",
+ lastccl, current_maxccls,
+ cclmap[lastccl] + ccllen[lastccl],
+ current_max_ccl_tbl_size, cclreuse );
- fprintf( stderr, " %d/%d start conditions\n", lastsc,
- current_max_scs );
- fprintf( stderr, " %d epsilon states, %d double epsilon states\n",
- numeps, eps2 );
+ fprintf( stderr, " %d state/nextstate pairs created\n",
+ numsnpairs );
+ fprintf( stderr, " %d/%d unique/duplicate transitions\n",
+ numuniq, numdup );
- if ( lastccl == 0 )
- fprintf( stderr, " no character classes\n" );
- else
- fprintf( stderr,
- " %d/%d character classes needed %d/%d words of storage, %d reused\n",
- lastccl, current_maxccls,
- cclmap[lastccl] + ccllen[lastccl],
- current_max_ccl_tbl_size, cclreuse );
+ if ( fulltbl )
+ {
+ tblsiz = lastdfa * numecs;
+ fprintf( stderr, " %d table entries\n", tblsiz );
+ }
- fprintf( stderr, " %d state/nextstate pairs created\n", numsnpairs );
- fprintf( stderr, " %d/%d unique/duplicate transitions\n",
- numuniq, numdup );
+ else
+ {
+ tblsiz = 2 * (lastdfa + numtemps) + 2 * tblend;
+
+ fprintf( stderr, " %d/%d base-def entries created\n",
+ lastdfa + numtemps, current_max_dfas );
+ fprintf( stderr,
+ " %d/%d (peak %d) nxt-chk entries created\n",
+ tblend, current_max_xpairs, peakpairs );
+ fprintf( stderr,
+ " %d/%d (peak %d) template nxt-chk entries created\n",
+ numtemps * nummecs, current_max_template_xpairs,
+ numtemps * numecs );
+ fprintf( stderr, " %d empty table entries\n", nummt );
+ fprintf( stderr, " %d protos created\n", numprots );
+ fprintf( stderr, " %d templates created, %d uses\n",
+ numtemps, tmpuses );
+ }
- if ( fulltbl )
- {
- tblsiz = lastdfa * numecs;
- fprintf( stderr, " %d table entries\n", tblsiz );
- }
+ if ( useecs )
+ {
+ tblsiz = tblsiz + csize;
+ fprintf( stderr,
+ " %d/%d equivalence classes created\n",
+ numecs, csize );
+ }
- else
- {
- tblsiz = 2 * (lastdfa + numtemps) + 2 * tblend;
-
- fprintf( stderr, " %d/%d base-def entries created\n",
- lastdfa + numtemps, current_max_dfas );
- fprintf( stderr, " %d/%d (peak %d) nxt-chk entries created\n",
- tblend, current_max_xpairs, peakpairs );
- fprintf( stderr,
- " %d/%d (peak %d) template nxt-chk entries created\n",
- numtemps * nummecs, current_max_template_xpairs,
- numtemps * numecs );
- fprintf( stderr, " %d empty table entries\n", nummt );
- fprintf( stderr, " %d protos created\n", numprots );
- fprintf( stderr, " %d templates created, %d uses\n",
- numtemps, tmpuses );
- }
+ if ( usemecs )
+ {
+ tblsiz = tblsiz + numecs;
+ fprintf( stderr,
+ " %d/%d meta-equivalence classes created\n",
+ nummecs, csize );
+ }
- if ( useecs )
- {
- tblsiz = tblsiz + csize;
- fprintf( stderr, " %d/%d equivalence classes created\n",
- numecs, csize );
- }
-
- if ( usemecs )
- {
- tblsiz = tblsiz + numecs;
- fprintf( stderr, " %d/%d meta-equivalence classes created\n",
- nummecs, csize );
- }
-
- fprintf( stderr, " %d (%d saved) hash collisions, %d DFAs equal\n",
- hshcol, hshsave, dfaeql );
- fprintf( stderr, " %d sets of reallocations needed\n", num_reallocs );
- fprintf( stderr, " %d total table entries needed\n", tblsiz );
- }
+ fprintf( stderr,
+ " %d (%d saved) hash collisions, %d DFAs equal\n",
+ hshcol, hshsave, dfaeql );
+ fprintf( stderr, " %d sets of reallocations needed\n",
+ num_reallocs );
+ fprintf( stderr, " %d total table entries needed\n", tblsiz );
+ }
#ifndef VMS
- exit( status );
+ exit( exit_status );
#else
- exit( status + 1 );
+ exit( exit_status + 1 );
#endif
- }
+ }
-/* flexinit - initialize flex
- *
- * synopsis
- * int argc;
- * char **argv;
- * flexinit( argc, argv );
- */
+/* flexinit - initialize flex */
void flexinit( argc, argv )
int argc;
char **argv;
-
- {
- int i, sawcmpflag;
- int csize_given, interactive_given;
- char *arg, *flex_gettime(), *mktemp();
-
- printstats = syntaxerror = trace = spprdflt = caseins = false;
- backtrack_report = ddebug = fulltbl = fullspd = false;
- nowarn = yymore_used = continued_action = reject = yytext_is_array = false;
- yymore_really_used = reject_really_used = false;
- gen_line_dirs = usemecs = useecs = true;
- performance_report = 0;
-
- sawcmpflag = false;
- use_stdout = false;
- csize_given = false;
- interactive_given = false;
-
- /* Initialize dynamic array for holding the rule actions. */
- action_size = 2048; /* default size of action array in bytes */
- prolog = action = action_array = allocate_character_array( action_size );
- action_offset = action_index = 0;
-
- starttime = flex_gettime();
-
- program_name = argv[0];
-
- /* read flags */
- for ( --argc, ++argv; argc ; --argc, ++argv )
{
- if ( argv[0][0] != '-' || argv[0][1] == '\0' )
- break;
-
- arg = argv[0];
-
- for ( i = 1; arg[i] != '\0'; ++i )
- switch ( arg[i] )
+ int i, sawcmpflag;
+ int csize_given, interactive_given;
+ char *arg, *flex_gettime(), *mktemp();
+
+ printstats = syntaxerror = trace = spprdflt = caseins = false;
+ backtrack_report = ddebug = fulltbl = fullspd = false;
+ nowarn = yymore_used = continued_action = reject = false;
+ yytext_is_array = yymore_really_used = reject_really_used = false;
+ gen_line_dirs = usemecs = useecs = true;
+ performance_report = 0;
+
+ sawcmpflag = false;
+ use_stdout = false;
+ csize_given = false;
+ interactive_given = false;
+
+ /* Initialize dynamic array for holding the rule actions. */
+ action_size = 2048; /* default size of action array in bytes */
+ prolog = action = action_array =
+ allocate_character_array( action_size );
+ action_offset = action_index = 0;
+
+ starttime = flex_gettime();
+
+ program_name = argv[0];
+
+ /* read flags */
+ for ( --argc, ++argv; argc ; --argc, ++argv )
{
- case 'B':
- interactive = false;
- interactive_given = true;
- break;
-
- case 'b':
- backtrack_report = true;
- break;
+ if ( argv[0][0] != '-' || argv[0][1] == '\0' )
+ break;
- case 'c':
- fprintf( stderr,
- "%s: Assuming use of deprecated -c flag is really intended to be -C\n",
- program_name );
-
- /* fall through */
-
- case 'C':
- if ( i != 1 )
- flexerror( "-C flag must be given separately" );
+ arg = argv[0];
- if ( ! sawcmpflag )
- {
- useecs = false;
- usemecs = false;
- fulltbl = false;
- sawcmpflag = true;
- }
-
- for ( ++i; arg[i] != '\0'; ++i )
+ for ( i = 1; arg[i] != '\0'; ++i )
switch ( arg[i] )
- {
- case 'e':
- useecs = true;
- break;
-
- case 'F':
- fullspd = true;
- break;
-
- case 'f':
- fulltbl = true;
- break;
-
- case 'm':
- usemecs = true;
- break;
-
- default:
- lerrif( "unknown -C option '%c'",
- (int) arg[i] );
- break;
- }
-
- goto get_next_arg;
-
- case 'd':
- ddebug = true;
- break;
-
- case 'f':
- useecs = usemecs = false;
- fulltbl = true;
- break;
-
- case 'F':
- useecs = usemecs = false;
- fullspd = true;
- break;
-
- case 'h':
- usage();
- exit( 0 );
-
- case 'I':
- interactive = true;
- interactive_given = true;
- break;
-
- case 'i':
- caseins = true;
- break;
-
- case 'L':
- gen_line_dirs = false;
- break;
-
- case 'n':
- /* stupid do-nothing deprecated option */
- break;
-
- case 'p':
- ++performance_report;
- break;
-
- case 'S':
- if ( i != 1 )
- flexerror( "-S flag must be given separately" );
-
- skelname = arg + i + 1;
- goto get_next_arg;
-
- case 's':
- spprdflt = true;
- break;
-
- case 't':
- use_stdout = true;
- break;
-
- case 'T':
- trace = true;
- break;
-
- case 'v':
- printstats = true;
- break;
-
- case 'V':
- fprintf( stderr, "%s version %s\n",
- program_name, flex_version );
- exit( 0 );
-
- case 'w':
- nowarn = true;
- break;
-
- case '7':
- csize = 128;
- csize_given = true;
- break;
-
- case '8':
- csize = CSIZE;
- csize_given = true;
- break;
-
- default:
- fprintf( stderr, "%s: unknown flag '%c'\n",
- program_name, (int) arg[i] );
- usage();
- exit( 1 );
+ {
+ case 'B':
+ interactive = false;
+ interactive_given = true;
+ break;
+
+ case 'b':
+ backtrack_report = true;
+ break;
+
+ case 'c':
+ fprintf( stderr,
+ "%s: Assuming use of deprecated -c flag is really intended to be -C\n",
+ program_name );
+
+ /* fall through */
+
+ case 'C':
+ if ( i != 1 )
+ flexerror(
+ "-C flag must be given separately" );
+
+ if ( ! sawcmpflag )
+ {
+ useecs = false;
+ usemecs = false;
+ fulltbl = false;
+ sawcmpflag = true;
+ }
+
+ for ( ++i; arg[i] != '\0'; ++i )
+ switch ( arg[i] )
+ {
+ case 'e':
+ useecs = true;
+ break;
+
+ case 'F':
+ fullspd = true;
+ break;
+
+ case 'f':
+ fulltbl = true;
+ break;
+
+ case 'm':
+ usemecs = true;
+ break;
+
+ default:
+ lerrif(
+ "unknown -C option '%c'",
+ (int) arg[i] );
+ break;
+ }
+
+ goto get_next_arg;
+
+ case 'd':
+ ddebug = true;
+ break;
+
+ case 'f':
+ useecs = usemecs = false;
+ fulltbl = true;
+ break;
+
+ case 'F':
+ useecs = usemecs = false;
+ fullspd = true;
+ break;
+
+ case 'h':
+ usage();
+ exit( 0 );
+
+ case 'I':
+ interactive = true;
+ interactive_given = true;
+ break;
+
+ case 'i':
+ caseins = true;
+ break;
+
+ case 'L':
+ gen_line_dirs = false;
+ break;
+
+ case 'n':
+ /* Stupid do-nothing deprecated
+ * option.
+ */
+ break;
+
+ case 'p':
+ ++performance_report;
+ break;
+
+ case 'S':
+ if ( i != 1 )
+ flexerror(
+ "-S flag must be given separately" );
+
+ skelname = arg + i + 1;
+ goto get_next_arg;
+
+ case 's':
+ spprdflt = true;
+ break;
+
+ case 't':
+ use_stdout = true;
+ break;
+
+ case 'T':
+ trace = true;
+ break;
+
+ case 'v':
+ printstats = true;
+ break;
+
+ case 'V':
+ fprintf( stderr, "%s version %s\n",
+ program_name, flex_version );
+ exit( 0 );
+
+ case 'w':
+ nowarn = true;
+ break;
+
+ case '7':
+ csize = 128;
+ csize_given = true;
+ break;
+
+ case '8':
+ csize = CSIZE;
+ csize_given = true;
+ break;
+
+ default:
+ fprintf( stderr,
+ "%s: unknown flag '%c'\n",
+ program_name, (int) arg[i] );
+ usage();
+ exit( 1 );
+ }
+
+ /* Used by -C and -S flags in lieu of a "continue 2" control. */
+ get_next_arg: ;
}
-get_next_arg: /* used by -C and -S flags in lieu of a "continue 2" control */
- ;
- }
-
- if ( ! csize_given )
- {
- if ( fulltbl || fullspd )
- csize = DEFAULT_CSIZE;
- else
- csize = CSIZE;
- }
+ if ( ! csize_given )
+ {
+ if ( fulltbl || fullspd )
+ csize = DEFAULT_CSIZE;
+ else
+ csize = CSIZE;
+ }
- if ( ! interactive_given )
- {
- if ( fulltbl || fullspd )
- interactive = false;
- else
- interactive = true;
- }
+ if ( ! interactive_given )
+ {
+ if ( fulltbl || fullspd )
+ interactive = false;
+ else
+ interactive = true;
+ }
- if ( (fulltbl || fullspd) && usemecs )
- flexerror( "full table and -Cm don't make sense together" );
+ if ( (fulltbl || fullspd) && usemecs )
+ flexerror( "full table and -Cm don't make sense together" );
- if ( (fulltbl || fullspd) && interactive )
- flexerror( "full table and -I are incompatible" );
+ if ( (fulltbl || fullspd) && interactive )
+ flexerror( "full table and -I are incompatible" );
- if ( fulltbl && fullspd )
- flexerror( "full table and -F are mutually exclusive" );
+ if ( fulltbl && fullspd )
+ flexerror( "full table and -F are mutually exclusive" );
- if ( ! use_stdout )
- {
- FILE *prev_stdout = freopen( outfile, "w", stdout );
+ if ( ! use_stdout )
+ {
+ FILE *prev_stdout = freopen( outfile, "w", stdout );
- if ( prev_stdout == NULL )
- lerrsf( "could not create %s", outfile );
+ if ( prev_stdout == NULL )
+ lerrsf( "could not create %s", outfile );
- outfile_created = 1;
- }
+ outfile_created = 1;
+ }
- num_input_files = argc;
- input_files = argv;
- set_input_file( num_input_files > 0 ? input_files[0] : NULL );
+ num_input_files = argc;
+ input_files = argv;
+ set_input_file( num_input_files > 0 ? input_files[0] : NULL );
- if ( backtrack_report )
- {
+ if ( backtrack_report )
+ {
#ifndef SHORT_FILE_NAMES
- backtrack_file = fopen( "lex.backtrack", "w" );
+ backtrack_file = fopen( "lex.backtrack", "w" );
#else
- backtrack_file = fopen( "lex.bck", "w" );
+ backtrack_file = fopen( "lex.bck", "w" );
#endif
- if ( backtrack_file == NULL )
- flexerror( "could not create lex.backtrack" );
- }
-
- else
- backtrack_file = NULL;
+ if ( backtrack_file == NULL )
+ flexerror( "could not create lex.backtrack" );
+ }
+ else
+ backtrack_file = NULL;
- lastccl = 0;
- lastsc = 0;
- if ( skelname && (skelfile = fopen( skelname, "r" )) == NULL )
- lerrsf( "can't open skeleton file %s", skelname );
+ lastccl = 0;
+ lastsc = 0;
- lastdfa = lastnfa = 0;
- num_rules = num_eof_rules = default_rule = numas = numsnpairs = tmpuses = 0;
- numecs = numeps = eps2 = num_reallocs = hshcol = dfaeql = totnst = 0;
- numuniq = numdup = hshsave = eofseen = datapos = dataline = 0;
- num_backtracking = onesp = numprots = 0;
- variable_trailing_context_rules = bol_needed = false;
+ if ( skelname && (skelfile = fopen( skelname, "r" )) == NULL )
+ lerrsf( "can't open skeleton file %s", skelname );
- linenum = sectnum = 1;
- firstprot = NIL;
+ lastdfa = lastnfa = 0;
+ num_rules = num_eof_rules = default_rule = 0;
+ numas = numsnpairs = tmpuses = 0;
+ numecs = numeps = eps2 = num_reallocs = hshcol = dfaeql = totnst = 0;
+ numuniq = numdup = hshsave = eofseen = datapos = dataline = 0;
+ num_backtracking = onesp = numprots = 0;
+ variable_trailing_context_rules = bol_needed = false;
- /* used in mkprot() so that the first proto goes in slot 1
- * of the proto queue
- */
- lastprot = 1;
+ linenum = sectnum = 1;
+ firstprot = NIL;
- if ( useecs )
- { /* set up doubly-linked equivalence classes */
- /* We loop all the way up to csize, since ecgroup[csize] is the
- * position used for NUL characters
+ /* Used in mkprot() so that the first proto goes in slot 1
+ * of the proto queue.
*/
- ecgroup[1] = NIL;
+ lastprot = 1;
- for ( i = 2; i <= csize; ++i )
- {
- ecgroup[i] = i - 1;
- nextecm[i - 1] = i;
- }
+ if ( useecs )
+ {
+ /* Set up doubly-linked equivalence classes. */
- nextecm[csize] = NIL;
- }
+ /* We loop all the way up to csize, since ecgroup[csize] is
+ * the position used for NUL characters.
+ */
+ ecgroup[1] = NIL;
- else
- { /* put everything in its own equivalence class */
- for ( i = 1; i <= csize; ++i )
- {
- ecgroup[i] = i;
- nextecm[i] = BAD_SUBSCRIPT; /* to catch errors */
- }
- }
+ for ( i = 2; i <= csize; ++i )
+ {
+ ecgroup[i] = i - 1;
+ nextecm[i - 1] = i;
+ }
- set_up_initial_allocations();
- }
+ nextecm[csize] = NIL;
+ }
+ else
+ {
+ /* Put everything in its own equivalence class. */
+ for ( i = 1; i <= csize; ++i )
+ {
+ ecgroup[i] = i;
+ nextecm[i] = BAD_SUBSCRIPT; /* to catch errors */
+ }
+ }
-/* readin - read in the rules section of the input file(s)
- *
- * synopsis
- * readin();
- */
+ set_up_initial_allocations();
+ }
-void readin()
- {
- skelout();
+/* readin - read in the rules section of the input file(s) */
- if ( ddebug )
- puts( "#define FLEX_DEBUG" );
+void readin()
+ {
+ skelout();
- if ( csize == 256 )
- puts( "typedef unsigned char YY_CHAR;" );
- else
- puts( "typedef char YY_CHAR;" );
+ if ( ddebug )
+ puts( "#define FLEX_DEBUG" );
- line_directive_out( stdout );
+ if ( csize == 256 )
+ puts( "typedef unsigned char YY_CHAR;" );
+ else
+ puts( "typedef char YY_CHAR;" );
- if ( yyparse() )
- {
- pinpoint_message( "fatal parse error" );
- flexend( 1 );
- }
+ line_directive_out( stdout );
- if ( useecs )
- numecs = cre8ecs( nextecm, ecgroup, csize );
- else
- numecs = csize;
+ if ( yyparse() )
+ {
+ pinpoint_message( "fatal parse error" );
+ flexend( 1 );
+ }
- /* now map the equivalence class for NUL to its expected place */
- ecgroup[0] = ecgroup[csize];
- NUL_ec = abs( ecgroup[0] );
+ if ( useecs )
+ numecs = cre8ecs( nextecm, ecgroup, csize );
+ else
+ numecs = csize;
- if ( useecs )
- ccl2ecl();
+ /* Now map the equivalence class for NUL to its expected place. */
+ ecgroup[0] = ecgroup[csize];
+ NUL_ec = abs( ecgroup[0] );
- if ( yytext_is_array )
- {
- puts( "extern char yytext[];\n" );
- puts( "#ifndef YYLMAX" );
- puts( "#define YYLMAX YY_READ_BUF_SIZE" );
- puts( "#endif YYLMAX\n" );
- puts( "char yytext[YYLMAX];" );
- puts( "YY_CHAR *yytext_ptr;" );
- }
+ if ( useecs )
+ ccl2ecl();
- else
- {
- puts( "extern YY_CHAR *yytext;" );
- puts( "YY_CHAR *yytext;" );
- puts( "#define yytext_ptr yytext" );
+ if ( yytext_is_array )
+ {
+ puts( "extern char yytext[];\n" );
+ puts( "#ifndef YYLMAX" );
+ puts( "#define YYLMAX YY_READ_BUF_SIZE" );
+ puts( "#endif YYLMAX\n" );
+ puts( "char yytext[YYLMAX];" );
+ puts( "YY_CHAR *yytext_ptr;" );
+ }
+
+ else
+ {
+ puts( "extern YY_CHAR *yytext;" );
+ puts( "YY_CHAR *yytext;" );
+ puts( "#define yytext_ptr yytext" );
+ }
}
- }
/* set_up_initial_allocations - allocate memory for internal tables */
void set_up_initial_allocations()
-
- {
- current_mns = INITIAL_MNS;
- firstst = allocate_integer_array( current_mns );
- lastst = allocate_integer_array( current_mns );
- finalst = allocate_integer_array( current_mns );
- transchar = allocate_integer_array( current_mns );
- trans1 = allocate_integer_array( current_mns );
- trans2 = allocate_integer_array( current_mns );
- accptnum = allocate_integer_array( current_mns );
- assoc_rule = allocate_integer_array( current_mns );
- state_type = allocate_integer_array( current_mns );
-
- current_max_rules = INITIAL_MAX_RULES;
- rule_type = allocate_integer_array( current_max_rules );
- rule_linenum = allocate_integer_array( current_max_rules );
- rule_useful = allocate_integer_array( current_max_rules );
-
- current_max_scs = INITIAL_MAX_SCS;
- scset = allocate_integer_array( current_max_scs );
- scbol = allocate_integer_array( current_max_scs );
- scxclu = allocate_integer_array( current_max_scs );
- sceof = allocate_integer_array( current_max_scs );
- scname = allocate_char_ptr_array( current_max_scs );
- actvsc = allocate_integer_array( current_max_scs );
-
- current_maxccls = INITIAL_MAX_CCLS;
- cclmap = allocate_integer_array( current_maxccls );
- ccllen = allocate_integer_array( current_maxccls );
- cclng = allocate_integer_array( current_maxccls );
-
- current_max_ccl_tbl_size = INITIAL_MAX_CCL_TBL_SIZE;
- ccltbl = allocate_Character_array( current_max_ccl_tbl_size );
-
- current_max_dfa_size = INITIAL_MAX_DFA_SIZE;
-
- current_max_xpairs = INITIAL_MAX_XPAIRS;
- nxt = allocate_integer_array( current_max_xpairs );
- chk = allocate_integer_array( current_max_xpairs );
-
- current_max_template_xpairs = INITIAL_MAX_TEMPLATE_XPAIRS;
- tnxt = allocate_integer_array( current_max_template_xpairs );
-
- current_max_dfas = INITIAL_MAX_DFAS;
- base = allocate_integer_array( current_max_dfas );
- def = allocate_integer_array( current_max_dfas );
- dfasiz = allocate_integer_array( current_max_dfas );
- accsiz = allocate_integer_array( current_max_dfas );
- dhash = allocate_integer_array( current_max_dfas );
- dss = allocate_int_ptr_array( current_max_dfas );
- dfaacc = allocate_dfaacc_union( current_max_dfas );
-
- nultrans = (int *) 0;
- }
+ {
+ current_mns = INITIAL_MNS;
+ firstst = allocate_integer_array( current_mns );
+ lastst = allocate_integer_array( current_mns );
+ finalst = allocate_integer_array( current_mns );
+ transchar = allocate_integer_array( current_mns );
+ trans1 = allocate_integer_array( current_mns );
+ trans2 = allocate_integer_array( current_mns );
+ accptnum = allocate_integer_array( current_mns );
+ assoc_rule = allocate_integer_array( current_mns );
+ state_type = allocate_integer_array( current_mns );
+
+ current_max_rules = INITIAL_MAX_RULES;
+ rule_type = allocate_integer_array( current_max_rules );
+ rule_linenum = allocate_integer_array( current_max_rules );
+ rule_useful = allocate_integer_array( current_max_rules );
+
+ current_max_scs = INITIAL_MAX_SCS;
+ scset = allocate_integer_array( current_max_scs );
+ scbol = allocate_integer_array( current_max_scs );
+ scxclu = allocate_integer_array( current_max_scs );
+ sceof = allocate_integer_array( current_max_scs );
+ scname = allocate_char_ptr_array( current_max_scs );
+ actvsc = allocate_integer_array( current_max_scs );
+
+ current_maxccls = INITIAL_MAX_CCLS;
+ cclmap = allocate_integer_array( current_maxccls );
+ ccllen = allocate_integer_array( current_maxccls );
+ cclng = allocate_integer_array( current_maxccls );
+
+ current_max_ccl_tbl_size = INITIAL_MAX_CCL_TBL_SIZE;
+ ccltbl = allocate_Character_array( current_max_ccl_tbl_size );
+
+ current_max_dfa_size = INITIAL_MAX_DFA_SIZE;
+
+ current_max_xpairs = INITIAL_MAX_XPAIRS;
+ nxt = allocate_integer_array( current_max_xpairs );
+ chk = allocate_integer_array( current_max_xpairs );
+
+ current_max_template_xpairs = INITIAL_MAX_TEMPLATE_XPAIRS;
+ tnxt = allocate_integer_array( current_max_template_xpairs );
+
+ current_max_dfas = INITIAL_MAX_DFAS;
+ base = allocate_integer_array( current_max_dfas );
+ def = allocate_integer_array( current_max_dfas );
+ dfasiz = allocate_integer_array( current_max_dfas );
+ accsiz = allocate_integer_array( current_max_dfas );
+ dhash = allocate_integer_array( current_max_dfas );
+ dss = allocate_int_ptr_array( current_max_dfas );
+ dfaacc = allocate_dfaacc_union( current_max_dfas );
+
+ nultrans = (int *) 0;
+ }
void usage()
- {
- fprintf( stderr,
+ {
+ fprintf( stderr,
"%s [-bcdfhinpstvwBFILTV78 -C[efmF] -Sskeleton] [filename ...]\n",
- program_name );
-
- fprintf( stderr,
- "\t-b generate backtracking information to lex.backtrack\n" );
- fprintf( stderr, "\t-c do-nothing POSIX option\n" );
- fprintf( stderr, "\t-d turn on debug mode in generated scanner\n" );
- fprintf( stderr, "\t-f generate fast, large scanner\n" );
- fprintf( stderr, "\t-h produce this help message\n" );
- fprintf( stderr, "\t-i generate case-insensitive scanner\n" );
- fprintf( stderr, "\t-n do-nothing POSIX option\n" );
- fprintf( stderr, "\t-p generate performance report to stderr\n" );
- fprintf( stderr, "\t-s suppress default rule to ECHO unmatched text\n" );
- fprintf( stderr,
+ program_name );
+
+ fprintf( stderr,
+ "\t-b generate backtracking information to lex.backtrack\n" );
+ fprintf( stderr, "\t-c do-nothing POSIX option\n" );
+ fprintf( stderr, "\t-d turn on debug mode in generated scanner\n" );
+ fprintf( stderr, "\t-f generate fast, large scanner\n" );
+ fprintf( stderr, "\t-h produce this help message\n" );
+ fprintf( stderr, "\t-i generate case-insensitive scanner\n" );
+ fprintf( stderr, "\t-n do-nothing POSIX option\n" );
+ fprintf( stderr, "\t-p generate performance report to stderr\n" );
+ fprintf( stderr,
+ "\t-s suppress default rule to ECHO unmatched text\n" );
+ fprintf( stderr,
"\t-t write generated scanner on stdout instead of lex.yy.c\n" );
- fprintf( stderr, "\t-v write summary of scanner statistics to stderr\n" );
- fprintf( stderr, "\t-w do not generate warnings\n" );
- fprintf( stderr, "\t-B generate batch scanner (opposite of -I)\n" );
- fprintf( stderr, "\t-F use alternative fast scanner representation\n" );
- fprintf( stderr, "\t-I generate interactive scanner (opposite of -B)\n" );
- fprintf( stderr, "\t-L suppress #line directives in scanner\n" );
- fprintf( stderr, "\t-T %s should run in trace mode\n", program_name );
- fprintf( stderr, "\t-V report %s version\n", program_name );
- fprintf( stderr, "\t-7 generate 7-bit scanner\n" );
- fprintf( stderr, "\t-8 generate 8-bit scanner\n" );
- fprintf( stderr,
+ fprintf( stderr,
+ "\t-v write summary of scanner statistics to stderr\n" );
+ fprintf( stderr, "\t-w do not generate warnings\n" );
+ fprintf( stderr, "\t-B generate batch scanner (opposite of -I)\n" );
+ fprintf( stderr,
+ "\t-F use alternative fast scanner representation\n" );
+ fprintf( stderr,
+ "\t-I generate interactive scanner (opposite of -B)\n" );
+ fprintf( stderr, "\t-L suppress #line directives in scanner\n" );
+ fprintf( stderr, "\t-T %s should run in trace mode\n", program_name );
+ fprintf( stderr, "\t-V report %s version\n", program_name );
+ fprintf( stderr, "\t-7 generate 7-bit scanner\n" );
+ fprintf( stderr, "\t-8 generate 8-bit scanner\n" );
+ fprintf( stderr,
"\t-C specify degree of table compression (default is -Cem):\n" );
- fprintf( stderr, "\t\t-Ce construct equivalence classes\n" );
- fprintf( stderr,
+ fprintf( stderr, "\t\t-Ce construct equivalence classes\n" );
+ fprintf( stderr,
"\t\t-Cf do not compress scanner tables; use -f representation\n" );
- fprintf( stderr, "\t\t-Cm construct meta-equivalence classes\n" );
- fprintf( stderr,
+ fprintf( stderr, "\t\t-Cm construct meta-equivalence classes\n" );
+ fprintf( stderr,
"\t\t-CF do not compress scanner tables; use -F representation\n" );
- fprintf( stderr, "\t-S specify non-default skeleton file\n" );
- }
+ fprintf( stderr, "\t-S specify non-default skeleton file\n" );
+ }
void add_action( new_text )
char *new_text;
- {
- int len = strlen( new_text );
-
- while ( len + action_index + action_offset >= action_size - 10 /* slop */ )
{
- action_size *= 2;
- prolog = action_array =
- reallocate_character_array( action_array, action_size );
- action = &action_array[action_offset];
- }
+ int len = strlen( new_text );
- strcpy( &action[action_index], new_text );
+ while ( len + action_index + action_offset >= action_size - 10
+ /* slop */ )
+ {
+ action_size *= 2;
+ prolog = action_array =
+ reallocate_character_array( action_array, action_size );
+ action = &action_array[action_offset];
+ }
+
+ strcpy( &action[action_index], new_text );
- action_index += len;
- }
+ action_index += len;
+ }
/* allocate_array - allocate memory for an integer array of the given size */
void *allocate_array( size, element_size )
int size, element_size;
+ {
+ register void *mem;
- {
- register void *mem;
+ /* On 16-bit int machines (e.g., 80286) we might be trying to
+ * allocate more than a signed int can hold, and that won't
+ * work. Cheap test:
+ */
+ if ( element_size * size <= 0 )
+ flexfatal( "request for < 1 byte in allocate_array()" );
- /* on 16-bit int machines (e.g., 80286) we might be trying to
- * allocate more than a signed int can hold, and that won't
- * work. Cheap test:
- */
- if ( element_size * size <= 0 )
- flexfatal( "request for < 1 byte in allocate_array()" );
+ mem = (void *) malloc( (unsigned) (element_size * size) );
- mem = (void *) malloc( (unsigned) (element_size * size) );
+ if ( mem == NULL )
+ flexfatal( "memory allocation failed in allocate_array()" );
- if ( mem == NULL )
- flexfatal( "memory allocation failed in allocate_array()" );
+ return mem;
+ }
- return ( mem );
- }
-
-/* all_lower - true if a string is all lower-case
- *
- * synopsis:
- * Char *str;
- * int all_lower();
- * true/false = all_lower( str );
- */
+/* all_lower - true if a string is all lower-case */
int all_lower( str )
register Char *str;
-
- {
- while ( *str )
{
- if ( ! isascii( *str ) || ! islower( *str ) )
- return ( 0 );
- ++str;
+ while ( *str )
+ {
+ if ( ! isascii( *str ) || ! islower( *str ) )
+ return 0;
+ ++str;
+ }
+
+ return 1;
}
- return ( 1 );
- }
-
-/* all_upper - true if a string is all upper-case
- *
- * synopsis:
- * Char *str;
- * int all_upper();
- * true/false = all_upper( str );
- */
+/* all_upper - true if a string is all upper-case */
int all_upper( str )
register Char *str;
-
- {
- while ( *str )
{
- if ( ! isascii( *str ) || ! isupper( (char) *str ) )
- return ( 0 );
- ++str;
- }
+ while ( *str )
+ {
+ if ( ! isascii( *str ) || ! isupper( (char) *str ) )
+ return 0;
+ ++str;
+ }
- return ( 1 );
- }
+ return 1;
+ }
/* bubble - bubble sort an integer array in increasing order
*
* synopsis
* int v[n], n;
- * bubble( v, n );
+ * void bubble( v, n );
*
* description
* sorts the first n elements of array v and replaces them in
*
* passed
* v - the array to be sorted
- * n - the number of elements of 'v' to be sorted */
+ * n - the number of elements of 'v' to be sorted
+ */
void bubble( v, n )
int v[], n;
-
- {
- register int i, j, k;
-
- for ( i = n; i > 1; --i )
- for ( j = 1; j < i; ++j )
- if ( v[j] > v[j + 1] ) /* compare */
- {
- k = v[j]; /* exchange */
- v[j] = v[j + 1];
- v[j + 1] = k;
- }
- }
+ {
+ register int i, j, k;
+
+ for ( i = n; i > 1; --i )
+ for ( j = 1; j < i; ++j )
+ if ( v[j] > v[j + 1] ) /* compare */
+ {
+ k = v[j]; /* exchange */
+ v[j] = v[j + 1];
+ v[j + 1] = k;
+ }
+ }
-/* clower - replace upper-case letter to lower-case
- *
- * synopsis:
- * Char clower();
- * int c;
- * c = clower( c );
- */
+/* clower - replace upper-case letter to lower-case */
Char clower( c )
register int c;
-
- {
- return ( (isascii( c ) && isupper( c )) ? tolower( c ) : c );
- }
+ {
+ return (isascii( c ) && isupper( c )) ? tolower( c ) : c;
+ }
-/* copy_string - returns a dynamically allocated copy of a string
- *
- * synopsis
- * char *str, *copy, *copy_string();
- * copy = copy_string( str );
- */
+/* copy_string - returns a dynamically allocated copy of a string */
char *copy_string( str )
register char *str;
+ {
+ register char *c;
+ char *copy;
- {
- register char *c;
- char *copy;
-
- /* find length */
- for ( c = str; *c; ++c )
- ;
+ /* find length */
+ for ( c = str; *c; ++c )
+ ;
- copy = malloc( (unsigned) ((c - str + 1) * sizeof( char )) );
+ copy = malloc( (unsigned) ((c - str + 1) * sizeof( char )) );
- if ( copy == NULL )
- flexfatal( "dynamic memory failure in copy_string()" );
+ if ( copy == NULL )
+ flexfatal( "dynamic memory failure in copy_string()" );
- for ( c = copy; (*c++ = *str++); )
- ;
+ for ( c = copy; (*c++ = *str++); )
+ ;
- return ( copy );
- }
+ return copy;
+ }
/* copy_unsigned_string -
* returns a dynamically allocated copy of a (potentially) unsigned string
- *
- * synopsis
- * Char *str, *copy, *copy_unsigned_string();
- * copy = copy_unsigned_string( str );
*/
Char *copy_unsigned_string( str )
register Char *str;
+ {
+ register Char *c;
+ Char *copy;
- {
- register Char *c;
- Char *copy;
-
- /* find length */
- for ( c = str; *c; ++c )
- ;
+ /* find length */
+ for ( c = str; *c; ++c )
+ ;
- copy = allocate_Character_array( c - str + 1 );
+ copy = allocate_Character_array( c - str + 1 );
- for ( c = copy; (*c++ = *str++); )
- ;
+ for ( c = copy; (*c++ = *str++); )
+ ;
- return ( copy );
- }
+ return copy;
+ }
/* cshell - shell sort a character array in increasing order
* cshell( v, n, special_case_0 );
*
* description
- * does a shell sort of the first n elements of array v.
+ * Does a shell sort of the first n elements of array v.
* If special_case_0 is true, then any element equal to 0
* is instead assumed to have infinite weight.
*
void cshell( v, n, special_case_0 )
Char v[];
int n, special_case_0;
-
- {
- int gap, i, j, jg;
- Char k;
-
- for ( gap = n / 2; gap > 0; gap = gap / 2 )
- for ( i = gap; i < n; ++i )
- for ( j = i - gap; j >= 0; j = j - gap )
- {
- jg = j + gap;
-
- if ( special_case_0 )
- {
- if ( v[jg] == 0 )
- break;
-
- else if ( v[j] != 0 && v[j] <= v[jg] )
- break;
- }
-
- else if ( v[j] <= v[jg] )
- break;
-
- k = v[j];
- v[j] = v[jg];
- v[jg] = k;
- }
- }
+ {
+ int gap, i, j, jg;
+ Char k;
+
+ for ( gap = n / 2; gap > 0; gap = gap / 2 )
+ for ( i = gap; i < n; ++i )
+ for ( j = i - gap; j >= 0; j = j - gap )
+ {
+ jg = j + gap;
+
+ if ( special_case_0 )
+ {
+ if ( v[jg] == 0 )
+ break;
+
+ else if ( v[j] != 0 && v[j] <= v[jg] )
+ break;
+ }
+
+ else if ( v[j] <= v[jg] )
+ break;
+
+ k = v[j];
+ v[j] = v[jg];
+ v[jg] = k;
+ }
+ }
-/* dataend - finish up a block of data declarations
- *
- * synopsis
- * dataend();
- */
+/* dataend - finish up a block of data declarations */
void dataend()
+ {
+ if ( datapos > 0 )
+ dataflush();
- {
- if ( datapos > 0 )
- dataflush();
-
- /* add terminator for initialization */
- puts( " } ;\n" );
-
- dataline = 0;
- datapos = 0;
- }
+ /* add terminator for initialization; { for vi */
+ puts( " } ;\n" );
+ dataline = 0;
+ datapos = 0;
+ }
-/* dataflush - flush generated data statements
- *
- * synopsis
- * dataflush();
- */
+/* dataflush - flush generated data statements */
void dataflush()
-
- {
- putchar( '\n' );
-
- if ( ++dataline >= NUMDATALINES )
{
- /* put out a blank line so that the table is grouped into
- * large blocks that enable the user to find elements easily
- */
putchar( '\n' );
- dataline = 0;
- }
- /* reset the number of characters written on the current line */
- datapos = 0;
- }
+ if ( ++dataline >= NUMDATALINES )
+ {
+ /* Put out a blank line so that the table is grouped into
+ * large blocks that enable the user to find elements easily.
+ */
+ putchar( '\n' );
+ dataline = 0;
+ }
+ /* Reset the number of characters written on the current line. */
+ datapos = 0;
+ }
-/* flexerror - report an error message and terminate
- *
- * synopsis
- * char msg[];
- * flexerror( msg );
- */
+
+/* flexerror - report an error message and terminate */
void flexerror( msg )
char msg[];
-
- {
- fprintf( stderr, "%s: %s\n", program_name, msg );
-
- flexend( 1 );
- }
+ {
+ fprintf( stderr, "%s: %s\n", program_name, msg );
+ flexend( 1 );
+ }
-/* flexfatal - report a fatal error message and terminate
- *
- * synopsis
- * char msg[];
- * flexfatal( msg );
- */
+/* flexfatal - report a fatal error message and terminate */
void flexfatal( msg )
char msg[];
-
- {
- fprintf( stderr, "%s: fatal internal error, %s\n", program_name, msg );
- exit( 1 );
- }
+ {
+ fprintf( stderr, "%s: fatal internal error, %s\n", program_name, msg );
+ exit( 1 );
+ }
/* flex_gettime - return current time
- *
- * synopsis
- * char *flex_gettime(), *time_str;
- * time_str = flex_gettime();
*
* note
* the routine name has the "flex_" prefix because of name clashes
#endif
char *flex_gettime()
+ {
+ time_t t, time();
+ char *result, *ctime(), *copy_string();
- {
- time_t t, time();
- char *result, *ctime(), *copy_string();
-
- t = time( (long *) 0 );
+ t = time( (long *) 0 );
- result = copy_string( ctime( &t ) );
+ result = copy_string( ctime( &t ) );
- /* get rid of trailing newline */
- result[24] = '\0';
+ /* get rid of trailing newline */
+ result[24] = '\0';
- return ( result );
- }
+ return result;
+ }
-/* lerrif - report an error message formatted with one integer argument
- *
- * synopsis
- * char msg[];
- * int arg;
- * lerrif( msg, arg );
- */
+/* lerrif - report an error message formatted with one integer argument */
void lerrif( msg, arg )
char msg[];
int arg;
-
- {
- char errmsg[MAXLINE];
- (void) sprintf( errmsg, msg, arg );
- flexerror( errmsg );
- }
+ {
+ char errmsg[MAXLINE];
+ (void) sprintf( errmsg, msg, arg );
+ flexerror( errmsg );
+ }
-/* lerrsf - report an error message formatted with one string argument
- *
- * synopsis
- * char msg[], arg[];
- * lerrsf( msg, arg );
- */
+/* lerrsf - report an error message formatted with one string argument */
void lerrsf( msg, arg )
char msg[], arg[];
+ {
+ char errmsg[MAXLINE];
- {
- char errmsg[MAXLINE];
-
- (void) sprintf( errmsg, msg, arg );
- flexerror( errmsg );
- }
+ (void) sprintf( errmsg, msg, arg );
+ flexerror( errmsg );
+ }
-/* htoi - convert a hexadecimal digit string to an integer value
- *
- * synopsis:
- * int val, htoi();
- * Char str[];
- * val = htoi( str );
- */
+/* htoi - convert a hexadecimal digit string to an integer value */
int htoi( str )
Char str[];
+ {
+ unsigned int result;
- {
- unsigned int result;
-
- (void) sscanf( (char *) str, "%x", &result );
+ (void) sscanf( (char *) str, "%x", &result );
- return ( result );
- }
+ return result;
+ }
/* is_hex_digit - returns true if a character is a valid hex digit, false
* otherwise
- *
- * synopsis:
- * int true_or_false, is_hex_digit();
- * int ch;
- * val = is_hex_digit( ch );
*/
int is_hex_digit( ch )
int ch;
-
- {
- if ( isdigit( ch ) )
- return ( 1 );
-
- switch ( clower( ch ) )
{
- case 'a':
- case 'b':
- case 'c':
- case 'd':
- case 'e':
- case 'f':
- return ( 1 );
-
- default:
- return ( 0 );
+ if ( isdigit( ch ) )
+ return 1;
+
+ switch ( clower( ch ) )
+ {
+ case 'a':
+ case 'b':
+ case 'c':
+ case 'd':
+ case 'e':
+ case 'f':
+ return 1;
+
+ default:
+ return 0;
+ }
}
- }
/* line_directive_out - spit out a "# line" statement */
void line_directive_out( output_file )
FILE *output_file;
-
- {
- if ( infilename && gen_line_dirs )
{
- char directive[MAXLINE];
- sprintf( directive, "# line %d \"%s\"\n", linenum, infilename );
+ if ( infilename && gen_line_dirs )
+ {
+ char directive[MAXLINE];
+ sprintf( directive, "# line %d \"%s\"\n", linenum, infilename );
- /* if output_file is nil then we should put the directive in
- * the accumulated actions.
- */
- if ( output_file )
- fputs( directive, output_file );
- else
- add_action( directive );
+ /* If output_file is nil then we should put the directive in
+ * the accumulated actions.
+ */
+ if ( output_file )
+ fputs( directive, output_file );
+ else
+ add_action( directive );
+ }
}
- }
/* mark_prolog - mark the current position in the action array as
* representing the action prolog
*/
void mark_prolog()
- {
- prolog = action_array;
- action_array[action_index++] = '\0';
- action_offset = action_index;
- action = &action_array[action_offset];
- action_index = 0;
- action[action_index] = '\0';
- }
+ {
+ prolog = action_array;
+ action_array[action_index++] = '\0';
+ action_offset = action_index;
+ action = &action_array[action_offset];
+ action_index = 0;
+ action[action_index] = '\0';
+ }
/* mk2data - generate a data statement for a two-dimensional array
*
- * synopsis
- * int value;
- * mk2data( value );
- *
- * generates a data statement initializing the current 2-D array to "value"
+ * Generates a data statement initializing the current 2-D array to "value".
*/
void mk2data( value )
int value;
-
- {
- if ( datapos >= NUMDATAITEMS )
{
- putchar( ',' );
- dataflush();
- }
+ if ( datapos >= NUMDATAITEMS )
+ {
+ putchar( ',' );
+ dataflush();
+ }
- if ( datapos == 0 )
- /* indent */
- fputs( " ", stdout );
+ if ( datapos == 0 )
+ /* Indent. */
+ fputs( " ", stdout );
- else
- putchar( ',' );
+ else
+ putchar( ',' );
- ++datapos;
+ ++datapos;
- printf( "%5d", value );
- }
+ printf( "%5d", value );
+ }
/* mkdata - generate a data statement
*
- * synopsis
- * int value;
- * mkdata( value );
- *
- * generates a data statement initializing the current array element to
- * "value"
+ * Generates a data statement initializing the current array element to
+ * "value".
*/
void mkdata( value )
int value;
-
- {
- if ( datapos >= NUMDATAITEMS )
{
- putchar( ',' );
- dataflush();
- }
-
- if ( datapos == 0 )
- /* indent */
- fputs( " ", stdout );
+ if ( datapos >= NUMDATAITEMS )
+ {
+ putchar( ',' );
+ dataflush();
+ }
- else
- putchar( ',' );
+ if ( datapos == 0 )
+ /* Indent. */
+ fputs( " ", stdout );
+ else
+ putchar( ',' );
- ++datapos;
+ ++datapos;
- printf( "%5d", value );
- }
+ printf( "%5d", value );
+ }
-/* myctoi - return the integer represented by a string of digits
- *
- * synopsis
- * Char array[];
- * int val, myctoi();
- * val = myctoi( array );
- *
- */
+/* myctoi - return the integer represented by a string of digits */
int myctoi( array )
Char array[];
+ {
+ int val = 0;
- {
- int val = 0;
-
- (void) sscanf( (char *) array, "%d", &val );
+ (void) sscanf( (char *) array, "%d", &val );
- return ( val );
- }
+ return val;
+ }
-/* myesc - return character corresponding to escape sequence
- *
- * synopsis
- * Char array[], c, myesc();
- * c = myesc( array );
- *
- */
+/* myesc - return character corresponding to escape sequence */
Char myesc( array )
Char array[];
-
- {
- Char c, esc_char;
- register int sptr;
-
- switch ( array[1] )
{
+ Char c, esc_char;
+ register int sptr;
+
+ switch ( array[1] )
+ {
#ifdef __STDC__
- case 'a': return ( '\a' );
+ case 'a': return '\a';
#else
- case 'a': return ( '\007' );
+ case 'a': return '\007';
#endif
- case 'b': return ( '\b' );
- case 'f': return ( '\f' );
- case 'n': return ( '\n' );
- case 'r': return ( '\r' );
- case 't': return ( '\t' );
- case 'v': return ( '\v' );
-
- case '0':
- case '1':
- case '2':
- case '3':
- case '4':
- case '5':
- case '6':
- case '7':
- case '8':
- case '9':
- { /* \<octal> */
- sptr = 1;
-
- while ( isascii( array[sptr] ) && isdigit( array[sptr] ) )
- /* don't increment inside loop control because if
- * isdigit() is a macro it might expand into multiple
- * increments ...
- */
- ++sptr;
-
- c = array[sptr];
- array[sptr] = '\0';
-
- esc_char = otoi( array + 1 );
-
- array[sptr] = c;
-
- return ( esc_char );
- }
-
- case 'x':
- { /* \x<hex> */
- int sptr = 2;
-
- while ( isascii( array[sptr] ) &&
- is_hex_digit( (char) array[sptr] ) )
- /* don't increment inside loop control because if
- * isdigit() is a macro it might expand into multiple
- * increments ...
- */
- ++sptr;
-
- c = array[sptr];
- array[sptr] = '\0';
-
- esc_char = htoi( array + 2 );
-
- array[sptr] = c;
-
- return ( esc_char );
- }
-
- default:
- return ( array[1] );
+ case 'b': return '\b';
+ case 'f': return '\f';
+ case 'n': return '\n';
+ case 'r': return '\r';
+ case 't': return '\t';
+ case 'v': return '\v';
+
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
+ { /* \<octal> */
+ sptr = 1;
+
+ while ( isascii( array[sptr] ) &&
+ isdigit( array[sptr] ) )
+ /* Don't increment inside loop control
+ * because if isdigit() is a macro it might
+ * expand into multiple increments ...
+ */
+ ++sptr;
+
+ c = array[sptr];
+ array[sptr] = '\0';
+
+ esc_char = otoi( array + 1 );
+
+ array[sptr] = c;
+
+ return esc_char;
+ }
+
+ case 'x':
+ { /* \x<hex> */
+ int sptr = 2;
+
+ while ( isascii( array[sptr] ) &&
+ is_hex_digit( (char) array[sptr] ) )
+ /* Don't increment inside loop control
+ * because if isdigit() is a macro it might
+ * expand into multiple increments ...
+ */
+ ++sptr;
+
+ c = array[sptr];
+ array[sptr] = '\0';
+
+ esc_char = htoi( array + 2 );
+
+ array[sptr] = c;
+
+ return esc_char;
+ }
+
+ default:
+ return array[1];
+ }
}
- }
-/* otoi - convert an octal digit string to an integer value
- *
- * synopsis:
- * int val, otoi();
- * Char str[];
- * val = otoi( str );
- */
+/* otoi - convert an octal digit string to an integer value */
int otoi( str )
Char str[];
+ {
+ unsigned int result;
- {
- unsigned int result;
-
- (void) sscanf( (char *) str, "%o", &result );
-
- return ( result );
- }
+ (void) sscanf( (char *) str, "%o", &result );
+ return result;
+ }
/* readable_form - return the the human-readable form of a character
- *
- * synopsis:
- * int c;
- * char *readable_form();
- * <string> = readable_form( c );
*
* The returned string is in static storage.
*/
char *readable_form( c )
register int c;
-
- {
- static char rform[10];
-
- if ( (c >= 0 && c < 32) || c >= 127 )
{
- switch ( c )
- {
+ static char rform[10];
+
+ if ( (c >= 0 && c < 32) || c >= 127 )
+ {
+ switch ( c )
+ {
#ifdef __STDC__
- case '\a': return ( "\\a" );
+ case '\a': return "\\a";
#endif
- case '\b': return ( "\\b" );
- case '\f': return ( "\\f" );
- case '\n': return ( "\\n" );
- case '\r': return ( "\\r" );
- case '\t': return ( "\\t" );
- case '\v': return ( "\\v" );
-
- default:
- (void) sprintf( rform, "\\%.3o", (unsigned int) c );
- return ( rform );
- }
- }
+ case '\b': return "\\b";
+ case '\f': return "\\f";
+ case '\n': return "\\n";
+ case '\r': return "\\r";
+ case '\t': return "\\t";
+ case '\v': return "\\v";
+
+ default:
+ (void) sprintf( rform, "\\%.3o",
+ (unsigned int) c );
+ return rform;
+ }
+ }
- else if ( c == ' ' )
- return ( "' '" );
+ else if ( c == ' ' )
+ return "' '";
- else
- {
- rform[0] = c;
- rform[1] = '\0';
+ else
+ {
+ rform[0] = c;
+ rform[1] = '\0';
- return ( rform );
+ return rform;
+ }
}
- }
/* reallocate_array - increase the size of a dynamic array */
void *reallocate_array( array, size, element_size )
void *array;
int size, element_size;
+ {
+ register void *new_array;
- {
- register void *new_array;
-
- /* same worry as in allocate_array(): */
- if ( size * element_size <= 0 )
- flexfatal( "attempt to increase array size by less than 1 byte" );
+ /* Same worry as in allocate_array(): */
+ if ( size * element_size <= 0 )
+ flexfatal(
+ "attempt to increase array size by less than 1 byte" );
- new_array =
+ new_array =
(void *) realloc( (char *)array, (unsigned) (size * element_size ));
- if ( new_array == NULL )
- flexfatal( "attempt to increase array size failed" );
+ if ( new_array == NULL )
+ flexfatal( "attempt to increase array size failed" );
- return ( new_array );
- }
+ return new_array;
+ }
/* skelout - write out one section of the skeleton file
*
- * synopsis
- * skelout();
- *
- * DESCRIPTION
+ * Description
* Copies skelfile or skel array to stdout until a line beginning with
* "%%" or EOF is found.
*/
void skelout()
-
- {
- if ( skelfile )
{
- char buf[MAXLINE];
-
- while ( fgets( buf, MAXLINE, skelfile ) != NULL )
- if ( buf[0] == '%' && buf[1] == '%' )
- break;
- else
- fputs( buf, stdout );
- }
+ if ( skelfile )
+ {
+ char buf[MAXLINE];
- else
- { /* copy from skel array */
- char *buf;
+ while ( fgets( buf, MAXLINE, skelfile ) != NULL )
+ if ( buf[0] == '%' && buf[1] == '%' )
+ break;
+ else
+ fputs( buf, stdout );
+ }
- while ( (buf = skel[skel_ind++]) )
- if ( buf[0] == '%' && buf[1] == '%' )
- break;
- else
- printf( "%s\n", buf );
+ else
+ { /* copy from skel array */
+ char *buf;
+
+ while ( (buf = skel[skel_ind++]) )
+ if ( buf[0] == '%' && buf[1] == '%' )
+ break;
+ else
+ printf( "%s\n", buf );
+ }
}
- }
/* transition_struct_out - output a yy_trans_info structure
- *
- * synopsis
- * int element_v, element_n;
- * transition_struct_out( element_v, element_n );
*
* outputs the yy_trans_info structure with the two elements, element_v and
* element_n. Formats the output with spaces and carriage returns.
void transition_struct_out( element_v, element_n )
int element_v, element_n;
+ {
+ printf( "%7d, %5d,", element_v, element_n );
- {
- printf( "%7d, %5d,", element_v, element_n );
-
- datapos += TRANS_STRUCT_PRINT_LENGTH;
+ datapos += TRANS_STRUCT_PRINT_LENGTH;
- if ( datapos >= 75 )
- {
- putchar( '\n' );
+ if ( datapos >= 75 )
+ {
+ putchar( '\n' );
- if ( ++dataline % 10 == 0 )
- putchar( '\n' );
+ if ( ++dataline % 10 == 0 )
+ putchar( '\n' );
- datapos = 0;
+ datapos = 0;
+ }
}
- }
/* zero_out - set a region of memory to 0
*
- * synopsis
- * char *region_ptr;
- * int size_in_bytes;
- * zero_out( region_ptr, size_in_bytes );
- *
- * sets region_ptr[0] through region_ptr[size_in_bytes - 1] to zero.
+ * Sets region_ptr[0] through region_ptr[size_in_bytes - 1] to zero.
*/
void zero_out( region_ptr, size_in_bytes )
char *region_ptr;
int size_in_bytes;
+ {
+ register char *rp, *rp_end;
- {
- register char *rp, *rp_end;
-
- rp = region_ptr;
- rp_end = region_ptr + size_in_bytes;
+ rp = region_ptr;
+ rp_end = region_ptr + size_in_bytes;
- while ( rp < rp_end )
- *rp++ = 0;
- }
+ while ( rp < rp_end )
+ *rp++ = 0;
+ }
/* add_accept - add an accepting state to a machine
- *
- * synopsis
- *
- * add_accept( mach, accepting_number );
*
* accepting_number becomes mach's accepting number.
*/
void add_accept( mach, accepting_number )
int mach, accepting_number;
+ {
+ /* Hang the accepting number off an epsilon state. if it is associated
+ * with a state that has a non-epsilon out-transition, then the state
+ * will accept BEFORE it makes that transition, i.e., one character
+ * too soon.
+ */
- {
- /* hang the accepting number off an epsilon state. if it is associated
- * with a state that has a non-epsilon out-transition, then the state
- * will accept BEFORE it makes that transition, i.e., one character
- * too soon
- */
-
- if ( transchar[finalst[mach]] == SYM_EPSILON )
- accptnum[finalst[mach]] = accepting_number;
+ if ( transchar[finalst[mach]] == SYM_EPSILON )
+ accptnum[finalst[mach]] = accepting_number;
- else
- {
- int astate = mkstate( SYM_EPSILON );
- accptnum[astate] = accepting_number;
- mach = link_machines( mach, astate );
+ else
+ {
+ int astate = mkstate( SYM_EPSILON );
+ accptnum[astate] = accepting_number;
+ mach = link_machines( mach, astate );
+ }
}
- }
/* copysingl - make a given number of copies of a singleton machine
int copysingl( singl, num )
int singl, num;
+ {
+ int copy, i;
- {
- int copy, i;
+ copy = mkstate( SYM_EPSILON );
- copy = mkstate( SYM_EPSILON );
+ for ( i = 1; i <= num; ++i )
+ copy = link_machines( copy, dupmachine( singl ) );
- for ( i = 1; i <= num; ++i )
- copy = link_machines( copy, dupmachine( singl ) );
+ return copy;
+ }
- return ( copy );
- }
-
-/* dumpnfa - debugging routine to write out an nfa
- *
- * synopsis
- * int state1;
- * dumpnfa( state1 );
- */
+/* dumpnfa - debugging routine to write out an nfa */
void dumpnfa( state1 )
int state1;
- {
- int sym, tsp1, tsp2, anum, ns;
+ {
+ int sym, tsp1, tsp2, anum, ns;
- fprintf( stderr, "\n\n********** beginning dump of nfa with start state %d\n",
- state1 );
+ fprintf( stderr,
+ "\n\n********** beginning dump of nfa with start state %d\n",
+ state1 );
- /* we probably should loop starting at firstst[state1] and going to
- * lastst[state1], but they're not maintained properly when we "or"
- * all of the rules together. So we use our knowledge that the machine
- * starts at state 1 and ends at lastnfa.
- */
+ /* We probably should loop starting at firstst[state1] and going to
+ * lastst[state1], but they're not maintained properly when we "or"
+ * all of the rules together. So we use our knowledge that the machine
+ * starts at state 1 and ends at lastnfa.
+ */
- /* for ( ns = firstst[state1]; ns <= lastst[state1]; ++ns ) */
- for ( ns = 1; ns <= lastnfa; ++ns )
- {
- fprintf( stderr, "state # %4d\t", ns );
+ /* for ( ns = firstst[state1]; ns <= lastst[state1]; ++ns ) */
+ for ( ns = 1; ns <= lastnfa; ++ns )
+ {
+ fprintf( stderr, "state # %4d\t", ns );
- sym = transchar[ns];
- tsp1 = trans1[ns];
- tsp2 = trans2[ns];
- anum = accptnum[ns];
+ sym = transchar[ns];
+ tsp1 = trans1[ns];
+ tsp2 = trans2[ns];
+ anum = accptnum[ns];
- fprintf( stderr, "%3d: %4d, %4d", sym, tsp1, tsp2 );
+ fprintf( stderr, "%3d: %4d, %4d", sym, tsp1, tsp2 );
- if ( anum != NIL )
- fprintf( stderr, " [%d]", anum );
+ if ( anum != NIL )
+ fprintf( stderr, " [%d]", anum );
- fprintf( stderr, "\n" );
- }
+ fprintf( stderr, "\n" );
+ }
- fprintf( stderr, "********** end of dump\n" );
- }
+ fprintf( stderr, "********** end of dump\n" );
+ }
/* dupmachine - make a duplicate of a given machine
int dupmachine( mach )
int mach;
-
- {
- int i, init, state_offset;
- int state = 0;
- int last = lastst[mach];
-
- for ( i = firstst[mach]; i <= last; ++i )
{
- state = mkstate( transchar[i] );
+ int i, init, state_offset;
+ int state = 0;
+ int last = lastst[mach];
- if ( trans1[i] != NO_TRANSITION )
- {
- mkxtion( finalst[state], trans1[i] + state - i );
+ for ( i = firstst[mach]; i <= last; ++i )
+ {
+ state = mkstate( transchar[i] );
- if ( transchar[i] == SYM_EPSILON && trans2[i] != NO_TRANSITION )
- mkxtion( finalst[state], trans2[i] + state - i );
- }
+ if ( trans1[i] != NO_TRANSITION )
+ {
+ mkxtion( finalst[state], trans1[i] + state - i );
- accptnum[state] = accptnum[i];
- }
+ if ( transchar[i] == SYM_EPSILON &&
+ trans2[i] != NO_TRANSITION )
+ mkxtion( finalst[state],
+ trans2[i] + state - i );
+ }
- if ( state == 0 )
- flexfatal( "empty machine in dupmachine()" );
+ accptnum[state] = accptnum[i];
+ }
+
+ if ( state == 0 )
+ flexfatal( "empty machine in dupmachine()" );
- state_offset = state - i + 1;
+ state_offset = state - i + 1;
- init = mach + state_offset;
- firstst[init] = firstst[mach] + state_offset;
- finalst[init] = finalst[mach] + state_offset;
- lastst[init] = lastst[mach] + state_offset;
+ init = mach + state_offset;
+ firstst[init] = firstst[mach] + state_offset;
+ finalst[init] = finalst[mach] + state_offset;
+ lastst[init] = lastst[mach] + state_offset;
- return ( init );
- }
+ return init;
+ }
/* finish_rule - finish up the processing for a rule
- *
- * synopsis
- *
- * finish_rule( mach, variable_trail_rule, headcnt, trailcnt );
*
* An accepting number is added to the given machine. If variable_trail_rule
* is true then the rule has trailing context and both the head and trail
void finish_rule( mach, variable_trail_rule, headcnt, trailcnt )
int mach, variable_trail_rule, headcnt, trailcnt;
+ {
+ char action_text[MAXLINE];
- {
- char action_text[MAXLINE];
-
- add_accept( mach, num_rules );
+ add_accept( mach, num_rules );
- /* we did this in new_rule(), but it often gets the wrong
- * number because we do it before we start parsing the current rule
- */
- rule_linenum[num_rules] = linenum;
+ /* We did this in new_rule(), but it often gets the wrong
+ * number because we do it before we start parsing the current rule.
+ */
+ rule_linenum[num_rules] = linenum;
- /* if this is a continued action, then the line-number has
- * already been updated, giving us the wrong number
- */
- if ( continued_action )
- --rule_linenum[num_rules];
+ /* If this is a continued action, then the line-number has already
+ * been updated, giving us the wrong number.
+ */
+ if ( continued_action )
+ --rule_linenum[num_rules];
- sprintf( action_text, "case %d:\n", num_rules );
- add_action( action_text );
+ sprintf( action_text, "case %d:\n", num_rules );
+ add_action( action_text );
- if ( variable_trail_rule )
- {
- rule_type[num_rules] = RULE_VARIABLE;
+ if ( variable_trail_rule )
+ {
+ rule_type[num_rules] = RULE_VARIABLE;
- if ( performance_report > 0 )
- fprintf( stderr, "Variable trailing context rule at line %d\n",
- rule_linenum[num_rules] );
+ if ( performance_report > 0 )
+ fprintf( stderr,
+ "Variable trailing context rule at line %d\n",
+ rule_linenum[num_rules] );
- variable_trailing_context_rules = true;
- }
+ variable_trailing_context_rules = true;
+ }
- else
- {
- rule_type[num_rules] = RULE_NORMAL;
+ else
+ {
+ rule_type[num_rules] = RULE_NORMAL;
- if ( headcnt > 0 || trailcnt > 0 )
- {
- /* do trailing context magic to not match the trailing characters */
- char *scanner_cp = "yy_c_buf_p = yy_cp";
- char *scanner_bp = "yy_bp";
+ if ( headcnt > 0 || trailcnt > 0 )
+ {
+ /* Do trailing context magic to not match the trailing
+ * characters.
+ */
+ char *scanner_cp = "yy_c_buf_p = yy_cp";
+ char *scanner_bp = "yy_bp";
- add_action(
+ add_action(
"*yy_cp = yy_hold_char; /* undo effects of setting up yytext */\n" );
- if ( headcnt > 0 )
- {
- sprintf( action_text, "%s = %s + %d;\n",
- scanner_cp, scanner_bp, headcnt );
- add_action( action_text );
+ if ( headcnt > 0 )
+ {
+ sprintf( action_text, "%s = %s + %d;\n",
+ scanner_cp, scanner_bp, headcnt );
+ add_action( action_text );
+ }
+
+ else
+ {
+ sprintf( action_text, "%s -= %d;\n",
+ scanner_cp, trailcnt );
+ add_action( action_text );
+ }
+
+ add_action(
+ "YY_DO_BEFORE_ACTION; /* set up yytext again */\n" );
+ }
}
- else
- {
- sprintf( action_text, "%s -= %d;\n", scanner_cp, trailcnt );
- add_action( action_text );
- }
-
- add_action( "YY_DO_BEFORE_ACTION; /* set up yytext again */\n" );
- }
+ line_directive_out( (FILE *) 0 );
}
- line_directive_out( (FILE *) 0 );
- }
-
/* link_machines - connect two machines together
*
int link_machines( first, last )
int first, last;
+ {
+ if ( first == NIL )
+ return last;
- {
- if ( first == NIL )
- return ( last );
-
- else if ( last == NIL )
- return ( first );
+ else if ( last == NIL )
+ return first;
- else
- {
- mkxtion( finalst[first], last );
- finalst[first] = finalst[last];
- lastst[first] = max( lastst[first], lastst[last] );
- firstst[first] = min( firstst[first], firstst[last] );
+ else
+ {
+ mkxtion( finalst[first], last );
+ finalst[first] = finalst[last];
+ lastst[first] = max( lastst[first], lastst[last] );
+ firstst[first] = min( firstst[first], firstst[last] );
- return ( first );
+ return first;
+ }
}
- }
/* mark_beginning_as_normal - mark each "beginning" state in a machine
* as being a "normal" (i.e., not trailing context-
* associated) states
*
- * synopsis
- *
- * mark_beginning_as_normal( mach )
- *
- * mach - machine to mark
- *
* The "beginning" states are the epsilon closure of the first state
*/
void mark_beginning_as_normal( mach )
register int mach;
-
- {
- switch ( state_type[mach] )
{
- case STATE_NORMAL:
- /* oh, we've already visited here */
- return;
-
- case STATE_TRAILING_CONTEXT:
- state_type[mach] = STATE_NORMAL;
-
- if ( transchar[mach] == SYM_EPSILON )
+ switch ( state_type[mach] )
{
- if ( trans1[mach] != NO_TRANSITION )
- mark_beginning_as_normal( trans1[mach] );
-
- if ( trans2[mach] != NO_TRANSITION )
- mark_beginning_as_normal( trans2[mach] );
+ case STATE_NORMAL:
+ /* Oh, we've already visited here. */
+ return;
+
+ case STATE_TRAILING_CONTEXT:
+ state_type[mach] = STATE_NORMAL;
+
+ if ( transchar[mach] == SYM_EPSILON )
+ {
+ if ( trans1[mach] != NO_TRANSITION )
+ mark_beginning_as_normal(
+ trans1[mach] );
+
+ if ( trans2[mach] != NO_TRANSITION )
+ mark_beginning_as_normal(
+ trans2[mach] );
+ }
+ break;
+
+ default:
+ flexerror(
+ "bad state type in mark_beginning_as_normal()" );
+ break;
}
- break;
-
- default:
- flexerror( "bad state type in mark_beginning_as_normal()" );
- break;
}
- }
/* mkbranch - make a machine that branches to two machines
* branch - a machine which matches either first's pattern or second's
* first, second - machines whose patterns are to be or'ed (the | operator)
*
- * note that first and second are NEITHER destroyed by the operation. Also,
+ * Note that first and second are NEITHER destroyed by the operation. Also,
* the resulting machine CANNOT be used with any other "mk" operation except
* more mkbranch's. Compare with mkor()
*/
int mkbranch( first, second )
int first, second;
+ {
+ int eps;
- {
- int eps;
-
- if ( first == NO_TRANSITION )
- return ( second );
+ if ( first == NO_TRANSITION )
+ return second;
- else if ( second == NO_TRANSITION )
- return ( first );
+ else if ( second == NO_TRANSITION )
+ return first;
- eps = mkstate( SYM_EPSILON );
+ eps = mkstate( SYM_EPSILON );
- mkxtion( eps, first );
- mkxtion( eps, second );
+ mkxtion( eps, first );
+ mkxtion( eps, second );
- return ( eps );
- }
+ return eps;
+ }
/* mkclos - convert a machine into a closure
* synopsis
* new = mkclos( state );
*
- * new - a new state which matches the closure of "state"
+ * new - a new state which matches the closure of "state"
*/
int mkclos( state )
int state;
-
- {
- return ( mkopt( mkposcl( state ) ) );
- }
+ {
+ return mkopt( mkposcl( state ) );
+ }
/* mkopt - make a machine optional
int mkopt( mach )
int mach;
+ {
+ int eps;
- {
- int eps;
+ if ( ! SUPER_FREE_EPSILON(finalst[mach]) )
+ {
+ eps = mkstate( SYM_EPSILON );
+ mach = link_machines( mach, eps );
+ }
- if ( ! SUPER_FREE_EPSILON(finalst[mach]) )
- {
+ /* Can't skimp on the following if FREE_EPSILON(mach) is true because
+ * some state interior to "mach" might point back to the beginning
+ * for a closure.
+ */
eps = mkstate( SYM_EPSILON );
- mach = link_machines( mach, eps );
- }
-
- /* can't skimp on the following if FREE_EPSILON(mach) is true because
- * some state interior to "mach" might point back to the beginning
- * for a closure
- */
- eps = mkstate( SYM_EPSILON );
- mach = link_machines( eps, mach );
+ mach = link_machines( eps, mach );
- mkxtion( mach, finalst[mach] );
+ mkxtion( mach, finalst[mach] );
- return ( mach );
- }
+ return mach;
+ }
/* mkor - make a machine that matches either one of two machines
int mkor( first, second )
int first, second;
-
- {
- int eps, orend;
-
- if ( first == NIL )
- return ( second );
-
- else if ( second == NIL )
- return ( first );
-
- else
{
- /* see comment in mkopt() about why we can't use the first state
- * of "first" or "second" if they satisfy "FREE_EPSILON"
- */
- eps = mkstate( SYM_EPSILON );
+ int eps, orend;
- first = link_machines( eps, first );
+ if ( first == NIL )
+ return second;
- mkxtion( first, second );
-
- if ( SUPER_FREE_EPSILON(finalst[first]) &&
- accptnum[finalst[first]] == NIL )
- {
- orend = finalst[first];
- mkxtion( finalst[second], orend );
- }
-
- else if ( SUPER_FREE_EPSILON(finalst[second]) &&
- accptnum[finalst[second]] == NIL )
- {
- orend = finalst[second];
- mkxtion( finalst[first], orend );
- }
+ else if ( second == NIL )
+ return first;
else
- {
- eps = mkstate( SYM_EPSILON );
-
- first = link_machines( first, eps );
- orend = finalst[first];
+ {
+ /* See comment in mkopt() about why we can't use the first
+ * state of "first" or "second" if they satisfy "FREE_EPSILON".
+ */
+ eps = mkstate( SYM_EPSILON );
+
+ first = link_machines( eps, first );
+
+ mkxtion( first, second );
+
+ if ( SUPER_FREE_EPSILON(finalst[first]) &&
+ accptnum[finalst[first]] == NIL )
+ {
+ orend = finalst[first];
+ mkxtion( finalst[second], orend );
+ }
+
+ else if ( SUPER_FREE_EPSILON(finalst[second]) &&
+ accptnum[finalst[second]] == NIL )
+ {
+ orend = finalst[second];
+ mkxtion( finalst[first], orend );
+ }
+
+ else
+ {
+ eps = mkstate( SYM_EPSILON );
+
+ first = link_machines( first, eps );
+ orend = finalst[first];
+
+ mkxtion( finalst[second], orend );
+ }
+ }
- mkxtion( finalst[second], orend );
- }
+ finalst[first] = orend;
+ return first;
}
- finalst[first] = orend;
- return ( first );
- }
-
/* mkposcl - convert a machine into a positive closure
*
int mkposcl( state )
int state;
-
- {
- int eps;
-
- if ( SUPER_FREE_EPSILON(finalst[state]) )
{
- mkxtion( finalst[state], state );
- return ( state );
- }
+ int eps;
- else
- {
- eps = mkstate( SYM_EPSILON );
- mkxtion( eps, state );
- return ( link_machines( state, eps ) );
+ if ( SUPER_FREE_EPSILON(finalst[state]) )
+ {
+ mkxtion( finalst[state], state );
+ return state;
+ }
+
+ else
+ {
+ eps = mkstate( SYM_EPSILON );
+ mkxtion( eps, state );
+ return link_machines( state, eps );
+ }
}
- }
/* mkrep - make a replicated machine
int mkrep( mach, lb, ub )
int mach, lb, ub;
+ {
+ int base_mach, tail, copy, i;
- {
- int base_mach, tail, copy, i;
+ base_mach = copysingl( mach, lb - 1 );
- base_mach = copysingl( mach, lb - 1 );
+ if ( ub == INFINITY )
+ {
+ copy = dupmachine( mach );
+ mach = link_machines( mach,
+ link_machines( base_mach, mkclos( copy ) ) );
+ }
- if ( ub == INFINITY )
- {
- copy = dupmachine( mach );
- mach = link_machines( mach,
- link_machines( base_mach, mkclos( copy ) ) );
- }
+ else
+ {
+ tail = mkstate( SYM_EPSILON );
- else
- {
- tail = mkstate( SYM_EPSILON );
+ for ( i = lb; i < ub; ++i )
+ {
+ copy = dupmachine( mach );
+ tail = mkopt( link_machines( copy, tail ) );
+ }
- for ( i = lb; i < ub; ++i )
- {
- copy = dupmachine( mach );
- tail = mkopt( link_machines( copy, tail ) );
- }
+ mach = link_machines( mach, link_machines( base_mach, tail ) );
+ }
- mach = link_machines( mach, link_machines( base_mach, tail ) );
+ return mach;
}
- return ( mach );
- }
-
/* mkstate - create a state with a transition on a given symbol
*
int mkstate( sym )
int sym;
-
- {
- if ( ++lastnfa >= current_mns )
{
- if ( (current_mns += MNS_INCREMENT) >= MAXIMUM_MNS )
- lerrif( "input rules are too complicated (>= %d NFA states)",
- current_mns );
-
- ++num_reallocs;
-
- firstst = reallocate_integer_array( firstst, current_mns );
- lastst = reallocate_integer_array( lastst, current_mns );
- finalst = reallocate_integer_array( finalst, current_mns );
- transchar = reallocate_integer_array( transchar, current_mns );
- trans1 = reallocate_integer_array( trans1, current_mns );
- trans2 = reallocate_integer_array( trans2, current_mns );
- accptnum = reallocate_integer_array( accptnum, current_mns );
- assoc_rule = reallocate_integer_array( assoc_rule, current_mns );
- state_type = reallocate_integer_array( state_type, current_mns );
- }
+ if ( ++lastnfa >= current_mns )
+ {
+ if ( (current_mns += MNS_INCREMENT) >= MAXIMUM_MNS )
+ lerrif(
+ "input rules are too complicated (>= %d NFA states)",
+ current_mns );
+
+ ++num_reallocs;
+
+ firstst = reallocate_integer_array( firstst, current_mns );
+ lastst = reallocate_integer_array( lastst, current_mns );
+ finalst = reallocate_integer_array( finalst, current_mns );
+ transchar = reallocate_integer_array( transchar, current_mns );
+ trans1 = reallocate_integer_array( trans1, current_mns );
+ trans2 = reallocate_integer_array( trans2, current_mns );
+ accptnum = reallocate_integer_array( accptnum, current_mns );
+ assoc_rule =
+ reallocate_integer_array( assoc_rule, current_mns );
+ state_type =
+ reallocate_integer_array( state_type, current_mns );
+ }
- firstst[lastnfa] = lastnfa;
- finalst[lastnfa] = lastnfa;
- lastst[lastnfa] = lastnfa;
- transchar[lastnfa] = sym;
- trans1[lastnfa] = NO_TRANSITION;
- trans2[lastnfa] = NO_TRANSITION;
- accptnum[lastnfa] = NIL;
- assoc_rule[lastnfa] = num_rules;
- state_type[lastnfa] = current_state_type;
-
- /* fix up equivalence classes base on this transition. Note that any
- * character which has its own transition gets its own equivalence class.
- * Thus only characters which are only in character classes have a chance
- * at being in the same equivalence class. E.g. "a|b" puts 'a' and 'b'
- * into two different equivalence classes. "[ab]" puts them in the same
- * equivalence class (barring other differences elsewhere in the input).
- */
-
- if ( sym < 0 )
- {
- /* we don't have to update the equivalence classes since that was
- * already done when the ccl was created for the first time
+ firstst[lastnfa] = lastnfa;
+ finalst[lastnfa] = lastnfa;
+ lastst[lastnfa] = lastnfa;
+ transchar[lastnfa] = sym;
+ trans1[lastnfa] = NO_TRANSITION;
+ trans2[lastnfa] = NO_TRANSITION;
+ accptnum[lastnfa] = NIL;
+ assoc_rule[lastnfa] = num_rules;
+ state_type[lastnfa] = current_state_type;
+
+ /* Fix up equivalence classes base on this transition. Note that any
+ * character which has its own transition gets its own equivalence
+ * class. Thus only characters which are only in character classes
+ * have a chance at being in the same equivalence class. E.g. "a|b"
+ * puts 'a' and 'b' into two different equivalence classes. "[ab]"
+ * puts them in the same equivalence class (barring other differences
+ * elsewhere in the input).
*/
- }
- else if ( sym == SYM_EPSILON )
- ++numeps;
+ if ( sym < 0 )
+ {
+ /* We don't have to update the equivalence classes since
+ * that was already done when the ccl was created for the
+ * first time.
+ */
+ }
- else
- {
- if ( useecs )
- /* map NUL's to csize */
- mkechar( sym ? sym : csize, nextecm, ecgroup );
- }
+ else if ( sym == SYM_EPSILON )
+ ++numeps;
- return ( lastnfa );
- }
+ else
+ {
+ if ( useecs )
+ /* Map NUL's to csize. */
+ mkechar( sym ? sym : csize, nextecm, ecgroup );
+ }
+
+ return lastnfa;
+ }
/* mkxtion - make a transition from one state to another
void mkxtion( statefrom, stateto )
int statefrom, stateto;
+ {
+ if ( trans1[statefrom] == NO_TRANSITION )
+ trans1[statefrom] = stateto;
- {
- if ( trans1[statefrom] == NO_TRANSITION )
- trans1[statefrom] = stateto;
-
- else if ( (transchar[statefrom] != SYM_EPSILON) ||
- (trans2[statefrom] != NO_TRANSITION) )
- flexfatal( "found too many transitions in mkxtion()" );
+ else if ( (transchar[statefrom] != SYM_EPSILON) ||
+ (trans2[statefrom] != NO_TRANSITION) )
+ flexfatal( "found too many transitions in mkxtion()" );
- else
- { /* second out-transition for an epsilon state */
- ++eps2;
- trans2[statefrom] = stateto;
+ else
+ { /* second out-transition for an epsilon state */
+ ++eps2;
+ trans2[statefrom] = stateto;
+ }
}
- }
-/* new_rule - initialize for a new rule
- *
- * synopsis
- *
- * new_rule();
- *
- * the global num_rules is incremented and the any corresponding dynamic
- * arrays (such as rule_type[]) are grown as needed.
- */
+/* new_rule - initialize for a new rule */
void new_rule()
-
- {
- if ( ++num_rules >= current_max_rules )
{
- ++num_reallocs;
- current_max_rules += MAX_RULES_INCREMENT;
- rule_type = reallocate_integer_array( rule_type, current_max_rules );
- rule_linenum =
- reallocate_integer_array( rule_linenum, current_max_rules );
- rule_useful =
- reallocate_integer_array( rule_useful, current_max_rules );
- }
+ if ( ++num_rules >= current_max_rules )
+ {
+ ++num_reallocs;
+ current_max_rules += MAX_RULES_INCREMENT;
+ rule_type = reallocate_integer_array( rule_type,
+ current_max_rules );
+ rule_linenum = reallocate_integer_array( rule_linenum,
+ current_max_rules );
+ rule_useful = reallocate_integer_array( rule_useful,
+ current_max_rules );
+ }
- if ( num_rules > MAX_RULE )
- lerrif( "too many rules (> %d)!", MAX_RULE );
+ if ( num_rules > MAX_RULE )
+ lerrif( "too many rules (> %d)!", MAX_RULE );
- rule_linenum[num_rules] = linenum;
- rule_useful[num_rules] = false;
- }
+ rule_linenum[num_rules] = linenum;
+ rule_useful[num_rules] = false;
+ }
def_rule = mkstate( -pat );
- /* remember the number of the default rule so we
+ /* Remember the number of the default rule so we
* don't generate "can't match" warnings for it.
*/
default_rule = num_rules;
finish_rule( def_rule, false, 0, 0 );
for ( i = 1; i <= lastsc; ++i )
- scset[i] = mkbranch( scset[i], def_rule );
+ scset[i] = mkbranch( scset[i], def_rule );
if ( spprdflt )
- add_action(
+ add_action(
"YY_FATAL_ERROR( \"flex scanner jammed\" )" );
else
- add_action( "ECHO" );
+ add_action( "ECHO" );
add_action( ";\n\tYY_BREAK\n" );
}
initlex :
{ /* initialize for processing rules */
- /* create default DFA start condition */
+ /* Create default DFA start condition. */
scinstal( "INITIAL", false );
- /* initially, the start condition scoping is
- * "no start conditions active"
+ /* Initially, the start condition scoping is
+ * "no start conditions active".
*/
actvp = 0;
}
sect1end : SECTEND
{
- /* we now know how many start conditions there
+ /* We now know how many start conditions there
* are, so create the "activity" map indicating
* which conditions are active.
*/
active_ss = allocate_integer_array( lastsc + 1 );
for ( i = 1; i <= lastsc; ++i )
- active_ss[i] = 0;
+ active_ss[i] = 0;
}
;
startconddecl : SCDECL
- {
- /* these productions are separate from the s1object
- * rule because the semantics must be done before
- * we parse the remainder of an s1object
- */
-
- xcluflg = false;
- }
+ { xcluflg = false; }
| XSCDECL
{ xcluflg = true; }
{ scinstal( nmstr, xcluflg ); }
| error
- { synerr( "bad start condition list" ); }
+ { synerr( "bad start condition list" ); }
;
sect2 : sect2 initforrule flexrule '\n'
initforrule :
{
- /* initialize for a parse of one rule */
+ /* Initialize for a parse of one rule. */
trlcontxt = variable_trail_rule = varlength = false;
trailcnt = headcnt = rulelen = 0;
current_state_type = STATE_NORMAL;
;
flexrule : scon '^' rule
- {
+ {
pat = $3;
finish_rule( pat, variable_trail_rule,
- headcnt, trailcnt );
+ headcnt, trailcnt );
for ( i = 1; i <= actvp; ++i )
- scbol[actvsc[i]] =
- mkbranch( scbol[actvsc[i]], pat );
+ scbol[actvsc[i]] =
+ mkbranch( scbol[actvsc[i]], pat );
if ( ! bol_needed )
- {
- bol_needed = true;
+ {
+ bol_needed = true;
- if ( performance_report > 1 )
- pinpoint_message(
- "'^' operator results in sub-optimal performance" );
- }
+ if ( performance_report > 1 )
+ pinpoint_message(
+ "'^' operator results in sub-optimal performance" );
+ }
}
| scon rule
- {
+ {
pat = $2;
finish_rule( pat, variable_trail_rule,
- headcnt, trailcnt );
+ headcnt, trailcnt );
for ( i = 1; i <= actvp; ++i )
- scset[actvsc[i]] =
- mkbranch( scset[actvsc[i]], pat );
+ scset[actvsc[i]] =
+ mkbranch( scset[actvsc[i]], pat );
}
| '^' rule
{
pat = $2;
finish_rule( pat, variable_trail_rule,
- headcnt, trailcnt );
+ headcnt, trailcnt );
- /* add to all non-exclusive start conditions,
- * including the default (0) start condition
+ /* Add to all non-exclusive start conditions,
+ * including the default (0) start condition.
*/
for ( i = 1; i <= lastsc; ++i )
- if ( ! scxclu[i] )
- scbol[i] = mkbranch( scbol[i], pat );
+ if ( ! scxclu[i] )
+ scbol[i] = mkbranch( scbol[i], pat );
if ( ! bol_needed )
- {
- bol_needed = true;
+ {
+ bol_needed = true;
- if ( performance_report > 1 )
- pinpoint_message(
- "'^' operator results in sub-optimal performance" );
- }
+ if ( performance_report > 1 )
+ pinpoint_message(
+ "'^' operator results in sub-optimal performance" );
+ }
}
| rule
{
pat = $1;
finish_rule( pat, variable_trail_rule,
- headcnt, trailcnt );
+ headcnt, trailcnt );
for ( i = 1; i <= lastsc; ++i )
- if ( ! scxclu[i] )
- scset[i] = mkbranch( scset[i], pat );
+ if ( ! scxclu[i] )
+ scset[i] = mkbranch( scset[i], pat );
}
| scon EOF_OP
| EOF_OP
{
- /* this EOF applies to all start conditions
- * which don't already have EOF actions
+ /* This EOF applies to all start conditions
+ * which don't already have EOF actions.
*/
actvp = 0;
for ( i = 1; i <= lastsc; ++i )
- if ( ! sceof[i] )
- actvsc[++actvp] = i;
+ if ( ! sceof[i] )
+ actvsc[++actvp] = i;
if ( actvp == 0 )
- warn(
- "all start conditions already have <<EOF>> rules" );
+ warn(
+ "all start conditions already have <<EOF>> rules" );
else
- build_eof_action();
+ build_eof_action();
}
| error
sconname : NAME
{
if ( (scnum = sclookup( nmstr )) == 0 )
- format_pinpoint_message(
- "undeclared start condition %s", nmstr );
+ format_pinpoint_message(
+ "undeclared start condition %s",
+ nmstr );
else
- {
- if ( ++actvp >= current_max_scs )
- /* some bozo has included multiple instances
- * of start condition names
- */
- pinpoint_message(
+ {
+ if ( ++actvp >= current_max_scs )
+ /* Some bozo has included multiple
+ * instances of start condition names.
+ */
+ pinpoint_message(
"too many start conditions in <> construct!" );
- else
- actvsc[actvp] = scnum;
- }
+ else
+ actvsc[actvp] = scnum;
+ }
}
;
rule : re2 re
{
if ( transchar[lastst[$2]] != SYM_EPSILON )
- /* provide final transition \now/ so it
- * will be marked as a trailing context
- * state
- */
- $2 = link_machines( $2, mkstate( SYM_EPSILON ) );
+ /* Provide final transition \now/ so it
+ * will be marked as a trailing context
+ * state.
+ */
+ $2 = link_machines( $2,
+ mkstate( SYM_EPSILON ) );
mark_beginning_as_normal( $2 );
current_state_type = STATE_NORMAL;
if ( previous_continued_action )
- {
- /* we need to treat this as variable trailing
- * context so that the backup does not happen
- * in the action but before the action switch
- * statement. If the backup happens in the
- * action, then the rules "falling into" this
- * one's action will *also* do the backup,
- * erroneously.
- */
- if ( ! varlength || headcnt != 0 )
- warn(
+ {
+ /* We need to treat this as variable trailing
+ * context so that the backup does not happen
+ * in the action but before the action switch
+ * statement. If the backup happens in the
+ * action, then the rules "falling into" this
+ * one's action will *also* do the backup,
+ * erroneously.
+ */
+ if ( ! varlength || headcnt != 0 )
+ warn(
"trailing context made variable due to preceding '|' action" );
- /* mark as variable */
- varlength = true;
- headcnt = 0;
- }
+ /* Mark as variable. */
+ varlength = true;
+ headcnt = 0;
+ }
if ( varlength && headcnt == 0 )
- { /* variable trailing context rule */
- /* mark the first part of the rule as the accepting
- * "head" part of a trailing context rule
- */
- /* by the way, we didn't do this at the beginning
- * of this production because back then
- * current_state_type was set up for a trail
- * rule, and add_accept() can create a new
- * state ...
- */
- add_accept( $1, num_rules | YY_TRAILING_HEAD_MASK );
- variable_trail_rule = true;
- }
+ { /* variable trailing context rule */
+ /* Mark the first part of the rule as the
+ * accepting "head" part of a trailing
+ * context rule.
+ *
+ * By the way, we didn't do this at the
+ * beginning of this production because back
+ * then current_state_type was set up for a
+ * trail rule, and add_accept() can create
+ * a new state ...
+ */
+ add_accept( $1,
+ num_rules | YY_TRAILING_HEAD_MASK );
+ variable_trail_rule = true;
+ }
else
- trailcnt = rulelen;
+ trailcnt = rulelen;
$$ = link_machines( $1, $2 );
}
{ synerr( "trailing context used twice" ); }
| re '$'
- {
+ {
if ( trlcontxt )
- {
- synerr( "trailing context used twice" );
- $$ = mkstate( SYM_EPSILON );
- }
+ {
+ synerr( "trailing context used twice" );
+ $$ = mkstate( SYM_EPSILON );
+ }
else if ( previous_continued_action )
- {
- /* see the comment in the rule for "re2 re"
- * above
- */
- if ( ! varlength || headcnt != 0 )
- warn(
+ {
+ /* See the comment in the rule for "re2 re"
+ * above.
+ */
+ if ( ! varlength || headcnt != 0 )
+ warn(
"trailing context made variable due to preceding '|' action" );
- /* mark as variable */
- varlength = true;
- headcnt = 0;
- }
+ /* Mark as variable. */
+ varlength = true;
+ headcnt = 0;
+ }
if ( varlength && headcnt == 0 )
- {
- /* again, see the comment in the rule for "re2 re"
- * above
- */
- add_accept( $1, num_rules | YY_TRAILING_HEAD_MASK );
- variable_trail_rule = true;
- }
+ {
+ /* Again, see the comment in the rule for
+ * "re2 re" above.
+ */
+ add_accept( $1,
+ num_rules | YY_TRAILING_HEAD_MASK );
+ variable_trail_rule = true;
+ }
else
- {
- if ( ! varlength )
- headcnt = rulelen;
+ {
+ if ( ! varlength )
+ headcnt = rulelen;
- ++rulelen;
- trailcnt = 1;
- }
+ ++rulelen;
+ trailcnt = 1;
+ }
trlcontxt = true;
eps = mkstate( SYM_EPSILON );
$$ = link_machines( $1,
- link_machines( eps, mkstate( '\n' ) ) );
+ link_machines( eps, mkstate( '\n' ) ) );
}
| re
{
- $$ = $1;
+ $$ = $1;
if ( trlcontxt )
- {
- if ( varlength && headcnt == 0 )
- /* both head and trail are variable-length */
- variable_trail_rule = true;
- else
- trailcnt = rulelen;
- }
- }
+ {
+ if ( varlength && headcnt == 0 )
+ /* Both head and trail are
+ * variable-length.
+ */
+ variable_trail_rule = true;
+ else
+ trailcnt = rulelen;
+ }
+ }
;
re : re '|' series
- {
+ {
varlength = true;
$$ = mkor( $1, $3 );
}
re2 : re '/'
{
- /* this rule is written separately so
- * the reduction will occur before the trailing
- * series is parsed
+ /* This rule is written separately so the
+ * reduction will occur before the trailing
+ * series is parsed.
*/
if ( trlcontxt )
- synerr( "trailing context used twice" );
+ synerr( "trailing context used twice" );
else
- trlcontxt = true;
+ trlcontxt = true;
if ( varlength )
- /* we hope the trailing context is fixed-length */
- varlength = false;
+ /* We hope the trailing context is
+ * fixed-length.
+ */
+ varlength = false;
else
- headcnt = rulelen;
+ headcnt = rulelen;
rulelen = 0;
;
series : series singleton
- {
- /* this is where concatenation of adjacent patterns
- * gets done
+ {
+ /* This is where concatenation of adjacent patterns
+ * gets done.
*/
$$ = link_machines( $1, $2 );
}
;
singleton : singleton '*'
- {
+ {
varlength = true;
$$ = mkclos( $1 );
| singleton '+'
{
varlength = true;
-
$$ = mkposcl( $1 );
}
| singleton '?'
{
varlength = true;
-
$$ = mkopt( $1 );
}
varlength = true;
if ( $3 > $5 || $3 < 0 )
- {
- synerr( "bad iteration values" );
- $$ = $1;
- }
+ {
+ synerr( "bad iteration values" );
+ $$ = $1;
+ }
else
- {
- if ( $3 == 0 )
{
- if ( $5 <= 0 )
- {
- synerr( "bad iteration values" );
- $$ = $1;
- }
+ if ( $3 == 0 )
+ {
+ if ( $5 <= 0 )
+ {
+ synerr(
+ "bad iteration values" );
+ $$ = $1;
+ }
+ else
+ $$ = mkopt(
+ mkrep( $1, 1, $5 ) );
+ }
else
- $$ = mkopt( mkrep( $1, 1, $5 ) );
+ $$ = mkrep( $1, $3, $5 );
}
- else
- $$ = mkrep( $1, $3, $5 );
- }
}
| singleton '{' NUMBER ',' '}'
varlength = true;
if ( $3 <= 0 )
- {
- synerr( "iteration value must be positive" );
- $$ = $1;
- }
+ {
+ synerr( "iteration value must be positive" );
+ $$ = $1;
+ }
else
- $$ = mkrep( $1, $3, INFINITY );
+ $$ = mkrep( $1, $3, INFINITY );
}
| singleton '{' NUMBER '}'
{
- /* the singleton could be something like "(foo)",
+ /* The singleton could be something like "(foo)",
* in which case we have no idea what its length
* is, so we punt here.
*/
varlength = true;
if ( $3 <= 0 )
- {
- synerr( "iteration value must be positive" );
- $$ = $1;
- }
+ {
+ synerr( "iteration value must be positive" );
+ $$ = $1;
+ }
else
- $$ = link_machines( $1, copysingl( $1, $3 - 1 ) );
+ $$ = link_machines( $1,
+ copysingl( $1, $3 - 1 ) );
}
| '.'
{
if ( ! madeany )
- {
- /* create the '.' character class */
- anyccl = cclinit();
- ccladd( anyccl, '\n' );
- cclnegate( anyccl );
+ {
+ /* Create the '.' character class. */
+ anyccl = cclinit();
+ ccladd( anyccl, '\n' );
+ cclnegate( anyccl );
- if ( useecs )
- mkeccl( ccltbl + cclmap[anyccl],
- ccllen[anyccl], nextecm,
- ecgroup, csize, csize );
+ if ( useecs )
+ mkeccl( ccltbl + cclmap[anyccl],
+ ccllen[anyccl], nextecm,
+ ecgroup, csize, csize );
- madeany = true;
- }
+ madeany = true;
+ }
++rulelen;
| fullccl
{
if ( ! cclsorted )
- /* sort characters for fast searching. We use a
- * shell sort since this list could be large.
- */
- cshell( ccltbl + cclmap[$1], ccllen[$1], true );
+ /* Sort characters for fast searching. We
+ * use a shell sort since this list could
+ * be large.
+ */
+ cshell( ccltbl + cclmap[$1], ccllen[$1], true );
if ( useecs )
- mkeccl( ccltbl + cclmap[$1], ccllen[$1],
- nextecm, ecgroup, csize, csize );
+ mkeccl( ccltbl + cclmap[$1], ccllen[$1],
+ nextecm, ecgroup, csize, csize );
++rulelen;
++rulelen;
if ( caseins && $1 >= 'A' && $1 <= 'Z' )
- $1 = clower( $1 );
+ $1 = clower( $1 );
$$ = mkstate( $1 );
}
| '[' '^' ccl ']'
{
- /* *Sigh* - to be compatible Unix lex, negated ccls
- * match newlines
- */
-#if 0
- ccladd( $3, '\n' ); /* negated ccls don't match '\n' */
- cclsorted = false; /* because we added the newline */
-#endif
cclnegate( $3 );
$$ = $3;
}
;
ccl : ccl CHAR '-' CHAR
- {
+ {
if ( $2 > $4 )
- synerr( "negative range in character class" );
+ synerr( "negative range in character class" );
else
- {
- if ( caseins )
{
- if ( $2 >= 'A' && $2 <= 'Z' )
- $2 = clower( $2 );
- if ( $4 >= 'A' && $4 <= 'Z' )
- $4 = clower( $4 );
+ if ( caseins )
+ {
+ if ( $2 >= 'A' && $2 <= 'Z' )
+ $2 = clower( $2 );
+ if ( $4 >= 'A' && $4 <= 'Z' )
+ $4 = clower( $4 );
+ }
+
+ for ( i = $2; i <= $4; ++i )
+ ccladd( $1, i );
+
+ /* Keep track if this ccl is staying in
+ * alphabetical order.
+ */
+ cclsorted = cclsorted && ($2 > lastchar);
+ lastchar = $4;
}
- for ( i = $2; i <= $4; ++i )
- ccladd( $1, i );
-
- /* keep track if this ccl is staying in alphabetical
- * order
- */
- cclsorted = cclsorted && ($2 > lastchar);
- lastchar = $4;
- }
-
$$ = $1;
}
| ccl CHAR
- {
- if ( caseins )
- if ( $2 >= 'A' && $2 <= 'Z' )
+ {
+ if ( caseins && $2 >= 'A' && $2 <= 'Z' )
$2 = clower( $2 );
ccladd( $1, $2 );
;
string : string CHAR
- {
- if ( caseins )
- if ( $2 >= 'A' && $2 <= 'Z' )
+ {
+ if ( caseins && $2 >= 'A' && $2 <= 'Z' )
$2 = clower( $2 );
++rulelen;
*/
void build_eof_action()
-
- {
- register int i;
- char action_text[MAXLINE];
-
- for ( i = 1; i <= actvp; ++i )
{
- if ( sceof[actvsc[i]] )
- format_pinpoint_message(
- "multiple <<EOF>> rules for start condition %s",
- scname[actvsc[i]] );
-
- else
- {
- sceof[actvsc[i]] = true;
- sprintf( action_text, "case YY_STATE_EOF(%s):\n",
- scname[actvsc[i]] );
- add_action( action_text );
- }
- }
+ register int i;
+ char action_text[MAXLINE];
- line_directive_out( (FILE *) 0 );
+ for ( i = 1; i <= actvp; ++i )
+ {
+ if ( sceof[actvsc[i]] )
+ format_pinpoint_message(
+ "multiple <<EOF>> rules for start condition %s",
+ scname[actvsc[i]] );
- /* this isn't a normal rule after all - don't count it as
- * such, so we don't have any holes in the rule numbering
- * (which make generating "rule can never match" warnings
- * more difficult
- */
- --num_rules;
- ++num_eof_rules;
- }
+ else
+ {
+ sceof[actvsc[i]] = true;
+ sprintf( action_text, "case YY_STATE_EOF(%s):\n",
+ scname[actvsc[i]] );
+ add_action( action_text );
+ }
+ }
+
+ line_directive_out( (FILE *) 0 );
+
+ /* This isn't a normal rule after all - don't count it as
+ * such, so we don't have any holes in the rule numbering
+ * (which make generating "rule can never match" warnings
+ * more difficult.
+ */
+ --num_rules;
+ ++num_eof_rules;
+ }
/* format_synerr - write out formatted syntax error */
void format_synerr( msg, arg )
char msg[], arg[];
+ {
+ char errmsg[MAXLINE];
- {
- char errmsg[MAXLINE];
-
- (void) sprintf( errmsg, msg, arg );
- synerr( errmsg );
- }
+ (void) sprintf( errmsg, msg, arg );
+ synerr( errmsg );
+ }
/* synerr - report a syntax error */
void synerr( str )
char str[];
-
- {
- syntaxerror = true;
- pinpoint_message( str );
- }
+ {
+ syntaxerror = true;
+ pinpoint_message( str );
+ }
/* warn - report a warning, unless -w was given */
void warn( str )
char str[];
- {
- line_warning( str, linenum );
- }
+ {
+ line_warning( str, linenum );
+ }
/* format_pinpoint_message - write out a message formatted with one string,
* pinpointing its location
void format_pinpoint_message( msg, arg )
char msg[], arg[];
+ {
+ char errmsg[MAXLINE];
- {
- char errmsg[MAXLINE];
-
- (void) sprintf( errmsg, msg, arg );
- pinpoint_message( errmsg );
- }
+ (void) sprintf( errmsg, msg, arg );
+ pinpoint_message( errmsg );
+ }
/* pinpoint_message - write out a message, pinpointing its location */
void pinpoint_message( str )
char str[];
-
- {
- line_pinpoint( str, linenum );
- }
+ {
+ line_pinpoint( str, linenum );
+ }
/* line_warning - report a warning at a given line, unless -w was given */
void line_warning( str, line )
char str[];
int line;
- {
- char warning[MAXLINE];
-
- if ( ! nowarn )
{
- sprintf( warning, "warning, %s", str );
- line_pinpoint( warning, line );
+ char warning[MAXLINE];
+
+ if ( ! nowarn )
+ {
+ sprintf( warning, "warning, %s", str );
+ line_pinpoint( warning, line );
+ }
}
- }
/* line_pinpoint - write out a message, pinpointing it at the given line */
void line_pinpoint( str, line )
char str[];
int line;
-
- {
- fprintf( stderr, "\"%s\", line %d: %s\n", infilename, line, str );
- }
+ {
+ fprintf( stderr, "\"%s\", line %d: %s\n", infilename, line, str );
+ }
/* yyerror - eat up an error message from the parser;
void yyerror( msg )
char msg[];
-
- {
- }
+ {
+ }
#define PUT_BACK_STRING(str, start) \
for ( i = strlen( (char *) (str) ) - 1; i >= start; --i ) \
- unput((str)[i])
+ unput((str)[i])
#define CHECK_REJECT(str) \
if ( all_upper( str ) ) \
- reject = true;
+ reject = true;
#define CHECK_YYMORE(str) \
if ( all_lower( str ) ) \
- yymore_used = true;
+ yymore_used = true;
%}
%x SECT2 SECT2PROLOG SECT3 CODEBLOCK PICKUPDEF SC CARETISBOL NUM QUOTE
CCL_CHAR [^\\\n\]]|{ESCSEQ}
%%
- static int bracelevel, didadef, indented_code, checking_used;
+ static int bracelevel, didadef, indented_code, checking_used;
- int doing_codeblock = false;
- int i;
- Char nmdef[MAXLINE], myesc();
+ int doing_codeblock = false;
+ int i;
+ Char nmdef[MAXLINE], myesc();
^{WS} indented_code = true; BEGIN(CODEBLOCK);
++linenum;
ECHO;
if ( indented_code )
- BEGIN(INITIAL);
+ BEGIN(INITIAL);
}
<PICKUPDEF>{NOT_WS}.* {
(void) strcpy( (char *) nmdef, (char *) yytext );
- /* skip trailing whitespace */
+ /* Skip trailing whitespace. */
for ( i = strlen( (char *) nmdef ) - 1;
- i >= 0 &&
- (nmdef[i] == ' ' || nmdef[i] == '\t');
+ i >= 0 && (nmdef[i] == ' ' || nmdef[i] == '\t');
--i )
- ;
+ ;
nmdef[i + 1] = '\0';
- ndinstal( nmstr, nmdef );
+ ndinstal( nmstr, nmdef );
didadef = true;
}
<PICKUPDEF>{NL} {
if ( ! didadef )
- synerr( "incomplete name definition" );
+ synerr( "incomplete name definition" );
BEGIN(INITIAL);
++linenum;
}
<USED_LIST>{WS}
<USED_LIST>"reject" {
if ( all_upper( yytext ) )
- reject_really_used = checking_used;
+ reject_really_used = checking_used;
else
- synerr( "unrecognized %used/%unused construct" );
+ synerr(
+ "unrecognized %used/%unused construct" );
}
<USED_LIST>"yymore" {
if ( all_lower( yytext ) )
- yymore_really_used = checking_used;
+ yymore_really_used = checking_used;
else
- synerr( "unrecognized %used/%unused construct" );
+ synerr(
+ "unrecognized %used/%unused construct" );
}
<USED_LIST>{NOT_WS}+ synerr( "unrecognized %used/%unused construct" );
bracelevel = 1;
if ( indented_code )
- ACTION_ECHO;
+ ACTION_ECHO;
BEGIN(CODEBLOCK_2);
}
<SECT2>{WS}"|".*{NL} continued_action = true; ++linenum; return '\n';
<SECT2>{WS} {
- /* this rule is separate from the one below because
+ /* This rule is separate from the one below because
* otherwise we get variable trailing context, so
- * we can't build the scanner using -{f,F}
+ * we can't build the scanner using -{f,F}.
*/
bracelevel = 0;
continued_action = false;
(void) strcpy( nmstr, (char *) yytext );
- /* check to see if we've already encountered this ccl */
+ /* Check to see if we've already encountered this
+ * ccl.
+ */
if ( (cclval = ccllookup( (Char *) nmstr )) )
- {
- if ( input() != ']' )
- synerr( "bad character class" );
-
- yylval = cclval;
- ++cclreuse;
- return PREVCCL;
- }
- else
- {
- /* we fudge a bit. We know that this ccl will
- * soon be numbered as lastccl + 1 by cclinit
- */
- cclinstal( (Char *) nmstr, lastccl + 1 );
-
- /* push back everything but the leading bracket
- * so the ccl can be rescanned
- */
- yyless( 1 );
+ {
+ if ( input() != ']' )
+ synerr( "bad character class" );
- BEGIN(FIRSTCCL);
- return '[';
- }
+ yylval = cclval;
+ ++cclreuse;
+ return PREVCCL;
+ }
+ else
+ {
+ /* We fudge a bit. We know that this ccl will
+ * soon be numbered as lastccl + 1 by cclinit.
+ */
+ cclinstal( (Char *) nmstr, lastccl + 1 );
+
+ /* Push back everything but the leading bracket
+ * so the ccl can be rescanned.
+ */
+ yyless( 1 );
+
+ BEGIN(FIRSTCCL);
+ return '[';
+ }
}
<SECT2>"{"{NAME}"}" {
nmstr[yyleng - 2] = '\0'; /* chop trailing brace */
if ( ! (nmdefptr = ndlookup( nmstr )) )
- format_synerr( "undefined definition {%s}", nmstr );
+ format_synerr( "undefined definition {%s}",
+ nmstr );
else
- { /* push back name surrounded by ()'s */
- int len = strlen( nmdefptr );
-
- if ( nmdefptr[0] == '^' ||
- (len > 0 && nmdefptr[len - 1] == '$') )
- {
- PUT_BACK_STRING(nmdefptr, 0);
-
- if ( nmdefptr[0] == '^' )
- BEGIN(CARETISBOL);
- }
-
- else
- {
- unput(')');
- PUT_BACK_STRING(nmdefptr, 0);
- unput('(');
+ { /* push back name surrounded by ()'s */
+ int len = strlen( nmdefptr );
+
+ if ( nmdefptr[0] == '^' ||
+ (len > 0 && nmdefptr[len - 1] == '$') )
+ {
+ PUT_BACK_STRING(nmdefptr, 0);
+
+ if ( nmdefptr[0] == '^' )
+ BEGIN(CARETISBOL);
+ }
+
+ else
+ {
+ unput(')');
+ PUT_BACK_STRING(nmdefptr, 0);
+ unput('(');
+ }
}
- }
}
<SECT2>[/|*+?.()] return yytext[0];
ACTION_ECHO;
if ( bracelevel == 0 ||
(doing_codeblock && indented_code) )
- {
- if ( ! doing_codeblock )
- add_action( "\tYY_BREAK\n" );
-
- doing_codeblock = false;
- BEGIN(SECT2);
- }
+ {
+ if ( ! doing_codeblock )
+ add_action( "\tYY_BREAK\n" );
+
+ doing_codeblock = false;
+ BEGIN(SECT2);
+ }
}
++linenum;
ACTION_ECHO;
if ( bracelevel == 0 )
- {
- add_action( "\tYY_BREAK\n" );
- BEGIN(SECT2);
- }
+ {
+ add_action( "\tYY_BREAK\n" );
+ BEGIN(SECT2);
+ }
}
<ACTION>. ACTION_ECHO;
<ACTION_COMMENT>"*/" {
ACTION_ECHO;
if ( doing_codeblock )
- BEGIN(CODEBLOCK_2);
+ BEGIN(CODEBLOCK_2);
else
- BEGIN(ACTION);
+ BEGIN(ACTION);
}
<ACTION_COMMENT>"*" ACTION_ECHO;
int yywrap()
-
- {
- if ( --num_input_files > 0 )
{
- set_input_file( *++input_files );
- return 0;
+ if ( --num_input_files > 0 )
+ {
+ set_input_file( *++input_files );
+ return 0;
+ }
+
+ else
+ return 1;
}
- else
- return 1;
- }
-
/* set_input_file - open the given file (if NULL, stdin) for scanning */
void set_input_file( file )
char *file;
-
- {
- if ( file )
- {
- infilename = file;
- yyin = fopen( infilename, "r" );
-
- if ( yyin == NULL )
- lerrsf( "can't open %s", file );
- }
-
- else
{
- yyin = stdin;
- infilename = "<stdin>";
+ if ( file )
+ {
+ infilename = file;
+ yyin = fopen( infilename, "r" );
+
+ if ( yyin == NULL )
+ lerrsf( "can't open %s", file );
+ }
+
+ else
+ {
+ yyin = stdin;
+ infilename = "<stdin>";
+ }
}
- }
/* addsym - add symbol and definitions to symbol table
- *
- * synopsis
- * char sym[], *str_def;
- * int int_def;
- * hash_table table;
- * int table_size;
- * 0 / -1 = addsym( sym, def, int_def, table, table_size );
*
* -1 is returned if the symbol already exists, and the change not made.
*/
int int_def;
hash_table table;
int table_size;
-
- {
- int hash_val = hashfunct( sym, table_size );
- register struct hash_entry *sym_entry = table[hash_val];
- register struct hash_entry *new_entry;
- register struct hash_entry *successor;
-
- while ( sym_entry )
{
- if ( ! strcmp( sym, sym_entry->name ) )
- { /* entry already exists */
- return ( -1 );
- }
-
- sym_entry = sym_entry->next;
+ int hash_val = hashfunct( sym, table_size );
+ register struct hash_entry *sym_entry = table[hash_val];
+ register struct hash_entry *new_entry;
+ register struct hash_entry *successor;
+
+ while ( sym_entry )
+ {
+ if ( ! strcmp( sym, sym_entry->name ) )
+ { /* entry already exists */
+ return -1;
+ }
+
+ sym_entry = sym_entry->next;
+ }
+
+ /* create new entry */
+ new_entry = (struct hash_entry *) malloc( sizeof( struct hash_entry ) );
+
+ if ( new_entry == NULL )
+ flexfatal( "symbol table memory allocation failed" );
+
+ if ( (successor = table[hash_val]) )
+ {
+ new_entry->next = successor;
+ successor->prev = new_entry;
+ }
+ else
+ new_entry->next = NULL;
+
+ new_entry->prev = NULL;
+ new_entry->name = sym;
+ new_entry->str_val = str_def;
+ new_entry->int_val = int_def;
+
+ table[hash_val] = new_entry;
+
+ return 0;
}
- /* create new entry */
- new_entry = (struct hash_entry *) malloc( sizeof( struct hash_entry ) );
-
- if ( new_entry == NULL )
- flexfatal( "symbol table memory allocation failed" );
-
- if ( (successor = table[hash_val]) )
- {
- new_entry->next = successor;
- successor->prev = new_entry;
- }
- else
- new_entry->next = NULL;
- new_entry->prev = NULL;
- new_entry->name = sym;
- new_entry->str_val = str_def;
- new_entry->int_val = int_def;
-
- table[hash_val] = new_entry;
-
- return ( 0 );
- }
-
-
-/* cclinstal - save the text of a character class
- *
- * synopsis
- * Char ccltxt[];
- * int cclnum;
- * cclinstal( ccltxt, cclnum );
- */
+/* cclinstal - save the text of a character class */
void cclinstal( ccltxt, cclnum )
Char ccltxt[];
int cclnum;
-
- {
- /* we don't bother checking the return status because we are not called
- * unless the symbol is new
- */
- Char *copy_unsigned_string();
-
- (void) addsym( (char *) copy_unsigned_string( ccltxt ), (char *) 0, cclnum,
- ccltab, CCL_HASH_SIZE );
- }
+ {
+ /* We don't bother checking the return status because we are not
+ * called unless the symbol is new.
+ */
+ Char *copy_unsigned_string();
+
+ (void) addsym( (char *) copy_unsigned_string( ccltxt ),
+ (char *) 0, cclnum,
+ ccltab, CCL_HASH_SIZE );
+ }
/* ccllookup - lookup the number associated with character class text
*
- * synopsis
- * Char ccltxt[];
- * int ccllookup, cclval;
- * cclval/0 = ccllookup( ccltxt );
+ * Returns 0 if there's no CCL associated with the text.
*/
int ccllookup( ccltxt )
Char ccltxt[];
+ {
+ return findsym( (char *) ccltxt, ccltab, CCL_HASH_SIZE )->int_val;
+ }
- {
- return ( findsym( (char *) ccltxt, ccltab, CCL_HASH_SIZE )->int_val );
- }
-
-/* findsym - find symbol in symbol table
- *
- * synopsis
- * char sym[];
- * hash_table table;
- * int table_size;
- * struct hash_entry *sym_entry, *findsym();
- * sym_entry = findsym( sym, table, table_size );
- */
+/* findsym - find symbol in symbol table */
struct hash_entry *findsym( sym, table, table_size )
register char sym[];
hash_table table;
int table_size;
-
- {
- register struct hash_entry *sym_entry = table[hashfunct( sym, table_size )];
- static struct hash_entry empty_entry =
{
- (struct hash_entry *) 0, (struct hash_entry *) 0, NULL, NULL, 0,
- } ;
-
- while ( sym_entry )
- {
- if ( ! strcmp( sym, sym_entry->name ) )
- return ( sym_entry );
- sym_entry = sym_entry->next;
+ static struct hash_entry empty_entry =
+ {
+ (struct hash_entry *) 0, (struct hash_entry *) 0, NULL, NULL, 0,
+ } ;
+ register struct hash_entry *sym_entry =
+ table[hashfunct( sym, table_size )];
+
+ while ( sym_entry )
+ {
+ if ( ! strcmp( sym, sym_entry->name ) )
+ return sym_entry;
+ sym_entry = sym_entry->next;
+ }
+
+ return &empty_entry;
}
- return ( &empty_entry );
- }
-
-/* hashfunct - compute the hash value for "str" and hash size "hash_size"
- *
- * synopsis
- * char str[];
- * int hash_size, hash_val;
- * hash_val = hashfunct( str, hash_size );
- */
+/* hashfunct - compute the hash value for "str" and hash size "hash_size" */
int hashfunct( str, hash_size )
register char str[];
int hash_size;
+ {
+ register int hashval;
+ register int locstr;
- {
- register int hashval;
- register int locstr;
-
- hashval = 0;
- locstr = 0;
+ hashval = 0;
+ locstr = 0;
- while ( str[locstr] )
- hashval = ((hashval << 1) + (unsigned char) str[locstr++]) % hash_size;
+ while ( str[locstr] )
+ hashval = ((hashval << 1) + (unsigned char) str[locstr++]) %
+ hash_size;
- return ( hashval );
- }
+ return hashval;
+ }
-/* ndinstal - install a name definition
- *
- * synopsis
- * char nd[];
- * Char def[];
- * ndinstal( nd, def );
- */
+/* ndinstal - install a name definition */
void ndinstal( nd, def )
char nd[];
Char def[];
+ {
+ char *copy_string();
+ Char *copy_unsigned_string();
- {
- char *copy_string();
- Char *copy_unsigned_string();
-
- if ( addsym( copy_string( nd ), (char *) copy_unsigned_string( def ), 0,
- ndtbl, NAME_TABLE_HASH_SIZE ) )
- synerr( "name defined twice" );
- }
+ if ( addsym( copy_string( nd ), (char *) copy_unsigned_string( def ), 0,
+ ndtbl, NAME_TABLE_HASH_SIZE ) )
+ synerr( "name defined twice" );
+ }
/* ndlookup - lookup a name definition
*
- * synopsis
- * char nd[], *def;
- * char *ndlookup();
- * def/NULL = ndlookup( nd );
+ * Returns a nil pointer if the name definition does not exist.
*/
Char *ndlookup( nd )
char nd[];
-
- {
- return ( (Char *) findsym( nd, ndtbl, NAME_TABLE_HASH_SIZE )->str_val );
- }
+ {
+ return (Char *) findsym( nd, ndtbl, NAME_TABLE_HASH_SIZE )->str_val;
+ }
-/* scextend - increase the maximum number of start conditions
- *
- * synopsis
- * scextend();
- */
+/* scextend - increase the maximum number of start conditions */
void scextend()
+ {
+ current_max_scs += MAX_SCS_INCREMENT;
- {
- current_max_scs += MAX_SCS_INCREMENT;
-
- ++num_reallocs;
+ ++num_reallocs;
- scset = reallocate_integer_array( scset, current_max_scs );
- scbol = reallocate_integer_array( scbol, current_max_scs );
- scxclu = reallocate_integer_array( scxclu, current_max_scs );
- sceof = reallocate_integer_array( sceof, current_max_scs );
- scname = reallocate_char_ptr_array( scname, current_max_scs );
- actvsc = reallocate_integer_array( actvsc, current_max_scs );
- }
+ scset = reallocate_integer_array( scset, current_max_scs );
+ scbol = reallocate_integer_array( scbol, current_max_scs );
+ scxclu = reallocate_integer_array( scxclu, current_max_scs );
+ sceof = reallocate_integer_array( sceof, current_max_scs );
+ scname = reallocate_char_ptr_array( scname, current_max_scs );
+ actvsc = reallocate_integer_array( actvsc, current_max_scs );
+ }
/* scinstal - make a start condition
- *
- * synopsis
- * char str[];
- * int xcluflg;
- * scinstal( str, xcluflg );
*
* NOTE
- * the start condition is Exclusive if xcluflg is true
+ * The start condition is "exclusive" if xcluflg is true.
*/
void scinstal( str, xcluflg )
char str[];
int xcluflg;
+ {
+ char *copy_string();
- {
- char *copy_string();
-
- /* bit of a hack. We know how the default start-condition is
- * declared, and don't put out a define for it, because it
- * would come out as "#define 0 1"
- */
- /* actually, this is no longer the case. The default start-condition
- * is now called "INITIAL". But we keep the following for the sake
- * of future robustness.
- */
-
- if ( strcmp( str, "0" ) )
+ /* Generate start condition definition, for use in BEGIN et al. */
printf( "#define %s %d\n", str, lastsc );
- if ( ++lastsc >= current_max_scs )
- scextend();
+ if ( ++lastsc >= current_max_scs )
+ scextend();
- scname[lastsc] = copy_string( str );
+ scname[lastsc] = copy_string( str );
- if ( addsym( scname[lastsc], (char *) 0, lastsc,
- sctbl, START_COND_HASH_SIZE ) )
- format_pinpoint_message( "start condition %s declared twice", str );
+ if ( addsym( scname[lastsc], (char *) 0, lastsc,
+ sctbl, START_COND_HASH_SIZE ) )
+ format_pinpoint_message( "start condition %s declared twice",
+ str );
- scset[lastsc] = mkstate( SYM_EPSILON );
- scbol[lastsc] = mkstate( SYM_EPSILON );
- scxclu[lastsc] = xcluflg;
- sceof[lastsc] = false;
- }
+ scset[lastsc] = mkstate( SYM_EPSILON );
+ scbol[lastsc] = mkstate( SYM_EPSILON );
+ scxclu[lastsc] = xcluflg;
+ sceof[lastsc] = false;
+ }
/* sclookup - lookup the number associated with a start condition
*
- * synopsis
- * char str[], scnum;
- * int sclookup;
- * scnum/0 = sclookup( str );
+ * Returns 0 if no such start condition.
*/
int sclookup( str )
char str[];
-
- {
- return ( findsym( str, sctbl, START_COND_HASH_SIZE )->int_val );
- }
+ {
+ return findsym( str, sctbl, START_COND_HASH_SIZE )->int_val;
+ }
void bldtbl( state, statenum, totaltrans, comstate, comfreq )
int state[], statenum, totaltrans, comstate, comfreq;
+ {
+ int extptr, extrct[2][CSIZE + 1];
+ int mindiff, minprot, i, d;
+
+ /* If extptr is 0 then the first array of extrct holds the result
+ * of the "best difference" to date, which is those transitions
+ * which occur in "state" but not in the proto which, to date,
+ * has the fewest differences between itself and "state". If
+ * extptr is 1 then the second array of extrct hold the best
+ * difference. The two arrays are toggled between so that the
+ * best difference to date can be kept around and also a difference
+ * just created by checking against a candidate "best" proto.
+ */
- {
- int extptr, extrct[2][CSIZE + 1];
- int mindiff, minprot, i, d;
- int checkcom;
+ extptr = 0;
- /* If extptr is 0 then the first array of extrct holds the result of the
- * "best difference" to date, which is those transitions which occur in
- * "state" but not in the proto which, to date, has the fewest differences
- * between itself and "state". If extptr is 1 then the second array of
- * extrct hold the best difference. The two arrays are toggled
- * between so that the best difference to date can be kept around and
- * also a difference just created by checking against a candidate "best"
- * proto.
- */
+ /* If the state has too few out-transitions, don't bother trying to
+ * compact its tables.
+ */
- extptr = 0;
+ if ( (totaltrans * 100) < (numecs * PROTO_SIZE_PERCENTAGE) )
+ mkentry( state, numecs, statenum, JAMSTATE, totaltrans );
- /* if the state has too few out-transitions, don't bother trying to
- * compact its tables
- */
+ else
+ {
+ /* "checkcom" is true if we should only check "state" against
+ * protos which have the same "comstate" value.
+ */
+ int checkcom =
+ comfreq * 100 > totaltrans * CHECK_COM_PERCENTAGE;
- if ( (totaltrans * 100) < (numecs * PROTO_SIZE_PERCENTAGE) )
- mkentry( state, numecs, statenum, JAMSTATE, totaltrans );
+ minprot = firstprot;
+ mindiff = totaltrans;
+
+ if ( checkcom )
+ {
+ /* Find first proto which has the same "comstate". */
+ for ( i = firstprot; i != NIL; i = protnext[i] )
+ if ( protcomst[i] == comstate )
+ {
+ minprot = i;
+ mindiff = tbldiff( state, minprot,
+ extrct[extptr] );
+ break;
+ }
+ }
- else
- {
- /* checkcom is true if we should only check "state" against
- * protos which have the same "comstate" value
- */
+ else
+ {
+ /* Since we've decided that the most common destination
+ * out of "state" does not occur with a high enough
+ * frequency, we set the "comstate" to zero, assuring
+ * that if this state is entered into the proto list,
+ * it will not be considered a template.
+ */
+ comstate = 0;
+
+ if ( firstprot != NIL )
+ {
+ minprot = firstprot;
+ mindiff = tbldiff( state, minprot,
+ extrct[extptr] );
+ }
+ }
- checkcom = comfreq * 100 > totaltrans * CHECK_COM_PERCENTAGE;
+ /* We now have the first interesting proto in "minprot". If
+ * it matches within the tolerances set for the first proto,
+ * we don't want to bother scanning the rest of the proto list
+ * to see if we have any other reasonable matches.
+ */
- minprot = firstprot;
- mindiff = totaltrans;
+ if ( mindiff * 100 > totaltrans * FIRST_MATCH_DIFF_PERCENTAGE )
+ {
+ /* Not a good enough match. Scan the rest of the
+ * protos.
+ */
+ for ( i = minprot; i != NIL; i = protnext[i] )
+ {
+ d = tbldiff( state, i, extrct[1 - extptr] );
+ if ( d < mindiff )
+ {
+ extptr = 1 - extptr;
+ mindiff = d;
+ minprot = i;
+ }
+ }
+ }
- if ( checkcom )
- {
- /* find first proto which has the same "comstate" */
- for ( i = firstprot; i != NIL; i = protnext[i] )
- if ( protcomst[i] == comstate )
- {
- minprot = i;
- mindiff = tbldiff( state, minprot, extrct[extptr] );
- break;
- }
- }
+ /* Check if the proto we've decided on as our best bet is close
+ * enough to the state we want to match to be usable.
+ */
- else
- {
- /* since we've decided that the most common destination out
- * of "state" does not occur with a high enough frequency,
- * we set the "comstate" to zero, assuring that if this state
- * is entered into the proto list, it will not be considered
- * a template.
- */
- comstate = 0;
-
- if ( firstprot != NIL )
- {
- minprot = firstprot;
- mindiff = tbldiff( state, minprot, extrct[extptr] );
- }
- }
+ if ( mindiff * 100 > totaltrans * ACCEPTABLE_DIFF_PERCENTAGE )
+ {
+ /* No good. If the state is homogeneous enough,
+ * we make a template out of it. Otherwise, we
+ * make a proto.
+ */
- /* we now have the first interesting proto in "minprot". If
- * it matches within the tolerances set for the first proto,
- * we don't want to bother scanning the rest of the proto list
- * to see if we have any other reasonable matches.
- */
+ if ( comfreq * 100 >=
+ totaltrans * TEMPLATE_SAME_PERCENTAGE )
+ mktemplate( state, statenum, comstate );
- if ( mindiff * 100 > totaltrans * FIRST_MATCH_DIFF_PERCENTAGE )
- { /* not a good enough match. Scan the rest of the protos */
- for ( i = minprot; i != NIL; i = protnext[i] )
- {
- d = tbldiff( state, i, extrct[1 - extptr] );
- if ( d < mindiff )
- {
- extptr = 1 - extptr;
- mindiff = d;
- minprot = i;
- }
- }
- }
+ else
+ {
+ mkprot( state, statenum, comstate );
+ mkentry( state, numecs, statenum,
+ JAMSTATE, totaltrans );
+ }
+ }
- /* check if the proto we've decided on as our best bet is close
- * enough to the state we want to match to be usable
- */
+ else
+ { /* use the proto */
+ mkentry( extrct[extptr], numecs, statenum,
+ prottbl[minprot], mindiff );
- if ( mindiff * 100 > totaltrans * ACCEPTABLE_DIFF_PERCENTAGE )
- {
- /* no good. If the state is homogeneous enough, we make a
- * template out of it. Otherwise, we make a proto.
- */
+ /* If this state was sufficiently different from the
+ * proto we built it from, make it, too, a proto.
+ */
- if ( comfreq * 100 >= totaltrans * TEMPLATE_SAME_PERCENTAGE )
- mktemplate( state, statenum, comstate );
+ if ( mindiff * 100 >=
+ totaltrans * NEW_PROTO_DIFF_PERCENTAGE )
+ mkprot( state, statenum, comstate );
+
+ /* Since mkprot added a new proto to the proto queue,
+ * it's possible that "minprot" is no longer on the
+ * proto queue (if it happened to have been the last
+ * entry, it would have been bumped off). If it's
+ * not there, then the new proto took its physical
+ * place (though logically the new proto is at the
+ * beginning of the queue), so in that case the
+ * following call will do nothing.
+ */
- else
- {
- mkprot( state, statenum, comstate );
- mkentry( state, numecs, statenum, JAMSTATE, totaltrans );
+ mv2front( minprot );
+ }
}
- }
-
- else
- { /* use the proto */
- mkentry( extrct[extptr], numecs, statenum,
- prottbl[minprot], mindiff );
-
- /* if this state was sufficiently different from the proto
- * we built it from, make it, too, a proto
- */
-
- if ( mindiff * 100 >= totaltrans * NEW_PROTO_DIFF_PERCENTAGE )
- mkprot( state, statenum, comstate );
-
- /* since mkprot added a new proto to the proto queue, it's possible
- * that "minprot" is no longer on the proto queue (if it happened
- * to have been the last entry, it would have been bumped off).
- * If it's not there, then the new proto took its physical place
- * (though logically the new proto is at the beginning of the
- * queue), so in that case the following call will do nothing.
- */
-
- mv2front( minprot );
- }
}
- }
/* cmptmps - compress template table entries
*
- * synopsis
- * cmptmps();
- *
- * template tables are compressed by using the 'template equivalence
- * classes', which are collections of transition character equivalence
- * classes which always appear together in templates - really meta-equivalence
- * classes. until this point, the tables for templates have been stored
- * up at the top end of the nxt array; they will now be compressed and have
- * table entries made for them.
+ * Template tables are compressed by using the 'template equivalence
+ * classes', which are collections of transition character equivalence
+ * classes which always appear together in templates - really meta-equivalence
+ * classes. until this point, the tables for templates have been stored
+ * up at the top end of the nxt array; they will now be compressed and have
+ * table entries made for them.
*/
void cmptmps()
-
- {
- int tmpstorage[CSIZE + 1];
- register int *tmp = tmpstorage, i, j;
- int totaltrans, trans;
-
- peakpairs = numtemps * numecs + tblend;
-
- if ( usemecs )
{
- /* create equivalence classes based on data gathered on template
- * transitions
- */
+ int tmpstorage[CSIZE + 1];
+ register int *tmp = tmpstorage, i, j;
+ int totaltrans, trans;
- nummecs = cre8ecs( tecfwd, tecbck, numecs );
- }
-
- else
- nummecs = numecs;
+ peakpairs = numtemps * numecs + tblend;
- while ( lastdfa + numtemps + 1 >= current_max_dfas )
- increase_max_dfas();
+ if ( usemecs )
+ {
+ /* Create equivalence classes based on data gathered on
+ * template transitions.
+ */
+ nummecs = cre8ecs( tecfwd, tecbck, numecs );
+ }
- /* loop through each template */
+ else
+ nummecs = numecs;
- for ( i = 1; i <= numtemps; ++i )
- {
- totaltrans = 0; /* number of non-jam transitions out of this template */
+ while ( lastdfa + numtemps + 1 >= current_max_dfas )
+ increase_max_dfas();
- for ( j = 1; j <= numecs; ++j )
- {
- trans = tnxt[numecs * i + j];
+ /* Loop through each template. */
- if ( usemecs )
+ for ( i = 1; i <= numtemps; ++i )
{
- /* the absolute value of tecbck is the meta-equivalence class
- * of a given equivalence class, as set up by cre8ecs
- */
- if ( tecbck[j] > 0 )
- {
- tmp[tecbck[j]] = trans;
-
- if ( trans > 0 )
- ++totaltrans;
- }
- }
+ /* Number of non-jam transitions out of this template. */
+ totaltrans = 0;
+
+ for ( j = 1; j <= numecs; ++j )
+ {
+ trans = tnxt[numecs * i + j];
+
+ if ( usemecs )
+ {
+ /* The absolute value of tecbck is the
+ * meta-equivalence class of a given
+ * equivalence class, as set up by cre8ecs().
+ */
+ if ( tecbck[j] > 0 )
+ {
+ tmp[tecbck[j]] = trans;
+
+ if ( trans > 0 )
+ ++totaltrans;
+ }
+ }
+
+ else
+ {
+ tmp[j] = trans;
+
+ if ( trans > 0 )
+ ++totaltrans;
+ }
+ }
- else
- {
- tmp[j] = trans;
+ /* It is assumed (in a rather subtle way) in the skeleton
+ * that if we're using meta-equivalence classes, the def[]
+ * entry for all templates is the jam template, i.e.,
+ * templates never default to other non-jam table entries
+ * (e.g., another template)
+ */
- if ( trans > 0 )
- ++totaltrans;
+ /* Leave room for the jam-state after the last real state. */
+ mkentry( tmp, nummecs, lastdfa + i + 1, JAMSTATE, totaltrans );
}
- }
-
- /* it is assumed (in a rather subtle way) in the skeleton that
- * if we're using meta-equivalence classes, the def[] entry for
- * all templates is the jam template, i.e., templates never default
- * to other non-jam table entries (e.g., another template)
- */
-
- /* leave room for the jam-state after the last real state */
- mkentry( tmp, nummecs, lastdfa + i + 1, JAMSTATE, totaltrans );
}
- }
/* expand_nxt_chk - expand the next check arrays */
void expand_nxt_chk()
+ {
+ register int old_max = current_max_xpairs;
- {
- register int old_max = current_max_xpairs;
-
- current_max_xpairs += MAX_XPAIRS_INCREMENT;
+ current_max_xpairs += MAX_XPAIRS_INCREMENT;
- ++num_reallocs;
+ ++num_reallocs;
- nxt = reallocate_integer_array( nxt, current_max_xpairs );
- chk = reallocate_integer_array( chk, current_max_xpairs );
+ nxt = reallocate_integer_array( nxt, current_max_xpairs );
+ chk = reallocate_integer_array( chk, current_max_xpairs );
- zero_out( (char *) (chk + old_max),
- MAX_XPAIRS_INCREMENT * sizeof( int ) / sizeof( char ) );
- }
+ zero_out( (char *) (chk + old_max),
+ MAX_XPAIRS_INCREMENT * sizeof( int ) / sizeof( char ) );
+ }
/* find_table_space - finds a space in the table for a state to be placed
int find_table_space( state, numtrans )
int *state, numtrans;
-
- {
- /* firstfree is the position of the first possible occurrence of two
- * consecutive unused records in the chk and nxt arrays
- */
- register int i;
- register int *state_ptr, *chk_ptr;
- register int *ptr_to_last_entry_in_state;
-
- /* if there are too many out-transitions, put the state at the end of
- * nxt and chk
- */
- if ( numtrans > MAX_XTIONS_FULL_INTERIOR_FIT )
{
- /* if table is empty, return the first available spot in chk/nxt,
- * which should be 1
+ /* Firstfree is the position of the first possible occurrence of two
+ * consecutive unused records in the chk and nxt arrays.
*/
- if ( tblend < 2 )
- return ( 1 );
-
- i = tblend - numecs; /* start searching for table space near the
- * end of chk/nxt arrays
- */
- }
-
- else
- i = firstfree; /* start searching for table space from the
- * beginning (skipping only the elements
- * which will definitely not hold the new
- * state)
- */
+ register int i;
+ register int *state_ptr, *chk_ptr;
+ register int *ptr_to_last_entry_in_state;
- while ( 1 ) /* loops until a space is found */
- {
- while ( i + numecs >= current_max_xpairs )
- expand_nxt_chk();
-
- /* loops until space for end-of-buffer and action number are found */
- while ( 1 )
- {
- if ( chk[i - 1] == 0 ) /* check for action number space */
+ /* If there are too many out-transitions, put the state at the end of
+ * nxt and chk.
+ */
+ if ( numtrans > MAX_XTIONS_FULL_INTERIOR_FIT )
{
- if ( chk[i] == 0 ) /* check for end-of-buffer space */
- break;
+ /* If table is empty, return the first available spot in
+ * chk/nxt, which should be 1.
+ */
+ if ( tblend < 2 )
+ return 1;
- else
- i += 2; /* since i != 0, there is no use checking to
- * see if (++i) - 1 == 0, because that's the
- * same as i == 0, so we skip a space
- */
+ /* Start searching for table space near the end of
+ * chk/nxt arrays.
+ */
+ i = tblend - numecs;
}
- else
- ++i;
+ else
+ /* Start searching for table space from the beginning
+ * (skipping only the elements which will definitely not
+ * hold the new state).
+ */
+ i = firstfree;
- while ( i + numecs >= current_max_xpairs )
- expand_nxt_chk();
- }
+ while ( 1 ) /* loops until a space is found */
+ {
+ while ( i + numecs >= current_max_xpairs )
+ expand_nxt_chk();
- /* if we started search from the beginning, store the new firstfree for
- * the next call of find_table_space()
- */
- if ( numtrans <= MAX_XTIONS_FULL_INTERIOR_FIT )
- firstfree = i + 1;
+ /* Loops until space for end-of-buffer and action number
+ * are found.
+ */
+ while ( 1 )
+ {
+ /* Check for action number space. */
+ if ( chk[i - 1] == 0 )
+ {
+ /* Check for end-of-buffer space. */
+ if ( chk[i] == 0 )
+ break;
+
+ else
+ /* Since i != 0, there is no use
+ * checking to see if (++i) - 1 == 0,
+ * because that's the same as i == 0,
+ * so we skip a space.
+ */
+ i += 2;
+ }
+
+ else
+ ++i;
+
+ while ( i + numecs >= current_max_xpairs )
+ expand_nxt_chk();
+ }
- /* check to see if all elements in chk (and therefore nxt) that are
- * needed for the new state have not yet been taken
- */
+ /* If we started search from the beginning, store the new
+ * firstfree for the next call of find_table_space().
+ */
+ if ( numtrans <= MAX_XTIONS_FULL_INTERIOR_FIT )
+ firstfree = i + 1;
- state_ptr = &state[1];
- ptr_to_last_entry_in_state = &chk[i + numecs + 1];
+ /* Check to see if all elements in chk (and therefore nxt)
+ * that are needed for the new state have not yet been taken.
+ */
- for ( chk_ptr = &chk[i + 1]; chk_ptr != ptr_to_last_entry_in_state;
- ++chk_ptr )
- if ( *(state_ptr++) != 0 && *chk_ptr != 0 )
- break;
+ state_ptr = &state[1];
+ ptr_to_last_entry_in_state = &chk[i + numecs + 1];
- if ( chk_ptr == ptr_to_last_entry_in_state )
- return ( i );
+ for ( chk_ptr = &chk[i + 1];
+ chk_ptr != ptr_to_last_entry_in_state; ++chk_ptr )
+ if ( *(state_ptr++) != 0 && *chk_ptr != 0 )
+ break;
- else
- ++i;
+ if ( chk_ptr == ptr_to_last_entry_in_state )
+ return i;
+
+ else
+ ++i;
+ }
}
- }
/* inittbl - initialize transition tables
- *
- * synopsis
- * inittbl();
*
* Initializes "firstfree" to be one beyond the end of the table. Initializes
* all "chk" entries to be zero. Note that templates are built in their
* with the non-template entries during table generation.
*/
void inittbl()
+ {
+ register int i;
- {
- register int i;
-
- zero_out( (char *) chk,
- current_max_xpairs * sizeof( int ) / sizeof( char ) );
+ zero_out( (char *) chk,
+ current_max_xpairs * sizeof( int ) / sizeof( char ) );
- tblend = 0;
- firstfree = tblend + 1;
- numtemps = 0;
+ tblend = 0;
+ firstfree = tblend + 1;
+ numtemps = 0;
- if ( usemecs )
- {
- /* set up doubly-linked meta-equivalence classes
- * these are sets of equivalence classes which all have identical
- * transitions out of TEMPLATES
- */
+ if ( usemecs )
+ {
+ /* Set up doubly-linked meta-equivalence classes; these
+ * are sets of equivalence classes which all have identical
+ * transitions out of TEMPLATES.
+ */
- tecbck[1] = NIL;
+ tecbck[1] = NIL;
- for ( i = 2; i <= numecs; ++i )
- {
- tecbck[i] = i - 1;
- tecfwd[i - 1] = i;
- }
+ for ( i = 2; i <= numecs; ++i )
+ {
+ tecbck[i] = i - 1;
+ tecfwd[i - 1] = i;
+ }
- tecfwd[numecs] = NIL;
+ tecfwd[numecs] = NIL;
+ }
}
- }
-/* mkdeftbl - make the default, "jam" table entries
- *
- * synopsis
- * mkdeftbl();
- */
+/* mkdeftbl - make the default, "jam" table entries */
void mkdeftbl()
+ {
+ int i;
- {
- int i;
-
- jamstate = lastdfa + 1;
+ jamstate = lastdfa + 1;
- ++tblend; /* room for transition on end-of-buffer character */
+ ++tblend; /* room for transition on end-of-buffer character */
- while ( tblend + numecs >= current_max_xpairs )
- expand_nxt_chk();
+ while ( tblend + numecs >= current_max_xpairs )
+ expand_nxt_chk();
- /* add in default end-of-buffer transition */
- nxt[tblend] = end_of_buffer_state;
- chk[tblend] = jamstate;
+ /* Add in default end-of-buffer transition. */
+ nxt[tblend] = end_of_buffer_state;
+ chk[tblend] = jamstate;
- for ( i = 1; i <= numecs; ++i )
- {
- nxt[tblend + i] = 0;
- chk[tblend + i] = jamstate;
- }
+ for ( i = 1; i <= numecs; ++i )
+ {
+ nxt[tblend + i] = 0;
+ chk[tblend + i] = jamstate;
+ }
- jambase = tblend;
+ jambase = tblend;
- base[jamstate] = jambase;
- def[jamstate] = 0;
+ base[jamstate] = jambase;
+ def[jamstate] = 0;
- tblend += numecs;
- ++numtemps;
- }
+ tblend += numecs;
+ ++numtemps;
+ }
/* mkentry - create base/def and nxt/chk entries for transition array
void mkentry( state, numchars, statenum, deflink, totaltrans )
register int *state;
int numchars, statenum, deflink, totaltrans;
+ {
+ register int minec, maxec, i, baseaddr;
+ int tblbase, tbllast;
- {
- register int minec, maxec, i, baseaddr;
- int tblbase, tbllast;
+ if ( totaltrans == 0 )
+ { /* there are no out-transitions */
+ if ( deflink == JAMSTATE )
+ base[statenum] = JAMSTATE;
+ else
+ base[statenum] = 0;
- if ( totaltrans == 0 )
- { /* there are no out-transitions */
- if ( deflink == JAMSTATE )
- base[statenum] = JAMSTATE;
- else
- base[statenum] = 0;
+ def[statenum] = deflink;
+ return;
+ }
- def[statenum] = deflink;
- return;
- }
+ for ( minec = 1; minec <= numchars; ++minec )
+ {
+ if ( state[minec] != SAME_TRANS )
+ if ( state[minec] != 0 || deflink != JAMSTATE )
+ break;
+ }
- for ( minec = 1; minec <= numchars; ++minec )
- {
- if ( state[minec] != SAME_TRANS )
- if ( state[minec] != 0 || deflink != JAMSTATE )
- break;
- }
+ if ( totaltrans == 1 )
+ {
+ /* There's only one out-transition. Save it for later to fill
+ * in holes in the tables.
+ */
+ stack1( statenum, minec, state[minec], deflink );
+ return;
+ }
- if ( totaltrans == 1 )
- {
- /* there's only one out-transition. Save it for later to fill
- * in holes in the tables.
- */
- stack1( statenum, minec, state[minec], deflink );
- return;
- }
+ for ( maxec = numchars; maxec > 0; --maxec )
+ {
+ if ( state[maxec] != SAME_TRANS )
+ if ( state[maxec] != 0 || deflink != JAMSTATE )
+ break;
+ }
- for ( maxec = numchars; maxec > 0; --maxec )
- {
- if ( state[maxec] != SAME_TRANS )
- if ( state[maxec] != 0 || deflink != JAMSTATE )
- break;
- }
+ /* Whether we try to fit the state table in the middle of the table
+ * entries we have already generated, or if we just take the state
+ * table at the end of the nxt/chk tables, we must make sure that we
+ * have a valid base address (i.e., non-negative). Note that not
+ * only are negative base addresses dangerous at run-time (because
+ * indexing the next array with one and a low-valued character might
+ * generate an array-out-of-bounds error message), but at compile-time
+ * negative base addresses denote TEMPLATES.
+ */
- /* Whether we try to fit the state table in the middle of the table
- * entries we have already generated, or if we just take the state
- * table at the end of the nxt/chk tables, we must make sure that we
- * have a valid base address (i.e., non-negative). Note that not only are
- * negative base addresses dangerous at run-time (because indexing the
- * next array with one and a low-valued character might generate an
- * array-out-of-bounds error message), but at compile-time negative
- * base addresses denote TEMPLATES.
- */
-
- /* find the first transition of state that we need to worry about. */
- if ( totaltrans * 100 <= numchars * INTERIOR_FIT_PERCENTAGE )
- { /* attempt to squeeze it into the middle of the tabls */
- baseaddr = firstfree;
-
- while ( baseaddr < minec )
- {
- /* using baseaddr would result in a negative base address below
- * find the next free slot
- */
- for ( ++baseaddr; chk[baseaddr] != 0; ++baseaddr )
- ;
- }
-
- while ( baseaddr + maxec - minec + 1 >= current_max_xpairs )
- expand_nxt_chk();
+ /* Find the first transition of state that we need to worry about. */
+ if ( totaltrans * 100 <= numchars * INTERIOR_FIT_PERCENTAGE )
+ {
+ /* Attempt to squeeze it into the middle of the tables. */
+ baseaddr = firstfree;
- for ( i = minec; i <= maxec; ++i )
- if ( state[i] != SAME_TRANS )
- if ( state[i] != 0 || deflink != JAMSTATE )
- if ( chk[baseaddr + i - minec] != 0 )
- { /* baseaddr unsuitable - find another */
- for ( ++baseaddr;
- baseaddr < current_max_xpairs &&
- chk[baseaddr] != 0;
- ++baseaddr )
- ;
-
- while ( baseaddr + maxec - minec + 1 >=
- current_max_xpairs )
- expand_nxt_chk();
-
- /* reset the loop counter so we'll start all
- * over again next time it's incremented
+ while ( baseaddr < minec )
+ {
+ /* Using baseaddr would result in a negative base
+ * address below; find the next free slot.
*/
-
- i = minec - 1;
+ for ( ++baseaddr; chk[baseaddr] != 0; ++baseaddr )
+ ;
}
- }
- else
- {
- /* ensure that the base address we eventually generate is
- * non-negative
- */
- baseaddr = max( tblend + 1, minec );
- }
-
- tblbase = baseaddr - minec;
- tbllast = tblbase + maxec;
-
- while ( tbllast + 1 >= current_max_xpairs )
- expand_nxt_chk();
+ while ( baseaddr + maxec - minec + 1 >= current_max_xpairs )
+ expand_nxt_chk();
+
+ for ( i = minec; i <= maxec; ++i )
+ if ( state[i] != SAME_TRANS &&
+ (state[i] != 0 || deflink != JAMSTATE) &&
+ chk[baseaddr + i - minec] != 0 )
+ { /* baseaddr unsuitable - find another */
+ for ( ++baseaddr;
+ baseaddr < current_max_xpairs &&
+ chk[baseaddr] != 0; ++baseaddr )
+ ;
+
+ while ( baseaddr + maxec - minec + 1 >=
+ current_max_xpairs )
+ expand_nxt_chk();
+
+ /* Reset the loop counter so we'll start all
+ * over again next time it's incremented.
+ */
- base[statenum] = tblbase;
- def[statenum] = deflink;
+ i = minec - 1;
+ }
+ }
- for ( i = minec; i <= maxec; ++i )
- if ( state[i] != SAME_TRANS )
- if ( state[i] != 0 || deflink != JAMSTATE )
+ else
{
- nxt[tblbase + i] = state[i];
- chk[tblbase + i] = statenum;
+ /* Ensure that the base address we eventually generate is
+ * non-negative.
+ */
+ baseaddr = max( tblend + 1, minec );
}
- if ( baseaddr == firstfree )
- /* find next free slot in tables */
- for ( ++firstfree; chk[firstfree] != 0; ++firstfree )
- ;
+ tblbase = baseaddr - minec;
+ tbllast = tblbase + maxec;
- tblend = max( tblend, tbllast );
- }
+ while ( tbllast + 1 >= current_max_xpairs )
+ expand_nxt_chk();
+
+ base[statenum] = tblbase;
+ def[statenum] = deflink;
+
+ for ( i = minec; i <= maxec; ++i )
+ if ( state[i] != SAME_TRANS )
+ if ( state[i] != 0 || deflink != JAMSTATE )
+ {
+ nxt[tblbase + i] = state[i];
+ chk[tblbase + i] = statenum;
+ }
+
+ if ( baseaddr == firstfree )
+ /* Find next free slot in tables. */
+ for ( ++firstfree; chk[firstfree] != 0; ++firstfree )
+ ;
+
+ tblend = max( tblend, tbllast );
+ }
/* mk1tbl - create table entries for a state (or state fragment) which
* has only one out-transition
- *
- * synopsis
- * int state, sym, onenxt, onedef;
- * mk1tbl( state, sym, onenxt, onedef );
*/
void mk1tbl( state, sym, onenxt, onedef )
int state, sym, onenxt, onedef;
+ {
+ if ( firstfree < sym )
+ firstfree = sym;
- {
- if ( firstfree < sym )
- firstfree = sym;
-
- while ( chk[firstfree] != 0 )
- if ( ++firstfree >= current_max_xpairs )
- expand_nxt_chk();
+ while ( chk[firstfree] != 0 )
+ if ( ++firstfree >= current_max_xpairs )
+ expand_nxt_chk();
- base[state] = firstfree - sym;
- def[state] = onedef;
- chk[firstfree] = state;
- nxt[firstfree] = onenxt;
+ base[state] = firstfree - sym;
+ def[state] = onedef;
+ chk[firstfree] = state;
+ nxt[firstfree] = onenxt;
- if ( firstfree > tblend )
- {
- tblend = firstfree++;
+ if ( firstfree > tblend )
+ {
+ tblend = firstfree++;
- if ( firstfree >= current_max_xpairs )
- expand_nxt_chk();
+ if ( firstfree >= current_max_xpairs )
+ expand_nxt_chk();
+ }
}
- }
-/* mkprot - create new proto entry
- *
- * synopsis
- * int state[], statenum, comstate;
- * mkprot( state, statenum, comstate );
- */
+/* mkprot - create new proto entry */
void mkprot( state, statenum, comstate )
int state[], statenum, comstate;
-
- {
- int i, slot, tblbase;
-
- if ( ++numprots >= MSP || numecs * numprots >= PROT_SAVE_SIZE )
{
- /* gotta make room for the new proto by dropping last entry in
- * the queue
- */
- slot = lastprot;
- lastprot = protprev[lastprot];
- protnext[lastprot] = NIL;
- }
+ int i, slot, tblbase;
- else
- slot = numprots;
+ if ( ++numprots >= MSP || numecs * numprots >= PROT_SAVE_SIZE )
+ {
+ /* Gotta make room for the new proto by dropping last entry in
+ * the queue.
+ */
+ slot = lastprot;
+ lastprot = protprev[lastprot];
+ protnext[lastprot] = NIL;
+ }
- protnext[slot] = firstprot;
+ else
+ slot = numprots;
- if ( firstprot != NIL )
- protprev[firstprot] = slot;
+ protnext[slot] = firstprot;
- firstprot = slot;
- prottbl[slot] = statenum;
- protcomst[slot] = comstate;
+ if ( firstprot != NIL )
+ protprev[firstprot] = slot;
- /* copy state into save area so it can be compared with rapidly */
- tblbase = numecs * (slot - 1);
+ firstprot = slot;
+ prottbl[slot] = statenum;
+ protcomst[slot] = comstate;
- for ( i = 1; i <= numecs; ++i )
- protsave[tblbase + i] = state[i];
- }
+ /* Copy state into save area so it can be compared with rapidly. */
+ tblbase = numecs * (slot - 1);
+
+ for ( i = 1; i <= numecs; ++i )
+ protsave[tblbase + i] = state[i];
+ }
/* mktemplate - create a template entry based on a state, and connect the state
* to it
- *
- * synopsis
- * int state[], statenum, comstate, totaltrans;
- * mktemplate( state, statenum, comstate, totaltrans );
*/
void mktemplate( state, statenum, comstate )
int state[], statenum, comstate;
+ {
+ int i, numdiff, tmpbase, tmp[CSIZE + 1];
+ Char transset[CSIZE + 1];
+ int tsptr;
- {
- int i, numdiff, tmpbase, tmp[CSIZE + 1];
- Char transset[CSIZE + 1];
- int tsptr;
-
- ++numtemps;
+ ++numtemps;
- tsptr = 0;
+ tsptr = 0;
- /* calculate where we will temporarily store the transition table
- * of the template in the tnxt[] array. The final transition table
- * gets created by cmptmps()
- */
+ /* Calculate where we will temporarily store the transition table
+ * of the template in the tnxt[] array. The final transition table
+ * gets created by cmptmps().
+ */
- tmpbase = numtemps * numecs;
+ tmpbase = numtemps * numecs;
- if ( tmpbase + numecs >= current_max_template_xpairs )
- {
- current_max_template_xpairs += MAX_TEMPLATE_XPAIRS_INCREMENT;
+ if ( tmpbase + numecs >= current_max_template_xpairs )
+ {
+ current_max_template_xpairs += MAX_TEMPLATE_XPAIRS_INCREMENT;
- ++num_reallocs;
+ ++num_reallocs;
- tnxt = reallocate_integer_array( tnxt, current_max_template_xpairs );
- }
+ tnxt = reallocate_integer_array( tnxt,
+ current_max_template_xpairs );
+ }
- for ( i = 1; i <= numecs; ++i )
- if ( state[i] == 0 )
- tnxt[tmpbase + i] = 0;
- else
- {
- transset[tsptr++] = i;
- tnxt[tmpbase + i] = comstate;
- }
+ for ( i = 1; i <= numecs; ++i )
+ if ( state[i] == 0 )
+ tnxt[tmpbase + i] = 0;
+ else
+ {
+ transset[tsptr++] = i;
+ tnxt[tmpbase + i] = comstate;
+ }
- if ( usemecs )
- mkeccl( transset, tsptr, tecfwd, tecbck, numecs, 0 );
+ if ( usemecs )
+ mkeccl( transset, tsptr, tecfwd, tecbck, numecs, 0 );
- mkprot( tnxt + tmpbase, -numtemps, comstate );
+ mkprot( tnxt + tmpbase, -numtemps, comstate );
- /* we rely on the fact that mkprot adds things to the beginning
- * of the proto queue
- */
+ /* We rely on the fact that mkprot adds things to the beginning
+ * of the proto queue.
+ */
- numdiff = tbldiff( state, firstprot, tmp );
- mkentry( tmp, numecs, statenum, -numtemps, numdiff );
- }
+ numdiff = tbldiff( state, firstprot, tmp );
+ mkentry( tmp, numecs, statenum, -numtemps, numdiff );
+ }
-/* mv2front - move proto queue element to front of queue
- *
- * synopsis
- * int qelm;
- * mv2front( qelm );
- */
+/* mv2front - move proto queue element to front of queue */
void mv2front( qelm )
int qelm;
-
- {
- if ( firstprot != qelm )
{
- if ( qelm == lastprot )
- lastprot = protprev[lastprot];
+ if ( firstprot != qelm )
+ {
+ if ( qelm == lastprot )
+ lastprot = protprev[lastprot];
- protnext[protprev[qelm]] = protnext[qelm];
+ protnext[protprev[qelm]] = protnext[qelm];
- if ( protnext[qelm] != NIL )
- protprev[protnext[qelm]] = protprev[qelm];
+ if ( protnext[qelm] != NIL )
+ protprev[protnext[qelm]] = protprev[qelm];
- protprev[qelm] = NIL;
- protnext[qelm] = firstprot;
- protprev[firstprot] = qelm;
- firstprot = qelm;
+ protprev[qelm] = NIL;
+ protnext[qelm] = firstprot;
+ protprev[firstprot] = qelm;
+ firstprot = qelm;
+ }
}
- }
/* place_state - place a state into full speed transition table
- *
- * synopsis
- * int *state, statenum, transnum;
- * place_state( state, statenum, transnum );
*
* State is the statenum'th state. It is indexed by equivalence class and
* gives the number of the state to enter for a given equivalence class.
void place_state( state, statenum, transnum )
int *state, statenum, transnum;
+ {
+ register int i;
+ register int *state_ptr;
+ int position = find_table_space( state, transnum );
- {
- register int i;
- register int *state_ptr;
- int position = find_table_space( state, transnum );
-
- /* base is the table of start positions */
- base[statenum] = position;
+ /* "base" is the table of start positions. */
+ base[statenum] = position;
- /* put in action number marker; this non-zero number makes sure that
- * find_table_space() knows that this position in chk/nxt is taken
- * and should not be used for another accepting number in another state
- */
- chk[position - 1] = 1;
+ /* Put in action number marker; this non-zero number makes sure that
+ * find_table_space() knows that this position in chk/nxt is taken
+ * and should not be used for another accepting number in another
+ * state.
+ */
+ chk[position - 1] = 1;
- /* put in end-of-buffer marker; this is for the same purposes as above */
- chk[position] = 1;
+ /* Put in end-of-buffer marker; this is for the same purposes as
+ * above.
+ */
+ chk[position] = 1;
- /* place the state into chk and nxt */
- state_ptr = &state[1];
+ /* Place the state into chk and nxt. */
+ state_ptr = &state[1];
- for ( i = 1; i <= numecs; ++i, ++state_ptr )
- if ( *state_ptr != 0 )
- {
- chk[position + i] = i;
- nxt[position + i] = *state_ptr;
- }
+ for ( i = 1; i <= numecs; ++i, ++state_ptr )
+ if ( *state_ptr != 0 )
+ {
+ chk[position + i] = i;
+ nxt[position + i] = *state_ptr;
+ }
- if ( position + numecs > tblend )
- tblend = position + numecs;
- }
+ if ( position + numecs > tblend )
+ tblend = position + numecs;
+ }
/* stack1 - save states with only one out-transition to be processed later
- *
- * synopsis
- * int statenum, sym, nextstate, deflink;
- * stack1( statenum, sym, nextstate, deflink );
*
* if there's room for another state on the "one-transition" stack, the
* state is pushed onto it, to be processed later by mk1tbl. If there's
void stack1( statenum, sym, nextstate, deflink )
int statenum, sym, nextstate, deflink;
-
- {
- if ( onesp >= ONE_STACK_SIZE - 1 )
- mk1tbl( statenum, sym, nextstate, deflink );
-
- else
{
- ++onesp;
- onestate[onesp] = statenum;
- onesym[onesp] = sym;
- onenext[onesp] = nextstate;
- onedef[onesp] = deflink;
+ if ( onesp >= ONE_STACK_SIZE - 1 )
+ mk1tbl( statenum, sym, nextstate, deflink );
+
+ else
+ {
+ ++onesp;
+ onestate[onesp] = statenum;
+ onesym[onesp] = sym;
+ onenext[onesp] = nextstate;
+ onedef[onesp] = deflink;
+ }
}
- }
/* tbldiff - compute differences between two state tables
- *
- * synopsis
- * int state[], pr, ext[];
- * int tbldiff, numdifferences;
- * numdifferences = tbldiff( state, pr, ext )
*
* "state" is the state array which is to be extracted from the pr'th
* proto. "pr" is both the number of the proto we are extracting from
* and an index into the save area where we can find the proto's complete
* state table. Each entry in "state" which differs from the corresponding
* entry of "pr" will appear in "ext".
+ *
* Entries which are the same in both "state" and "pr" will be marked
* as transitions to "SAME_TRANS" in "ext". The total number of differences
* between "state" and "pr" is returned as function value. Note that this
int tbldiff( state, pr, ext )
int state[], pr, ext[];
+ {
+ register int i, *sp = state, *ep = ext, *protp;
+ register int numdiff = 0;
- {
- register int i, *sp = state, *ep = ext, *protp;
- register int numdiff = 0;
+ protp = &protsave[numecs * (pr - 1)];
- protp = &protsave[numecs * (pr - 1)];
+ for ( i = numecs; i > 0; --i )
+ {
+ if ( *++protp == *++sp )
+ *++ep = SAME_TRANS;
+ else
+ {
+ *++ep = *sp;
+ ++numdiff;
+ }
+ }
- for ( i = numecs; i > 0; --i )
- {
- if ( *++protp == *++sp )
- *++ep = SAME_TRANS;
- else
- {
- *++ep = *sp;
- ++numdiff;
- }
+ return numdiff;
}
-
- return ( numdiff );
- }
#endif
-/* yylex - scan for a regular expression token
- *
- * synopsis
- *
- * token = yylex();
- *
- * token - return token found
- */
+/* yylex - scan for a regular expression token */
int yylex()
-
- {
- int toktype;
- static int beglin = false;
-
- if ( eofseen )
- toktype = EOF;
- else
- toktype = flexscan();
-
- if ( toktype == EOF || toktype == 0 )
{
- eofseen = 1;
-
- if ( sectnum == 1 )
- {
- synerr( "premature EOF" );
- sectnum = 2;
- toktype = SECTEND;
- }
-
- else if ( sectnum == 2 )
- {
- sectnum = 3;
- toktype = 0;
- }
+ int toktype;
+ static int beglin = false;
+ if ( eofseen )
+ toktype = EOF;
else
- toktype = 0;
- }
-
- if ( trace )
- {
- if ( beglin )
- {
- fprintf( stderr, "%d\t", num_rules + 1 );
- beglin = 0;
- }
-
- switch ( toktype )
- {
- case '<':
- case '>':
- case '^':
- case '$':
- case '"':
- case '[':
- case ']':
- case '{':
- case '}':
- case '|':
- case '(':
- case ')':
- case '-':
- case '/':
- case '\\':
- case '?':
- case '.':
- case '*':
- case '+':
- case ',':
- (void) putc( toktype, stderr );
- break;
-
- case '\n':
- (void) putc( '\n', stderr );
-
- if ( sectnum == 2 )
- beglin = 1;
-
- break;
-
- case SCDECL:
- fputs( "%s", stderr );
- break;
-
- case XSCDECL:
- fputs( "%x", stderr );
- break;
-
- case WHITESPACE:
- (void) putc( ' ', stderr );
- break;
-
- case SECTEND:
- fputs( "%%\n", stderr );
-
- /* we set beglin to be true so we'll start
- * writing out numbers as we echo rules. flexscan() has
- * already assigned sectnum
- */
-
- if ( sectnum == 2 )
- beglin = 1;
-
- break;
-
- case NAME:
- fprintf( stderr, "'%s'", nmstr );
- break;
-
- case CHAR:
- switch ( yylval )
- {
- case '<':
- case '>':
- case '^':
- case '$':
- case '"':
- case '[':
- case ']':
- case '{':
- case '}':
- case '|':
- case '(':
- case ')':
- case '-':
- case '/':
- case '\\':
- case '?':
- case '.':
- case '*':
- case '+':
- case ',':
- fprintf( stderr, "\\%c", yylval );
- break;
-
- default:
- if ( ! isascii( yylval ) || ! isprint( yylval ) )
- fprintf( stderr, "\\%.3o", (unsigned int) yylval );
- else
- (void) putc( yylval, stderr );
- break;
- }
-
- break;
-
- case NUMBER:
- fprintf( stderr, "%d", yylval );
- break;
-
- case PREVCCL:
- fprintf( stderr, "[%d]", yylval );
- break;
-
- case EOF_OP:
- fprintf( stderr, "<<EOF>>" );
- break;
-
- case 0:
- fprintf( stderr, "End Marker" );
- break;
-
- default:
- fprintf( stderr, "*Something Weird* - tok: %d val: %d\n",
- toktype, yylval );
- break;
- }
+ toktype = flexscan();
+
+ if ( toktype == EOF || toktype == 0 )
+ {
+ eofseen = 1;
+
+ if ( sectnum == 1 )
+ {
+ synerr( "premature EOF" );
+ sectnum = 2;
+ toktype = SECTEND;
+ }
+
+ else if ( sectnum == 2 )
+ {
+ sectnum = 3;
+ toktype = 0;
+ }
+
+ else
+ toktype = 0;
+ }
+
+ if ( trace )
+ {
+ if ( beglin )
+ {
+ fprintf( stderr, "%d\t", num_rules + 1 );
+ beglin = 0;
+ }
+
+ switch ( toktype )
+ {
+ case '<':
+ case '>':
+ case '^':
+ case '$':
+ case '"':
+ case '[':
+ case ']':
+ case '{':
+ case '}':
+ case '|':
+ case '(':
+ case ')':
+ case '-':
+ case '/':
+ case '\\':
+ case '?':
+ case '.':
+ case '*':
+ case '+':
+ case ',':
+ (void) putc( toktype, stderr );
+ break;
+
+ case '\n':
+ (void) putc( '\n', stderr );
+
+ if ( sectnum == 2 )
+ beglin = 1;
+
+ break;
+
+ case SCDECL:
+ fputs( "%s", stderr );
+ break;
+
+ case XSCDECL:
+ fputs( "%x", stderr );
+ break;
+
+ case WHITESPACE:
+ (void) putc( ' ', stderr );
+ break;
+
+ case SECTEND:
+ fputs( "%%\n", stderr );
+
+ /* We set beglin to be true so we'll start
+ * writing out numbers as we echo rules.
+ * flexscan() has already assigned sectnum.
+ */
+
+ if ( sectnum == 2 )
+ beglin = 1;
+
+ break;
+
+ case NAME:
+ fprintf( stderr, "'%s'", nmstr );
+ break;
+
+ case CHAR:
+ switch ( yylval )
+ {
+ case '<':
+ case '>':
+ case '^':
+ case '$':
+ case '"':
+ case '[':
+ case ']':
+ case '{':
+ case '}':
+ case '|':
+ case '(':
+ case ')':
+ case '-':
+ case '/':
+ case '\\':
+ case '?':
+ case '.':
+ case '*':
+ case '+':
+ case ',':
+ fprintf( stderr, "\\%c",
+ yylval );
+ break;
+
+ default:
+ if ( ! isascii( yylval ) ||
+ ! isprint( yylval ) )
+ fprintf( stderr,
+ "\\%.3o",
+ (unsigned int) yylval );
+ else
+ (void) putc( yylval,
+ stderr );
+ break;
+ }
+
+ break;
+
+ case NUMBER:
+ fprintf( stderr, "%d", yylval );
+ break;
+
+ case PREVCCL:
+ fprintf( stderr, "[%d]", yylval );
+ break;
+
+ case EOF_OP:
+ fprintf( stderr, "<<EOF>>" );
+ break;
+
+ case 0:
+ fprintf( stderr, "End Marker" );
+ break;
+
+ default:
+ fprintf( stderr,
+ "*Something Weird* - tok: %d val: %d\n",
+ toktype, yylval );
+ break;
+ }
+ }
+
+ return toktype;
}
-
- return ( toktype );
- }
projects / flex / commitdiff