Aren
/
NetBSD
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
NetBSD/gnu/usr.bin/lex/dfa.c

1076 lines
26 KiB
C
Raw Blame History

/* dfa - DFA construction routines */
/*-
* Copyright (c) 1990 The Regents of the University of California.
* All rights reserved.
*
* This code is derived from software contributed to Berkeley by
* Vern Paxson.
*
* The United States Government has rights in this work pursuant
* to contract no. DE-AC03-76SF00098 between the United States
* Department of Energy and the University of California.
*
* Redistribution and use in source and binary forms are permitted provided
* that: (1) source distributions retain this entire copyright notice and
* comment, and (2) distributions including binaries display the following
* acknowledgement: ``This product includes software developed by the
* University of California, Berkeley and its contributors'' in the
* documentation or other materials provided with the distribution and in
* all advertising materials mentioning features or use of this software.
* Neither the name of the University nor the names of its contributors may
* be used to endorse or promote products derived from this software without
* specific prior written permission.
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*/
#ifndef lint
static char rcsid[] =
"@(#) $Header: /cvsroot/src/gnu/usr.bin/lex/Attic/dfa.c,v 1.2 1993/05/04 07:44:42 cgd Exp $ (LBL)";
#endif
#include "flexdef.h"
/* declare functions that have forward references */
void dump_associated_rules PROTO((FILE*, int));
void dump_transitions PROTO((FILE*, int[]));
void sympartition PROTO((int[], int, int[], int[]));
int symfollowset PROTO((int[], int, int, int[]));
/* check_for_backtracking - check a DFA state for backtracking
*
* synopsis
* int ds, state[numecs];
* check_for_backtracking( ds, state );
*
* 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
*/
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 ( backtrack_report )
{
fprintf( backtrack_file, "State #%d is non-accepting -\n", 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 );
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 );
*
* NOTES
* 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
* message is issued.
*
* nfa_states[1 .. num_states] is the list of NFA states in the DFA.
* accset[1 .. nacc] is the list of accepting numbers for the DFA state.
*/
void check_trailing_context( nfa_states, num_states, accset, nacc )
int *nfa_states, num_states;
int *accset;
register int nacc;
{
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];
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 )
{
fprintf( stderr,
"%s: Dangerous trailing context in rule at line %d\n",
program_name, rule_linenum[ar] );
return;
}
}
}
}
/* dump_associated_rules - list the rules associated with a DFA state
*
* synopisis
* int ds;
* FILE *file;
* dump_associated_rules( file, ds );
*
* 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
*/
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 rule_num = rule_linenum[assoc_rule[dset[i]]];
for ( j = 1; j <= num_associated_rules; ++j )
if ( rule_num == rule_set[j] )
break;
if ( j > num_associated_rules )
{ /* new rule */
if ( num_associated_rules < MAX_ASSOC_RULES )
rule_set[++num_associated_rules] = rule_num;
}
}
bubble( rule_set, num_associated_rules );
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 );
}
/* dump_transitions - list the transitions associated with a DFA state
*
* synopisis
* int state[numecs];
* FILE *file;
* dump_transitions( file, state );
*
* 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];
for ( i = 0; i < csize; ++i )
{
ec = abs( ecgroup[i] );
out_char_set[i] = state[ec];
}
fprintf( file, " out-transitions: " );
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];
fprintf( file, "\n jam-transitions: EOF " );
list_character_set( file, out_char_set );
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 );
*
* NOTES
* 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.
*
* 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;
#define MARK_STATE(state) \
trans1[state] = trans1[state] - MARKER_DIFFERENCE;
#define IS_MARKED(state) (trans1[state] < 0)
#define UNMARK_STATE(state) \
trans1[state] = trans1[state] + MARKER_DIFFERENCE;
#define CHECK_ACCEPT(state) \
{ \
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 ); \
} \
#define PUT_ON_STACK(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; \
}
#define STACK_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];
/* the state could be marked if we've already pushed it onto
* the stack
*/
if ( ! IS_MARKED(ns) )
PUT_ON_STACK(ns)
CHECK_ACCEPT(ns)
hashval = hashval + ns;
}
for ( stkpos = 1; stkpos <= stkend; ++stkpos )
{
ns = stk[stkpos];
transsym = transchar[ns];
if ( transsym == SYM_EPSILON )
{
tsp = trans1[ns] + MARKER_DIFFERENCE;
if ( tsp != NO_TRANSITION )
{
if ( ! IS_MARKED(tsp) )
STACK_STATE(tsp)
tsp = trans2[ns];
if ( tsp != NO_TRANSITION )
if ( ! IS_MARKED(tsp) )
STACK_STATE(tsp)
}
}
}
/* 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()" );
}
*ns_addr = numstates;
*hv_addr = hashval;
*nacc_addr = nacc;
return ( t );
}
/* increase_max_dfas - increase the maximum number of DFAs */
void increase_max_dfas()
{
current_max_dfas += MAX_DFAS_INCREMENT;
++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 );
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.
*/
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;
}
for ( i = 0; i <= num_rules; ++i )
accset[i] = NIL;
if ( trace )
{
dumpnfa( scset[1] );
fputs( "\n\nDFA Dump:\n\n", stderr );
}
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 equilvalence 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
*/
}
if ( fullspd )
{
for ( i = 0; i <= numecs; ++i )
state[i] = 0;
place_state( state, 0, 0 );
}
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;
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;
}
/* create the first states */
num_start_states = lastsc * 2;
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] );
nset = epsclosure( nset, &numstates, accset, &nacc, &hashval );
if ( snstods( nset, numstates, accset, nacc, hashval, &ds ) )
{
numas += nacc;
totnst += numstates;
++todo_next;
if ( variable_trailing_context_rules && nacc > 0 )
check_trailing_context( nset, numstates, accset, nacc );
}
}
if ( ! fullspd )
{
if ( ! snstods( nset, 0, accset, 0, 0, &end_of_buffer_state ) )
flexfatal( "could not create unique end-of-buffer state" );
++numas;
++num_start_states;
++todo_next;
}
while ( todo_head < todo_next )
{
targptr = 0;
totaltrans = 0;
for ( i = 1; i <= numecs; ++i )
state[i] = 0;
ds = ++todo_head;
dset = dss[ds];
dsize = dfasiz[ds];
if ( trace )
fprintf( stderr, "state # %d:\n", ds );
sympartition( dset, dsize, symlist, duplist );
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;
}
}
numsnpairs = numsnpairs + totaltrans;
if ( caseins && ! useecs )
{
register int j;
for ( i = 'A', j = 'a'; i <= 'Z'; ++i, ++j )
state[i] = state[j];
}
if ( ds > num_start_states )
check_for_backtracking( ds, state );
if ( nultrans )
{
nultrans[ds] = state[NUL_ec];
state[NUL_ec] = 0; /* remove transition */
}
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();
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;
}
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 );
*
* 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;
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;
}
/* make a new dfa */
if ( ++lastdfa >= current_max_dfas )
increase_max_dfas();
newds = lastdfa;
dss[newds] = (int *) malloc( (unsigned) ((numstates + 1) * sizeof( int )) );
if ( ! dss[newds] )
flexfatal( "dynamic memory failure in snstods()" );
/* if we haven't already sorted the states in sns, we do so now, so that
* future comparisons with it can be made quickly
*/
if ( ! didsort )
bubble( sns, numstates );
for ( i = 1; i <= numstates; ++i )
dss[newds][i] = sns[i];
dfasiz[newds] = numstates;
dhash[newds] = hashval;
if ( nacc == 0 )
{
if ( reject )
dfaacc[newds].dfaacc_set = (int *) 0;
else
dfaacc[newds].dfaacc_state = 0;
accsiz[newds] = 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.
*/
bubble( accset, nacc );
dfaacc[newds].dfaacc_set =
(int *) malloc( (unsigned) ((nacc + 1) * sizeof( int )) );
if ( ! dfaacc[newds].dfaacc_set )
flexfatal( "dynamic memory failure in snstods()" );
/* save the accepting set for later */
for ( i = 1; i <= nacc; ++i )
dfaacc[newds].dfaacc_set[i] = accset[i];
accsiz[newds] = nacc;
}
else
{ /* find lowest numbered rule so the disambiguating rule will work */
j = num_rules + 1;
for ( i = 1; i <= nacc; ++i )
if ( accset[i] < j )
j = accset[i];
dfaacc[newds].dfaacc_state = j;
}
*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 );
*/
int symfollowset( ds, dsize, transsym, nset )
int ds[], dsize, transsym, nset[];
{
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 ( ch == transsym )
{
nset[++numstates] = tsp;
break;
}
}
}
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;
bottom:
;
}
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 );
*/
void sympartition( ds, numstates, symlist, duplist )
int ds[], numstates, duplist[];
int symlist[];
{
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;
}
duplist[1] = NIL;
dupfwd[numecs] = NIL;
for ( i = 1; i <= numstates; ++i )
{
ns = ds[i];
tch = transchar[ns];
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] );
mkechar( ec, dupfwd, duplist );
symlist[ec] = 1;
}
else
{ /* character class */
tch = -tch;
lenccl = ccllen[tch];
cclp = cclmap[tch];
mkeccl( ccltbl + cclp, lenccl, dupfwd, duplist, numecs,
NUL_ec );
if ( cclng[tch] )
{
j = 0;
for ( k = 0; k < lenccl; ++k )
{
ich = ccltbl[cclp + k];
if ( ich == 0 )
ich = NUL_ec;
for ( ++j; j < ich; ++j )
symlist[j] = 1;
}
for ( ++j; j <= numecs; ++j )
symlist[j] = 1;
}
else
for ( k = 0; k < lenccl; ++k )
{
ich = ccltbl[cclp + k];
if ( ich == 0 )
ich = NUL_ec;
symlist[ich] = 1;
}
}
}
}
}
Reference in New Issue View Git Blame Copy Permalink