#include "flexdef.h"

Include dependency graph for dfa.c:

Macros
#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)

#define	DO_REALLOCATION

#define	PUT_ON_STACK(state)

#define	ADD_STATE(state)

#define	STACK_STATE(state)

Functions
void	dump_associated_rules (FILE *, int)

void	dump_transitions (FILE *, int[])

void	sympartition (int[], int, int[], int[])

int	symfollowset (int[], int, int, int[])

void	check_for_backtracking (int ds, int state[])

void	check_trailing_context (int nfa_states, int num_states, int accset, int nacc)

int *	epsclosure (int t, int ns_addr, int accset[], int nacc_addr, int hv_addr)

void	increase_max_dfas (void)

void	ntod (void)

int	snstods (int sns[], int numstates, int accset[], int nacc, int hashval, int *newds_addr)

Macro Definition Documentation

#define ADD_STATE ( state )

Value:

{ \
        if ( ++numstates >= current_max_dfa_size ) \
            DO_REALLOCATION \
        t[numstates] = state; \
        hashval = hashval + state; \
        }

#define CHECK_ACCEPT ( state )

Value:

{ \
        nfaccnum = accptnum[state]; \
        if ( nfaccnum != NIL ) \
            accset[++nacc] = nfaccnum; \
        }

#define DO_REALLOCATION

Value:

{ \
        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 IS_MARKED ( state ) (trans1[state] < 0)

#define MARK_STATE ( state ) trans1[state] = trans1[state] - MARKER_DIFFERENCE;

#define PUT_ON_STACK ( state )

Value:

{ \
        if ( ++stkend >= current_max_dfa_size ) \
            DO_REALLOCATION \
        stk[stkend] = state; \
        MARK_STATE(state) \
        }

#define STACK_STATE ( state )

Value:

{ \
        PUT_ON_STACK(state) \
        CHECK_ACCEPT(state) \
        if ( nfaccnum != NIL || transchar[state] != SYM_EPSILON ) \
            ADD_STATE(state) \
        }

#define UNMARK_STATE ( state ) trans1[state] = trans1[state] + MARKER_DIFFERENCE;

Function Documentation

void check_for_backtracking	(	int	ds,
		int	state[]
	)

Definition at line 59 of file dfa.c.

 {
     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 );
             }
         }
     }

void check_trailing_context	(	int *	nfa_states,
		int	num_states,
		int *	accset,
		int	nacc
	)

Definition at line 103 of file dfa.c.

 {
     int i, j;
 
     for ( i = 1; i <= num_states; ++i )
         {
         int ns = nfa_states[i];
         int type = state_type[ns];
         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;
                     }
             }
         }
     }

void dump_associated_rules	(	FILE *	file,
		int	ds
	)

Definition at line 149 of file dfa.c.

 {
     int i, j;
     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 )
         {
         int 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 );
     }

void dump_transitions	(	FILE *	file,
		int	state[]
	)

Definition at line 201 of file dfa.c.

 {
     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 );
     }

int* epsclosure	(	int *	t,
		int *	ns_addr,
		int	accset[],
		int *	nacc_addr,
		int *	hv_addr
	)

Definition at line 249 of file dfa.c.

 {
     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 );
     }

void increase_max_dfas ( void )

Definition at line 370 of file dfa.c.

 {
     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 );
     }

void ntod ( void )

Definition at line 398 of file dfa.c.

 {
     int *accset, ds, nacc, newds;
     int sym, hashval, numstates, dsize;
     int num_full_table_rows = 0;        /* used only for -f */
     int *nset, *dset;
     int targptr, totaltrans, i, comstate, comfreq, targ;
     int *epsclosure(int *t, int *ns_addr, int *accset, int *nacc_addr, int *hv_addr);
     int snstods(int *sns, int numstates, int *accset, int nacc, int hashval, int *newds_addr);
     int 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 )
             {
             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();
         }
     }

int snstods	(	int	sns[],
		int	numstates,
		int	accset[],
		int	nacc,
		int	hashval,
		int *	newds_addr
	)

Definition at line 763 of file dfa.c.

 {
     int didsort = 0;
     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 );
     }

int symfollowset	(	int	ds[],
		int	dsize,
		int	transsym,
		int	nset[]
	)

Definition at line 887 of file dfa.c.

 {
     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 );
     }

void sympartition	(	int	ds[],
		int	numstates,
		int	symlist[],
		int	duplist[]
	)

Definition at line 971 of file dfa.c.

 {
     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;
                         }
                 }
             }
         }
     }

Macros

Functions

Macro Definition Documentation

Function Documentation