fatbase

dfa.c (25910B)

---

 /*	$OpenBSD: dfa.c,v 1.6 2003/06/04 17:34:44 millert Exp $	*/
 
 /* 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, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * Neither the name of the University nor the names of its contributors
  * may be used to endorse or promote products derived from this software
  * without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE.
  */
 
 /* $Header: /cvs/src/usr.bin/lex/dfa.c,v 1.6 2003/06/04 17:34:44 millert Exp $ */
 
 #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_backing_up - check a DFA state for backing up
  *
  * synopsis
  *     void check_for_backing_up( int ds, int state[numecs] );
  *
  * ds is the number of the state to check and state[] is its out-transitions,
  * indexed by equivalence class.
  */
 
 void check_for_backing_up( ds, state )
 int ds;
 int state[];
 	{
 	if ( (reject && ! dfaacc[ds].dfaacc_set) ||
 	     (! reject && ! dfaacc[ds].dfaacc_state) )
 		{ /* state is non-accepting */
 		++num_backing_up;
 
 		if ( backing_up_report )
 			{
 			fprintf( backing_up_file,
 				_( "State #%d is non-accepting -\n" ), ds );
 
 			/* identify the state */
 			dump_associated_rules( backing_up_file, ds );
 
 			/* Now identify it further using the out- and
 			 * jam-transitions.
 			 */
 			dump_transitions( backing_up_file, state );
 
 			putc( '\n', backing_up_file );
 			}
 		}
 	}
 
 
 /* check_trailing_context - check to see if NFA state set constitutes
  *                          "dangerous" trailing context
  *
  * synopsis
  *    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
  *  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;
 int nacc;
 	{
 	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 )
 					{
 					line_warning(
 					_( "dangerous trailing context" ),
 						rule_linenum[ar] );
 					return;
 					}
 			}
 		}
 	}
 
 
 /* dump_associated_rules - list the rules associated with a DFA state
  *
  * 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;
 	{
 	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 );
 	}
 
 
 /* dump_transitions - list the transitions associated with a DFA state
  *
  * synopsis
  *     dump_transitions( FILE *file, int state[numecs] );
  *
  * 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[];
 	{
 	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 *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
  *  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_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.
  */
 
 int *epsclosure( t, ns_addr, accset, nacc_addr, hv_addr )
 int *t, *ns_addr, accset[], *nacc_addr, *hv_addr;
 	{
 	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 += 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 += 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 && ! 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
  *
  * 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 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];
 
 	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 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 it's 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 );
 		dfaacc[0].dfaacc_state = 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;
 
 		/* Unless -Ca, declare it "short" because it's a real
 		 * long-shot that that won't be large enough.
 		 */
 		out_str_dec( "static yyconst %s yy_nxt[][%d] =\n    {\n",
 			/* '}' so vi doesn't get too confused */
 			long_align ? "long" : "short", num_full_table_rows );
 
 		outn( "    {" );
 
 		/* Generate 0 entries for state #0. */
 		for ( i = 0; i < num_full_table_rows; ++i )
 			mk2data( 0 );
 
 		dataflush();
 		outn( "    },\n" );
 		}
 
 	/* 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;
 				}
 			}
 
 		if ( caseins && ! useecs )
 			{
 			int j;
 
 			for ( i = 'A', j = 'a'; i <= 'Z'; ++i, ++j )
 				{
 				if ( state[i] == 0 && state[j] != 0 )
 					/* We're adding a transition. */
 					++totaltrans;
 
 				else if ( state[i] != 0 && state[j] == 0 )
 					/* We're taking away a transition. */
 					--totaltrans;
 
 				state[i] = state[j];
 				}
 			}
 
 		numsnpairs += totaltrans;
 
 		if ( ds > num_start_states )
 			check_for_backing_up( ds, state );
 
 		if ( nultrans )
 			{
 			nultrans[ds] = state[NUL_ec];
 			state[NUL_ec] = 0;	/* remove transition */
 			}
 
 		if ( fulltbl )
 			{
 			outn( "    {" );
 
 			/* 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 );
 
 			dataflush();
 			outn( "    },\n" );
 			}
 
 		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();
 		}
 
 	flex_free( (void *) accset );
 	flex_free( (void *) nset );
 	}
 
 
 /* snstods - converts a set of ndfa states into a dfa state
  *
  * synopsis
  *    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.
  */
 
 int snstods( sns, numstates, accset, nacc, hashval, newds_addr )
 int sns[], numstates, accset[], nacc, hashval, *newds_addr;
 	{
 	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] = allocate_integer_array( numstates + 1 );
 
 	/* 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 = allocate_integer_array( nacc + 1 );
 
 		/* Save the accepting set for later */
 		for ( i = 1; i <= nacc; ++i )
 			{
 			dfaacc[newds].dfaacc_set[i] = accset[i];
 
 			if ( accset[i] <= num_rules )
 				/* Who knows, perhaps a REJECT can yield
 				 * this rule.
 				 */
 				rule_useful[accset[i]] = true;
 			}
 
 		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;
 
 		if ( j <= num_rules )
 			rule_useful[j] = true;
 		}
 
 	*newds_addr = newds;
 
 	return 1;
 	}
 
 
 /* symfollowset - follow the symbol transitions one step
  *
  * synopsis
  *    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;
 						}
 					}
 			}
 
 		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
  *    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;
 
 	/* 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 )
 				{
 				flexfatal(
 		_( "bad transition character detected in sympartition()" ) );
 				}
 
 			if ( tch >= 0 )
 				{ /* character transition */
 				int ec = 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;
 						}
 				}
 			}
 		}
 	}