/* 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: (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. *//* $Header: /home/daffy/u0/vern/flex/RCS/dfa.c,v 2.26 95/04/20 13:53:14 vern 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;	{	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 )					{					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;	{	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]]];		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[];	{	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 *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;	{	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 += 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" );		}