1*d9805213SSascha Wildner /* dfa - DFA construction routines */
2*d9805213SSascha Wildner
3*d9805213SSascha Wildner /* Copyright (c) 1990 The Regents of the University of California. */
4*d9805213SSascha Wildner /* All rights reserved. */
5*d9805213SSascha Wildner
6*d9805213SSascha Wildner /* This code is derived from software contributed to Berkeley by */
7*d9805213SSascha Wildner /* Vern Paxson. */
8*d9805213SSascha Wildner
9*d9805213SSascha Wildner /* The United States Government has rights in this work pursuant */
10*d9805213SSascha Wildner /* to contract no. DE-AC03-76SF00098 between the United States */
11*d9805213SSascha Wildner /* Department of Energy and the University of California. */
12*d9805213SSascha Wildner
13*d9805213SSascha Wildner /* Redistribution and use in source and binary forms, with or without */
14*d9805213SSascha Wildner /* modification, are permitted provided that the following conditions */
15*d9805213SSascha Wildner /* are met: */
16*d9805213SSascha Wildner
17*d9805213SSascha Wildner /* 1. Redistributions of source code must retain the above copyright */
18*d9805213SSascha Wildner /* notice, this list of conditions and the following disclaimer. */
19*d9805213SSascha Wildner /* 2. Redistributions in binary form must reproduce the above copyright */
20*d9805213SSascha Wildner /* notice, this list of conditions and the following disclaimer in the */
21*d9805213SSascha Wildner /* documentation and/or other materials provided with the distribution. */
22*d9805213SSascha Wildner
23*d9805213SSascha Wildner /* Neither the name of the University nor the names of its contributors */
24*d9805213SSascha Wildner /* may be used to endorse or promote products derived from this software */
25*d9805213SSascha Wildner /* without specific prior written permission. */
26*d9805213SSascha Wildner
27*d9805213SSascha Wildner /* THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR */
28*d9805213SSascha Wildner /* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED */
29*d9805213SSascha Wildner /* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR */
30*d9805213SSascha Wildner /* PURPOSE. */
31*d9805213SSascha Wildner
32*d9805213SSascha Wildner #include "flexdef.h"
33*d9805213SSascha Wildner #include "tables.h"
34*d9805213SSascha Wildner
35*d9805213SSascha Wildner /* declare functions that have forward references */
36*d9805213SSascha Wildner
37*d9805213SSascha Wildner void dump_associated_rules(FILE *, int);
38*d9805213SSascha Wildner void dump_transitions(FILE *, int[]);
39*d9805213SSascha Wildner void sympartition(int[], int, int[], int[]);
40*d9805213SSascha Wildner int symfollowset(int[], int, int, int[]);
41*d9805213SSascha Wildner
42*d9805213SSascha Wildner
43*d9805213SSascha Wildner /* check_for_backing_up - check a DFA state for backing up
44*d9805213SSascha Wildner *
45*d9805213SSascha Wildner * synopsis
46*d9805213SSascha Wildner * void check_for_backing_up( int ds, int state[numecs] );
47*d9805213SSascha Wildner *
48*d9805213SSascha Wildner * ds is the number of the state to check and state[] is its out-transitions,
49*d9805213SSascha Wildner * indexed by equivalence class.
50*d9805213SSascha Wildner */
51*d9805213SSascha Wildner
check_for_backing_up(int ds,int state[])52*d9805213SSascha Wildner void check_for_backing_up (int ds, int state[])
53*d9805213SSascha Wildner {
54*d9805213SSascha Wildner if ((reject && !dfaacc[ds].dfaacc_set) || (!reject && !dfaacc[ds].dfaacc_state)) { /* state is non-accepting */
55*d9805213SSascha Wildner ++num_backing_up;
56*d9805213SSascha Wildner
57*d9805213SSascha Wildner if (backing_up_report) {
58*d9805213SSascha Wildner fprintf (backing_up_file,
59*d9805213SSascha Wildner _("State #%d is non-accepting -\n"), ds);
60*d9805213SSascha Wildner
61*d9805213SSascha Wildner /* identify the state */
62*d9805213SSascha Wildner dump_associated_rules (backing_up_file, ds);
63*d9805213SSascha Wildner
64*d9805213SSascha Wildner /* Now identify it further using the out- and
65*d9805213SSascha Wildner * jam-transitions.
66*d9805213SSascha Wildner */
67*d9805213SSascha Wildner dump_transitions (backing_up_file, state);
68*d9805213SSascha Wildner
69*d9805213SSascha Wildner putc ('\n', backing_up_file);
70*d9805213SSascha Wildner }
71*d9805213SSascha Wildner }
72*d9805213SSascha Wildner }
73*d9805213SSascha Wildner
74*d9805213SSascha Wildner
75*d9805213SSascha Wildner /* check_trailing_context - check to see if NFA state set constitutes
76*d9805213SSascha Wildner * "dangerous" trailing context
77*d9805213SSascha Wildner *
78*d9805213SSascha Wildner * synopsis
79*d9805213SSascha Wildner * void check_trailing_context( int nfa_states[num_states+1], int num_states,
80*d9805213SSascha Wildner * int accset[nacc+1], int nacc );
81*d9805213SSascha Wildner *
82*d9805213SSascha Wildner * NOTES
83*d9805213SSascha Wildner * Trailing context is "dangerous" if both the head and the trailing
84*d9805213SSascha Wildner * part are of variable size \and/ there's a DFA state which contains
85*d9805213SSascha Wildner * both an accepting state for the head part of the rule and NFA states
86*d9805213SSascha Wildner * which occur after the beginning of the trailing context.
87*d9805213SSascha Wildner *
88*d9805213SSascha Wildner * When such a rule is matched, it's impossible to tell if having been
89*d9805213SSascha Wildner * in the DFA state indicates the beginning of the trailing context or
90*d9805213SSascha Wildner * further-along scanning of the pattern. In these cases, a warning
91*d9805213SSascha Wildner * message is issued.
92*d9805213SSascha Wildner *
93*d9805213SSascha Wildner * nfa_states[1 .. num_states] is the list of NFA states in the DFA.
94*d9805213SSascha Wildner * accset[1 .. nacc] is the list of accepting numbers for the DFA state.
95*d9805213SSascha Wildner */
96*d9805213SSascha Wildner
check_trailing_context(int * nfa_states,int num_states,int * accset,int nacc)97*d9805213SSascha Wildner void check_trailing_context (int *nfa_states, int num_states, int *accset, int nacc)
98*d9805213SSascha Wildner {
99*d9805213SSascha Wildner int i, j;
100*d9805213SSascha Wildner
101*d9805213SSascha Wildner for (i = 1; i <= num_states; ++i) {
102*d9805213SSascha Wildner int ns = nfa_states[i];
103*d9805213SSascha Wildner int type = state_type[ns];
104*d9805213SSascha Wildner int ar = assoc_rule[ns];
105*d9805213SSascha Wildner
106*d9805213SSascha Wildner if (type == STATE_NORMAL || rule_type[ar] != RULE_VARIABLE) { /* do nothing */
107*d9805213SSascha Wildner }
108*d9805213SSascha Wildner
109*d9805213SSascha Wildner else if (type == STATE_TRAILING_CONTEXT) {
110*d9805213SSascha Wildner /* Potential trouble. Scan set of accepting numbers
111*d9805213SSascha Wildner * for the one marking the end of the "head". We
112*d9805213SSascha Wildner * assume that this looping will be fairly cheap
113*d9805213SSascha Wildner * since it's rare that an accepting number set
114*d9805213SSascha Wildner * is large.
115*d9805213SSascha Wildner */
116*d9805213SSascha Wildner for (j = 1; j <= nacc; ++j)
117*d9805213SSascha Wildner if (accset[j] & YY_TRAILING_HEAD_MASK) {
118*d9805213SSascha Wildner line_warning (_
119*d9805213SSascha Wildner ("dangerous trailing context"),
120*d9805213SSascha Wildner rule_linenum[ar]);
121*d9805213SSascha Wildner return;
122*d9805213SSascha Wildner }
123*d9805213SSascha Wildner }
124*d9805213SSascha Wildner }
125*d9805213SSascha Wildner }
126*d9805213SSascha Wildner
127*d9805213SSascha Wildner
128*d9805213SSascha Wildner /* dump_associated_rules - list the rules associated with a DFA state
129*d9805213SSascha Wildner *
130*d9805213SSascha Wildner * Goes through the set of NFA states associated with the DFA and
131*d9805213SSascha Wildner * extracts the first MAX_ASSOC_RULES unique rules, sorts them,
132*d9805213SSascha Wildner * and writes a report to the given file.
133*d9805213SSascha Wildner */
134*d9805213SSascha Wildner
dump_associated_rules(FILE * file,int ds)135*d9805213SSascha Wildner void dump_associated_rules (FILE *file, int ds)
136*d9805213SSascha Wildner {
137*d9805213SSascha Wildner int i, j;
138*d9805213SSascha Wildner int num_associated_rules = 0;
139*d9805213SSascha Wildner int rule_set[MAX_ASSOC_RULES + 1];
140*d9805213SSascha Wildner int *dset = dss[ds];
141*d9805213SSascha Wildner int size = dfasiz[ds];
142*d9805213SSascha Wildner
143*d9805213SSascha Wildner for (i = 1; i <= size; ++i) {
144*d9805213SSascha Wildner int rule_num = rule_linenum[assoc_rule[dset[i]]];
145*d9805213SSascha Wildner
146*d9805213SSascha Wildner for (j = 1; j <= num_associated_rules; ++j)
147*d9805213SSascha Wildner if (rule_num == rule_set[j])
148*d9805213SSascha Wildner break;
149*d9805213SSascha Wildner
150*d9805213SSascha Wildner if (j > num_associated_rules) { /* new rule */
151*d9805213SSascha Wildner if (num_associated_rules < MAX_ASSOC_RULES)
152*d9805213SSascha Wildner rule_set[++num_associated_rules] =
153*d9805213SSascha Wildner rule_num;
154*d9805213SSascha Wildner }
155*d9805213SSascha Wildner }
156*d9805213SSascha Wildner
157*d9805213SSascha Wildner qsort (&rule_set [1], (size_t) num_associated_rules, sizeof (rule_set [1]), intcmp);
158*d9805213SSascha Wildner
159*d9805213SSascha Wildner fprintf (file, _(" associated rule line numbers:"));
160*d9805213SSascha Wildner
161*d9805213SSascha Wildner for (i = 1; i <= num_associated_rules; ++i) {
162*d9805213SSascha Wildner if (i % 8 == 1)
163*d9805213SSascha Wildner putc ('\n', file);
164*d9805213SSascha Wildner
165*d9805213SSascha Wildner fprintf (file, "\t%d", rule_set[i]);
166*d9805213SSascha Wildner }
167*d9805213SSascha Wildner
168*d9805213SSascha Wildner putc ('\n', file);
169*d9805213SSascha Wildner }
170*d9805213SSascha Wildner
171*d9805213SSascha Wildner
172*d9805213SSascha Wildner /* dump_transitions - list the transitions associated with a DFA state
173*d9805213SSascha Wildner *
174*d9805213SSascha Wildner * synopsis
175*d9805213SSascha Wildner * dump_transitions( FILE *file, int state[numecs] );
176*d9805213SSascha Wildner *
177*d9805213SSascha Wildner * Goes through the set of out-transitions and lists them in human-readable
178*d9805213SSascha Wildner * form (i.e., not as equivalence classes); also lists jam transitions
179*d9805213SSascha Wildner * (i.e., all those which are not out-transitions, plus EOF). The dump
180*d9805213SSascha Wildner * is done to the given file.
181*d9805213SSascha Wildner */
182*d9805213SSascha Wildner
dump_transitions(FILE * file,int state[])183*d9805213SSascha Wildner void dump_transitions (FILE *file, int state[])
184*d9805213SSascha Wildner {
185*d9805213SSascha Wildner int i, ec;
186*d9805213SSascha Wildner int out_char_set[CSIZE];
187*d9805213SSascha Wildner
188*d9805213SSascha Wildner for (i = 0; i < csize; ++i) {
189*d9805213SSascha Wildner ec = ABS (ecgroup[i]);
190*d9805213SSascha Wildner out_char_set[i] = state[ec];
191*d9805213SSascha Wildner }
192*d9805213SSascha Wildner
193*d9805213SSascha Wildner fprintf (file, _(" out-transitions: "));
194*d9805213SSascha Wildner
195*d9805213SSascha Wildner list_character_set (file, out_char_set);
196*d9805213SSascha Wildner
197*d9805213SSascha Wildner /* now invert the members of the set to get the jam transitions */
198*d9805213SSascha Wildner for (i = 0; i < csize; ++i)
199*d9805213SSascha Wildner out_char_set[i] = !out_char_set[i];
200*d9805213SSascha Wildner
201*d9805213SSascha Wildner fprintf (file, _("\n jam-transitions: EOF "));
202*d9805213SSascha Wildner
203*d9805213SSascha Wildner list_character_set (file, out_char_set);
204*d9805213SSascha Wildner
205*d9805213SSascha Wildner putc ('\n', file);
206*d9805213SSascha Wildner }
207*d9805213SSascha Wildner
208*d9805213SSascha Wildner
209*d9805213SSascha Wildner /* epsclosure - construct the epsilon closure of a set of ndfa states
210*d9805213SSascha Wildner *
211*d9805213SSascha Wildner * synopsis
212*d9805213SSascha Wildner * int *epsclosure( int t[num_states], int *numstates_addr,
213*d9805213SSascha Wildner * int accset[num_rules+1], int *nacc_addr,
214*d9805213SSascha Wildner * int *hashval_addr );
215*d9805213SSascha Wildner *
216*d9805213SSascha Wildner * NOTES
217*d9805213SSascha Wildner * The epsilon closure is the set of all states reachable by an arbitrary
218*d9805213SSascha Wildner * number of epsilon transitions, which themselves do not have epsilon
219*d9805213SSascha Wildner * transitions going out, unioned with the set of states which have non-null
220*d9805213SSascha Wildner * accepting numbers. t is an array of size numstates of nfa state numbers.
221*d9805213SSascha Wildner * Upon return, t holds the epsilon closure and *numstates_addr is updated.
222*d9805213SSascha Wildner * accset holds a list of the accepting numbers, and the size of accset is
223*d9805213SSascha Wildner * given by *nacc_addr. t may be subjected to reallocation if it is not
224*d9805213SSascha Wildner * large enough to hold the epsilon closure.
225*d9805213SSascha Wildner *
226*d9805213SSascha Wildner * hashval is the hash value for the dfa corresponding to the state set.
227*d9805213SSascha Wildner */
228*d9805213SSascha Wildner
epsclosure(int * t,int * ns_addr,int accset[],int * nacc_addr,int * hv_addr)229*d9805213SSascha Wildner int *epsclosure (int *t, int *ns_addr, int accset[], int *nacc_addr, int *hv_addr)
230*d9805213SSascha Wildner {
231*d9805213SSascha Wildner int stkpos, ns, tsp;
232*d9805213SSascha Wildner int numstates = *ns_addr, nacc, hashval, transsym, nfaccnum;
233*d9805213SSascha Wildner int stkend, nstate;
234*d9805213SSascha Wildner static int did_stk_init = false, *stk;
235*d9805213SSascha Wildner
236*d9805213SSascha Wildner #define MARK_STATE(state) \
237*d9805213SSascha Wildner do{ trans1[state] = trans1[state] - MARKER_DIFFERENCE;} while(0)
238*d9805213SSascha Wildner
239*d9805213SSascha Wildner #define IS_MARKED(state) (trans1[state] < 0)
240*d9805213SSascha Wildner
241*d9805213SSascha Wildner #define UNMARK_STATE(state) \
242*d9805213SSascha Wildner do{ trans1[state] = trans1[state] + MARKER_DIFFERENCE;} while(0)
243*d9805213SSascha Wildner
244*d9805213SSascha Wildner #define CHECK_ACCEPT(state) \
245*d9805213SSascha Wildner do{ \
246*d9805213SSascha Wildner nfaccnum = accptnum[state]; \
247*d9805213SSascha Wildner if ( nfaccnum != NIL ) \
248*d9805213SSascha Wildner accset[++nacc] = nfaccnum; \
249*d9805213SSascha Wildner }while(0)
250*d9805213SSascha Wildner
251*d9805213SSascha Wildner #define DO_REALLOCATION() \
252*d9805213SSascha Wildner do { \
253*d9805213SSascha Wildner current_max_dfa_size += MAX_DFA_SIZE_INCREMENT; \
254*d9805213SSascha Wildner ++num_reallocs; \
255*d9805213SSascha Wildner t = reallocate_integer_array( t, current_max_dfa_size ); \
256*d9805213SSascha Wildner stk = reallocate_integer_array( stk, current_max_dfa_size ); \
257*d9805213SSascha Wildner }while(0) \
258*d9805213SSascha Wildner
259*d9805213SSascha Wildner #define PUT_ON_STACK(state) \
260*d9805213SSascha Wildner do { \
261*d9805213SSascha Wildner if ( ++stkend >= current_max_dfa_size ) \
262*d9805213SSascha Wildner DO_REALLOCATION(); \
263*d9805213SSascha Wildner stk[stkend] = state; \
264*d9805213SSascha Wildner MARK_STATE(state); \
265*d9805213SSascha Wildner }while(0)
266*d9805213SSascha Wildner
267*d9805213SSascha Wildner #define ADD_STATE(state) \
268*d9805213SSascha Wildner do { \
269*d9805213SSascha Wildner if ( ++numstates >= current_max_dfa_size ) \
270*d9805213SSascha Wildner DO_REALLOCATION(); \
271*d9805213SSascha Wildner t[numstates] = state; \
272*d9805213SSascha Wildner hashval += state; \
273*d9805213SSascha Wildner }while(0)
274*d9805213SSascha Wildner
275*d9805213SSascha Wildner #define STACK_STATE(state) \
276*d9805213SSascha Wildner do { \
277*d9805213SSascha Wildner PUT_ON_STACK(state); \
278*d9805213SSascha Wildner CHECK_ACCEPT(state); \
279*d9805213SSascha Wildner if ( nfaccnum != NIL || transchar[state] != SYM_EPSILON ) \
280*d9805213SSascha Wildner ADD_STATE(state); \
281*d9805213SSascha Wildner }while(0)
282*d9805213SSascha Wildner
283*d9805213SSascha Wildner
284*d9805213SSascha Wildner if (!did_stk_init) {
285*d9805213SSascha Wildner stk = allocate_integer_array (current_max_dfa_size);
286*d9805213SSascha Wildner did_stk_init = true;
287*d9805213SSascha Wildner }
288*d9805213SSascha Wildner
289*d9805213SSascha Wildner nacc = stkend = hashval = 0;
290*d9805213SSascha Wildner
291*d9805213SSascha Wildner for (nstate = 1; nstate <= numstates; ++nstate) {
292*d9805213SSascha Wildner ns = t[nstate];
293*d9805213SSascha Wildner
294*d9805213SSascha Wildner /* The state could be marked if we've already pushed it onto
295*d9805213SSascha Wildner * the stack.
296*d9805213SSascha Wildner */
297*d9805213SSascha Wildner if (!IS_MARKED (ns)) {
298*d9805213SSascha Wildner PUT_ON_STACK (ns);
299*d9805213SSascha Wildner CHECK_ACCEPT (ns);
300*d9805213SSascha Wildner hashval += ns;
301*d9805213SSascha Wildner }
302*d9805213SSascha Wildner }
303*d9805213SSascha Wildner
304*d9805213SSascha Wildner for (stkpos = 1; stkpos <= stkend; ++stkpos) {
305*d9805213SSascha Wildner ns = stk[stkpos];
306*d9805213SSascha Wildner transsym = transchar[ns];
307*d9805213SSascha Wildner
308*d9805213SSascha Wildner if (transsym == SYM_EPSILON) {
309*d9805213SSascha Wildner tsp = trans1[ns] + MARKER_DIFFERENCE;
310*d9805213SSascha Wildner
311*d9805213SSascha Wildner if (tsp != NO_TRANSITION) {
312*d9805213SSascha Wildner if (!IS_MARKED (tsp))
313*d9805213SSascha Wildner STACK_STATE (tsp);
314*d9805213SSascha Wildner
315*d9805213SSascha Wildner tsp = trans2[ns];
316*d9805213SSascha Wildner
317*d9805213SSascha Wildner if (tsp != NO_TRANSITION
318*d9805213SSascha Wildner && !IS_MARKED (tsp))
319*d9805213SSascha Wildner STACK_STATE (tsp);
320*d9805213SSascha Wildner }
321*d9805213SSascha Wildner }
322*d9805213SSascha Wildner }
323*d9805213SSascha Wildner
324*d9805213SSascha Wildner /* Clear out "visit" markers. */
325*d9805213SSascha Wildner
326*d9805213SSascha Wildner for (stkpos = 1; stkpos <= stkend; ++stkpos) {
327*d9805213SSascha Wildner if (IS_MARKED (stk[stkpos]))
328*d9805213SSascha Wildner UNMARK_STATE (stk[stkpos]);
329*d9805213SSascha Wildner else
330*d9805213SSascha Wildner flexfatal (_
331*d9805213SSascha Wildner ("consistency check failed in epsclosure()"));
332*d9805213SSascha Wildner }
333*d9805213SSascha Wildner
334*d9805213SSascha Wildner *ns_addr = numstates;
335*d9805213SSascha Wildner *hv_addr = hashval;
336*d9805213SSascha Wildner *nacc_addr = nacc;
337*d9805213SSascha Wildner
338*d9805213SSascha Wildner return t;
339*d9805213SSascha Wildner }
340*d9805213SSascha Wildner
341*d9805213SSascha Wildner
342*d9805213SSascha Wildner /* increase_max_dfas - increase the maximum number of DFAs */
343*d9805213SSascha Wildner
increase_max_dfas(void)344*d9805213SSascha Wildner void increase_max_dfas (void)
345*d9805213SSascha Wildner {
346*d9805213SSascha Wildner current_max_dfas += MAX_DFAS_INCREMENT;
347*d9805213SSascha Wildner
348*d9805213SSascha Wildner ++num_reallocs;
349*d9805213SSascha Wildner
350*d9805213SSascha Wildner base = reallocate_integer_array (base, current_max_dfas);
351*d9805213SSascha Wildner def = reallocate_integer_array (def, current_max_dfas);
352*d9805213SSascha Wildner dfasiz = reallocate_integer_array (dfasiz, current_max_dfas);
353*d9805213SSascha Wildner accsiz = reallocate_integer_array (accsiz, current_max_dfas);
354*d9805213SSascha Wildner dhash = reallocate_integer_array (dhash, current_max_dfas);
355*d9805213SSascha Wildner dss = reallocate_int_ptr_array (dss, current_max_dfas);
356*d9805213SSascha Wildner dfaacc = reallocate_dfaacc_union (dfaacc, current_max_dfas);
357*d9805213SSascha Wildner
358*d9805213SSascha Wildner if (nultrans)
359*d9805213SSascha Wildner nultrans =
360*d9805213SSascha Wildner reallocate_integer_array (nultrans,
361*d9805213SSascha Wildner current_max_dfas);
362*d9805213SSascha Wildner }
363*d9805213SSascha Wildner
364*d9805213SSascha Wildner
365*d9805213SSascha Wildner /* ntod - convert an ndfa to a dfa
366*d9805213SSascha Wildner *
367*d9805213SSascha Wildner * Creates the dfa corresponding to the ndfa we've constructed. The
368*d9805213SSascha Wildner * dfa starts out in state #1.
369*d9805213SSascha Wildner */
370*d9805213SSascha Wildner
ntod(void)371*d9805213SSascha Wildner void ntod (void)
372*d9805213SSascha Wildner {
373*d9805213SSascha Wildner int *accset, ds, nacc, newds;
374*d9805213SSascha Wildner int sym, hashval, numstates, dsize;
375*d9805213SSascha Wildner int num_full_table_rows=0; /* used only for -f */
376*d9805213SSascha Wildner int *nset, *dset;
377*d9805213SSascha Wildner int targptr, totaltrans, i, comstate, comfreq, targ;
378*d9805213SSascha Wildner int symlist[CSIZE + 1];
379*d9805213SSascha Wildner int num_start_states;
380*d9805213SSascha Wildner int todo_head, todo_next;
381*d9805213SSascha Wildner
382*d9805213SSascha Wildner struct yytbl_data *yynxt_tbl = 0;
383*d9805213SSascha Wildner flex_int32_t *yynxt_data = 0, yynxt_curr = 0;
384*d9805213SSascha Wildner
385*d9805213SSascha Wildner /* Note that the following are indexed by *equivalence classes*
386*d9805213SSascha Wildner * and not by characters. Since equivalence classes are indexed
387*d9805213SSascha Wildner * beginning with 1, even if the scanner accepts NUL's, this
388*d9805213SSascha Wildner * means that (since every character is potentially in its own
389*d9805213SSascha Wildner * equivalence class) these arrays must have room for indices
390*d9805213SSascha Wildner * from 1 to CSIZE, so their size must be CSIZE + 1.
391*d9805213SSascha Wildner */
392*d9805213SSascha Wildner int duplist[CSIZE + 1], state[CSIZE + 1];
393*d9805213SSascha Wildner int targfreq[CSIZE + 1] = {0}, targstate[CSIZE + 1];
394*d9805213SSascha Wildner
395*d9805213SSascha Wildner /* accset needs to be large enough to hold all of the rules present
396*d9805213SSascha Wildner * in the input, *plus* their YY_TRAILING_HEAD_MASK variants.
397*d9805213SSascha Wildner */
398*d9805213SSascha Wildner accset = allocate_integer_array ((num_rules + 1) * 2);
399*d9805213SSascha Wildner nset = allocate_integer_array (current_max_dfa_size);
400*d9805213SSascha Wildner
401*d9805213SSascha Wildner /* The "todo" queue is represented by the head, which is the DFA
402*d9805213SSascha Wildner * state currently being processed, and the "next", which is the
403*d9805213SSascha Wildner * next DFA state number available (not in use). We depend on the
404*d9805213SSascha Wildner * fact that snstods() returns DFA's \in increasing order/, and thus
405*d9805213SSascha Wildner * need only know the bounds of the dfas to be processed.
406*d9805213SSascha Wildner */
407*d9805213SSascha Wildner todo_head = todo_next = 0;
408*d9805213SSascha Wildner
409*d9805213SSascha Wildner for (i = 0; i <= csize; ++i) {
410*d9805213SSascha Wildner duplist[i] = NIL;
411*d9805213SSascha Wildner symlist[i] = false;
412*d9805213SSascha Wildner }
413*d9805213SSascha Wildner
414*d9805213SSascha Wildner for (i = 0; i <= num_rules; ++i)
415*d9805213SSascha Wildner accset[i] = NIL;
416*d9805213SSascha Wildner
417*d9805213SSascha Wildner if (trace) {
418*d9805213SSascha Wildner dumpnfa (scset[1]);
419*d9805213SSascha Wildner fputs (_("\n\nDFA Dump:\n\n"), stderr);
420*d9805213SSascha Wildner }
421*d9805213SSascha Wildner
422*d9805213SSascha Wildner inittbl ();
423*d9805213SSascha Wildner
424*d9805213SSascha Wildner /* Check to see whether we should build a separate table for
425*d9805213SSascha Wildner * transitions on NUL characters. We don't do this for full-speed
426*d9805213SSascha Wildner * (-F) scanners, since for them we don't have a simple state
427*d9805213SSascha Wildner * number lying around with which to index the table. We also
428*d9805213SSascha Wildner * don't bother doing it for scanners unless (1) NUL is in its own
429*d9805213SSascha Wildner * equivalence class (indicated by a positive value of
430*d9805213SSascha Wildner * ecgroup[NUL]), (2) NUL's equivalence class is the last
431*d9805213SSascha Wildner * equivalence class, and (3) the number of equivalence classes is
432*d9805213SSascha Wildner * the same as the number of characters. This latter case comes
433*d9805213SSascha Wildner * about when useecs is false or when it's true but every character
434*d9805213SSascha Wildner * still manages to land in its own class (unlikely, but it's
435*d9805213SSascha Wildner * cheap to check for). If all these things are true then the
436*d9805213SSascha Wildner * character code needed to represent NUL's equivalence class for
437*d9805213SSascha Wildner * indexing the tables is going to take one more bit than the
438*d9805213SSascha Wildner * number of characters, and therefore we won't be assured of
439*d9805213SSascha Wildner * being able to fit it into a YY_CHAR variable. This rules out
440*d9805213SSascha Wildner * storing the transitions in a compressed table, since the code
441*d9805213SSascha Wildner * for interpreting them uses a YY_CHAR variable (perhaps it
442*d9805213SSascha Wildner * should just use an integer, though; this is worth pondering ...
443*d9805213SSascha Wildner * ###).
444*d9805213SSascha Wildner *
445*d9805213SSascha Wildner * Finally, for full tables, we want the number of entries in the
446*d9805213SSascha Wildner * table to be a power of two so the array references go fast (it
447*d9805213SSascha Wildner * will just take a shift to compute the major index). If
448*d9805213SSascha Wildner * encoding NUL's transitions in the table will spoil this, we
449*d9805213SSascha Wildner * give it its own table (note that this will be the case if we're
450*d9805213SSascha Wildner * not using equivalence classes).
451*d9805213SSascha Wildner */
452*d9805213SSascha Wildner
453*d9805213SSascha Wildner /* Note that the test for ecgroup[0] == numecs below accomplishes
454*d9805213SSascha Wildner * both (1) and (2) above
455*d9805213SSascha Wildner */
456*d9805213SSascha Wildner if (!fullspd && ecgroup[0] == numecs) {
457*d9805213SSascha Wildner /* NUL is alone in its equivalence class, which is the
458*d9805213SSascha Wildner * last one.
459*d9805213SSascha Wildner */
460*d9805213SSascha Wildner int use_NUL_table = (numecs == csize);
461*d9805213SSascha Wildner
462*d9805213SSascha Wildner if (fulltbl && !use_NUL_table) {
463*d9805213SSascha Wildner /* We still may want to use the table if numecs
464*d9805213SSascha Wildner * is a power of 2.
465*d9805213SSascha Wildner */
466*d9805213SSascha Wildner if (numecs <= csize && is_power_of_2(numecs)) {
467*d9805213SSascha Wildner use_NUL_table = true;
468*d9805213SSascha Wildner }
469*d9805213SSascha Wildner }
470*d9805213SSascha Wildner
471*d9805213SSascha Wildner if (use_NUL_table)
472*d9805213SSascha Wildner nultrans =
473*d9805213SSascha Wildner allocate_integer_array (current_max_dfas);
474*d9805213SSascha Wildner
475*d9805213SSascha Wildner /* From now on, nultrans != nil indicates that we're
476*d9805213SSascha Wildner * saving null transitions for later, separate encoding.
477*d9805213SSascha Wildner */
478*d9805213SSascha Wildner }
479*d9805213SSascha Wildner
480*d9805213SSascha Wildner
481*d9805213SSascha Wildner if (fullspd) {
482*d9805213SSascha Wildner for (i = 0; i <= numecs; ++i)
483*d9805213SSascha Wildner state[i] = 0;
484*d9805213SSascha Wildner
485*d9805213SSascha Wildner place_state (state, 0, 0);
486*d9805213SSascha Wildner dfaacc[0].dfaacc_state = 0;
487*d9805213SSascha Wildner }
488*d9805213SSascha Wildner
489*d9805213SSascha Wildner else if (fulltbl) {
490*d9805213SSascha Wildner if (nultrans)
491*d9805213SSascha Wildner /* We won't be including NUL's transitions in the
492*d9805213SSascha Wildner * table, so build it for entries from 0 .. numecs - 1.
493*d9805213SSascha Wildner */
494*d9805213SSascha Wildner num_full_table_rows = numecs;
495*d9805213SSascha Wildner
496*d9805213SSascha Wildner else
497*d9805213SSascha Wildner /* Take into account the fact that we'll be including
498*d9805213SSascha Wildner * the NUL entries in the transition table. Build it
499*d9805213SSascha Wildner * from 0 .. numecs.
500*d9805213SSascha Wildner */
501*d9805213SSascha Wildner num_full_table_rows = numecs + 1;
502*d9805213SSascha Wildner
503*d9805213SSascha Wildner /* Begin generating yy_nxt[][]
504*d9805213SSascha Wildner * This spans the entire LONG function.
505*d9805213SSascha Wildner * This table is tricky because we don't know how big it will be.
506*d9805213SSascha Wildner * So we'll have to realloc() on the way...
507*d9805213SSascha Wildner * we'll wait until we can calculate yynxt_tbl->td_hilen.
508*d9805213SSascha Wildner */
509*d9805213SSascha Wildner yynxt_tbl = calloc(1, sizeof (struct yytbl_data));
510*d9805213SSascha Wildner
511*d9805213SSascha Wildner yytbl_data_init (yynxt_tbl, YYTD_ID_NXT);
512*d9805213SSascha Wildner yynxt_tbl->td_hilen = 1;
513*d9805213SSascha Wildner yynxt_tbl->td_lolen = (flex_uint32_t) num_full_table_rows;
514*d9805213SSascha Wildner yynxt_tbl->td_data = yynxt_data =
515*d9805213SSascha Wildner calloc(yynxt_tbl->td_lolen *
516*d9805213SSascha Wildner yynxt_tbl->td_hilen,
517*d9805213SSascha Wildner sizeof (flex_int32_t));
518*d9805213SSascha Wildner yynxt_curr = 0;
519*d9805213SSascha Wildner
520*d9805213SSascha Wildner buf_prints (&yydmap_buf,
521*d9805213SSascha Wildner "\t{YYTD_ID_NXT, (void**)&yy_nxt, sizeof(%s)},\n",
522*d9805213SSascha Wildner long_align ? "flex_int32_t" : "flex_int16_t");
523*d9805213SSascha Wildner
524*d9805213SSascha Wildner /* Unless -Ca, declare it "short" because it's a real
525*d9805213SSascha Wildner * long-shot that that won't be large enough.
526*d9805213SSascha Wildner */
527*d9805213SSascha Wildner if (gentables)
528*d9805213SSascha Wildner out_str_dec
529*d9805213SSascha Wildner ("static const %s yy_nxt[][%d] =\n {\n",
530*d9805213SSascha Wildner long_align ? "flex_int32_t" : "flex_int16_t",
531*d9805213SSascha Wildner num_full_table_rows);
532*d9805213SSascha Wildner else {
533*d9805213SSascha Wildner out_dec ("#undef YY_NXT_LOLEN\n#define YY_NXT_LOLEN (%d)\n", num_full_table_rows);
534*d9805213SSascha Wildner out_str ("static const %s *yy_nxt =0;\n",
535*d9805213SSascha Wildner long_align ? "flex_int32_t" : "flex_int16_t");
536*d9805213SSascha Wildner }
537*d9805213SSascha Wildner
538*d9805213SSascha Wildner
539*d9805213SSascha Wildner if (gentables)
540*d9805213SSascha Wildner outn (" {");
541*d9805213SSascha Wildner
542*d9805213SSascha Wildner /* Generate 0 entries for state #0. */
543*d9805213SSascha Wildner for (i = 0; i < num_full_table_rows; ++i) {
544*d9805213SSascha Wildner mk2data (0);
545*d9805213SSascha Wildner yynxt_data[yynxt_curr++] = 0;
546*d9805213SSascha Wildner }
547*d9805213SSascha Wildner
548*d9805213SSascha Wildner dataflush ();
549*d9805213SSascha Wildner if (gentables)
550*d9805213SSascha Wildner outn (" },\n");
551*d9805213SSascha Wildner }
552*d9805213SSascha Wildner
553*d9805213SSascha Wildner /* Create the first states. */
554*d9805213SSascha Wildner
555*d9805213SSascha Wildner num_start_states = lastsc * 2;
556*d9805213SSascha Wildner
557*d9805213SSascha Wildner for (i = 1; i <= num_start_states; ++i) {
558*d9805213SSascha Wildner numstates = 1;
559*d9805213SSascha Wildner
560*d9805213SSascha Wildner /* For each start condition, make one state for the case when
561*d9805213SSascha Wildner * we're at the beginning of the line (the '^' operator) and
562*d9805213SSascha Wildner * one for the case when we're not.
563*d9805213SSascha Wildner */
564*d9805213SSascha Wildner if (i % 2 == 1)
565*d9805213SSascha Wildner nset[numstates] = scset[(i / 2) + 1];
566*d9805213SSascha Wildner else
567*d9805213SSascha Wildner nset[numstates] =
568*d9805213SSascha Wildner mkbranch (scbol[i / 2], scset[i / 2]);
569*d9805213SSascha Wildner
570*d9805213SSascha Wildner nset = epsclosure (nset, &numstates, accset, &nacc,
571*d9805213SSascha Wildner &hashval);
572*d9805213SSascha Wildner
573*d9805213SSascha Wildner if (snstods (nset, numstates, accset, nacc, hashval, &ds)) {
574*d9805213SSascha Wildner numas += nacc;
575*d9805213SSascha Wildner totnst += numstates;
576*d9805213SSascha Wildner ++todo_next;
577*d9805213SSascha Wildner
578*d9805213SSascha Wildner if (variable_trailing_context_rules && nacc > 0)
579*d9805213SSascha Wildner check_trailing_context (nset, numstates,
580*d9805213SSascha Wildner accset, nacc);
581*d9805213SSascha Wildner }
582*d9805213SSascha Wildner }
583*d9805213SSascha Wildner
584*d9805213SSascha Wildner if (!fullspd) {
585*d9805213SSascha Wildner if (!snstods (nset, 0, accset, 0, 0, &end_of_buffer_state))
586*d9805213SSascha Wildner flexfatal (_
587*d9805213SSascha Wildner ("could not create unique end-of-buffer state"));
588*d9805213SSascha Wildner
589*d9805213SSascha Wildner ++numas;
590*d9805213SSascha Wildner ++num_start_states;
591*d9805213SSascha Wildner ++todo_next;
592*d9805213SSascha Wildner }
593*d9805213SSascha Wildner
594*d9805213SSascha Wildner
595*d9805213SSascha Wildner while (todo_head < todo_next) {
596*d9805213SSascha Wildner targptr = 0;
597*d9805213SSascha Wildner totaltrans = 0;
598*d9805213SSascha Wildner
599*d9805213SSascha Wildner for (i = 1; i <= numecs; ++i)
600*d9805213SSascha Wildner state[i] = 0;
601*d9805213SSascha Wildner
602*d9805213SSascha Wildner ds = ++todo_head;
603*d9805213SSascha Wildner
604*d9805213SSascha Wildner dset = dss[ds];
605*d9805213SSascha Wildner dsize = dfasiz[ds];
606*d9805213SSascha Wildner
607*d9805213SSascha Wildner if (trace)
608*d9805213SSascha Wildner fprintf (stderr, _("state # %d:\n"), ds);
609*d9805213SSascha Wildner
610*d9805213SSascha Wildner sympartition (dset, dsize, symlist, duplist);
611*d9805213SSascha Wildner
612*d9805213SSascha Wildner for (sym = 1; sym <= numecs; ++sym) {
613*d9805213SSascha Wildner if (symlist[sym]) {
614*d9805213SSascha Wildner symlist[sym] = 0;
615*d9805213SSascha Wildner
616*d9805213SSascha Wildner if (duplist[sym] == NIL) {
617*d9805213SSascha Wildner /* Symbol has unique out-transitions. */
618*d9805213SSascha Wildner numstates =
619*d9805213SSascha Wildner symfollowset (dset, dsize,
620*d9805213SSascha Wildner sym, nset);
621*d9805213SSascha Wildner nset = epsclosure (nset,
622*d9805213SSascha Wildner &numstates,
623*d9805213SSascha Wildner accset, &nacc,
624*d9805213SSascha Wildner &hashval);
625*d9805213SSascha Wildner
626*d9805213SSascha Wildner if (snstods
627*d9805213SSascha Wildner (nset, numstates, accset, nacc,
628*d9805213SSascha Wildner hashval, &newds)) {
629*d9805213SSascha Wildner totnst = totnst +
630*d9805213SSascha Wildner numstates;
631*d9805213SSascha Wildner ++todo_next;
632*d9805213SSascha Wildner numas += nacc;
633*d9805213SSascha Wildner
634*d9805213SSascha Wildner if (variable_trailing_context_rules && nacc > 0)
635*d9805213SSascha Wildner check_trailing_context
636*d9805213SSascha Wildner (nset,
637*d9805213SSascha Wildner numstates,
638*d9805213SSascha Wildner accset,
639*d9805213SSascha Wildner nacc);
640*d9805213SSascha Wildner }
641*d9805213SSascha Wildner
642*d9805213SSascha Wildner state[sym] = newds;
643*d9805213SSascha Wildner
644*d9805213SSascha Wildner if (trace)
645*d9805213SSascha Wildner fprintf (stderr,
646*d9805213SSascha Wildner "\t%d\t%d\n", sym,
647*d9805213SSascha Wildner newds);
648*d9805213SSascha Wildner
649*d9805213SSascha Wildner targfreq[++targptr] = 1;
650*d9805213SSascha Wildner targstate[targptr] = newds;
651*d9805213SSascha Wildner ++numuniq;
652*d9805213SSascha Wildner }
653*d9805213SSascha Wildner
654*d9805213SSascha Wildner else {
655*d9805213SSascha Wildner /* sym's equivalence class has the same
656*d9805213SSascha Wildner * transitions as duplist(sym)'s
657*d9805213SSascha Wildner * equivalence class.
658*d9805213SSascha Wildner */
659*d9805213SSascha Wildner targ = state[duplist[sym]];
660*d9805213SSascha Wildner state[sym] = targ;
661*d9805213SSascha Wildner
662*d9805213SSascha Wildner if (trace)
663*d9805213SSascha Wildner fprintf (stderr,
664*d9805213SSascha Wildner "\t%d\t%d\n", sym,
665*d9805213SSascha Wildner targ);
666*d9805213SSascha Wildner
667*d9805213SSascha Wildner /* Update frequency count for
668*d9805213SSascha Wildner * destination state.
669*d9805213SSascha Wildner */
670*d9805213SSascha Wildner
671*d9805213SSascha Wildner i = 0;
672*d9805213SSascha Wildner while (targstate[++i] != targ) ;
673*d9805213SSascha Wildner
674*d9805213SSascha Wildner ++targfreq[i];
675*d9805213SSascha Wildner ++numdup;
676*d9805213SSascha Wildner }
677*d9805213SSascha Wildner
678*d9805213SSascha Wildner ++totaltrans;
679*d9805213SSascha Wildner duplist[sym] = NIL;
680*d9805213SSascha Wildner }
681*d9805213SSascha Wildner }
682*d9805213SSascha Wildner
683*d9805213SSascha Wildner
684*d9805213SSascha Wildner numsnpairs += totaltrans;
685*d9805213SSascha Wildner
686*d9805213SSascha Wildner if (ds > num_start_states)
687*d9805213SSascha Wildner check_for_backing_up (ds, state);
688*d9805213SSascha Wildner
689*d9805213SSascha Wildner if (nultrans) {
690*d9805213SSascha Wildner nultrans[ds] = state[NUL_ec];
691*d9805213SSascha Wildner state[NUL_ec] = 0; /* remove transition */
692*d9805213SSascha Wildner }
693*d9805213SSascha Wildner
694*d9805213SSascha Wildner if (fulltbl) {
695*d9805213SSascha Wildner
696*d9805213SSascha Wildner /* Each time we hit here, it's another td_hilen, so we realloc. */
697*d9805213SSascha Wildner yynxt_tbl->td_hilen++;
698*d9805213SSascha Wildner yynxt_tbl->td_data = yynxt_data =
699*d9805213SSascha Wildner realloc (yynxt_data,
700*d9805213SSascha Wildner yynxt_tbl->td_hilen *
701*d9805213SSascha Wildner yynxt_tbl->td_lolen *
702*d9805213SSascha Wildner sizeof (flex_int32_t));
703*d9805213SSascha Wildner
704*d9805213SSascha Wildner
705*d9805213SSascha Wildner if (gentables)
706*d9805213SSascha Wildner outn (" {");
707*d9805213SSascha Wildner
708*d9805213SSascha Wildner /* Supply array's 0-element. */
709*d9805213SSascha Wildner if (ds == end_of_buffer_state) {
710*d9805213SSascha Wildner mk2data (-end_of_buffer_state);
711*d9805213SSascha Wildner yynxt_data[yynxt_curr++] =
712*d9805213SSascha Wildner -end_of_buffer_state;
713*d9805213SSascha Wildner }
714*d9805213SSascha Wildner else {
715*d9805213SSascha Wildner mk2data (end_of_buffer_state);
716*d9805213SSascha Wildner yynxt_data[yynxt_curr++] =
717*d9805213SSascha Wildner end_of_buffer_state;
718*d9805213SSascha Wildner }
719*d9805213SSascha Wildner
720*d9805213SSascha Wildner for (i = 1; i < num_full_table_rows; ++i) {
721*d9805213SSascha Wildner /* Jams are marked by negative of state
722*d9805213SSascha Wildner * number.
723*d9805213SSascha Wildner */
724*d9805213SSascha Wildner mk2data (state[i] ? state[i] : -ds);
725*d9805213SSascha Wildner yynxt_data[yynxt_curr++] =
726*d9805213SSascha Wildner state[i] ? state[i] : -ds;
727*d9805213SSascha Wildner }
728*d9805213SSascha Wildner
729*d9805213SSascha Wildner dataflush ();
730*d9805213SSascha Wildner if (gentables)
731*d9805213SSascha Wildner outn (" },\n");
732*d9805213SSascha Wildner }
733*d9805213SSascha Wildner
734*d9805213SSascha Wildner else if (fullspd)
735*d9805213SSascha Wildner place_state (state, ds, totaltrans);
736*d9805213SSascha Wildner
737*d9805213SSascha Wildner else if (ds == end_of_buffer_state)
738*d9805213SSascha Wildner /* Special case this state to make sure it does what
739*d9805213SSascha Wildner * it's supposed to, i.e., jam on end-of-buffer.
740*d9805213SSascha Wildner */
741*d9805213SSascha Wildner stack1 (ds, 0, 0, JAMSTATE);
742*d9805213SSascha Wildner
743*d9805213SSascha Wildner else { /* normal, compressed state */
744*d9805213SSascha Wildner
745*d9805213SSascha Wildner /* Determine which destination state is the most
746*d9805213SSascha Wildner * common, and how many transitions to it there are.
747*d9805213SSascha Wildner */
748*d9805213SSascha Wildner
749*d9805213SSascha Wildner comfreq = 0;
750*d9805213SSascha Wildner comstate = 0;
751*d9805213SSascha Wildner
752*d9805213SSascha Wildner for (i = 1; i <= targptr; ++i)
753*d9805213SSascha Wildner if (targfreq[i] > comfreq) {
754*d9805213SSascha Wildner comfreq = targfreq[i];
755*d9805213SSascha Wildner comstate = targstate[i];
756*d9805213SSascha Wildner }
757*d9805213SSascha Wildner
758*d9805213SSascha Wildner bldtbl (state, ds, totaltrans, comstate, comfreq);
759*d9805213SSascha Wildner }
760*d9805213SSascha Wildner }
761*d9805213SSascha Wildner
762*d9805213SSascha Wildner if (fulltbl) {
763*d9805213SSascha Wildner dataend ();
764*d9805213SSascha Wildner if (tablesext) {
765*d9805213SSascha Wildner yytbl_data_compress (yynxt_tbl);
766*d9805213SSascha Wildner if (yytbl_data_fwrite (&tableswr, yynxt_tbl) < 0)
767*d9805213SSascha Wildner flexerror (_
768*d9805213SSascha Wildner ("Could not write yynxt_tbl[][]"));
769*d9805213SSascha Wildner }
770*d9805213SSascha Wildner if (yynxt_tbl) {
771*d9805213SSascha Wildner yytbl_data_destroy (yynxt_tbl);
772*d9805213SSascha Wildner yynxt_tbl = 0;
773*d9805213SSascha Wildner }
774*d9805213SSascha Wildner }
775*d9805213SSascha Wildner
776*d9805213SSascha Wildner else if (!fullspd) {
777*d9805213SSascha Wildner cmptmps (); /* create compressed template entries */
778*d9805213SSascha Wildner
779*d9805213SSascha Wildner /* Create tables for all the states with only one
780*d9805213SSascha Wildner * out-transition.
781*d9805213SSascha Wildner */
782*d9805213SSascha Wildner while (onesp > 0) {
783*d9805213SSascha Wildner mk1tbl (onestate[onesp], onesym[onesp],
784*d9805213SSascha Wildner onenext[onesp], onedef[onesp]);
785*d9805213SSascha Wildner --onesp;
786*d9805213SSascha Wildner }
787*d9805213SSascha Wildner
788*d9805213SSascha Wildner mkdeftbl ();
789*d9805213SSascha Wildner }
790*d9805213SSascha Wildner
791*d9805213SSascha Wildner free(accset);
792*d9805213SSascha Wildner free(nset);
793*d9805213SSascha Wildner }
794*d9805213SSascha Wildner
795*d9805213SSascha Wildner
796*d9805213SSascha Wildner /* snstods - converts a set of ndfa states into a dfa state
797*d9805213SSascha Wildner *
798*d9805213SSascha Wildner * synopsis
799*d9805213SSascha Wildner * is_new_state = snstods( int sns[numstates], int numstates,
800*d9805213SSascha Wildner * int accset[num_rules+1], int nacc,
801*d9805213SSascha Wildner * int hashval, int *newds_addr );
802*d9805213SSascha Wildner *
803*d9805213SSascha Wildner * On return, the dfa state number is in newds.
804*d9805213SSascha Wildner */
805*d9805213SSascha Wildner
snstods(int sns[],int numstates,int accset[],int nacc,int hashval,int * newds_addr)806*d9805213SSascha Wildner int snstods (int sns[], int numstates, int accset[], int nacc, int hashval, int *newds_addr)
807*d9805213SSascha Wildner {
808*d9805213SSascha Wildner int didsort = 0;
809*d9805213SSascha Wildner int i, j;
810*d9805213SSascha Wildner int newds, *oldsns;
811*d9805213SSascha Wildner
812*d9805213SSascha Wildner for (i = 1; i <= lastdfa; ++i)
813*d9805213SSascha Wildner if (hashval == dhash[i]) {
814*d9805213SSascha Wildner if (numstates == dfasiz[i]) {
815*d9805213SSascha Wildner oldsns = dss[i];
816*d9805213SSascha Wildner
817*d9805213SSascha Wildner if (!didsort) {
818*d9805213SSascha Wildner /* We sort the states in sns so we
819*d9805213SSascha Wildner * can compare it to oldsns quickly.
820*d9805213SSascha Wildner */
821*d9805213SSascha Wildner qsort (&sns [1], (size_t) numstates, sizeof (sns [1]), intcmp);
822*d9805213SSascha Wildner didsort = 1;
823*d9805213SSascha Wildner }
824*d9805213SSascha Wildner
825*d9805213SSascha Wildner for (j = 1; j <= numstates; ++j)
826*d9805213SSascha Wildner if (sns[j] != oldsns[j])
827*d9805213SSascha Wildner break;
828*d9805213SSascha Wildner
829*d9805213SSascha Wildner if (j > numstates) {
830*d9805213SSascha Wildner ++dfaeql;
831*d9805213SSascha Wildner *newds_addr = i;
832*d9805213SSascha Wildner return 0;
833*d9805213SSascha Wildner }
834*d9805213SSascha Wildner
835*d9805213SSascha Wildner ++hshcol;
836*d9805213SSascha Wildner }
837*d9805213SSascha Wildner
838*d9805213SSascha Wildner else
839*d9805213SSascha Wildner ++hshsave;
840*d9805213SSascha Wildner }
841*d9805213SSascha Wildner
842*d9805213SSascha Wildner /* Make a new dfa. */
843*d9805213SSascha Wildner
844*d9805213SSascha Wildner if (++lastdfa >= current_max_dfas)
845*d9805213SSascha Wildner increase_max_dfas ();
846*d9805213SSascha Wildner
847*d9805213SSascha Wildner newds = lastdfa;
848*d9805213SSascha Wildner
849*d9805213SSascha Wildner dss[newds] = allocate_integer_array (numstates + 1);
850*d9805213SSascha Wildner
851*d9805213SSascha Wildner /* If we haven't already sorted the states in sns, we do so now,
852*d9805213SSascha Wildner * so that future comparisons with it can be made quickly.
853*d9805213SSascha Wildner */
854*d9805213SSascha Wildner
855*d9805213SSascha Wildner if (!didsort)
856*d9805213SSascha Wildner qsort (&sns [1], (size_t) numstates, sizeof (sns [1]), intcmp);
857*d9805213SSascha Wildner
858*d9805213SSascha Wildner for (i = 1; i <= numstates; ++i)
859*d9805213SSascha Wildner dss[newds][i] = sns[i];
860*d9805213SSascha Wildner
861*d9805213SSascha Wildner dfasiz[newds] = numstates;
862*d9805213SSascha Wildner dhash[newds] = hashval;
863*d9805213SSascha Wildner
864*d9805213SSascha Wildner if (nacc == 0) {
865*d9805213SSascha Wildner if (reject)
866*d9805213SSascha Wildner dfaacc[newds].dfaacc_set = NULL;
867*d9805213SSascha Wildner else
868*d9805213SSascha Wildner dfaacc[newds].dfaacc_state = 0;
869*d9805213SSascha Wildner
870*d9805213SSascha Wildner accsiz[newds] = 0;
871*d9805213SSascha Wildner }
872*d9805213SSascha Wildner
873*d9805213SSascha Wildner else if (reject) {
874*d9805213SSascha Wildner /* We sort the accepting set in increasing order so the
875*d9805213SSascha Wildner * disambiguating rule that the first rule listed is considered
876*d9805213SSascha Wildner * match in the event of ties will work.
877*d9805213SSascha Wildner */
878*d9805213SSascha Wildner
879*d9805213SSascha Wildner qsort (&accset [1], (size_t) nacc, sizeof (accset [1]), intcmp);
880*d9805213SSascha Wildner
881*d9805213SSascha Wildner dfaacc[newds].dfaacc_set =
882*d9805213SSascha Wildner allocate_integer_array (nacc + 1);
883*d9805213SSascha Wildner
884*d9805213SSascha Wildner /* Save the accepting set for later */
885*d9805213SSascha Wildner for (i = 1; i <= nacc; ++i) {
886*d9805213SSascha Wildner dfaacc[newds].dfaacc_set[i] = accset[i];
887*d9805213SSascha Wildner
888*d9805213SSascha Wildner if (accset[i] <= num_rules)
889*d9805213SSascha Wildner /* Who knows, perhaps a REJECT can yield
890*d9805213SSascha Wildner * this rule.
891*d9805213SSascha Wildner */
892*d9805213SSascha Wildner rule_useful[accset[i]] = true;
893*d9805213SSascha Wildner }
894*d9805213SSascha Wildner
895*d9805213SSascha Wildner accsiz[newds] = nacc;
896*d9805213SSascha Wildner }
897*d9805213SSascha Wildner
898*d9805213SSascha Wildner else {
899*d9805213SSascha Wildner /* Find lowest numbered rule so the disambiguating rule
900*d9805213SSascha Wildner * will work.
901*d9805213SSascha Wildner */
902*d9805213SSascha Wildner j = num_rules + 1;
903*d9805213SSascha Wildner
904*d9805213SSascha Wildner for (i = 1; i <= nacc; ++i)
905*d9805213SSascha Wildner if (accset[i] < j)
906*d9805213SSascha Wildner j = accset[i];
907*d9805213SSascha Wildner
908*d9805213SSascha Wildner dfaacc[newds].dfaacc_state = j;
909*d9805213SSascha Wildner
910*d9805213SSascha Wildner if (j <= num_rules)
911*d9805213SSascha Wildner rule_useful[j] = true;
912*d9805213SSascha Wildner }
913*d9805213SSascha Wildner
914*d9805213SSascha Wildner *newds_addr = newds;
915*d9805213SSascha Wildner
916*d9805213SSascha Wildner return 1;
917*d9805213SSascha Wildner }
918*d9805213SSascha Wildner
919*d9805213SSascha Wildner
920*d9805213SSascha Wildner /* symfollowset - follow the symbol transitions one step
921*d9805213SSascha Wildner *
922*d9805213SSascha Wildner * synopsis
923*d9805213SSascha Wildner * numstates = symfollowset( int ds[current_max_dfa_size], int dsize,
924*d9805213SSascha Wildner * int transsym, int nset[current_max_dfa_size] );
925*d9805213SSascha Wildner */
926*d9805213SSascha Wildner
symfollowset(int ds[],int dsize,int transsym,int nset[])927*d9805213SSascha Wildner int symfollowset (int ds[], int dsize, int transsym, int nset[])
928*d9805213SSascha Wildner {
929*d9805213SSascha Wildner int ns, tsp, sym, i, j, lenccl, ch, numstates, ccllist;
930*d9805213SSascha Wildner
931*d9805213SSascha Wildner numstates = 0;
932*d9805213SSascha Wildner
933*d9805213SSascha Wildner for (i = 1; i <= dsize; ++i) { /* for each nfa state ns in the state set of ds */
934*d9805213SSascha Wildner ns = ds[i];
935*d9805213SSascha Wildner sym = transchar[ns];
936*d9805213SSascha Wildner tsp = trans1[ns];
937*d9805213SSascha Wildner
938*d9805213SSascha Wildner if (sym < 0) { /* it's a character class */
939*d9805213SSascha Wildner sym = -sym;
940*d9805213SSascha Wildner ccllist = cclmap[sym];
941*d9805213SSascha Wildner lenccl = ccllen[sym];
942*d9805213SSascha Wildner
943*d9805213SSascha Wildner if (cclng[sym]) {
944*d9805213SSascha Wildner for (j = 0; j < lenccl; ++j) {
945*d9805213SSascha Wildner /* Loop through negated character
946*d9805213SSascha Wildner * class.
947*d9805213SSascha Wildner */
948*d9805213SSascha Wildner ch = ccltbl[ccllist + j];
949*d9805213SSascha Wildner
950*d9805213SSascha Wildner if (ch == 0)
951*d9805213SSascha Wildner ch = NUL_ec;
952*d9805213SSascha Wildner
953*d9805213SSascha Wildner if (ch > transsym)
954*d9805213SSascha Wildner /* Transsym isn't in negated
955*d9805213SSascha Wildner * ccl.
956*d9805213SSascha Wildner */
957*d9805213SSascha Wildner break;
958*d9805213SSascha Wildner
959*d9805213SSascha Wildner else if (ch == transsym)
960*d9805213SSascha Wildner /* next 2 */
961*d9805213SSascha Wildner goto bottom;
962*d9805213SSascha Wildner }
963*d9805213SSascha Wildner
964*d9805213SSascha Wildner /* Didn't find transsym in ccl. */
965*d9805213SSascha Wildner nset[++numstates] = tsp;
966*d9805213SSascha Wildner }
967*d9805213SSascha Wildner
968*d9805213SSascha Wildner else
969*d9805213SSascha Wildner for (j = 0; j < lenccl; ++j) {
970*d9805213SSascha Wildner ch = ccltbl[ccllist + j];
971*d9805213SSascha Wildner
972*d9805213SSascha Wildner if (ch == 0)
973*d9805213SSascha Wildner ch = NUL_ec;
974*d9805213SSascha Wildner
975*d9805213SSascha Wildner if (ch > transsym)
976*d9805213SSascha Wildner break;
977*d9805213SSascha Wildner else if (ch == transsym) {
978*d9805213SSascha Wildner nset[++numstates] = tsp;
979*d9805213SSascha Wildner break;
980*d9805213SSascha Wildner }
981*d9805213SSascha Wildner }
982*d9805213SSascha Wildner }
983*d9805213SSascha Wildner
984*d9805213SSascha Wildner else if (sym == SYM_EPSILON) { /* do nothing */
985*d9805213SSascha Wildner }
986*d9805213SSascha Wildner
987*d9805213SSascha Wildner else if (ABS (ecgroup[sym]) == transsym)
988*d9805213SSascha Wildner nset[++numstates] = tsp;
989*d9805213SSascha Wildner
990*d9805213SSascha Wildner bottom:;
991*d9805213SSascha Wildner }
992*d9805213SSascha Wildner
993*d9805213SSascha Wildner return numstates;
994*d9805213SSascha Wildner }
995*d9805213SSascha Wildner
996*d9805213SSascha Wildner
997*d9805213SSascha Wildner /* sympartition - partition characters with same out-transitions
998*d9805213SSascha Wildner *
999*d9805213SSascha Wildner * synopsis
1000*d9805213SSascha Wildner * sympartition( int ds[current_max_dfa_size], int numstates,
1001*d9805213SSascha Wildner * int symlist[numecs], int duplist[numecs] );
1002*d9805213SSascha Wildner */
1003*d9805213SSascha Wildner
sympartition(int ds[],int numstates,int symlist[],int duplist[])1004*d9805213SSascha Wildner void sympartition (int ds[], int numstates, int symlist[], int duplist[])
1005*d9805213SSascha Wildner {
1006*d9805213SSascha Wildner int tch, i, j, k, ns, dupfwd[CSIZE + 1], lenccl, cclp, ich;
1007*d9805213SSascha Wildner
1008*d9805213SSascha Wildner /* Partitioning is done by creating equivalence classes for those
1009*d9805213SSascha Wildner * characters which have out-transitions from the given state. Thus
1010*d9805213SSascha Wildner * we are really creating equivalence classes of equivalence classes.
1011*d9805213SSascha Wildner */
1012*d9805213SSascha Wildner
1013*d9805213SSascha Wildner for (i = 1; i <= numecs; ++i) { /* initialize equivalence class list */
1014*d9805213SSascha Wildner duplist[i] = i - 1;
1015*d9805213SSascha Wildner dupfwd[i] = i + 1;
1016*d9805213SSascha Wildner }
1017*d9805213SSascha Wildner
1018*d9805213SSascha Wildner duplist[1] = NIL;
1019*d9805213SSascha Wildner dupfwd[numecs] = NIL;
1020*d9805213SSascha Wildner
1021*d9805213SSascha Wildner for (i = 1; i <= numstates; ++i) {
1022*d9805213SSascha Wildner ns = ds[i];
1023*d9805213SSascha Wildner tch = transchar[ns];
1024*d9805213SSascha Wildner
1025*d9805213SSascha Wildner if (tch != SYM_EPSILON) {
1026*d9805213SSascha Wildner if (tch < -lastccl || tch >= csize) {
1027*d9805213SSascha Wildner flexfatal (_
1028*d9805213SSascha Wildner ("bad transition character detected in sympartition()"));
1029*d9805213SSascha Wildner }
1030*d9805213SSascha Wildner
1031*d9805213SSascha Wildner if (tch >= 0) { /* character transition */
1032*d9805213SSascha Wildner int ec = ecgroup[tch];
1033*d9805213SSascha Wildner
1034*d9805213SSascha Wildner mkechar (ec, dupfwd, duplist);
1035*d9805213SSascha Wildner symlist[ec] = 1;
1036*d9805213SSascha Wildner }
1037*d9805213SSascha Wildner
1038*d9805213SSascha Wildner else { /* character class */
1039*d9805213SSascha Wildner tch = -tch;
1040*d9805213SSascha Wildner
1041*d9805213SSascha Wildner lenccl = ccllen[tch];
1042*d9805213SSascha Wildner cclp = cclmap[tch];
1043*d9805213SSascha Wildner mkeccl (ccltbl + cclp, lenccl, dupfwd,
1044*d9805213SSascha Wildner duplist, numecs, NUL_ec);
1045*d9805213SSascha Wildner
1046*d9805213SSascha Wildner if (cclng[tch]) {
1047*d9805213SSascha Wildner j = 0;
1048*d9805213SSascha Wildner
1049*d9805213SSascha Wildner for (k = 0; k < lenccl; ++k) {
1050*d9805213SSascha Wildner ich = ccltbl[cclp + k];
1051*d9805213SSascha Wildner
1052*d9805213SSascha Wildner if (ich == 0)
1053*d9805213SSascha Wildner ich = NUL_ec;
1054*d9805213SSascha Wildner
1055*d9805213SSascha Wildner for (++j; j < ich; ++j)
1056*d9805213SSascha Wildner symlist[j] = 1;
1057*d9805213SSascha Wildner }
1058*d9805213SSascha Wildner
1059*d9805213SSascha Wildner for (++j; j <= numecs; ++j)
1060*d9805213SSascha Wildner symlist[j] = 1;
1061*d9805213SSascha Wildner }
1062*d9805213SSascha Wildner
1063*d9805213SSascha Wildner else
1064*d9805213SSascha Wildner for (k = 0; k < lenccl; ++k) {
1065*d9805213SSascha Wildner ich = ccltbl[cclp + k];
1066*d9805213SSascha Wildner
1067*d9805213SSascha Wildner if (ich == 0)
1068*d9805213SSascha Wildner ich = NUL_ec;
1069*d9805213SSascha Wildner
1070*d9805213SSascha Wildner symlist[ich] = 1;
1071*d9805213SSascha Wildner }
1072*d9805213SSascha Wildner }
1073*d9805213SSascha Wildner }
1074*d9805213SSascha Wildner }
1075*d9805213SSascha Wildner }
1076