/*	$OpenBSD: dfa.c,v 1.8 2015/11/19 23:20:34 tedu 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. */

#include "flexdef.h"

#include "tables.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[];

				 _("State #%d is non-accepting -\n"), ds);

			/* identify the state */

			/* Now identify it further using the out- and

			 * jam-transitions.

			 */

		}

	}

/* 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;

		}

			/* 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.

			 */

						      ("dangerous trailing context"),

						      rule_linenum[ar]);

				}

		}

	}

}

/* 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     rule_set[MAX_ASSOC_RULES + 1];

					rule_num;

		}

	}

	}

}

/* 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];

	}

	/* now invert the members of the set to get the jam transitions */

}

/* 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     stkend, nstate;

	static int did_stk_init = false, *stk;

#define MARK_STATE(state) \

do{ trans1[state] = trans1[state] - MARKER_DIFFERENCE;} while(0)

#define IS_MARKED(state) (trans1[state] < 0)

#define UNMARK_STATE(state) \

do{ trans1[state] = trans1[state] + MARKER_DIFFERENCE;} while(0)

#define CHECK_ACCEPT(state) \

do{ \

nfaccnum = accptnum[state]; \

if ( nfaccnum != NIL ) \

accset[++nacc] = nfaccnum; \

}while(0)

#define DO_REALLOCATION() \

do { \

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 ); \

}while(0) \

#define PUT_ON_STACK(state) \

do { \

if ( ++stkend >= current_max_dfa_size ) \

DO_REALLOCATION(); \

stk[stkend] = state; \

MARK_STATE(state); \

}while(0)

#define ADD_STATE(state) \

do { \

if ( ++numstates >= current_max_dfa_size ) \

DO_REALLOCATION(); \

t[numstates] = state; \

hashval += state; \

}while(0)

#define STACK_STATE(state) \

do { \

PUT_ON_STACK(state); \

CHECK_ACCEPT(state); \

if ( nfaccnum != NIL || transchar[state] != SYM_EPSILON ) \

ADD_STATE(state); \

}while(0)

	}

		/* The state could be marked if we've already pushed it onto

		 * the stack.

		 */

		}

	}

				    && !IS_MARKED (tsp))

			}

		}

	}

	/* Clear out "visit" markers. */

		else

				   ("consistency check failed in epsclosure()"));

	}

}

/* increase_max_dfas - increase the maximum number of DFAs */

void increase_max_dfas ()

{

			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    *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 needs to be large enough to hold all of the rules present

	 * in the input, *plus* their YY_TRAILING_HEAD_MASK variants.

	 */

	/* 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.

	 */

	}

	}

	/* 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

	 */

		/* NUL is alone in its equivalence class, which is the

		 * last one.

		 */

			/* We still may want to use the table if numecs

			 * is a power of 2.

			 */

			int     power_of_two;

				}

		}

				allocate_integer_array (current_max_dfas);

		/* From now on, nultrans != nil indicates that we're

		 * saving null transitions for later, separate encoding.

		 */

	}

	}

			/* We won't be including NUL's transitions in the

			 * table, so build it for entries from 0 .. numecs - 1.

			 */

		else

			/* Take into account the fact that we'll be including

			 * the NUL entries in the transition table.  Build it

			 * from 0 .. numecs.

			 */

		/* Begin generating yy_nxt[][]

		 * This spans the entire LONG function.

		 * This table is tricky because we don't know how big it will be.

		 * So we'll have to realloc() on the way...

		 * we'll wait until we can calculate yynxt_tbl->td_hilen.

		 */

			(struct yytbl_data *) calloc (1,

						      sizeof (struct

							      yytbl_data));

			(flex_int32_t *) calloc (yynxt_tbl->td_lolen *

					    yynxt_tbl->td_hilen,

					    sizeof (flex_int32_t));

			    "\t{YYTD_ID_NXT, (void**)&yy_nxt, sizeof(%s)},\n",

			    long_align ? "flex_int32_t" : "flex_int16_t");

		/* Unless -Ca, declare it "short" because it's a real

		 * long-shot that that won't be large enough.

		 */

				("static yyconst %s yy_nxt[][%d] =\n    {\n",

				 long_align ? "flex_int32_t" : "flex_int16_t",

				 num_full_table_rows);

		else {

				 long_align ? "flex_int32_t" : "flex_int16_t");

		}

		/* Generate 0 entries for state #0. */

		}

	}

	/* Create the first states. */

		/* 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.

		 */

		else

				mkbranch (scbol[i / 2], scset[i / 2]);

				   &hashval);

							accset, nacc);

		}

	}

				   ("could not create unique end-of-buffer state"));

	}

					/* Symbol has unique out-transitions. */

						symfollowset (dset, dsize,

							      sym, nset);

							   &numstates,

							   accset, &nacc,

							   &hashval);

					    (nset, numstates, accset, nacc,

					     hashval, &newds)) {

							numstates;

								(nset,

								 numstates,

								 accset,

								 nacc);

					}

							 "\t%d\t%d\n", sym,

							 newds);

				}

				else {

					/* sym's equivalence class has the same

					 * transitions as duplist(sym)'s

					 * equivalence class.

					 */

							 "\t%d\t%d\n", sym,

							 targ);

					/* Update frequency count for

					 * destination state.

					 */

				}

			}

		}

		}

			/* Each time we hit here, it's another td_hilen, so we realloc. */

				(flex_int32_t *) realloc (yynxt_data,

						     yynxt_tbl->td_hilen *

						     yynxt_tbl->td_lolen *

						     sizeof (flex_int32_t));

			/* Supply array's 0-element. */

					-end_of_buffer_state;

			}

			else {

					end_of_buffer_state;

			}

				/* Jams are marked by negative of state

				 * number.

				 */

					state[i] ? state[i] : -ds;

			}

		}

			/* Special case this state to make sure it does what

			 * it's supposed to, i.e., jam on end-of-buffer.

			 */

		else {		/* normal, compressed state */

			/* Determine which destination state is the most

			 * common, and how many transitions to it there are.

			 */

				}

		}

	}

					   ("Could not write yynxt_tbl[][]"));

		}

		}

	}

		/* Create tables for all the states with only one

		 * out-transition.

		 */

				onenext[onesp], onedef[onesp]);

		}

	}

/* 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 i, j;

	int     newds, *oldsns;

					/* We sort the states in sns so we

					 * can compare it to oldsns quickly.

					 */

				}

				}

			}

			else

		}

	/* Make a new dfa. */

	/* If we haven't already sorted the states in sns, we do so now,

	 * so that future comparisons with it can be made quickly.

	 */

		else

	}

		/* 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.

		 */

			allocate_integer_array (nacc + 1);

		/* Save the accepting set for later */

				/* Who knows, perhaps a REJECT can yield

				 * this rule.

				 */

		}

	}

	else {

		/* Find lowest numbered rule so the disambiguating rule

		 * will work.

		 */

	}

}

/* 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;

					/* Loop through negated character

					 * class.

					 */