1 |
/* gen - actual generation (writing) of flex scanners */ |
2 |
|
3 |
/* Copyright (c) 1990 The Regents of the University of California. */ |
4 |
/* All rights reserved. */ |
5 |
|
6 |
/* This code is derived from software contributed to Berkeley by */ |
7 |
/* Vern Paxson. */ |
8 |
|
9 |
/* The United States Government has rights in this work pursuant */ |
10 |
/* to contract no. DE-AC03-76SF00098 between the United States */ |
11 |
/* Department of Energy and the University of California. */ |
12 |
|
13 |
/* This file is part of flex. */ |
14 |
|
15 |
/* Redistribution and use in source and binary forms, with or without */ |
16 |
/* modification, are permitted provided that the following conditions */ |
17 |
/* are met: */ |
18 |
|
19 |
/* 1. Redistributions of source code must retain the above copyright */ |
20 |
/* notice, this list of conditions and the following disclaimer. */ |
21 |
/* 2. Redistributions in binary form must reproduce the above copyright */ |
22 |
/* notice, this list of conditions and the following disclaimer in the */ |
23 |
/* documentation and/or other materials provided with the distribution. */ |
24 |
|
25 |
/* Neither the name of the University nor the names of its contributors */ |
26 |
/* may be used to endorse or promote products derived from this software */ |
27 |
/* without specific prior written permission. */ |
28 |
|
29 |
/* THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR */ |
30 |
/* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED */ |
31 |
/* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR */ |
32 |
/* PURPOSE. */ |
33 |
|
34 |
#include "flexdef.h" |
35 |
#include "tables.h" |
36 |
|
37 |
|
38 |
/* declare functions that have forward references */ |
39 |
|
40 |
void gen_next_state PROTO ((int)); |
41 |
void genecs PROTO ((void)); |
42 |
void indent_put2s PROTO ((const char *, const char *)); |
43 |
void indent_puts PROTO ((const char *)); |
44 |
|
45 |
|
46 |
static int indent_level = 0; /* each level is 8 spaces */ |
47 |
|
48 |
#define indent_up() (++indent_level) |
49 |
#define indent_down() (--indent_level) |
50 |
#define set_indent(indent_val) indent_level = indent_val |
51 |
|
52 |
/* Almost everything is done in terms of arrays starting at 1, so provide |
53 |
* a null entry for the zero element of all C arrays. (The exception |
54 |
* to this is that the fast table representation generally uses the |
55 |
* 0 elements of its arrays, too.) |
56 |
*/ |
57 |
|
58 |
static const char *get_int16_decl (void) |
59 |
{ |
60 |
return (gentables) |
61 |
? "static yyconst flex_int16_t %s[%d] =\n { 0,\n" |
62 |
: "static yyconst flex_int16_t * %s = 0;\n"; |
63 |
} |
64 |
|
65 |
|
66 |
static const char *get_int32_decl (void) |
67 |
{ |
68 |
return (gentables) |
69 |
? "static yyconst flex_int32_t %s[%d] =\n { 0,\n" |
70 |
: "static yyconst flex_int32_t * %s = 0;\n"; |
71 |
} |
72 |
|
73 |
static const char *get_state_decl (void) |
74 |
{ |
75 |
return (gentables) |
76 |
? "static yyconst yy_state_type %s[%d] =\n { 0,\n" |
77 |
: "static yyconst yy_state_type * %s = 0;\n"; |
78 |
} |
79 |
|
80 |
/* Indent to the current level. */ |
81 |
|
82 |
void do_indent () |
83 |
{ |
84 |
register int i = indent_level * 8; |
85 |
|
86 |
while (i >= 8) { |
87 |
outc ('\t'); |
88 |
i -= 8; |
89 |
} |
90 |
|
91 |
while (i > 0) { |
92 |
outc (' '); |
93 |
--i; |
94 |
} |
95 |
} |
96 |
|
97 |
|
98 |
/** Make the table for possible eol matches. |
99 |
* @return the newly allocated rule_can_match_eol table |
100 |
*/ |
101 |
static struct yytbl_data *mkeoltbl (void) |
102 |
{ |
103 |
int i; |
104 |
flex_int8_t *tdata = 0; |
105 |
struct yytbl_data *tbl; |
106 |
|
107 |
tbl = (struct yytbl_data *) calloc (1, sizeof (struct yytbl_data)); |
108 |
yytbl_data_init (tbl, YYTD_ID_RULE_CAN_MATCH_EOL); |
109 |
tbl->td_flags = YYTD_DATA8; |
110 |
tbl->td_lolen = num_rules + 1; |
111 |
tbl->td_data = tdata = |
112 |
(flex_int8_t *) calloc (tbl->td_lolen, sizeof (flex_int8_t)); |
113 |
|
114 |
for (i = 1; i <= num_rules; i++) |
115 |
tdata[i] = rule_has_nl[i] ? 1 : 0; |
116 |
|
117 |
buf_prints (&yydmap_buf, |
118 |
"\t{YYTD_ID_RULE_CAN_MATCH_EOL, (void**)&yy_rule_can_match_eol, sizeof(%s)},\n", |
119 |
"flex_int32_t"); |
120 |
return tbl; |
121 |
} |
122 |
|
123 |
/* Generate the table for possible eol matches. */ |
124 |
static void geneoltbl () |
125 |
{ |
126 |
int i; |
127 |
|
128 |
outn ("m4_ifdef( [[M4_YY_USE_LINENO]],[["); |
129 |
outn ("/* Table of booleans, true if rule could match eol. */"); |
130 |
out_str_dec (get_int32_decl (), "yy_rule_can_match_eol", |
131 |
num_rules + 1); |
132 |
|
133 |
if (gentables) { |
134 |
for (i = 1; i <= num_rules; i++) { |
135 |
out_dec ("%d, ", rule_has_nl[i] ? 1 : 0); |
136 |
/* format nicely, 20 numbers per line. */ |
137 |
if ((i % 20) == 19) |
138 |
out ("\n "); |
139 |
} |
140 |
out (" };\n"); |
141 |
} |
142 |
outn ("]])"); |
143 |
} |
144 |
|
145 |
|
146 |
/* Generate the code to keep backing-up information. */ |
147 |
|
148 |
void gen_backing_up () |
149 |
{ |
150 |
if (reject || num_backing_up == 0) |
151 |
return; |
152 |
|
153 |
if (fullspd) |
154 |
indent_puts ("if ( yy_current_state[-1].yy_nxt )"); |
155 |
else |
156 |
indent_puts ("if ( yy_accept[yy_current_state] )"); |
157 |
|
158 |
indent_up (); |
159 |
indent_puts ("{"); |
160 |
indent_puts ("YY_G(yy_last_accepting_state) = yy_current_state;"); |
161 |
indent_puts ("YY_G(yy_last_accepting_cpos) = yy_cp;"); |
162 |
indent_puts ("}"); |
163 |
indent_down (); |
164 |
} |
165 |
|
166 |
|
167 |
/* Generate the code to perform the backing up. */ |
168 |
|
169 |
void gen_bu_action () |
170 |
{ |
171 |
if (reject || num_backing_up == 0) |
172 |
return; |
173 |
|
174 |
set_indent (3); |
175 |
|
176 |
indent_puts ("case 0: /* must back up */"); |
177 |
indent_puts ("/* undo the effects of YY_DO_BEFORE_ACTION */"); |
178 |
indent_puts ("*yy_cp = YY_G(yy_hold_char);"); |
179 |
|
180 |
if (fullspd || fulltbl) |
181 |
indent_puts ("yy_cp = YY_G(yy_last_accepting_cpos) + 1;"); |
182 |
else |
183 |
/* Backing-up info for compressed tables is taken \after/ |
184 |
* yy_cp has been incremented for the next state. |
185 |
*/ |
186 |
indent_puts ("yy_cp = YY_G(yy_last_accepting_cpos);"); |
187 |
|
188 |
indent_puts ("yy_current_state = YY_G(yy_last_accepting_state);"); |
189 |
indent_puts ("goto yy_find_action;"); |
190 |
outc ('\n'); |
191 |
|
192 |
set_indent (0); |
193 |
} |
194 |
|
195 |
/** mkctbl - make full speed compressed transition table |
196 |
* This is an array of structs; each struct a pair of integers. |
197 |
* You should call mkssltbl() immediately after this. |
198 |
* Then, I think, mkecstbl(). Arrrg. |
199 |
* @return the newly allocated trans table |
200 |
*/ |
201 |
|
202 |
static struct yytbl_data *mkctbl (void) |
203 |
{ |
204 |
register int i; |
205 |
struct yytbl_data *tbl = 0; |
206 |
flex_int32_t *tdata = 0, curr = 0; |
207 |
int end_of_buffer_action = num_rules + 1; |
208 |
|
209 |
buf_prints (&yydmap_buf, |
210 |
"\t{YYTD_ID_TRANSITION, (void**)&yy_transition, sizeof(%s)},\n", |
211 |
((tblend + numecs + 1) >= INT16_MAX |
212 |
|| long_align) ? "flex_int32_t" : "flex_int16_t"); |
213 |
|
214 |
tbl = (struct yytbl_data *) calloc (1, sizeof (struct yytbl_data)); |
215 |
yytbl_data_init (tbl, YYTD_ID_TRANSITION); |
216 |
tbl->td_flags = YYTD_DATA32 | YYTD_STRUCT; |
217 |
tbl->td_hilen = 0; |
218 |
tbl->td_lolen = tblend + numecs + 1; /* number of structs */ |
219 |
|
220 |
tbl->td_data = tdata = |
221 |
(flex_int32_t *) calloc (tbl->td_lolen * 2, sizeof (flex_int32_t)); |
222 |
|
223 |
/* We want the transition to be represented as the offset to the |
224 |
* next state, not the actual state number, which is what it currently |
225 |
* is. The offset is base[nxt[i]] - (base of current state)]. That's |
226 |
* just the difference between the starting points of the two involved |
227 |
* states (to - from). |
228 |
* |
229 |
* First, though, we need to find some way to put in our end-of-buffer |
230 |
* flags and states. We do this by making a state with absolutely no |
231 |
* transitions. We put it at the end of the table. |
232 |
*/ |
233 |
|
234 |
/* We need to have room in nxt/chk for two more slots: One for the |
235 |
* action and one for the end-of-buffer transition. We now *assume* |
236 |
* that we're guaranteed the only character we'll try to index this |
237 |
* nxt/chk pair with is EOB, i.e., 0, so we don't have to make sure |
238 |
* there's room for jam entries for other characters. |
239 |
*/ |
240 |
|
241 |
while (tblend + 2 >= current_max_xpairs) |
242 |
expand_nxt_chk (); |
243 |
|
244 |
while (lastdfa + 1 >= current_max_dfas) |
245 |
increase_max_dfas (); |
246 |
|
247 |
base[lastdfa + 1] = tblend + 2; |
248 |
nxt[tblend + 1] = end_of_buffer_action; |
249 |
chk[tblend + 1] = numecs + 1; |
250 |
chk[tblend + 2] = 1; /* anything but EOB */ |
251 |
|
252 |
/* So that "make test" won't show arb. differences. */ |
253 |
nxt[tblend + 2] = 0; |
254 |
|
255 |
/* Make sure every state has an end-of-buffer transition and an |
256 |
* action #. |
257 |
*/ |
258 |
for (i = 0; i <= lastdfa; ++i) { |
259 |
int anum = dfaacc[i].dfaacc_state; |
260 |
int offset = base[i]; |
261 |
|
262 |
chk[offset] = EOB_POSITION; |
263 |
chk[offset - 1] = ACTION_POSITION; |
264 |
nxt[offset - 1] = anum; /* action number */ |
265 |
} |
266 |
|
267 |
for (i = 0; i <= tblend; ++i) { |
268 |
if (chk[i] == EOB_POSITION) { |
269 |
tdata[curr++] = 0; |
270 |
tdata[curr++] = base[lastdfa + 1] - i; |
271 |
} |
272 |
|
273 |
else if (chk[i] == ACTION_POSITION) { |
274 |
tdata[curr++] = 0; |
275 |
tdata[curr++] = nxt[i]; |
276 |
} |
277 |
|
278 |
else if (chk[i] > numecs || chk[i] == 0) { |
279 |
tdata[curr++] = 0; |
280 |
tdata[curr++] = 0; |
281 |
} |
282 |
else { /* verify, transition */ |
283 |
|
284 |
tdata[curr++] = chk[i]; |
285 |
tdata[curr++] = base[nxt[i]] - (i - chk[i]); |
286 |
} |
287 |
} |
288 |
|
289 |
|
290 |
/* Here's the final, end-of-buffer state. */ |
291 |
tdata[curr++] = chk[tblend + 1]; |
292 |
tdata[curr++] = nxt[tblend + 1]; |
293 |
|
294 |
tdata[curr++] = chk[tblend + 2]; |
295 |
tdata[curr++] = nxt[tblend + 2]; |
296 |
|
297 |
return tbl; |
298 |
} |
299 |
|
300 |
|
301 |
/** Make start_state_list table. |
302 |
* @return the newly allocated start_state_list table |
303 |
*/ |
304 |
static struct yytbl_data *mkssltbl (void) |
305 |
{ |
306 |
struct yytbl_data *tbl = 0; |
307 |
flex_int32_t *tdata = 0; |
308 |
flex_int32_t i; |
309 |
|
310 |
tbl = (struct yytbl_data *) calloc (1, sizeof (struct yytbl_data)); |
311 |
yytbl_data_init (tbl, YYTD_ID_START_STATE_LIST); |
312 |
tbl->td_flags = YYTD_DATA32 | YYTD_PTRANS; |
313 |
tbl->td_hilen = 0; |
314 |
tbl->td_lolen = lastsc * 2 + 1; |
315 |
|
316 |
tbl->td_data = tdata = |
317 |
(flex_int32_t *) calloc (tbl->td_lolen, sizeof (flex_int32_t)); |
318 |
|
319 |
for (i = 0; i <= lastsc * 2; ++i) |
320 |
tdata[i] = base[i]; |
321 |
|
322 |
buf_prints (&yydmap_buf, |
323 |
"\t{YYTD_ID_START_STATE_LIST, (void**)&yy_start_state_list, sizeof(%s)},\n", |
324 |
"struct yy_trans_info*"); |
325 |
|
326 |
return tbl; |
327 |
} |
328 |
|
329 |
|
330 |
|
331 |
/* genctbl - generates full speed compressed transition table */ |
332 |
|
333 |
void genctbl () |
334 |
{ |
335 |
register int i; |
336 |
int end_of_buffer_action = num_rules + 1; |
337 |
|
338 |
/* Table of verify for transition and offset to next state. */ |
339 |
if (gentables) |
340 |
out_dec ("static yyconst struct yy_trans_info yy_transition[%d] =\n {\n", tblend + numecs + 1); |
341 |
else |
342 |
outn ("static yyconst struct yy_trans_info *yy_transition = 0;"); |
343 |
|
344 |
/* We want the transition to be represented as the offset to the |
345 |
* next state, not the actual state number, which is what it currently |
346 |
* is. The offset is base[nxt[i]] - (base of current state)]. That's |
347 |
* just the difference between the starting points of the two involved |
348 |
* states (to - from). |
349 |
* |
350 |
* First, though, we need to find some way to put in our end-of-buffer |
351 |
* flags and states. We do this by making a state with absolutely no |
352 |
* transitions. We put it at the end of the table. |
353 |
*/ |
354 |
|
355 |
/* We need to have room in nxt/chk for two more slots: One for the |
356 |
* action and one for the end-of-buffer transition. We now *assume* |
357 |
* that we're guaranteed the only character we'll try to index this |
358 |
* nxt/chk pair with is EOB, i.e., 0, so we don't have to make sure |
359 |
* there's room for jam entries for other characters. |
360 |
*/ |
361 |
|
362 |
while (tblend + 2 >= current_max_xpairs) |
363 |
expand_nxt_chk (); |
364 |
|
365 |
while (lastdfa + 1 >= current_max_dfas) |
366 |
increase_max_dfas (); |
367 |
|
368 |
base[lastdfa + 1] = tblend + 2; |
369 |
nxt[tblend + 1] = end_of_buffer_action; |
370 |
chk[tblend + 1] = numecs + 1; |
371 |
chk[tblend + 2] = 1; /* anything but EOB */ |
372 |
|
373 |
/* So that "make test" won't show arb. differences. */ |
374 |
nxt[tblend + 2] = 0; |
375 |
|
376 |
/* Make sure every state has an end-of-buffer transition and an |
377 |
* action #. |
378 |
*/ |
379 |
for (i = 0; i <= lastdfa; ++i) { |
380 |
int anum = dfaacc[i].dfaacc_state; |
381 |
int offset = base[i]; |
382 |
|
383 |
chk[offset] = EOB_POSITION; |
384 |
chk[offset - 1] = ACTION_POSITION; |
385 |
nxt[offset - 1] = anum; /* action number */ |
386 |
} |
387 |
|
388 |
for (i = 0; i <= tblend; ++i) { |
389 |
if (chk[i] == EOB_POSITION) |
390 |
transition_struct_out (0, base[lastdfa + 1] - i); |
391 |
|
392 |
else if (chk[i] == ACTION_POSITION) |
393 |
transition_struct_out (0, nxt[i]); |
394 |
|
395 |
else if (chk[i] > numecs || chk[i] == 0) |
396 |
transition_struct_out (0, 0); /* unused slot */ |
397 |
|
398 |
else /* verify, transition */ |
399 |
transition_struct_out (chk[i], |
400 |
base[nxt[i]] - (i - |
401 |
chk[i])); |
402 |
} |
403 |
|
404 |
|
405 |
/* Here's the final, end-of-buffer state. */ |
406 |
transition_struct_out (chk[tblend + 1], nxt[tblend + 1]); |
407 |
transition_struct_out (chk[tblend + 2], nxt[tblend + 2]); |
408 |
|
409 |
if (gentables) |
410 |
outn (" };\n"); |
411 |
|
412 |
/* Table of pointers to start states. */ |
413 |
if (gentables) |
414 |
out_dec ("static yyconst struct yy_trans_info *yy_start_state_list[%d] =\n", lastsc * 2 + 1); |
415 |
else |
416 |
outn ("static yyconst struct yy_trans_info **yy_start_state_list =0;"); |
417 |
|
418 |
if (gentables) { |
419 |
outn (" {"); |
420 |
|
421 |
for (i = 0; i <= lastsc * 2; ++i) |
422 |
out_dec (" &yy_transition[%d],\n", base[i]); |
423 |
|
424 |
dataend (); |
425 |
} |
426 |
|
427 |
if (useecs) |
428 |
genecs (); |
429 |
} |
430 |
|
431 |
|
432 |
/* mkecstbl - Make equivalence-class tables. */ |
433 |
|
434 |
struct yytbl_data *mkecstbl (void) |
435 |
{ |
436 |
register int i; |
437 |
struct yytbl_data *tbl = 0; |
438 |
flex_int32_t *tdata = 0; |
439 |
|
440 |
tbl = (struct yytbl_data *) calloc (1, sizeof (struct yytbl_data)); |
441 |
yytbl_data_init (tbl, YYTD_ID_EC); |
442 |
tbl->td_flags |= YYTD_DATA32; |
443 |
tbl->td_hilen = 0; |
444 |
tbl->td_lolen = csize; |
445 |
|
446 |
tbl->td_data = tdata = |
447 |
(flex_int32_t *) calloc (tbl->td_lolen, sizeof (flex_int32_t)); |
448 |
|
449 |
for (i = 1; i < csize; ++i) { |
450 |
ecgroup[i] = ABS (ecgroup[i]); |
451 |
tdata[i] = ecgroup[i]; |
452 |
} |
453 |
|
454 |
buf_prints (&yydmap_buf, |
455 |
"\t{YYTD_ID_EC, (void**)&yy_ec, sizeof(%s)},\n", |
456 |
"flex_int32_t"); |
457 |
|
458 |
return tbl; |
459 |
} |
460 |
|
461 |
/* Generate equivalence-class tables. */ |
462 |
|
463 |
void genecs () |
464 |
{ |
465 |
register int i, j; |
466 |
int numrows; |
467 |
|
468 |
out_str_dec (get_int32_decl (), "yy_ec", csize); |
469 |
|
470 |
for (i = 1; i < csize; ++i) { |
471 |
ecgroup[i] = ABS (ecgroup[i]); |
472 |
mkdata (ecgroup[i]); |
473 |
} |
474 |
|
475 |
dataend (); |
476 |
|
477 |
if (trace) { |
478 |
fputs (_("\n\nEquivalence Classes:\n\n"), stderr); |
479 |
|
480 |
numrows = csize / 8; |
481 |
|
482 |
for (j = 0; j < numrows; ++j) { |
483 |
for (i = j; i < csize; i = i + numrows) { |
484 |
fprintf (stderr, "%4s = %-2d", |
485 |
readable_form (i), ecgroup[i]); |
486 |
|
487 |
putc (' ', stderr); |
488 |
} |
489 |
|
490 |
putc ('\n', stderr); |
491 |
} |
492 |
} |
493 |
} |
494 |
|
495 |
|
496 |
/* Generate the code to find the action number. */ |
497 |
|
498 |
void gen_find_action () |
499 |
{ |
500 |
if (fullspd) |
501 |
indent_puts ("yy_act = yy_current_state[-1].yy_nxt;"); |
502 |
|
503 |
else if (fulltbl) |
504 |
indent_puts ("yy_act = yy_accept[yy_current_state];"); |
505 |
|
506 |
else if (reject) { |
507 |
indent_puts ("yy_current_state = *--YY_G(yy_state_ptr);"); |
508 |
indent_puts ("YY_G(yy_lp) = yy_accept[yy_current_state];"); |
509 |
|
510 |
outn ("find_rule: /* we branch to this label when backing up */"); |
511 |
|
512 |
indent_puts |
513 |
("for ( ; ; ) /* until we find what rule we matched */"); |
514 |
|
515 |
indent_up (); |
516 |
|
517 |
indent_puts ("{"); |
518 |
|
519 |
indent_puts |
520 |
("if ( YY_G(yy_lp) && YY_G(yy_lp) < yy_accept[yy_current_state + 1] )"); |
521 |
indent_up (); |
522 |
indent_puts ("{"); |
523 |
indent_puts ("yy_act = yy_acclist[YY_G(yy_lp)];"); |
524 |
|
525 |
if (variable_trailing_context_rules) { |
526 |
indent_puts |
527 |
("if ( yy_act & YY_TRAILING_HEAD_MASK ||"); |
528 |
indent_puts (" YY_G(yy_looking_for_trail_begin) )"); |
529 |
indent_up (); |
530 |
indent_puts ("{"); |
531 |
|
532 |
indent_puts |
533 |
("if ( yy_act == YY_G(yy_looking_for_trail_begin) )"); |
534 |
indent_up (); |
535 |
indent_puts ("{"); |
536 |
indent_puts ("YY_G(yy_looking_for_trail_begin) = 0;"); |
537 |
indent_puts ("yy_act &= ~YY_TRAILING_HEAD_MASK;"); |
538 |
indent_puts ("break;"); |
539 |
indent_puts ("}"); |
540 |
indent_down (); |
541 |
|
542 |
indent_puts ("}"); |
543 |
indent_down (); |
544 |
|
545 |
indent_puts |
546 |
("else if ( yy_act & YY_TRAILING_MASK )"); |
547 |
indent_up (); |
548 |
indent_puts ("{"); |
549 |
indent_puts |
550 |
("YY_G(yy_looking_for_trail_begin) = yy_act & ~YY_TRAILING_MASK;"); |
551 |
indent_puts |
552 |
("YY_G(yy_looking_for_trail_begin) |= YY_TRAILING_HEAD_MASK;"); |
553 |
|
554 |
if (real_reject) { |
555 |
/* Remember matched text in case we back up |
556 |
* due to REJECT. |
557 |
*/ |
558 |
indent_puts |
559 |
("YY_G(yy_full_match) = yy_cp;"); |
560 |
indent_puts |
561 |
("YY_G(yy_full_state) = YY_G(yy_state_ptr);"); |
562 |
indent_puts ("YY_G(yy_full_lp) = YY_G(yy_lp);"); |
563 |
} |
564 |
|
565 |
indent_puts ("}"); |
566 |
indent_down (); |
567 |
|
568 |
indent_puts ("else"); |
569 |
indent_up (); |
570 |
indent_puts ("{"); |
571 |
indent_puts ("YY_G(yy_full_match) = yy_cp;"); |
572 |
indent_puts |
573 |
("YY_G(yy_full_state) = YY_G(yy_state_ptr);"); |
574 |
indent_puts ("YY_G(yy_full_lp) = YY_G(yy_lp);"); |
575 |
indent_puts ("break;"); |
576 |
indent_puts ("}"); |
577 |
indent_down (); |
578 |
|
579 |
indent_puts ("++YY_G(yy_lp);"); |
580 |
indent_puts ("goto find_rule;"); |
581 |
} |
582 |
|
583 |
else { |
584 |
/* Remember matched text in case we back up due to |
585 |
* trailing context plus REJECT. |
586 |
*/ |
587 |
indent_up (); |
588 |
indent_puts ("{"); |
589 |
indent_puts ("YY_G(yy_full_match) = yy_cp;"); |
590 |
indent_puts ("break;"); |
591 |
indent_puts ("}"); |
592 |
indent_down (); |
593 |
} |
594 |
|
595 |
indent_puts ("}"); |
596 |
indent_down (); |
597 |
|
598 |
indent_puts ("--yy_cp;"); |
599 |
|
600 |
/* We could consolidate the following two lines with those at |
601 |
* the beginning, but at the cost of complaints that we're |
602 |
* branching inside a loop. |
603 |
*/ |
604 |
indent_puts ("yy_current_state = *--YY_G(yy_state_ptr);"); |
605 |
indent_puts ("YY_G(yy_lp) = yy_accept[yy_current_state];"); |
606 |
|
607 |
indent_puts ("}"); |
608 |
|
609 |
indent_down (); |
610 |
} |
611 |
|
612 |
else { /* compressed */ |
613 |
indent_puts ("yy_act = yy_accept[yy_current_state];"); |
614 |
|
615 |
if (interactive && !reject) { |
616 |
/* Do the guaranteed-needed backing up to figure out |
617 |
* the match. |
618 |
*/ |
619 |
indent_puts ("if ( yy_act == 0 )"); |
620 |
indent_up (); |
621 |
indent_puts ("{ /* have to back up */"); |
622 |
indent_puts |
623 |
("yy_cp = YY_G(yy_last_accepting_cpos);"); |
624 |
indent_puts |
625 |
("yy_current_state = YY_G(yy_last_accepting_state);"); |
626 |
indent_puts |
627 |
("yy_act = yy_accept[yy_current_state];"); |
628 |
indent_puts ("}"); |
629 |
indent_down (); |
630 |
} |
631 |
} |
632 |
} |
633 |
|
634 |
/* mkftbl - make the full table and return the struct . |
635 |
* you should call mkecstbl() after this. |
636 |
*/ |
637 |
|
638 |
struct yytbl_data *mkftbl (void) |
639 |
{ |
640 |
register int i; |
641 |
int end_of_buffer_action = num_rules + 1; |
642 |
struct yytbl_data *tbl; |
643 |
flex_int32_t *tdata = 0; |
644 |
|
645 |
tbl = (struct yytbl_data *) calloc (1, sizeof (struct yytbl_data)); |
646 |
yytbl_data_init (tbl, YYTD_ID_ACCEPT); |
647 |
tbl->td_flags |= YYTD_DATA32; |
648 |
tbl->td_hilen = 0; /* it's a one-dimensional array */ |
649 |
tbl->td_lolen = lastdfa + 1; |
650 |
|
651 |
tbl->td_data = tdata = |
652 |
(flex_int32_t *) calloc (tbl->td_lolen, sizeof (flex_int32_t)); |
653 |
|
654 |
dfaacc[end_of_buffer_state].dfaacc_state = end_of_buffer_action; |
655 |
|
656 |
for (i = 1; i <= lastdfa; ++i) { |
657 |
register int anum = dfaacc[i].dfaacc_state; |
658 |
|
659 |
tdata[i] = anum; |
660 |
|
661 |
if (trace && anum) |
662 |
fprintf (stderr, _("state # %d accepts: [%d]\n"), |
663 |
i, anum); |
664 |
} |
665 |
|
666 |
buf_prints (&yydmap_buf, |
667 |
"\t{YYTD_ID_ACCEPT, (void**)&yy_accept, sizeof(%s)},\n", |
668 |
long_align ? "flex_int32_t" : "flex_int16_t"); |
669 |
return tbl; |
670 |
} |
671 |
|
672 |
|
673 |
/* genftbl - generate full transition table */ |
674 |
|
675 |
void genftbl () |
676 |
{ |
677 |
register int i; |
678 |
int end_of_buffer_action = num_rules + 1; |
679 |
|
680 |
out_str_dec (long_align ? get_int32_decl () : get_int16_decl (), |
681 |
"yy_accept", lastdfa + 1); |
682 |
|
683 |
dfaacc[end_of_buffer_state].dfaacc_state = end_of_buffer_action; |
684 |
|
685 |
for (i = 1; i <= lastdfa; ++i) { |
686 |
register int anum = dfaacc[i].dfaacc_state; |
687 |
|
688 |
mkdata (anum); |
689 |
|
690 |
if (trace && anum) |
691 |
fprintf (stderr, _("state # %d accepts: [%d]\n"), |
692 |
i, anum); |
693 |
} |
694 |
|
695 |
dataend (); |
696 |
|
697 |
if (useecs) |
698 |
genecs (); |
699 |
|
700 |
/* Don't have to dump the actual full table entries - they were |
701 |
* created on-the-fly. |
702 |
*/ |
703 |
} |
704 |
|
705 |
|
706 |
/* Generate the code to find the next compressed-table state. */ |
707 |
|
708 |
void gen_next_compressed_state (char_map) |
709 |
char *char_map; |
710 |
{ |
711 |
indent_put2s ("register YY_CHAR yy_c = %s;", char_map); |
712 |
|
713 |
/* Save the backing-up info \before/ computing the next state |
714 |
* because we always compute one more state than needed - we |
715 |
* always proceed until we reach a jam state |
716 |
*/ |
717 |
gen_backing_up (); |
718 |
|
719 |
indent_puts |
720 |
("while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )"); |
721 |
indent_up (); |
722 |
indent_puts ("{"); |
723 |
indent_puts ("yy_current_state = (int) yy_def[yy_current_state];"); |
724 |
|
725 |
if (usemecs) { |
726 |
/* We've arrange it so that templates are never chained |
727 |
* to one another. This means we can afford to make a |
728 |
* very simple test to see if we need to convert to |
729 |
* yy_c's meta-equivalence class without worrying |
730 |
* about erroneously looking up the meta-equivalence |
731 |
* class twice |
732 |
*/ |
733 |
do_indent (); |
734 |
|
735 |
/* lastdfa + 2 is the beginning of the templates */ |
736 |
out_dec ("if ( yy_current_state >= %d )\n", lastdfa + 2); |
737 |
|
738 |
indent_up (); |
739 |
indent_puts ("yy_c = yy_meta[(unsigned int) yy_c];"); |
740 |
indent_down (); |
741 |
} |
742 |
|
743 |
indent_puts ("}"); |
744 |
indent_down (); |
745 |
|
746 |
indent_puts |
747 |
("yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];"); |
748 |
} |
749 |
|
750 |
|
751 |
/* Generate the code to find the next match. */ |
752 |
|
753 |
void gen_next_match () |
754 |
{ |
755 |
/* NOTE - changes in here should be reflected in gen_next_state() and |
756 |
* gen_NUL_trans(). |
757 |
*/ |
758 |
char *char_map = useecs ? |
759 |
"yy_ec[YY_SC_TO_UI(*yy_cp)] " : "YY_SC_TO_UI(*yy_cp)"; |
760 |
|
761 |
char *char_map_2 = useecs ? |
762 |
"yy_ec[YY_SC_TO_UI(*++yy_cp)] " : "YY_SC_TO_UI(*++yy_cp)"; |
763 |
|
764 |
if (fulltbl) { |
765 |
if (gentables) |
766 |
indent_put2s |
767 |
("while ( (yy_current_state = yy_nxt[yy_current_state][ %s ]) > 0 )", |
768 |
char_map); |
769 |
else |
770 |
indent_put2s |
771 |
("while ( (yy_current_state = yy_nxt[yy_current_state*YY_NXT_LOLEN + %s ]) > 0 )", |
772 |
char_map); |
773 |
|
774 |
indent_up (); |
775 |
|
776 |
if (num_backing_up > 0) { |
777 |
indent_puts ("{"); |
778 |
gen_backing_up (); |
779 |
outc ('\n'); |
780 |
} |
781 |
|
782 |
indent_puts ("++yy_cp;"); |
783 |
|
784 |
if (num_backing_up > 0) |
785 |
|
786 |
indent_puts ("}"); |
787 |
|
788 |
indent_down (); |
789 |
|
790 |
outc ('\n'); |
791 |
indent_puts ("yy_current_state = -yy_current_state;"); |
792 |
} |
793 |
|
794 |
else if (fullspd) { |
795 |
indent_puts ("{"); |
796 |
indent_puts |
797 |
("register yyconst struct yy_trans_info *yy_trans_info;\n"); |
798 |
indent_puts ("register YY_CHAR yy_c;\n"); |
799 |
indent_put2s ("for ( yy_c = %s;", char_map); |
800 |
indent_puts |
801 |
(" (yy_trans_info = &yy_current_state[(unsigned int) yy_c])->"); |
802 |
indent_puts ("yy_verify == yy_c;"); |
803 |
indent_put2s (" yy_c = %s )", char_map_2); |
804 |
|
805 |
indent_up (); |
806 |
|
807 |
if (num_backing_up > 0) |
808 |
indent_puts ("{"); |
809 |
|
810 |
indent_puts ("yy_current_state += yy_trans_info->yy_nxt;"); |
811 |
|
812 |
if (num_backing_up > 0) { |
813 |
outc ('\n'); |
814 |
gen_backing_up (); |
815 |
indent_puts ("}"); |
816 |
} |
817 |
|
818 |
indent_down (); |
819 |
indent_puts ("}"); |
820 |
} |
821 |
|
822 |
else { /* compressed */ |
823 |
indent_puts ("do"); |
824 |
|
825 |
indent_up (); |
826 |
indent_puts ("{"); |
827 |
|
828 |
gen_next_state (false); |
829 |
|
830 |
indent_puts ("++yy_cp;"); |
831 |
|
832 |
|
833 |
indent_puts ("}"); |
834 |
indent_down (); |
835 |
|
836 |
do_indent (); |
837 |
|
838 |
if (interactive) |
839 |
out_dec ("while ( yy_base[yy_current_state] != %d );\n", jambase); |
840 |
else |
841 |
out_dec ("while ( yy_current_state != %d );\n", |
842 |
jamstate); |
843 |
|
844 |
if (!reject && !interactive) { |
845 |
/* Do the guaranteed-needed backing up to figure out |
846 |
* the match. |
847 |
*/ |
848 |
indent_puts |
849 |
("yy_cp = YY_G(yy_last_accepting_cpos);"); |
850 |
indent_puts |
851 |
("yy_current_state = YY_G(yy_last_accepting_state);"); |
852 |
} |
853 |
} |
854 |
} |
855 |
|
856 |
|
857 |
/* Generate the code to find the next state. */ |
858 |
|
859 |
void gen_next_state (worry_about_NULs) |
860 |
int worry_about_NULs; |
861 |
{ /* NOTE - changes in here should be reflected in gen_next_match() */ |
862 |
char char_map[256]; |
863 |
|
864 |
if (worry_about_NULs && !nultrans) { |
865 |
if (useecs) |
866 |
snprintf (char_map, sizeof(char_map), |
867 |
"(*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : %d)", |
868 |
NUL_ec); |
869 |
else |
870 |
snprintf (char_map, sizeof(char_map), |
871 |
"(*yy_cp ? YY_SC_TO_UI(*yy_cp) : %d)", |
872 |
NUL_ec); |
873 |
} |
874 |
|
875 |
else |
876 |
strcpy (char_map, useecs ? |
877 |
"yy_ec[YY_SC_TO_UI(*yy_cp)] " : |
878 |
"YY_SC_TO_UI(*yy_cp)"); |
879 |
|
880 |
if (worry_about_NULs && nultrans) { |
881 |
if (!fulltbl && !fullspd) |
882 |
/* Compressed tables back up *before* they match. */ |
883 |
gen_backing_up (); |
884 |
|
885 |
indent_puts ("if ( *yy_cp )"); |
886 |
indent_up (); |
887 |
indent_puts ("{"); |
888 |
} |
889 |
|
890 |
if (fulltbl) { |
891 |
if (gentables) |
892 |
indent_put2s |
893 |
("yy_current_state = yy_nxt[yy_current_state][%s];", |
894 |
char_map); |
895 |
else |
896 |
indent_put2s |
897 |
("yy_current_state = yy_nxt[yy_current_state*YY_NXT_LOLEN + %s];", |
898 |
char_map); |
899 |
} |
900 |
|
901 |
else if (fullspd) |
902 |
indent_put2s |
903 |
("yy_current_state += yy_current_state[%s].yy_nxt;", |
904 |
char_map); |
905 |
|
906 |
else |
907 |
gen_next_compressed_state (char_map); |
908 |
|
909 |
if (worry_about_NULs && nultrans) { |
910 |
|
911 |
indent_puts ("}"); |
912 |
indent_down (); |
913 |
indent_puts ("else"); |
914 |
indent_up (); |
915 |
indent_puts |
916 |
("yy_current_state = yy_NUL_trans[yy_current_state];"); |
917 |
indent_down (); |
918 |
} |
919 |
|
920 |
if (fullspd || fulltbl) |
921 |
gen_backing_up (); |
922 |
|
923 |
if (reject) |
924 |
indent_puts ("*YY_G(yy_state_ptr)++ = yy_current_state;"); |
925 |
} |
926 |
|
927 |
|
928 |
/* Generate the code to make a NUL transition. */ |
929 |
|
930 |
void gen_NUL_trans () |
931 |
{ /* NOTE - changes in here should be reflected in gen_next_match() */ |
932 |
/* Only generate a definition for "yy_cp" if we'll generate code |
933 |
* that uses it. Otherwise lint and the like complain. |
934 |
*/ |
935 |
int need_backing_up = (num_backing_up > 0 && !reject); |
936 |
|
937 |
if (need_backing_up && (!nultrans || fullspd || fulltbl)) |
938 |
/* We're going to need yy_cp lying around for the call |
939 |
* below to gen_backing_up(). |
940 |
*/ |
941 |
indent_puts ("register char *yy_cp = YY_G(yy_c_buf_p);"); |
942 |
|
943 |
outc ('\n'); |
944 |
|
945 |
if (nultrans) { |
946 |
indent_puts |
947 |
("yy_current_state = yy_NUL_trans[yy_current_state];"); |
948 |
indent_puts ("yy_is_jam = (yy_current_state == 0);"); |
949 |
} |
950 |
|
951 |
else if (fulltbl) { |
952 |
do_indent (); |
953 |
if (gentables) |
954 |
out_dec ("yy_current_state = yy_nxt[yy_current_state][%d];\n", NUL_ec); |
955 |
else |
956 |
out_dec ("yy_current_state = yy_nxt[yy_current_state*YY_NXT_LOLEN + %d];\n", NUL_ec); |
957 |
indent_puts ("yy_is_jam = (yy_current_state <= 0);"); |
958 |
} |
959 |
|
960 |
else if (fullspd) { |
961 |
do_indent (); |
962 |
out_dec ("register int yy_c = %d;\n", NUL_ec); |
963 |
|
964 |
indent_puts |
965 |
("register yyconst struct yy_trans_info *yy_trans_info;\n"); |
966 |
indent_puts |
967 |
("yy_trans_info = &yy_current_state[(unsigned int) yy_c];"); |
968 |
indent_puts ("yy_current_state += yy_trans_info->yy_nxt;"); |
969 |
|
970 |
indent_puts |
971 |
("yy_is_jam = (yy_trans_info->yy_verify != yy_c);"); |
972 |
} |
973 |
|
974 |
else { |
975 |
char NUL_ec_str[20]; |
976 |
|
977 |
snprintf (NUL_ec_str, sizeof(NUL_ec_str), "%d", NUL_ec); |
978 |
gen_next_compressed_state (NUL_ec_str); |
979 |
|
980 |
do_indent (); |
981 |
out_dec ("yy_is_jam = (yy_current_state == %d);\n", |
982 |
jamstate); |
983 |
|
984 |
if (reject) { |
985 |
/* Only stack this state if it's a transition we |
986 |
* actually make. If we stack it on a jam, then |
987 |
* the state stack and yy_c_buf_p get out of sync. |
988 |
*/ |
989 |
indent_puts ("if ( ! yy_is_jam )"); |
990 |
indent_up (); |
991 |
indent_puts |
992 |
("*YY_G(yy_state_ptr)++ = yy_current_state;"); |
993 |
indent_down (); |
994 |
} |
995 |
} |
996 |
|
997 |
/* If we've entered an accepting state, back up; note that |
998 |
* compressed tables have *already* done such backing up, so |
999 |
* we needn't bother with it again. |
1000 |
*/ |
1001 |
if (need_backing_up && (fullspd || fulltbl)) { |
1002 |
outc ('\n'); |
1003 |
indent_puts ("if ( ! yy_is_jam )"); |
1004 |
indent_up (); |
1005 |
indent_puts ("{"); |
1006 |
gen_backing_up (); |
1007 |
indent_puts ("}"); |
1008 |
indent_down (); |
1009 |
} |
1010 |
} |
1011 |
|
1012 |
|
1013 |
/* Generate the code to find the start state. */ |
1014 |
|
1015 |
void gen_start_state () |
1016 |
{ |
1017 |
if (fullspd) { |
1018 |
if (bol_needed) { |
1019 |
indent_puts |
1020 |
("yy_current_state = yy_start_state_list[YY_G(yy_start) + YY_AT_BOL()];"); |
1021 |
} |
1022 |
else |
1023 |
indent_puts |
1024 |
("yy_current_state = yy_start_state_list[YY_G(yy_start)];"); |
1025 |
} |
1026 |
|
1027 |
else { |
1028 |
indent_puts ("yy_current_state = YY_G(yy_start);"); |
1029 |
|
1030 |
if (bol_needed) |
1031 |
indent_puts ("yy_current_state += YY_AT_BOL();"); |
1032 |
|
1033 |
if (reject) { |
1034 |
/* Set up for storing up states. */ |
1035 |
outn ("m4_ifdef( [[M4_YY_USES_REJECT]],\n[["); |
1036 |
indent_puts |
1037 |
("YY_G(yy_state_ptr) = YY_G(yy_state_buf);"); |
1038 |
indent_puts |
1039 |
("*YY_G(yy_state_ptr)++ = yy_current_state;"); |
1040 |
outn ("]])"); |
1041 |
} |
1042 |
} |
1043 |
} |
1044 |
|
1045 |
|
1046 |
/* gentabs - generate data statements for the transition tables */ |
1047 |
|
1048 |
void gentabs () |
1049 |
{ |
1050 |
int i, j, k, *accset, nacc, *acc_array, total_states; |
1051 |
int end_of_buffer_action = num_rules + 1; |
1052 |
struct yytbl_data *yyacc_tbl = 0, *yymeta_tbl = 0, *yybase_tbl = 0, |
1053 |
*yydef_tbl = 0, *yynxt_tbl = 0, *yychk_tbl = 0, *yyacclist_tbl=0; |
1054 |
flex_int32_t *yyacc_data = 0, *yybase_data = 0, *yydef_data = 0, |
1055 |
*yynxt_data = 0, *yychk_data = 0, *yyacclist_data=0; |
1056 |
flex_int32_t yybase_curr = 0, yyacclist_curr=0,yyacc_curr=0; |
1057 |
|
1058 |
acc_array = allocate_integer_array (current_max_dfas); |
1059 |
nummt = 0; |
1060 |
|
1061 |
/* The compressed table format jams by entering the "jam state", |
1062 |
* losing information about the previous state in the process. |
1063 |
* In order to recover the previous state, we effectively need |
1064 |
* to keep backing-up information. |
1065 |
*/ |
1066 |
++num_backing_up; |
1067 |
|
1068 |
if (reject) { |
1069 |
/* Write out accepting list and pointer list. |
1070 |
|
1071 |
* First we generate the "yy_acclist" array. In the process, |
1072 |
* we compute the indices that will go into the "yy_accept" |
1073 |
* array, and save the indices in the dfaacc array. |
1074 |
*/ |
1075 |
int EOB_accepting_list[2]; |
1076 |
|
1077 |
/* Set up accepting structures for the End Of Buffer state. */ |
1078 |
EOB_accepting_list[0] = 0; |
1079 |
EOB_accepting_list[1] = end_of_buffer_action; |
1080 |
accsiz[end_of_buffer_state] = 1; |
1081 |
dfaacc[end_of_buffer_state].dfaacc_set = |
1082 |
EOB_accepting_list; |
1083 |
|
1084 |
out_str_dec (long_align ? get_int32_decl () : |
1085 |
get_int16_decl (), "yy_acclist", MAX (numas, |
1086 |
1) + 1); |
1087 |
|
1088 |
buf_prints (&yydmap_buf, |
1089 |
"\t{YYTD_ID_ACCLIST, (void**)&yy_acclist, sizeof(%s)},\n", |
1090 |
long_align ? "flex_int32_t" : "flex_int16_t"); |
1091 |
|
1092 |
yyacclist_tbl = (struct yytbl_data*)calloc(1,sizeof(struct yytbl_data)); |
1093 |
yytbl_data_init (yyacclist_tbl, YYTD_ID_ACCLIST); |
1094 |
yyacclist_tbl->td_lolen = MAX(numas,1) + 1; |
1095 |
yyacclist_tbl->td_data = yyacclist_data = |
1096 |
(flex_int32_t *) calloc (yyacclist_tbl->td_lolen, sizeof (flex_int32_t)); |
1097 |
yyacclist_curr = 1; |
1098 |
|
1099 |
j = 1; /* index into "yy_acclist" array */ |
1100 |
|
1101 |
for (i = 1; i <= lastdfa; ++i) { |
1102 |
acc_array[i] = j; |
1103 |
|
1104 |
if (accsiz[i] != 0) { |
1105 |
accset = dfaacc[i].dfaacc_set; |
1106 |
nacc = accsiz[i]; |
1107 |
|
1108 |
if (trace) |
1109 |
fprintf (stderr, |
1110 |
_("state # %d accepts: "), |
1111 |
i); |
1112 |
|
1113 |
for (k = 1; k <= nacc; ++k) { |
1114 |
int accnum = accset[k]; |
1115 |
|
1116 |
++j; |
1117 |
|
1118 |
if (variable_trailing_context_rules |
1119 |
&& !(accnum & |
1120 |
YY_TRAILING_HEAD_MASK) |
1121 |
&& accnum > 0 |
1122 |
&& accnum <= num_rules |
1123 |
&& rule_type[accnum] == |
1124 |
RULE_VARIABLE) { |
1125 |
/* Special hack to flag |
1126 |
* accepting number as part |
1127 |
* of trailing context rule. |
1128 |
*/ |
1129 |
accnum |= YY_TRAILING_MASK; |
1130 |
} |
1131 |
|
1132 |
mkdata (accnum); |
1133 |
yyacclist_data[yyacclist_curr++] = accnum; |
1134 |
|
1135 |
if (trace) { |
1136 |
fprintf (stderr, "[%d]", |
1137 |
accset[k]); |
1138 |
|
1139 |
if (k < nacc) |
1140 |
fputs (", ", |
1141 |
stderr); |
1142 |
else |
1143 |
putc ('\n', |
1144 |
stderr); |
1145 |
} |
1146 |
} |
1147 |
} |
1148 |
} |
1149 |
|
1150 |
/* add accepting number for the "jam" state */ |
1151 |
acc_array[i] = j; |
1152 |
|
1153 |
dataend (); |
1154 |
if (tablesext) { |
1155 |
yytbl_data_compress (yyacclist_tbl); |
1156 |
if (yytbl_data_fwrite (&tableswr, yyacclist_tbl) < 0) |
1157 |
flexerror (_("Could not write yyacclist_tbl")); |
1158 |
yytbl_data_destroy (yyacclist_tbl); |
1159 |
yyacclist_tbl = NULL; |
1160 |
} |
1161 |
} |
1162 |
|
1163 |
else { |
1164 |
dfaacc[end_of_buffer_state].dfaacc_state = |
1165 |
end_of_buffer_action; |
1166 |
|
1167 |
for (i = 1; i <= lastdfa; ++i) |
1168 |
acc_array[i] = dfaacc[i].dfaacc_state; |
1169 |
|
1170 |
/* add accepting number for jam state */ |
1171 |
acc_array[i] = 0; |
1172 |
} |
1173 |
|
1174 |
/* Begin generating yy_accept */ |
1175 |
|
1176 |
/* Spit out "yy_accept" array. If we're doing "reject", it'll be |
1177 |
* pointers into the "yy_acclist" array. Otherwise it's actual |
1178 |
* accepting numbers. In either case, we just dump the numbers. |
1179 |
*/ |
1180 |
|
1181 |
/* "lastdfa + 2" is the size of "yy_accept"; includes room for C arrays |
1182 |
* beginning at 0 and for "jam" state. |
1183 |
*/ |
1184 |
k = lastdfa + 2; |
1185 |
|
1186 |
if (reject) |
1187 |
/* We put a "cap" on the table associating lists of accepting |
1188 |
* numbers with state numbers. This is needed because we tell |
1189 |
* where the end of an accepting list is by looking at where |
1190 |
* the list for the next state starts. |
1191 |
*/ |
1192 |
++k; |
1193 |
|
1194 |
out_str_dec (long_align ? get_int32_decl () : get_int16_decl (), |
1195 |
"yy_accept", k); |
1196 |
|
1197 |
buf_prints (&yydmap_buf, |
1198 |
"\t{YYTD_ID_ACCEPT, (void**)&yy_accept, sizeof(%s)},\n", |
1199 |
long_align ? "flex_int32_t" : "flex_int16_t"); |
1200 |
|
1201 |
yyacc_tbl = |
1202 |
(struct yytbl_data *) calloc (1, |
1203 |
sizeof (struct yytbl_data)); |
1204 |
yytbl_data_init (yyacc_tbl, YYTD_ID_ACCEPT); |
1205 |
yyacc_tbl->td_lolen = k; |
1206 |
yyacc_tbl->td_data = yyacc_data = |
1207 |
(flex_int32_t *) calloc (yyacc_tbl->td_lolen, sizeof (flex_int32_t)); |
1208 |
yyacc_curr=1; |
1209 |
|
1210 |
for (i = 1; i <= lastdfa; ++i) { |
1211 |
mkdata (acc_array[i]); |
1212 |
yyacc_data[yyacc_curr++] = acc_array[i]; |
1213 |
|
1214 |
if (!reject && trace && acc_array[i]) |
1215 |
fprintf (stderr, _("state # %d accepts: [%d]\n"), |
1216 |
i, acc_array[i]); |
1217 |
} |
1218 |
|
1219 |
/* Add entry for "jam" state. */ |
1220 |
mkdata (acc_array[i]); |
1221 |
yyacc_data[yyacc_curr++] = acc_array[i]; |
1222 |
|
1223 |
if (reject) { |
1224 |
/* Add "cap" for the list. */ |
1225 |
mkdata (acc_array[i]); |
1226 |
yyacc_data[yyacc_curr++] = acc_array[i]; |
1227 |
} |
1228 |
|
1229 |
dataend (); |
1230 |
if (tablesext) { |
1231 |
yytbl_data_compress (yyacc_tbl); |
1232 |
if (yytbl_data_fwrite (&tableswr, yyacc_tbl) < 0) |
1233 |
flexerror (_("Could not write yyacc_tbl")); |
1234 |
yytbl_data_destroy (yyacc_tbl); |
1235 |
yyacc_tbl = NULL; |
1236 |
} |
1237 |
/* End generating yy_accept */ |
1238 |
|
1239 |
if (useecs) { |
1240 |
|
1241 |
genecs (); |
1242 |
if (tablesext) { |
1243 |
struct yytbl_data *tbl; |
1244 |
|
1245 |
tbl = mkecstbl (); |
1246 |
yytbl_data_compress (tbl); |
1247 |
if (yytbl_data_fwrite (&tableswr, tbl) < 0) |
1248 |
flexerror (_("Could not write ecstbl")); |
1249 |
yytbl_data_destroy (tbl); |
1250 |
tbl = 0; |
1251 |
} |
1252 |
} |
1253 |
|
1254 |
if (usemecs) { |
1255 |
/* Begin generating yy_meta */ |
1256 |
/* Write out meta-equivalence classes (used to index |
1257 |
* templates with). |
1258 |
*/ |
1259 |
flex_int32_t *yymecs_data = 0; |
1260 |
yymeta_tbl = |
1261 |
(struct yytbl_data *) calloc (1, |
1262 |
sizeof (struct |
1263 |
yytbl_data)); |
1264 |
yytbl_data_init (yymeta_tbl, YYTD_ID_META); |
1265 |
yymeta_tbl->td_lolen = numecs + 1; |
1266 |
yymeta_tbl->td_data = yymecs_data = |
1267 |
(flex_int32_t *) calloc (yymeta_tbl->td_lolen, |
1268 |
sizeof (flex_int32_t)); |
1269 |
|
1270 |
if (trace) |
1271 |
fputs (_("\n\nMeta-Equivalence Classes:\n"), |
1272 |
stderr); |
1273 |
|
1274 |
out_str_dec (get_int32_decl (), "yy_meta", numecs + 1); |
1275 |
buf_prints (&yydmap_buf, |
1276 |
"\t{YYTD_ID_META, (void**)&yy_meta, sizeof(%s)},\n", |
1277 |
"flex_int32_t"); |
1278 |
|
1279 |
for (i = 1; i <= numecs; ++i) { |
1280 |
if (trace) |
1281 |
fprintf (stderr, "%d = %d\n", |
1282 |
i, ABS (tecbck[i])); |
1283 |
|
1284 |
mkdata (ABS (tecbck[i])); |
1285 |
yymecs_data[i] = ABS (tecbck[i]); |
1286 |
} |
1287 |
|
1288 |
dataend (); |
1289 |
if (tablesext) { |
1290 |
yytbl_data_compress (yymeta_tbl); |
1291 |
if (yytbl_data_fwrite (&tableswr, yymeta_tbl) < 0) |
1292 |
flexerror (_ |
1293 |
("Could not write yymeta_tbl")); |
1294 |
yytbl_data_destroy (yymeta_tbl); |
1295 |
yymeta_tbl = NULL; |
1296 |
} |
1297 |
/* End generating yy_meta */ |
1298 |
} |
1299 |
|
1300 |
total_states = lastdfa + numtemps; |
1301 |
|
1302 |
/* Begin generating yy_base */ |
1303 |
out_str_dec ((tblend >= INT16_MAX || long_align) ? |
1304 |
get_int32_decl () : get_int16_decl (), |
1305 |
"yy_base", total_states + 1); |
1306 |
|
1307 |
buf_prints (&yydmap_buf, |
1308 |
"\t{YYTD_ID_BASE, (void**)&yy_base, sizeof(%s)},\n", |
1309 |
(tblend >= INT16_MAX |
1310 |
|| long_align) ? "flex_int32_t" : "flex_int16_t"); |
1311 |
yybase_tbl = |
1312 |
(struct yytbl_data *) calloc (1, |
1313 |
sizeof (struct yytbl_data)); |
1314 |
yytbl_data_init (yybase_tbl, YYTD_ID_BASE); |
1315 |
yybase_tbl->td_lolen = total_states + 1; |
1316 |
yybase_tbl->td_data = yybase_data = |
1317 |
(flex_int32_t *) calloc (yybase_tbl->td_lolen, |
1318 |
sizeof (flex_int32_t)); |
1319 |
yybase_curr = 1; |
1320 |
|
1321 |
for (i = 1; i <= lastdfa; ++i) { |
1322 |
register int d = def[i]; |
1323 |
|
1324 |
if (base[i] == JAMSTATE) |
1325 |
base[i] = jambase; |
1326 |
|
1327 |
if (d == JAMSTATE) |
1328 |
def[i] = jamstate; |
1329 |
|
1330 |
else if (d < 0) { |
1331 |
/* Template reference. */ |
1332 |
++tmpuses; |
1333 |
def[i] = lastdfa - d + 1; |
1334 |
} |
1335 |
|
1336 |
mkdata (base[i]); |
1337 |
yybase_data[yybase_curr++] = base[i]; |
1338 |
} |
1339 |
|
1340 |
/* Generate jam state's base index. */ |
1341 |
mkdata (base[i]); |
1342 |
yybase_data[yybase_curr++] = base[i]; |
1343 |
|
1344 |
for (++i /* skip jam state */ ; i <= total_states; ++i) { |
1345 |
mkdata (base[i]); |
1346 |
yybase_data[yybase_curr++] = base[i]; |
1347 |
def[i] = jamstate; |
1348 |
} |
1349 |
|
1350 |
dataend (); |
1351 |
if (tablesext) { |
1352 |
yytbl_data_compress (yybase_tbl); |
1353 |
if (yytbl_data_fwrite (&tableswr, yybase_tbl) < 0) |
1354 |
flexerror (_("Could not write yybase_tbl")); |
1355 |
yytbl_data_destroy (yybase_tbl); |
1356 |
yybase_tbl = NULL; |
1357 |
} |
1358 |
/* End generating yy_base */ |
1359 |
|
1360 |
|
1361 |
/* Begin generating yy_def */ |
1362 |
out_str_dec ((total_states >= INT16_MAX || long_align) ? |
1363 |
get_int32_decl () : get_int16_decl (), |
1364 |
"yy_def", total_states + 1); |
1365 |
|
1366 |
buf_prints (&yydmap_buf, |
1367 |
"\t{YYTD_ID_DEF, (void**)&yy_def, sizeof(%s)},\n", |
1368 |
(total_states >= INT16_MAX |
1369 |
|| long_align) ? "flex_int32_t" : "flex_int16_t"); |
1370 |
|
1371 |
yydef_tbl = |
1372 |
(struct yytbl_data *) calloc (1, |
1373 |
sizeof (struct yytbl_data)); |
1374 |
yytbl_data_init (yydef_tbl, YYTD_ID_DEF); |
1375 |
yydef_tbl->td_lolen = total_states + 1; |
1376 |
yydef_tbl->td_data = yydef_data = |
1377 |
(flex_int32_t *) calloc (yydef_tbl->td_lolen, sizeof (flex_int32_t)); |
1378 |
|
1379 |
for (i = 1; i <= total_states; ++i) { |
1380 |
mkdata (def[i]); |
1381 |
yydef_data[i] = def[i]; |
1382 |
} |
1383 |
|
1384 |
dataend (); |
1385 |
if (tablesext) { |
1386 |
yytbl_data_compress (yydef_tbl); |
1387 |
if (yytbl_data_fwrite (&tableswr, yydef_tbl) < 0) |
1388 |
flexerror (_("Could not write yydef_tbl")); |
1389 |
yytbl_data_destroy (yydef_tbl); |
1390 |
yydef_tbl = NULL; |
1391 |
} |
1392 |
/* End generating yy_def */ |
1393 |
|
1394 |
|
1395 |
/* Begin generating yy_nxt */ |
1396 |
out_str_dec ((total_states >= INT16_MAX || long_align) ? |
1397 |
get_int32_decl () : get_int16_decl (), "yy_nxt", |
1398 |
tblend + 1); |
1399 |
|
1400 |
buf_prints (&yydmap_buf, |
1401 |
"\t{YYTD_ID_NXT, (void**)&yy_nxt, sizeof(%s)},\n", |
1402 |
(total_states >= INT16_MAX |
1403 |
|| long_align) ? "flex_int32_t" : "flex_int16_t"); |
1404 |
|
1405 |
yynxt_tbl = |
1406 |
(struct yytbl_data *) calloc (1, |
1407 |
sizeof (struct yytbl_data)); |
1408 |
yytbl_data_init (yynxt_tbl, YYTD_ID_NXT); |
1409 |
yynxt_tbl->td_lolen = tblend + 1; |
1410 |
yynxt_tbl->td_data = yynxt_data = |
1411 |
(flex_int32_t *) calloc (yynxt_tbl->td_lolen, sizeof (flex_int32_t)); |
1412 |
|
1413 |
for (i = 1; i <= tblend; ++i) { |
1414 |
/* Note, the order of the following test is important. |
1415 |
* If chk[i] is 0, then nxt[i] is undefined. |
1416 |
*/ |
1417 |
if (chk[i] == 0 || nxt[i] == 0) |
1418 |
nxt[i] = jamstate; /* new state is the JAM state */ |
1419 |
|
1420 |
mkdata (nxt[i]); |
1421 |
yynxt_data[i] = nxt[i]; |
1422 |
} |
1423 |
|
1424 |
dataend (); |
1425 |
if (tablesext) { |
1426 |
yytbl_data_compress (yynxt_tbl); |
1427 |
if (yytbl_data_fwrite (&tableswr, yynxt_tbl) < 0) |
1428 |
flexerror (_("Could not write yynxt_tbl")); |
1429 |
yytbl_data_destroy (yynxt_tbl); |
1430 |
yynxt_tbl = NULL; |
1431 |
} |
1432 |
/* End generating yy_nxt */ |
1433 |
|
1434 |
/* Begin generating yy_chk */ |
1435 |
out_str_dec ((total_states >= INT16_MAX || long_align) ? |
1436 |
get_int32_decl () : get_int16_decl (), "yy_chk", |
1437 |
tblend + 1); |
1438 |
|
1439 |
buf_prints (&yydmap_buf, |
1440 |
"\t{YYTD_ID_CHK, (void**)&yy_chk, sizeof(%s)},\n", |
1441 |
(total_states >= INT16_MAX |
1442 |
|| long_align) ? "flex_int32_t" : "flex_int16_t"); |
1443 |
|
1444 |
yychk_tbl = |
1445 |
(struct yytbl_data *) calloc (1, |
1446 |
sizeof (struct yytbl_data)); |
1447 |
yytbl_data_init (yychk_tbl, YYTD_ID_CHK); |
1448 |
yychk_tbl->td_lolen = tblend + 1; |
1449 |
yychk_tbl->td_data = yychk_data = |
1450 |
(flex_int32_t *) calloc (yychk_tbl->td_lolen, sizeof (flex_int32_t)); |
1451 |
|
1452 |
for (i = 1; i <= tblend; ++i) { |
1453 |
if (chk[i] == 0) |
1454 |
++nummt; |
1455 |
|
1456 |
mkdata (chk[i]); |
1457 |
yychk_data[i] = chk[i]; |
1458 |
} |
1459 |
|
1460 |
dataend (); |
1461 |
if (tablesext) { |
1462 |
yytbl_data_compress (yychk_tbl); |
1463 |
if (yytbl_data_fwrite (&tableswr, yychk_tbl) < 0) |
1464 |
flexerror (_("Could not write yychk_tbl")); |
1465 |
yytbl_data_destroy (yychk_tbl); |
1466 |
yychk_tbl = NULL; |
1467 |
} |
1468 |
/* End generating yy_chk */ |
1469 |
|
1470 |
flex_free ((void *) acc_array); |
1471 |
} |
1472 |
|
1473 |
|
1474 |
/* Write out a formatted string (with a secondary string argument) at the |
1475 |
* current indentation level, adding a final newline. |
1476 |
*/ |
1477 |
|
1478 |
void indent_put2s (fmt, arg) |
1479 |
const char *fmt, *arg; |
1480 |
{ |
1481 |
do_indent (); |
1482 |
out_str (fmt, arg); |
1483 |
outn (""); |
1484 |
} |
1485 |
|
1486 |
|
1487 |
/* Write out a string at the current indentation level, adding a final |
1488 |
* newline. |
1489 |
*/ |
1490 |
|
1491 |
void indent_puts (str) |
1492 |
const char *str; |
1493 |
{ |
1494 |
do_indent (); |
1495 |
outn (str); |
1496 |
} |
1497 |
|
1498 |
|
1499 |
/* make_tables - generate transition tables and finishes generating output file |
1500 |
*/ |
1501 |
|
1502 |
void make_tables () |
1503 |
{ |
1504 |
register int i; |
1505 |
int did_eof_rule = false; |
1506 |
struct yytbl_data *yynultrans_tbl; |
1507 |
|
1508 |
|
1509 |
skelout (); /* %% [2.0] - break point in skel */ |
1510 |
|
1511 |
/* First, take care of YY_DO_BEFORE_ACTION depending on yymore |
1512 |
* being used. |
1513 |
*/ |
1514 |
set_indent (1); |
1515 |
|
1516 |
if (yymore_used && !yytext_is_array) { |
1517 |
indent_puts ("YY_G(yytext_ptr) -= YY_G(yy_more_len); \\"); |
1518 |
indent_puts |
1519 |
("yyleng = (size_t) (yy_cp - YY_G(yytext_ptr)); \\"); |
1520 |
} |
1521 |
|
1522 |
else |
1523 |
indent_puts ("yyleng = (size_t) (yy_cp - yy_bp); \\"); |
1524 |
|
1525 |
/* Now also deal with copying yytext_ptr to yytext if needed. */ |
1526 |
skelout (); /* %% [3.0] - break point in skel */ |
1527 |
if (yytext_is_array) { |
1528 |
if (yymore_used) |
1529 |
indent_puts |
1530 |
("if ( yyleng + YY_G(yy_more_offset) >= YYLMAX ) \\"); |
1531 |
else |
1532 |
indent_puts ("if ( yyleng >= YYLMAX ) \\"); |
1533 |
|
1534 |
indent_up (); |
1535 |
indent_puts |
1536 |
("YY_FATAL_ERROR( \"token too large, exceeds YYLMAX\" ); \\"); |
1537 |
indent_down (); |
1538 |
|
1539 |
if (yymore_used) { |
1540 |
indent_puts |
1541 |
("yy_flex_strncpy( &yytext[YY_G(yy_more_offset)], YY_G(yytext_ptr), yyleng + 1 M4_YY_CALL_LAST_ARG); \\"); |
1542 |
indent_puts ("yyleng += YY_G(yy_more_offset); \\"); |
1543 |
indent_puts |
1544 |
("YY_G(yy_prev_more_offset) = YY_G(yy_more_offset); \\"); |
1545 |
indent_puts ("YY_G(yy_more_offset) = 0; \\"); |
1546 |
} |
1547 |
else { |
1548 |
indent_puts |
1549 |
("yy_flex_strncpy( yytext, YY_G(yytext_ptr), yyleng + 1 M4_YY_CALL_LAST_ARG); \\"); |
1550 |
} |
1551 |
} |
1552 |
|
1553 |
set_indent (0); |
1554 |
|
1555 |
skelout (); /* %% [4.0] - break point in skel */ |
1556 |
|
1557 |
|
1558 |
/* This is where we REALLY begin generating the tables. */ |
1559 |
|
1560 |
out_dec ("#define YY_NUM_RULES %d\n", num_rules); |
1561 |
out_dec ("#define YY_END_OF_BUFFER %d\n", num_rules + 1); |
1562 |
|
1563 |
if (fullspd) { |
1564 |
/* Need to define the transet type as a size large |
1565 |
* enough to hold the biggest offset. |
1566 |
*/ |
1567 |
int total_table_size = tblend + numecs + 1; |
1568 |
char *trans_offset_type = |
1569 |
(total_table_size >= INT16_MAX || long_align) ? |
1570 |
"flex_int32_t" : "flex_int16_t"; |
1571 |
|
1572 |
set_indent (0); |
1573 |
indent_puts ("struct yy_trans_info"); |
1574 |
indent_up (); |
1575 |
indent_puts ("{"); |
1576 |
|
1577 |
/* We require that yy_verify and yy_nxt must be of the same size int. */ |
1578 |
indent_put2s ("%s yy_verify;", trans_offset_type); |
1579 |
|
1580 |
/* In cases where its sister yy_verify *is* a "yes, there is |
1581 |
* a transition", yy_nxt is the offset (in records) to the |
1582 |
* next state. In most cases where there is no transition, |
1583 |
* the value of yy_nxt is irrelevant. If yy_nxt is the -1th |
1584 |
* record of a state, though, then yy_nxt is the action number |
1585 |
* for that state. |
1586 |
*/ |
1587 |
|
1588 |
indent_put2s ("%s yy_nxt;", trans_offset_type); |
1589 |
indent_puts ("};"); |
1590 |
indent_down (); |
1591 |
} |
1592 |
else { |
1593 |
/* We generate a bogus 'struct yy_trans_info' data type |
1594 |
* so we can guarantee that it is always declared in the skel. |
1595 |
* This is so we can compile "sizeof(struct yy_trans_info)" |
1596 |
* in any scanner. |
1597 |
*/ |
1598 |
indent_puts |
1599 |
("/* This struct is not used in this scanner,"); |
1600 |
indent_puts (" but its presence is necessary. */"); |
1601 |
indent_puts ("struct yy_trans_info"); |
1602 |
indent_up (); |
1603 |
indent_puts ("{"); |
1604 |
indent_puts ("flex_int32_t yy_verify;"); |
1605 |
indent_puts ("flex_int32_t yy_nxt;"); |
1606 |
indent_puts ("};"); |
1607 |
indent_down (); |
1608 |
} |
1609 |
|
1610 |
if (fullspd) { |
1611 |
genctbl (); |
1612 |
if (tablesext) { |
1613 |
struct yytbl_data *tbl; |
1614 |
|
1615 |
tbl = mkctbl (); |
1616 |
yytbl_data_compress (tbl); |
1617 |
if (yytbl_data_fwrite (&tableswr, tbl) < 0) |
1618 |
flexerror (_("Could not write ftbl")); |
1619 |
yytbl_data_destroy (tbl); |
1620 |
|
1621 |
tbl = mkssltbl (); |
1622 |
yytbl_data_compress (tbl); |
1623 |
if (yytbl_data_fwrite (&tableswr, tbl) < 0) |
1624 |
flexerror (_("Could not write ssltbl")); |
1625 |
yytbl_data_destroy (tbl); |
1626 |
tbl = 0; |
1627 |
|
1628 |
if (useecs) { |
1629 |
tbl = mkecstbl (); |
1630 |
yytbl_data_compress (tbl); |
1631 |
if (yytbl_data_fwrite (&tableswr, tbl) < 0) |
1632 |
flexerror (_ |
1633 |
("Could not write ecstbl")); |
1634 |
yytbl_data_destroy (tbl); |
1635 |
tbl = 0; |
1636 |
} |
1637 |
} |
1638 |
} |
1639 |
else if (fulltbl) { |
1640 |
genftbl (); |
1641 |
if (tablesext) { |
1642 |
struct yytbl_data *tbl; |
1643 |
|
1644 |
tbl = mkftbl (); |
1645 |
yytbl_data_compress (tbl); |
1646 |
if (yytbl_data_fwrite (&tableswr, tbl) < 0) |
1647 |
flexerror (_("Could not write ftbl")); |
1648 |
yytbl_data_destroy (tbl); |
1649 |
tbl = 0; |
1650 |
|
1651 |
if (useecs) { |
1652 |
tbl = mkecstbl (); |
1653 |
yytbl_data_compress (tbl); |
1654 |
if (yytbl_data_fwrite (&tableswr, tbl) < 0) |
1655 |
flexerror (_ |
1656 |
("Could not write ecstbl")); |
1657 |
yytbl_data_destroy (tbl); |
1658 |
tbl = 0; |
1659 |
} |
1660 |
} |
1661 |
} |
1662 |
else |
1663 |
gentabs (); |
1664 |
|
1665 |
if (do_yylineno) { |
1666 |
|
1667 |
geneoltbl (); |
1668 |
|
1669 |
if (tablesext) { |
1670 |
struct yytbl_data *tbl; |
1671 |
|
1672 |
tbl = mkeoltbl (); |
1673 |
yytbl_data_compress (tbl); |
1674 |
if (yytbl_data_fwrite (&tableswr, tbl) < 0) |
1675 |
flexerror (_("Could not write eoltbl")); |
1676 |
yytbl_data_destroy (tbl); |
1677 |
tbl = 0; |
1678 |
} |
1679 |
} |
1680 |
|
1681 |
/* Definitions for backing up. We don't need them if REJECT |
1682 |
* is being used because then we use an alternative backin-up |
1683 |
* technique instead. |
1684 |
*/ |
1685 |
if (num_backing_up > 0 && !reject) { |
1686 |
if (!C_plus_plus && !reentrant) { |
1687 |
indent_puts |
1688 |
("static yy_state_type yy_last_accepting_state;"); |
1689 |
indent_puts |
1690 |
("static char *yy_last_accepting_cpos;\n"); |
1691 |
} |
1692 |
} |
1693 |
|
1694 |
if (nultrans) { |
1695 |
flex_int32_t *yynultrans_data = 0; |
1696 |
|
1697 |
/* Begin generating yy_NUL_trans */ |
1698 |
out_str_dec (get_state_decl (), "yy_NUL_trans", |
1699 |
lastdfa + 1); |
1700 |
buf_prints (&yydmap_buf, |
1701 |
"\t{YYTD_ID_NUL_TRANS, (void**)&yy_NUL_trans, sizeof(%s)},\n", |
1702 |
(fullspd) ? "struct yy_trans_info*" : |
1703 |
"flex_int32_t"); |
1704 |
|
1705 |
yynultrans_tbl = |
1706 |
(struct yytbl_data *) calloc (1, |
1707 |
sizeof (struct |
1708 |
yytbl_data)); |
1709 |
yytbl_data_init (yynultrans_tbl, YYTD_ID_NUL_TRANS); |
1710 |
if (fullspd) |
1711 |
yynultrans_tbl->td_flags |= YYTD_PTRANS; |
1712 |
yynultrans_tbl->td_lolen = lastdfa + 1; |
1713 |
yynultrans_tbl->td_data = yynultrans_data = |
1714 |
(flex_int32_t *) calloc (yynultrans_tbl->td_lolen, |
1715 |
sizeof (flex_int32_t)); |
1716 |
|
1717 |
for (i = 1; i <= lastdfa; ++i) { |
1718 |
if (fullspd) { |
1719 |
out_dec (" &yy_transition[%d],\n", |
1720 |
base[i]); |
1721 |
yynultrans_data[i] = base[i]; |
1722 |
} |
1723 |
else { |
1724 |
mkdata (nultrans[i]); |
1725 |
yynultrans_data[i] = nultrans[i]; |
1726 |
} |
1727 |
} |
1728 |
|
1729 |
dataend (); |
1730 |
if (tablesext) { |
1731 |
yytbl_data_compress (yynultrans_tbl); |
1732 |
if (yytbl_data_fwrite (&tableswr, yynultrans_tbl) < |
1733 |
0) |
1734 |
flexerror (_ |
1735 |
("Could not write yynultrans_tbl")); |
1736 |
yytbl_data_destroy (yynultrans_tbl); |
1737 |
yynultrans_tbl = NULL; |
1738 |
} |
1739 |
/* End generating yy_NUL_trans */ |
1740 |
} |
1741 |
|
1742 |
if (!C_plus_plus && !reentrant) { |
1743 |
indent_puts ("extern int yy_flex_debug;"); |
1744 |
indent_put2s ("int yy_flex_debug = %s;\n", |
1745 |
ddebug ? "1" : "0"); |
1746 |
} |
1747 |
|
1748 |
if (ddebug) { /* Spit out table mapping rules to line numbers. */ |
1749 |
out_str_dec (long_align ? get_int32_decl () : |
1750 |
get_int16_decl (), "yy_rule_linenum", |
1751 |
num_rules); |
1752 |
for (i = 1; i < num_rules; ++i) |
1753 |
mkdata (rule_linenum[i]); |
1754 |
dataend (); |
1755 |
} |
1756 |
|
1757 |
if (reject) { |
1758 |
outn ("m4_ifdef( [[M4_YY_USES_REJECT]],\n[["); |
1759 |
/* Declare state buffer variables. */ |
1760 |
if (!C_plus_plus && !reentrant) { |
1761 |
outn ("static yy_state_type *yy_state_buf=0, *yy_state_ptr=0;"); |
1762 |
outn ("static char *yy_full_match;"); |
1763 |
outn ("static int yy_lp;"); |
1764 |
} |
1765 |
|
1766 |
if (variable_trailing_context_rules) { |
1767 |
if (!C_plus_plus && !reentrant) { |
1768 |
outn ("static int yy_looking_for_trail_begin = 0;"); |
1769 |
outn ("static int yy_full_lp;"); |
1770 |
outn ("static int *yy_full_state;"); |
1771 |
} |
1772 |
|
1773 |
out_hex ("#define YY_TRAILING_MASK 0x%x\n", |
1774 |
(unsigned int) YY_TRAILING_MASK); |
1775 |
out_hex ("#define YY_TRAILING_HEAD_MASK 0x%x\n", |
1776 |
(unsigned int) YY_TRAILING_HEAD_MASK); |
1777 |
} |
1778 |
|
1779 |
outn ("#define REJECT \\"); |
1780 |
outn ("{ \\"); |
1781 |
outn ("*yy_cp = YY_G(yy_hold_char); /* undo effects of setting up yytext */ \\"); |
1782 |
outn ("yy_cp = YY_G(yy_full_match); /* restore poss. backed-over text */ \\"); |
1783 |
|
1784 |
if (variable_trailing_context_rules) { |
1785 |
outn ("YY_G(yy_lp) = YY_G(yy_full_lp); /* restore orig. accepting pos. */ \\"); |
1786 |
outn ("YY_G(yy_state_ptr) = YY_G(yy_full_state); /* restore orig. state */ \\"); |
1787 |
outn ("yy_current_state = *YY_G(yy_state_ptr); /* restore curr. state */ \\"); |
1788 |
} |
1789 |
|
1790 |
outn ("++YY_G(yy_lp); \\"); |
1791 |
outn ("goto find_rule; \\"); |
1792 |
|
1793 |
outn ("}"); |
1794 |
outn ("]])\n"); |
1795 |
} |
1796 |
|
1797 |
else { |
1798 |
outn ("/* The intent behind this definition is that it'll catch"); |
1799 |
outn (" * any uses of REJECT which flex missed."); |
1800 |
outn (" */"); |
1801 |
outn ("#define REJECT reject_used_but_not_detected"); |
1802 |
} |
1803 |
|
1804 |
if (yymore_used) { |
1805 |
if (!C_plus_plus) { |
1806 |
if (yytext_is_array) { |
1807 |
if (!reentrant){ |
1808 |
indent_puts ("static int yy_more_offset = 0;"); |
1809 |
indent_puts ("static int yy_prev_more_offset = 0;"); |
1810 |
} |
1811 |
} |
1812 |
else if (!reentrant) { |
1813 |
indent_puts |
1814 |
("static int yy_more_flag = 0;"); |
1815 |
indent_puts |
1816 |
("static int yy_more_len = 0;"); |
1817 |
} |
1818 |
} |
1819 |
|
1820 |
if (yytext_is_array) { |
1821 |
indent_puts |
1822 |
("#define yymore() (YY_G(yy_more_offset) = yy_flex_strlen( yytext M4_YY_CALL_LAST_ARG))"); |
1823 |
indent_puts ("#define YY_NEED_STRLEN"); |
1824 |
indent_puts ("#define YY_MORE_ADJ 0"); |
1825 |
indent_puts |
1826 |
("#define YY_RESTORE_YY_MORE_OFFSET \\"); |
1827 |
indent_up (); |
1828 |
indent_puts ("{ \\"); |
1829 |
indent_puts |
1830 |
("YY_G(yy_more_offset) = YY_G(yy_prev_more_offset); \\"); |
1831 |
indent_puts ("yyleng -= YY_G(yy_more_offset); \\"); |
1832 |
indent_puts ("}"); |
1833 |
indent_down (); |
1834 |
} |
1835 |
else { |
1836 |
indent_puts |
1837 |
("#define yymore() (YY_G(yy_more_flag) = 1)"); |
1838 |
indent_puts |
1839 |
("#define YY_MORE_ADJ YY_G(yy_more_len)"); |
1840 |
indent_puts ("#define YY_RESTORE_YY_MORE_OFFSET"); |
1841 |
} |
1842 |
} |
1843 |
|
1844 |
else { |
1845 |
indent_puts |
1846 |
("#define yymore() yymore_used_but_not_detected"); |
1847 |
indent_puts ("#define YY_MORE_ADJ 0"); |
1848 |
indent_puts ("#define YY_RESTORE_YY_MORE_OFFSET"); |
1849 |
} |
1850 |
|
1851 |
if (!C_plus_plus) { |
1852 |
if (yytext_is_array) { |
1853 |
outn ("#ifndef YYLMAX"); |
1854 |
outn ("#define YYLMAX 8192"); |
1855 |
outn ("#endif\n"); |
1856 |
if (!reentrant){ |
1857 |
outn ("char yytext[YYLMAX];"); |
1858 |
outn ("char *yytext_ptr;"); |
1859 |
} |
1860 |
} |
1861 |
|
1862 |
else { |
1863 |
if(! reentrant) |
1864 |
outn ("char *yytext;"); |
1865 |
} |
1866 |
} |
1867 |
|
1868 |
out (&action_array[defs1_offset]); |
1869 |
|
1870 |
line_directive_out (stdout, 0); |
1871 |
|
1872 |
skelout (); /* %% [5.0] - break point in skel */ |
1873 |
|
1874 |
if (!C_plus_plus) { |
1875 |
if (use_read) { |
1876 |
outn ("\terrno=0; \\"); |
1877 |
outn ("\twhile ( (result = read( fileno(yyin), (char *) buf, max_size )) < 0 ) \\"); |
1878 |
outn ("\t{ \\"); |
1879 |
outn ("\t\tif( errno != EINTR) \\"); |
1880 |
outn ("\t\t{ \\"); |
1881 |
outn ("\t\t\tYY_FATAL_ERROR( \"input in flex scanner failed\" ); \\"); |
1882 |
outn ("\t\t\tbreak; \\"); |
1883 |
outn ("\t\t} \\"); |
1884 |
outn ("\t\terrno=0; \\"); |
1885 |
outn ("\t\tclearerr(yyin); \\"); |
1886 |
outn ("\t}\\"); |
1887 |
} |
1888 |
|
1889 |
else { |
1890 |
outn ("\tif ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \\"); |
1891 |
outn ("\t\t{ \\"); |
1892 |
outn ("\t\tint c = '*'; \\"); |
1893 |
outn ("\t\tsize_t n; \\"); |
1894 |
outn ("\t\tfor ( n = 0; n < max_size && \\"); |
1895 |
outn ("\t\t\t (c = getc( yyin )) != EOF && c != '\\n'; ++n ) \\"); |
1896 |
outn ("\t\t\tbuf[n] = (char) c; \\"); |
1897 |
outn ("\t\tif ( c == '\\n' ) \\"); |
1898 |
outn ("\t\t\tbuf[n++] = (char) c; \\"); |
1899 |
outn ("\t\tif ( c == EOF && ferror( yyin ) ) \\"); |
1900 |
outn ("\t\t\tYY_FATAL_ERROR( \"input in flex scanner failed\" ); \\"); |
1901 |
outn ("\t\tresult = n; \\"); |
1902 |
outn ("\t\t} \\"); |
1903 |
outn ("\telse \\"); |
1904 |
outn ("\t\t{ \\"); |
1905 |
outn ("\t\terrno=0; \\"); |
1906 |
outn ("\t\twhile ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \\"); |
1907 |
outn ("\t\t\t{ \\"); |
1908 |
outn ("\t\t\tif( errno != EINTR) \\"); |
1909 |
outn ("\t\t\t\t{ \\"); |
1910 |
outn ("\t\t\t\tYY_FATAL_ERROR( \"input in flex scanner failed\" ); \\"); |
1911 |
outn ("\t\t\t\tbreak; \\"); |
1912 |
outn ("\t\t\t\t} \\"); |
1913 |
outn ("\t\t\terrno=0; \\"); |
1914 |
outn ("\t\t\tclearerr(yyin); \\"); |
1915 |
outn ("\t\t\t} \\"); |
1916 |
outn ("\t\t}\\"); |
1917 |
} |
1918 |
} |
1919 |
|
1920 |
skelout (); /* %% [6.0] - break point in skel */ |
1921 |
|
1922 |
indent_puts ("#define YY_RULE_SETUP \\"); |
1923 |
indent_up (); |
1924 |
if (bol_needed) { |
1925 |
indent_puts ("if ( yyleng > 0 ) \\"); |
1926 |
indent_up (); |
1927 |
indent_puts ("YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \\"); |
1928 |
indent_puts ("\t\t(yytext[yyleng - 1] == '\\n'); \\"); |
1929 |
indent_down (); |
1930 |
} |
1931 |
indent_puts ("YY_USER_ACTION"); |
1932 |
indent_down (); |
1933 |
|
1934 |
skelout (); /* %% [7.0] - break point in skel */ |
1935 |
|
1936 |
/* Copy prolog to output file. */ |
1937 |
out (&action_array[prolog_offset]); |
1938 |
|
1939 |
line_directive_out (stdout, 0); |
1940 |
|
1941 |
skelout (); /* %% [8.0] - break point in skel */ |
1942 |
|
1943 |
set_indent (2); |
1944 |
|
1945 |
if (yymore_used && !yytext_is_array) { |
1946 |
indent_puts ("YY_G(yy_more_len) = 0;"); |
1947 |
indent_puts ("if ( YY_G(yy_more_flag) )"); |
1948 |
indent_up (); |
1949 |
indent_puts ("{"); |
1950 |
indent_puts |
1951 |
("YY_G(yy_more_len) = YY_G(yy_c_buf_p) - YY_G(yytext_ptr);"); |
1952 |
indent_puts ("YY_G(yy_more_flag) = 0;"); |
1953 |
indent_puts ("}"); |
1954 |
indent_down (); |
1955 |
} |
1956 |
|
1957 |
skelout (); /* %% [9.0] - break point in skel */ |
1958 |
|
1959 |
gen_start_state (); |
1960 |
|
1961 |
/* Note, don't use any indentation. */ |
1962 |
outn ("yy_match:"); |
1963 |
gen_next_match (); |
1964 |
|
1965 |
skelout (); /* %% [10.0] - break point in skel */ |
1966 |
set_indent (2); |
1967 |
gen_find_action (); |
1968 |
|
1969 |
skelout (); /* %% [11.0] - break point in skel */ |
1970 |
outn ("m4_ifdef( [[M4_YY_USE_LINENO]],[["); |
1971 |
indent_puts |
1972 |
("if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] )"); |
1973 |
indent_up (); |
1974 |
indent_puts ("{"); |
1975 |
indent_puts ("yy_size_t yyl;"); |
1976 |
do_indent (); |
1977 |
out_str ("for ( yyl = %s; yyl < yyleng; ++yyl )\n", |
1978 |
yymore_used ? (yytext_is_array ? "YY_G(yy_prev_more_offset)" : |
1979 |
"YY_G(yy_more_len)") : "0"); |
1980 |
indent_up (); |
1981 |
indent_puts ("if ( yytext[yyl] == '\\n' )"); |
1982 |
indent_up (); |
1983 |
indent_puts ("M4_YY_INCR_LINENO();"); |
1984 |
indent_down (); |
1985 |
indent_down (); |
1986 |
indent_puts ("}"); |
1987 |
indent_down (); |
1988 |
outn ("]])"); |
1989 |
|
1990 |
skelout (); /* %% [12.0] - break point in skel */ |
1991 |
if (ddebug) { |
1992 |
indent_puts ("if ( yy_flex_debug )"); |
1993 |
indent_up (); |
1994 |
|
1995 |
indent_puts ("{"); |
1996 |
indent_puts ("if ( yy_act == 0 )"); |
1997 |
indent_up (); |
1998 |
indent_puts (C_plus_plus ? |
1999 |
"std::cerr << \"--scanner backing up\\n\";" : |
2000 |
"fprintf( stderr, \"--scanner backing up\\n\" );"); |
2001 |
indent_down (); |
2002 |
|
2003 |
do_indent (); |
2004 |
out_dec ("else if ( yy_act < %d )\n", num_rules); |
2005 |
indent_up (); |
2006 |
|
2007 |
if (C_plus_plus) { |
2008 |
indent_puts |
2009 |
("std::cerr << \"--accepting rule at line \" << yy_rule_linenum[yy_act] <<"); |
2010 |
indent_puts |
2011 |
(" \"(\\\"\" << yytext << \"\\\")\\n\";"); |
2012 |
} |
2013 |
else { |
2014 |
indent_puts |
2015 |
("fprintf( stderr, \"--accepting rule at line %ld (\\\"%s\\\")\\n\","); |
2016 |
|
2017 |
indent_puts |
2018 |
(" (long)yy_rule_linenum[yy_act], yytext );"); |
2019 |
} |
2020 |
|
2021 |
indent_down (); |
2022 |
|
2023 |
do_indent (); |
2024 |
out_dec ("else if ( yy_act == %d )\n", num_rules); |
2025 |
indent_up (); |
2026 |
|
2027 |
if (C_plus_plus) { |
2028 |
indent_puts |
2029 |
("std::cerr << \"--accepting default rule (\\\"\" << yytext << \"\\\")\\n\";"); |
2030 |
} |
2031 |
else { |
2032 |
indent_puts |
2033 |
("fprintf( stderr, \"--accepting default rule (\\\"%s\\\")\\n\","); |
2034 |
indent_puts (" yytext );"); |
2035 |
} |
2036 |
|
2037 |
indent_down (); |
2038 |
|
2039 |
do_indent (); |
2040 |
out_dec ("else if ( yy_act == %d )\n", num_rules + 1); |
2041 |
indent_up (); |
2042 |
|
2043 |
indent_puts (C_plus_plus ? |
2044 |
"std::cerr << \"--(end of buffer or a NUL)\\n\";" : |
2045 |
"fprintf( stderr, \"--(end of buffer or a NUL)\\n\" );"); |
2046 |
|
2047 |
indent_down (); |
2048 |
|
2049 |
do_indent (); |
2050 |
outn ("else"); |
2051 |
indent_up (); |
2052 |
|
2053 |
if (C_plus_plus) { |
2054 |
indent_puts |
2055 |
("std::cerr << \"--EOF (start condition \" << YY_START << \")\\n\";"); |
2056 |
} |
2057 |
else { |
2058 |
indent_puts |
2059 |
("fprintf( stderr, \"--EOF (start condition %d)\\n\", YY_START );"); |
2060 |
} |
2061 |
|
2062 |
indent_down (); |
2063 |
|
2064 |
indent_puts ("}"); |
2065 |
indent_down (); |
2066 |
} |
2067 |
|
2068 |
/* Copy actions to output file. */ |
2069 |
skelout (); /* %% [13.0] - break point in skel */ |
2070 |
indent_up (); |
2071 |
gen_bu_action (); |
2072 |
out (&action_array[action_offset]); |
2073 |
|
2074 |
line_directive_out (stdout, 0); |
2075 |
|
2076 |
/* generate cases for any missing EOF rules */ |
2077 |
for (i = 1; i <= lastsc; ++i) |
2078 |
if (!sceof[i]) { |
2079 |
do_indent (); |
2080 |
out_str ("case YY_STATE_EOF(%s):\n", scname[i]); |
2081 |
did_eof_rule = true; |
2082 |
} |
2083 |
|
2084 |
if (did_eof_rule) { |
2085 |
indent_up (); |
2086 |
indent_puts ("yyterminate();"); |
2087 |
indent_down (); |
2088 |
} |
2089 |
|
2090 |
|
2091 |
/* Generate code for handling NUL's, if needed. */ |
2092 |
|
2093 |
/* First, deal with backing up and setting up yy_cp if the scanner |
2094 |
* finds that it should JAM on the NUL. |
2095 |
*/ |
2096 |
skelout (); /* %% [14.0] - break point in skel */ |
2097 |
set_indent (4); |
2098 |
|
2099 |
if (fullspd || fulltbl) |
2100 |
indent_puts ("yy_cp = YY_G(yy_c_buf_p);"); |
2101 |
|
2102 |
else { /* compressed table */ |
2103 |
if (!reject && !interactive) { |
2104 |
/* Do the guaranteed-needed backing up to figure |
2105 |
* out the match. |
2106 |
*/ |
2107 |
indent_puts |
2108 |
("yy_cp = YY_G(yy_last_accepting_cpos);"); |
2109 |
indent_puts |
2110 |
("yy_current_state = YY_G(yy_last_accepting_state);"); |
2111 |
} |
2112 |
|
2113 |
else |
2114 |
/* Still need to initialize yy_cp, though |
2115 |
* yy_current_state was set up by |
2116 |
* yy_get_previous_state(). |
2117 |
*/ |
2118 |
indent_puts ("yy_cp = YY_G(yy_c_buf_p);"); |
2119 |
} |
2120 |
|
2121 |
|
2122 |
/* Generate code for yy_get_previous_state(). */ |
2123 |
set_indent (1); |
2124 |
skelout (); /* %% [15.0] - break point in skel */ |
2125 |
|
2126 |
gen_start_state (); |
2127 |
|
2128 |
set_indent (2); |
2129 |
skelout (); /* %% [16.0] - break point in skel */ |
2130 |
gen_next_state (true); |
2131 |
|
2132 |
set_indent (1); |
2133 |
skelout (); /* %% [17.0] - break point in skel */ |
2134 |
gen_NUL_trans (); |
2135 |
|
2136 |
skelout (); /* %% [18.0] - break point in skel */ |
2137 |
skelout (); /* %% [19.0] - break point in skel */ |
2138 |
/* Update BOL and yylineno inside of input(). */ |
2139 |
if (bol_needed) { |
2140 |
indent_puts |
2141 |
("YY_CURRENT_BUFFER_LVALUE->yy_at_bol = (c == '\\n');"); |
2142 |
if (do_yylineno) { |
2143 |
indent_puts |
2144 |
("if ( YY_CURRENT_BUFFER_LVALUE->yy_at_bol )"); |
2145 |
indent_up (); |
2146 |
indent_puts ("M4_YY_INCR_LINENO();"); |
2147 |
indent_down (); |
2148 |
} |
2149 |
} |
2150 |
|
2151 |
else if (do_yylineno) { |
2152 |
indent_puts ("if ( c == '\\n' )"); |
2153 |
indent_up (); |
2154 |
indent_puts ("M4_YY_INCR_LINENO();"); |
2155 |
indent_down (); |
2156 |
} |
2157 |
|
2158 |
skelout (); |
2159 |
|
2160 |
/* Copy remainder of input to output. */ |
2161 |
|
2162 |
line_directive_out (stdout, 1); |
2163 |
|
2164 |
if (sectnum == 3) { |
2165 |
OUT_BEGIN_CODE (); |
2166 |
(void) flexscan (); /* copy remainder of input to output */ |
2167 |
OUT_END_CODE (); |
2168 |
} |
2169 |
} |