50 |
static short *shiftset = NULL; |
static short *shiftset = NULL; |
51 |
|
|
52 |
static short **kernel_base = NULL; |
static short **kernel_base = NULL; |
53 |
static short **kernel_end = NULL; |
static size_t *kernel_size = NULL; |
54 |
static short *kernel_items = NULL; |
static short *kernel_items = NULL; |
55 |
|
|
56 |
/* hash table for states, to recognize equivalent ones. */ |
/* hash table for states, to recognize equivalent ones. */ |
94 |
} |
} |
95 |
|
|
96 |
shift_symbol = symbol_count; |
shift_symbol = symbol_count; |
97 |
kernel_end = XCALLOC (short *, nsyms); |
kernel_size = XCALLOC (size_t, nsyms); |
98 |
} |
} |
99 |
|
|
100 |
|
|
116 |
XFREE (redset); |
XFREE (redset); |
117 |
XFREE (shiftset); |
XFREE (shiftset); |
118 |
XFREE (kernel_base); |
XFREE (kernel_base); |
119 |
XFREE (kernel_end); |
XFREE (kernel_size); |
120 |
XFREE (kernel_items); |
XFREE (kernel_items); |
121 |
XFREE (state_table); |
XFREE (state_table); |
122 |
} |
} |
132 |
| shift_symbol is set to a vector of the symbols that can be | |
| shift_symbol is set to a vector of the symbols that can be | |
133 |
| shifted. For each symbol in the grammar, kernel_base[symbol] | |
| shifted. For each symbol in the grammar, kernel_base[symbol] | |
134 |
| points to a vector of item numbers activated if that symbol is | |
| points to a vector of item numbers activated if that symbol is | |
135 |
| shifted, and kernel_end[symbol] points after the end of that | |
| shifted, and kernel_size[symbol] is their numbers. | |
|
| vector. | |
|
136 |
`----------------------------------------------------------------*/ |
`----------------------------------------------------------------*/ |
137 |
|
|
138 |
static void |
static void |
146 |
this_state->number); |
this_state->number); |
147 |
|
|
148 |
for (i = 0; i < nsyms; i++) |
for (i = 0; i < nsyms; i++) |
149 |
kernel_end[i] = NULL; |
kernel_size[i] = 0; |
150 |
|
|
151 |
shiftcount = 0; |
shiftcount = 0; |
152 |
|
|
155 |
int symbol = ritem[itemset[i]]; |
int symbol = ritem[itemset[i]]; |
156 |
if (symbol > 0) |
if (symbol > 0) |
157 |
{ |
{ |
158 |
short *ksp = kernel_end[symbol]; |
if (!kernel_size[symbol]) |
|
|
|
|
if (!ksp) |
|
159 |
{ |
{ |
160 |
shift_symbol[shiftcount] = symbol; |
shift_symbol[shiftcount] = symbol; |
|
ksp = kernel_base[symbol]; |
|
161 |
shiftcount++; |
shiftcount++; |
162 |
} |
} |
163 |
|
|
164 |
*ksp++ = itemset[i] + 1; |
kernel_base[symbol][kernel_size[symbol]] = itemset[i] + 1; |
165 |
kernel_end[symbol] = ksp; |
kernel_size[symbol]++; |
166 |
} |
} |
167 |
} |
} |
168 |
|
|
179 |
static core * |
static core * |
180 |
new_state (int symbol) |
new_state (int symbol) |
181 |
{ |
{ |
|
int n; |
|
182 |
core *p; |
core *p; |
183 |
|
|
184 |
if (trace_flag) |
if (trace_flag) |
188 |
if (nstates >= MAXSHORT) |
if (nstates >= MAXSHORT) |
189 |
fatal (_("too many states (max %d)"), MAXSHORT); |
fatal (_("too many states (max %d)"), MAXSHORT); |
190 |
|
|
191 |
n = kernel_end[symbol] - kernel_base[symbol]; |
p = CORE_ALLOC (kernel_size[symbol]); |
|
|
|
|
p = CORE_ALLOC (n); |
|
192 |
p->accessing_symbol = symbol; |
p->accessing_symbol = symbol; |
193 |
p->number = nstates; |
p->number = nstates; |
194 |
p->nitems = n; |
p->nitems = kernel_size[symbol]; |
195 |
|
|
196 |
shortcpy (p->items, kernel_base[symbol], n); |
shortcpy (p->items, kernel_base[symbol], kernel_size[symbol]); |
197 |
|
|
198 |
last_state->next = p; |
last_state->next = p; |
199 |
last_state = p; |
last_state = p; |
217 |
int i; |
int i; |
218 |
core *sp; |
core *sp; |
219 |
|
|
|
int n = kernel_end[symbol] - kernel_base[symbol]; |
|
|
|
|
220 |
if (trace_flag) |
if (trace_flag) |
221 |
fprintf (stderr, "Entering get_state, state = %d, symbol = %d (%s)\n", |
fprintf (stderr, "Entering get_state, state = %d, symbol = %d (%s)\n", |
222 |
this_state->number, symbol, tags[symbol]); |
this_state->number, symbol, tags[symbol]); |
224 |
/* Add up the target state's active item numbers to get a hash key. |
/* Add up the target state's active item numbers to get a hash key. |
225 |
*/ |
*/ |
226 |
key = 0; |
key = 0; |
227 |
for (i = 0; i < n; ++i) |
for (i = 0; i < kernel_size[symbol]; ++i) |
228 |
key += kernel_base[symbol][i]; |
key += kernel_base[symbol][i]; |
229 |
key = key % STATE_TABLE_SIZE; |
key = key % STATE_TABLE_SIZE; |
230 |
sp = state_table[key]; |
sp = state_table[key]; |
234 |
int found = 0; |
int found = 0; |
235 |
while (!found) |
while (!found) |
236 |
{ |
{ |
237 |
if (sp->nitems == n) |
if (sp->nitems == kernel_size[symbol]) |
238 |
{ |
{ |
239 |
int i; |
int i; |
240 |
found = 1; |
found = 1; |
241 |
for (i = 0; i < n; ++i) |
for (i = 0; i < kernel_size[symbol]; ++i) |
242 |
if (kernel_base[symbol][i] != sp->items[i]) |
if (kernel_base[symbol][i] != sp->items[i]) |
243 |
found = 0; |
found = 0; |
244 |
} |
} |