![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to gen.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / pgrm / lex|
Return to gen.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / pgrm / lex |
1.1 root 1: /*-
2: * Copyright (c) 1990 The Regents of the University of California.
3: * All rights reserved.
4: *
5: * This code is derived from software contributed to Berkeley by
6: * Vern Paxson.
7: *
8: * The United States Government has rights in this work pursuant
9: * to contract no. DE-AC03-76SF00098 between the United States
10: * Department of Energy and the University of California.
11: *
12: * Redistribution and use in source and binary forms are permitted provided
13: * that: (1) source distributions retain this entire copyright notice and
14: * comment, and (2) distributions including binaries display the following
15: * acknowledgement: ``This product includes software developed by the
16: * University of California, Berkeley and its contributors'' in the
17: * documentation or other materials provided with the distribution and in
18: * all advertising materials mentioning features or use of this software.
19: * Neither the name of the University nor the names of its contributors may
20: * be used to endorse or promote products derived from this software without
21: * specific prior written permission.
22: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
23: * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
24: * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
25: */
26:
27: #ifndef lint
28: static char sccsid[] = "@(#)gen.c 5.2 (Berkeley) 6/18/90";
29: #endif /* not lint */
30:
31: /* gen - actual generation (writing) of flex scanners */
32:
33: #include "flexdef.h"
34:
35: /* declare functions that have forward references */
36:
37: void gen_next_state PROTO((int));
38: void genecs PROTO(());
39: void indent_put2s PROTO((char [], char []));
40: void indent_puts PROTO((char []));
41:
42:
43: static int indent_level = 0; /* each level is 4 spaces */
44:
45: #define indent_up() (++indent_level)
46: #define indent_down() (--indent_level)
47: #define set_indent(indent_val) indent_level = indent_val
48:
49: /* *everything* is done in terms of arrays starting at 1, so provide
50: * a null entry for the zero element of all C arrays
51: */
52: static char C_short_decl[] = "static const short int %s[%d] =\n { 0,\n";
53: static char C_long_decl[] = "static const long int %s[%d] =\n { 0,\n";
54: static char C_state_decl[] =
55: "static const yy_state_type %s[%d] =\n { 0,\n";
56:
57:
58: /* indent to the current level */
59:
60: void do_indent()
61:
62: {
63: register int i = indent_level * 4;
64:
65: while ( i >= 8 )
66: {
67: putchar( '\t' );
68: i -= 8;
69: }
70:
71: while ( i > 0 )
72: {
73: putchar( ' ' );
74: --i;
75: }
76: }
77:
78:
79: /* generate the code to keep backtracking information */
80:
81: void gen_backtracking()
82:
83: {
84: if ( reject || num_backtracking == 0 )
85: return;
86:
87: if ( fullspd )
88: indent_puts( "if ( yy_current_state[-1].yy_nxt )" );
89: else
90: indent_puts( "if ( yy_accept[yy_current_state] )" );
91:
92: indent_up();
93: indent_puts( "{" );
94: indent_puts( "yy_last_accepting_state = yy_current_state;" );
95: indent_puts( "yy_last_accepting_cpos = yy_cp;" );
96: indent_puts( "}" );
97: indent_down();
98: }
99:
100:
101: /* generate the code to perform the backtrack */
102:
103: void gen_bt_action()
104:
105: {
106: if ( reject || num_backtracking == 0 )
107: return;
108:
109: set_indent( 3 );
110:
111: indent_puts( "case 0: /* must backtrack */" );
112: indent_puts( "/* undo the effects of YY_DO_BEFORE_ACTION */" );
113: indent_puts( "*yy_cp = yy_hold_char;" );
114:
115: if ( fullspd || fulltbl )
116: indent_puts( "yy_cp = yy_last_accepting_cpos + 1;" );
117: else
118: /* backtracking info for compressed tables is taken \after/
119: * yy_cp has been incremented for the next state
120: */
121: indent_puts( "yy_cp = yy_last_accepting_cpos;" );
122:
123: indent_puts( "yy_current_state = yy_last_accepting_state;" );
124: indent_puts( "goto yy_find_action;" );
125: putchar( '\n' );
126:
127: set_indent( 0 );
128: }
129:
130:
131: /* genctbl - generates full speed compressed transition table
132: *
133: * synopsis
134: * genctbl();
135: */
136:
137: void genctbl()
138:
139: {
140: register int i;
141: int end_of_buffer_action = num_rules + 1;
142:
143: /* table of verify for transition and offset to next state */
144: printf( "static const struct yy_trans_info yy_transition[%d] =\n",
145: tblend + numecs + 1 );
146: printf( " {\n" );
147:
148: /* We want the transition to be represented as the offset to the
149: * next state, not the actual state number, which is what it currently is.
150: * The offset is base[nxt[i]] - base[chk[i]]. That's just the
151: * difference between the starting points of the two involved states
152: * (to - from).
153: *
154: * first, though, we need to find some way to put in our end-of-buffer
155: * flags and states. We do this by making a state with absolutely no
156: * transitions. We put it at the end of the table.
157: */
158: /* at this point, we're guaranteed that there's enough room in nxt[]
159: * and chk[] to hold tblend + numecs entries. We need just two slots.
160: * One for the action and one for the end-of-buffer transition. We
161: * now *assume* that we're guaranteed the only character we'll try to
162: * index this nxt/chk pair with is EOB, i.e., 0, so we don't have to
163: * make sure there's room for jam entries for other characters.
164: */
165:
166: base[lastdfa + 1] = tblend + 2;
167: nxt[tblend + 1] = end_of_buffer_action;
168: chk[tblend + 1] = numecs + 1;
169: chk[tblend + 2] = 1; /* anything but EOB */
170: nxt[tblend + 2] = 0; /* so that "make test" won't show arb. differences */
171:
172: /* make sure every state has a end-of-buffer transition and an action # */
173: for ( i = 0; i <= lastdfa; ++i )
174: {
175: register int anum = dfaacc[i].dfaacc_state;
176:
177: chk[base[i]] = EOB_POSITION;
178: chk[base[i] - 1] = ACTION_POSITION;
179: nxt[base[i] - 1] = anum; /* action number */
180: }
181:
182: for ( i = 0; i <= tblend; ++i )
183: {
184: if ( chk[i] == EOB_POSITION )
185: transition_struct_out( 0, base[lastdfa + 1] - i );
186:
187: else if ( chk[i] == ACTION_POSITION )
188: transition_struct_out( 0, nxt[i] );
189:
190: else if ( chk[i] > numecs || chk[i] == 0 )
191: transition_struct_out( 0, 0 ); /* unused slot */
192:
193: else /* verify, transition */
194: transition_struct_out( chk[i], base[nxt[i]] - (i - chk[i]) );
195: }
196:
197:
198: /* here's the final, end-of-buffer state */
199: transition_struct_out( chk[tblend + 1], nxt[tblend + 1] );
200: transition_struct_out( chk[tblend + 2], nxt[tblend + 2] );
201:
202: printf( " };\n" );
203: printf( "\n" );
204:
205: /* table of pointers to start states */
206: printf( "static const struct yy_trans_info *yy_start_state_list[%d] =\n",
207: lastsc * 2 + 1 );
208: printf( " {\n" );
209:
210: for ( i = 0; i <= lastsc * 2; ++i )
211: printf( " &yy_transition[%d],\n", base[i] );
212:
213: dataend();
214:
215: if ( useecs )
216: genecs();
217: }
218:
219:
220: /* generate equivalence-class tables */
221:
222: void genecs()
223:
224: {
225: register int i, j;
226: static char C_char_decl[] = "static const %s %s[%d] =\n { 0,\n";
227: int numrows;
228: Char clower();
229:
230: if ( numecs < csize )
231: printf( C_char_decl, "YY_CHAR", "yy_ec", csize );
232: else
233: printf( C_char_decl, "short", "yy_ec", csize );
234:
235: for ( i = 1; i < csize; ++i )
236: {
237: if ( caseins && (i >= 'A') && (i <= 'Z') )
238: ecgroup[i] = ecgroup[clower( i )];
239:
240: ecgroup[i] = abs( ecgroup[i] );
241: mkdata( ecgroup[i] );
242: }
243:
244: dataend();
245:
246: if ( trace )
247: {
248: char *readable_form();
249:
250: fputs( "\n\nEquivalence Classes:\n\n", stderr );
251:
252: numrows = csize / 8;
253:
254: for ( j = 0; j < numrows; ++j )
255: {
256: for ( i = j; i < csize; i = i + numrows )
257: {
258: fprintf( stderr, "%4s = %-2d", readable_form( i ), ecgroup[i] );
259:
260: putc( ' ', stderr );
261: }
262:
263: putc( '\n', stderr );
264: }
265: }
266: }
267:
268:
269: /* generate the code to find the action number */
270:
271: void gen_find_action()
272:
273: {
274: if ( fullspd )
275: indent_puts( "yy_act = yy_current_state[-1].yy_nxt;" );
276:
277: else if ( fulltbl )
278: indent_puts( "yy_act = yy_accept[yy_current_state];" );
279:
280: else if ( reject )
281: {
282: indent_puts( "yy_current_state = *--yy_state_ptr;" );
283: indent_puts( "yy_lp = yy_accept[yy_current_state];" );
284:
285: puts( "find_rule: /* we branch to this label when backtracking */" );
286:
287: indent_puts( "for ( ; ; ) /* until we find what rule we matched */" );
288:
289: indent_up();
290:
291: indent_puts( "{" );
292:
293: indent_puts( "if ( yy_lp && yy_lp < yy_accept[yy_current_state + 1] )" );
294: indent_up();
295: indent_puts( "{" );
296: indent_puts( "yy_act = yy_acclist[yy_lp];" );
297:
298: if ( variable_trailing_context_rules )
299: {
300: indent_puts( "if ( yy_act & YY_TRAILING_HEAD_MASK ||" );
301: indent_puts( " yy_looking_for_trail_begin )" );
302: indent_up();
303: indent_puts( "{" );
304:
305: indent_puts( "if ( yy_act == yy_looking_for_trail_begin )" );
306: indent_up();
307: indent_puts( "{" );
308: indent_puts( "yy_looking_for_trail_begin = 0;" );
309: indent_puts( "yy_act &= ~YY_TRAILING_HEAD_MASK;" );
310: indent_puts( "break;" );
311: indent_puts( "}" );
312: indent_down();
313:
314: indent_puts( "}" );
315: indent_down();
316:
317: indent_puts( "else if ( yy_act & YY_TRAILING_MASK )" );
318: indent_up();
319: indent_puts( "{" );
320: indent_puts(
321: "yy_looking_for_trail_begin = yy_act & ~YY_TRAILING_MASK;" );
322: indent_puts(
323: "yy_looking_for_trail_begin |= YY_TRAILING_HEAD_MASK;" );
324:
325: if ( real_reject )
326: {
327: /* remember matched text in case we back up due to REJECT */
328: indent_puts( "yy_full_match = yy_cp;" );
329: indent_puts( "yy_full_state = yy_state_ptr;" );
330: indent_puts( "yy_full_lp = yy_lp;" );
331: }
332:
333: indent_puts( "}" );
334: indent_down();
335:
336: indent_puts( "else" );
337: indent_up();
338: indent_puts( "{" );
339: indent_puts( "yy_full_match = yy_cp;" );
340: indent_puts( "yy_full_state = yy_state_ptr;" );
341: indent_puts( "yy_full_lp = yy_lp;" );
342: indent_puts( "break;" );
343: indent_puts( "}" );
344: indent_down();
345:
346: indent_puts( "++yy_lp;" );
347: indent_puts( "goto find_rule;" );
348: }
349:
350: else
351: {
352: /* remember matched text in case we back up due to trailing context
353: * plus REJECT
354: */
355: indent_up();
356: indent_puts( "{" );
357: indent_puts( "yy_full_match = yy_cp;" );
358: indent_puts( "break;" );
359: indent_puts( "}" );
360: indent_down();
361: }
362:
363: indent_puts( "}" );
364: indent_down();
365:
366: indent_puts( "--yy_cp;" );
367:
368: /* we could consolidate the following two lines with those at
369: * the beginning, but at the cost of complaints that we're
370: * branching inside a loop
371: */
372: indent_puts( "yy_current_state = *--yy_state_ptr;" );
373: indent_puts( "yy_lp = yy_accept[yy_current_state];" );
374:
375: indent_puts( "}" );
376:
377: indent_down();
378: }
379:
380: else
381: /* compressed */
382: indent_puts( "yy_act = yy_accept[yy_current_state];" );
383: }
384:
385:
386: /* genftbl - generates full transition table
387: *
388: * synopsis
389: * genftbl();
390: */
391:
392: void genftbl()
393:
394: {
395: register int i;
396: int end_of_buffer_action = num_rules + 1;
397:
398: printf( C_short_decl, "yy_accept", lastdfa + 1 );
399:
400:
401: dfaacc[end_of_buffer_state].dfaacc_state = end_of_buffer_action;
402:
403: for ( i = 1; i <= lastdfa; ++i )
404: {
405: register int anum = dfaacc[i].dfaacc_state;
406:
407: mkdata( anum );
408:
409: if ( trace && anum )
410: fprintf( stderr, "state # %d accepts: [%d]\n", i, anum );
411: }
412:
413: dataend();
414:
415: if ( useecs )
416: genecs();
417:
418: /* don't have to dump the actual full table entries - they were created
419: * on-the-fly
420: */
421: }
422:
423:
424: /* generate the code to find the next compressed-table state */
425:
426: void gen_next_compressed_state( char_map )
427: char *char_map;
428:
429: {
430: indent_put2s( "register YY_CHAR yy_c = %s;", char_map );
431:
432: /* save the backtracking info \before/ computing the next state
433: * because we always compute one more state than needed - we
434: * always proceed until we reach a jam state
435: */
436: gen_backtracking();
437:
438: indent_puts(
439: "while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )" );
440: indent_up();
441: indent_puts( "{" );
442: indent_puts( "yy_current_state = yy_def[yy_current_state];" );
443:
444: if ( usemecs )
445: {
446: /* we've arrange it so that templates are never chained
447: * to one another. This means we can afford make a
448: * very simple test to see if we need to convert to
449: * yy_c's meta-equivalence class without worrying
450: * about erroneously looking up the meta-equivalence
451: * class twice
452: */
453: do_indent();
454: /* lastdfa + 2 is the beginning of the templates */
455: printf( "if ( yy_current_state >= %d )\n", lastdfa + 2 );
456:
457: indent_up();
458: indent_puts( "yy_c = yy_meta[yy_c];" );
459: indent_down();
460: }
461:
462: indent_puts( "}" );
463: indent_down();
464:
465: indent_puts(
466: "yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];" );
467: }
468:
469:
470: /* generate the code to find the next match */
471:
472: void gen_next_match()
473:
474: {
475: /* NOTE - changes in here should be reflected in gen_next_state() and
476: * gen_NUL_trans()
477: */
478: char *char_map = useecs ? "yy_ec[*yy_cp]" : "*yy_cp";
479: char *char_map_2 = useecs ? "yy_ec[*++yy_cp]" : "*++yy_cp";
480:
481: if ( fulltbl )
482: {
483: indent_put2s(
484: "while ( (yy_current_state = yy_nxt[yy_current_state][%s]) > 0 )",
485: char_map );
486:
487: indent_up();
488:
489: if ( num_backtracking > 0 )
490: {
491: indent_puts( "{" );
492: gen_backtracking();
493: putchar( '\n' );
494: }
495:
496: indent_puts( "++yy_cp;" );
497:
498: if ( num_backtracking > 0 )
499: indent_puts( "}" );
500:
501: indent_down();
502:
503: putchar( '\n' );
504: indent_puts( "yy_current_state = -yy_current_state;" );
505: }
506:
507: else if ( fullspd )
508: {
509: indent_puts( "{" );
510: indent_puts( "register const struct yy_trans_info *yy_trans_info;\n" );
511: indent_puts( "register YY_CHAR yy_c;\n" );
512: indent_put2s( "for ( yy_c = %s;", char_map );
513: indent_puts(
514: " (yy_trans_info = &yy_current_state[yy_c])->yy_verify == yy_c;" );
515: indent_put2s( " yy_c = %s )", char_map_2 );
516:
517: indent_up();
518:
519: if ( num_backtracking > 0 )
520: indent_puts( "{" );
521:
522: indent_puts( "yy_current_state += yy_trans_info->yy_nxt;" );
523:
524: if ( num_backtracking > 0 )
525: {
526: putchar( '\n' );
527: gen_backtracking();
528: indent_puts( "}" );
529: }
530:
531: indent_down();
532: indent_puts( "}" );
533: }
534:
535: else
536: { /* compressed */
537: indent_puts( "do" );
538:
539: indent_up();
540: indent_puts( "{" );
541:
542: gen_next_state( false );
543:
544: indent_puts( "++yy_cp;" );
545:
546: indent_puts( "}" );
547: indent_down();
548:
549: do_indent();
550:
551: if ( interactive )
552: printf( "while ( yy_base[yy_current_state] != %d );\n", jambase );
553: else
554: printf( "while ( yy_current_state != %d );\n", jamstate );
555:
556: if ( ! reject && ! interactive )
557: {
558: /* do the guaranteed-needed backtrack to figure out the match */
559: indent_puts( "yy_cp = yy_last_accepting_cpos;" );
560: indent_puts( "yy_current_state = yy_last_accepting_state;" );
561: }
562: }
563: }
564:
565:
566: /* generate the code to find the next state */
567:
568: void gen_next_state( worry_about_NULs )
569: int worry_about_NULs;
570:
571: { /* NOTE - changes in here should be reflected in get_next_match() */
572: char char_map[256];
573:
574: if ( worry_about_NULs && ! nultrans )
575: {
576: if ( useecs )
577: (void) sprintf( char_map, "(*yy_cp ? yy_ec[*yy_cp] : %d)", NUL_ec );
578: else
579: (void) sprintf( char_map, "(*yy_cp ? *yy_cp : %d)", NUL_ec );
580: }
581:
582: else
583: (void) strcpy( char_map, useecs ? "yy_ec[*yy_cp]" : "*yy_cp" );
584:
585: if ( worry_about_NULs && nultrans )
586: {
587: if ( ! fulltbl && ! fullspd )
588: /* compressed tables backtrack *before* they match */
589: gen_backtracking();
590:
591: indent_puts( "if ( *yy_cp )" );
592: indent_up();
593: indent_puts( "{" );
594: }
595:
596: if ( fulltbl )
597: indent_put2s( "yy_current_state = yy_nxt[yy_current_state][%s];",
598: char_map );
599:
600: else if ( fullspd )
601: indent_put2s( "yy_current_state += yy_current_state[%s].yy_nxt;",
602: char_map );
603:
604: else
605: gen_next_compressed_state( char_map );
606:
607: if ( worry_about_NULs && nultrans )
608: {
609: indent_puts( "}" );
610: indent_down();
611: indent_puts( "else" );
612: indent_up();
613: indent_puts( "yy_current_state = yy_NUL_trans[yy_current_state];" );
614: indent_down();
615: }
616:
617: if ( fullspd || fulltbl )
618: gen_backtracking();
619:
620: if ( reject )
621: indent_puts( "*yy_state_ptr++ = yy_current_state;" );
622: }
623:
624:
625: /* generate the code to make a NUL transition */
626:
627: void gen_NUL_trans()
628:
629: { /* NOTE - changes in here should be reflected in get_next_match() */
630: int need_backtracking = (num_backtracking > 0 && ! reject);
631:
632: if ( need_backtracking )
633: /* we'll need yy_cp lying around for the gen_backtracking() */
634: indent_puts( "register YY_CHAR *yy_cp = yy_c_buf_p;" );
635:
636: putchar( '\n' );
637:
638: if ( nultrans )
639: {
640: indent_puts( "yy_current_state = yy_NUL_trans[yy_current_state];" );
641: indent_puts( "yy_is_jam = (yy_current_state == 0);" );
642: }
643:
644: else if ( fulltbl )
645: {
646: do_indent();
647: printf( "yy_current_state = yy_nxt[yy_current_state][%d];\n",
648: NUL_ec );
649: indent_puts( "yy_is_jam = (yy_current_state <= 0);" );
650: }
651:
652: else if ( fullspd )
653: {
654: do_indent();
655: printf( "register int yy_c = %d;\n", NUL_ec );
656:
657: indent_puts(
658: "register const struct yy_trans_info *yy_trans_info;\n" );
659: indent_puts( "yy_trans_info = &yy_current_state[yy_c];" );
660: indent_puts( "yy_current_state += yy_trans_info->yy_nxt;" );
661:
662: indent_puts( "yy_is_jam = (yy_trans_info->yy_verify != yy_c);" );
663: }
664:
665: else
666: {
667: char NUL_ec_str[20];
668:
669: (void) sprintf( NUL_ec_str, "%d", NUL_ec );
670: gen_next_compressed_state( NUL_ec_str );
671:
672: if ( reject )
673: indent_puts( "*yy_state_ptr++ = yy_current_state;" );
674:
675: do_indent();
676:
677: if ( interactive )
678: printf( "yy_is_jam = (yy_base[yy_current_state] == %d);\n",
679: jambase );
680: else
681: printf( "yy_is_jam = (yy_current_state == %d);\n", jamstate );
682: }
683:
684: /* if we've entered an accepting state, backtrack; note that
685: * compressed tables have *already* done such backtracking, so
686: * we needn't bother with it again
687: */
688: if ( need_backtracking && (fullspd || fulltbl) )
689: {
690: putchar( '\n' );
691: indent_puts( "if ( ! yy_is_jam )" );
692: indent_up();
693: indent_puts( "{" );
694: gen_backtracking();
695: indent_puts( "}" );
696: indent_down();
697: }
698: }
699:
700:
701: /* generate the code to find the start state */
702:
703: void gen_start_state()
704:
705: {
706: if ( fullspd )
707: indent_put2s( "yy_current_state = yy_start_state_list[yy_start%s];",
708: bol_needed ? " + (yy_bp[-1] == '\\n' ? 1 : 0)" : "" );
709:
710: else
711: {
712: indent_puts( "yy_current_state = yy_start;" );
713:
714: if ( bol_needed )
715: {
716: indent_puts( "if ( yy_bp[-1] == '\\n' )" );
717: indent_up();
718: indent_puts( "++yy_current_state;" );
719: indent_down();
720: }
721:
722: if ( reject )
723: {
724: /* set up for storing up states */
725: indent_puts( "yy_state_ptr = yy_state_buf;" );
726: indent_puts( "*yy_state_ptr++ = yy_current_state;" );
727: }
728: }
729: }
730:
731:
732: /* gentabs - generate data statements for the transition tables
733: *
734: * synopsis
735: * gentabs();
736: */
737:
738: void gentabs()
739:
740: {
741: int i, j, k, *accset, nacc, *acc_array, total_states;
742: int end_of_buffer_action = num_rules + 1;
743:
744: /* *everything* is done in terms of arrays starting at 1, so provide
745: * a null entry for the zero element of all C arrays
746: */
747: static char C_char_decl[] =
748: "static const YY_CHAR %s[%d] =\n { 0,\n";
749:
750: acc_array = allocate_integer_array( current_max_dfas );
751: nummt = 0;
752:
753: /* the compressed table format jams by entering the "jam state",
754: * losing information about the previous state in the process.
755: * In order to recover the previous state, we effectively need
756: * to keep backtracking information.
757: */
758: ++num_backtracking;
759:
760: if ( reject )
761: {
762: /* write out accepting list and pointer list
763: *
764: * first we generate the "yy_acclist" array. In the process, we compute
765: * the indices that will go into the "yy_accept" array, and save the
766: * indices in the dfaacc array
767: */
768: int EOB_accepting_list[2];
769:
770: /* set up accepting structures for the End Of Buffer state */
771: EOB_accepting_list[0] = 0;
772: EOB_accepting_list[1] = end_of_buffer_action;
773: accsiz[end_of_buffer_state] = 1;
774: dfaacc[end_of_buffer_state].dfaacc_set = EOB_accepting_list;
775:
776: printf( C_short_decl, "yy_acclist", max( numas, 1 ) + 1 );
777:
778: j = 1; /* index into "yy_acclist" array */
779:
780: for ( i = 1; i <= lastdfa; ++i )
781: {
782: acc_array[i] = j;
783:
784: if ( accsiz[i] != 0 )
785: {
786: accset = dfaacc[i].dfaacc_set;
787: nacc = accsiz[i];
788:
789: if ( trace )
790: fprintf( stderr, "state # %d accepts: ", i );
791:
792: for ( k = 1; k <= nacc; ++k )
793: {
794: int accnum = accset[k];
795:
796: ++j;
797:
798: if ( variable_trailing_context_rules &&
799: ! (accnum & YY_TRAILING_HEAD_MASK) &&
800: accnum > 0 &&
801: rule_type[accnum] == RULE_VARIABLE )
802: {
803: /* special hack to flag accepting number as part
804: * of trailing context rule
805: */
806: accnum |= YY_TRAILING_MASK;
807: }
808:
809: mkdata( accnum );
810:
811: if ( trace )
812: {
813: fprintf( stderr, "[%d]", accset[k] );
814:
815: if ( k < nacc )
816: fputs( ", ", stderr );
817: else
818: putc( '\n', stderr );
819: }
820: }
821: }
822: }
823:
824: /* add accepting number for the "jam" state */
825: acc_array[i] = j;
826:
827: dataend();
828: }
829:
830: else
831: {
832: dfaacc[end_of_buffer_state].dfaacc_state = end_of_buffer_action;
833:
834: for ( i = 1; i <= lastdfa; ++i )
835: acc_array[i] = dfaacc[i].dfaacc_state;
836:
837: /* add accepting number for jam state */
838: acc_array[i] = 0;
839: }
840:
841: /* spit out "yy_accept" array. If we're doing "reject", it'll be pointers
842: * into the "yy_acclist" array. Otherwise it's actual accepting numbers.
843: * In either case, we just dump the numbers.
844: */
845:
846: /* "lastdfa + 2" is the size of "yy_accept"; includes room for C arrays
847: * beginning at 0 and for "jam" state
848: */
849: k = lastdfa + 2;
850:
851: if ( reject )
852: /* we put a "cap" on the table associating lists of accepting
853: * numbers with state numbers. This is needed because we tell
854: * where the end of an accepting list is by looking at where
855: * the list for the next state starts.
856: */
857: ++k;
858:
859: printf( C_short_decl, "yy_accept", k );
860:
861: for ( i = 1; i <= lastdfa; ++i )
862: {
863: mkdata( acc_array[i] );
864:
865: if ( ! reject && trace && acc_array[i] )
866: fprintf( stderr, "state # %d accepts: [%d]\n", i, acc_array[i] );
867: }
868:
869: /* add entry for "jam" state */
870: mkdata( acc_array[i] );
871:
872: if ( reject )
873: /* add "cap" for the list */
874: mkdata( acc_array[i] );
875:
876: dataend();
877:
878: if ( useecs )
879: genecs();
880:
881: if ( usemecs )
882: {
883: /* write out meta-equivalence classes (used to index templates with) */
884:
885: if ( trace )
886: fputs( "\n\nMeta-Equivalence Classes:\n", stderr );
887:
888: printf( C_char_decl, "yy_meta", numecs + 1 );
889:
890: for ( i = 1; i <= numecs; ++i )
891: {
892: if ( trace )
893: fprintf( stderr, "%d = %d\n", i, abs( tecbck[i] ) );
894:
895: mkdata( abs( tecbck[i] ) );
896: }
897:
898: dataend();
899: }
900:
901: total_states = lastdfa + numtemps;
902:
903: printf( tblend > MAX_SHORT ? C_long_decl : C_short_decl,
904: "yy_base", total_states + 1 );
905:
906: for ( i = 1; i <= lastdfa; ++i )
907: {
908: register int d = def[i];
909:
910: if ( base[i] == JAMSTATE )
911: base[i] = jambase;
912:
913: if ( d == JAMSTATE )
914: def[i] = jamstate;
915:
916: else if ( d < 0 )
917: {
918: /* template reference */
919: ++tmpuses;
920: def[i] = lastdfa - d + 1;
921: }
922:
923: mkdata( base[i] );
924: }
925:
926: /* generate jam state's base index */
927: mkdata( base[i] );
928:
929: for ( ++i /* skip jam state */; i <= total_states; ++i )
930: {
931: mkdata( base[i] );
932: def[i] = jamstate;
933: }
934:
935: dataend();
936:
937: printf( tblend > MAX_SHORT ? C_long_decl : C_short_decl,
938: "yy_def", total_states + 1 );
939:
940: for ( i = 1; i <= total_states; ++i )
941: mkdata( def[i] );
942:
943: dataend();
944:
945: printf( lastdfa > MAX_SHORT ? C_long_decl : C_short_decl,
946: "yy_nxt", tblend + 1 );
947:
948: for ( i = 1; i <= tblend; ++i )
949: {
950: if ( nxt[i] == 0 || chk[i] == 0 )
951: nxt[i] = jamstate; /* new state is the JAM state */
952:
953: mkdata( nxt[i] );
954: }
955:
956: dataend();
957:
958: printf( lastdfa > MAX_SHORT ? C_long_decl : C_short_decl,
959: "yy_chk", tblend + 1 );
960:
961: for ( i = 1; i <= tblend; ++i )
962: {
963: if ( chk[i] == 0 )
964: ++nummt;
965:
966: mkdata( chk[i] );
967: }
968:
969: dataend();
970: }
971:
972:
973: /* write out a formatted string (with a secondary string argument) at the
974: * current indentation level, adding a final newline
975: */
976:
977: void indent_put2s( fmt, arg )
978: char fmt[], arg[];
979:
980: {
981: do_indent();
982: printf( fmt, arg );
983: putchar( '\n' );
984: }
985:
986:
987: /* write out a string at the current indentation level, adding a final
988: * newline
989: */
990:
991: void indent_puts( str )
992: char str[];
993:
994: {
995: do_indent();
996: puts( str );
997: }
998:
999:
1000: /* make_tables - generate transition tables
1001: *
1002: * synopsis
1003: * make_tables();
1004: *
1005: * Generates transition tables and finishes generating output file
1006: */
1007:
1008: void make_tables()
1009:
1010: {
1011: register int i;
1012: int did_eof_rule = false;
1013:
1014: skelout();
1015:
1016: /* first, take care of YY_DO_BEFORE_ACTION depending on yymore being used */
1017: set_indent( 2 );
1018:
1019: if ( yymore_used )
1020: {
1021: indent_puts( "yytext -= yy_more_len; \\" );
1022: indent_puts( "yyleng = yy_cp - yytext; \\" );
1023: }
1024:
1025: else
1026: indent_puts( "yyleng = yy_cp - yy_bp; \\" );
1027:
1028: set_indent( 0 );
1029:
1030: skelout();
1031:
1032:
1033: printf( "#define YY_END_OF_BUFFER %d\n", num_rules + 1 );
1034:
1035: if ( fullspd )
1036: { /* need to define the transet type as a size large
1037: * enough to hold the biggest offset
1038: */
1039: int total_table_size = tblend + numecs + 1;
1040: char *trans_offset_type =
1041: total_table_size > MAX_SHORT ? "long" : "short";
1042:
1043: set_indent( 0 );
1044: indent_puts( "struct yy_trans_info" );
1045: indent_up();
1046: indent_puts( "{" );
1047: indent_puts( "short yy_verify;" );
1048:
1049: /* in cases where its sister yy_verify *is* a "yes, there is a
1050: * transition", yy_nxt is the offset (in records) to the next state.
1051: * In most cases where there is no transition, the value of yy_nxt
1052: * is irrelevant. If yy_nxt is the -1th record of a state, though,
1053: * then yy_nxt is the action number for that state
1054: */
1055:
1056: indent_put2s( "%s yy_nxt;", trans_offset_type );
1057: indent_puts( "};" );
1058: indent_down();
1059:
1060: indent_puts( "typedef const struct yy_trans_info *yy_state_type;" );
1061: }
1062:
1063: else
1064: indent_puts( "typedef int yy_state_type;" );
1065:
1066: if ( fullspd )
1067: genctbl();
1068:
1069: else if ( fulltbl )
1070: genftbl();
1071:
1072: else
1073: gentabs();
1074:
1075: if ( num_backtracking > 0 )
1076: {
1077: indent_puts( "static yy_state_type yy_last_accepting_state;" );
1078: indent_puts( "static YY_CHAR *yy_last_accepting_cpos;\n" );
1079: }
1080:
1081: if ( nultrans )
1082: {
1083: printf( C_state_decl, "yy_NUL_trans", lastdfa + 1 );
1084:
1085: for ( i = 1; i <= lastdfa; ++i )
1086: {
1087: if ( fullspd )
1088: {
1089: if ( nultrans )
1090: printf( " &yy_transition[%d],\n", base[i] );
1091: else
1092: printf( " 0,\n" );
1093: }
1094:
1095: else
1096: mkdata( nultrans[i] );
1097: }
1098:
1099: dataend();
1100: }
1101:
1102: if ( ddebug )
1103: { /* spit out table mapping rules to line numbers */
1104: indent_puts( "extern int yy_flex_debug;" );
1105: indent_puts( "int yy_flex_debug = 1;\n" );
1106:
1107: printf( C_short_decl, "yy_rule_linenum", num_rules );
1108: for ( i = 1; i < num_rules; ++i )
1109: mkdata( rule_linenum[i] );
1110: dataend();
1111: }
1112:
1113: if ( reject )
1114: {
1115: /* declare state buffer variables */
1116: puts(
1117: "static yy_state_type yy_state_buf[YY_BUF_SIZE + 2], *yy_state_ptr;" );
1118: puts( "static YY_CHAR *yy_full_match;" );
1119: puts( "static int yy_lp;" );
1120:
1121: if ( variable_trailing_context_rules )
1122: {
1123: puts( "static int yy_looking_for_trail_begin = 0;" );
1124: puts( "static int yy_full_lp;" );
1125: puts( "static int *yy_full_state;" );
1126: printf( "#define YY_TRAILING_MASK 0x%x\n", YY_TRAILING_MASK );
1127: printf( "#define YY_TRAILING_HEAD_MASK 0x%x\n",
1128: YY_TRAILING_HEAD_MASK );
1129: }
1130:
1131: puts( "#define REJECT \\" );
1132: puts( "{ \\" );
1133: puts(
1134: "*yy_cp = yy_hold_char; /* undo effects of setting up yytext */ \\" );
1135: puts(
1136: "yy_cp = yy_full_match; /* restore poss. backed-over text */ \\" );
1137:
1138: if ( variable_trailing_context_rules )
1139: {
1140: puts( "yy_lp = yy_full_lp; /* restore orig. accepting pos. */ \\" );
1141: puts(
1142: "yy_state_ptr = yy_full_state; /* restore orig. state */ \\" );
1143: puts(
1144: "yy_current_state = *yy_state_ptr; /* restore curr. state */ \\" );
1145: }
1146:
1147: puts( "++yy_lp; \\" );
1148: puts( "goto find_rule; \\" );
1149: puts( "}" );
1150: }
1151:
1152: else
1153: {
1154: puts( "/* the intent behind this definition is that it'll catch" );
1155: puts( " * any uses of REJECT which flex missed" );
1156: puts( " */" );
1157: puts( "#define REJECT reject_used_but_not_detected" );
1158: }
1159:
1160: if ( yymore_used )
1161: {
1162: indent_puts( "static int yy_more_flag = 0;" );
1163: indent_puts( "static int yy_doing_yy_more = 0;" );
1164: indent_puts( "static int yy_more_len = 0;" );
1165: indent_puts(
1166: "#define yymore() { yy_more_flag = 1; }" );
1167: indent_puts(
1168: "#define YY_MORE_ADJ (yy_doing_yy_more ? yy_more_len : 0)" );
1169: }
1170:
1171: else
1172: {
1173: indent_puts( "#define yymore() yymore_used_but_not_detected" );
1174: indent_puts( "#define YY_MORE_ADJ 0" );
1175: }
1176:
1177: skelout();
1178:
1179: if ( ferror( temp_action_file ) )
1180: flexfatal( "error occurred when writing temporary action file" );
1181:
1182: else if ( fclose( temp_action_file ) )
1183: flexfatal( "error occurred when closing temporary action file" );
1184:
1185: temp_action_file = fopen( action_file_name, "r" );
1186:
1187: if ( temp_action_file == NULL )
1188: flexfatal( "could not re-open temporary action file" );
1189:
1190: /* copy prolog from action_file to output file */
1191: action_out();
1192:
1193: skelout();
1194:
1195: set_indent( 2 );
1196:
1197: if ( yymore_used )
1198: {
1199: indent_puts( "yy_doing_yy_more = yy_more_flag;" );
1200: indent_puts( "if ( yy_doing_yy_more )" );
1201: indent_up();
1202: indent_puts( "{" );
1203: indent_puts( "yy_more_len = yyleng;" );
1204: indent_puts( "yy_more_flag = 0;" );
1205: indent_puts( "}" );
1206: indent_down();
1207: }
1208:
1209: skelout();
1210:
1211: gen_start_state();
1212:
1213: /* note, don't use any indentation */
1214: puts( "yy_match:" );
1215: gen_next_match();
1216:
1217: skelout();
1218: set_indent( 2 );
1219: gen_find_action();
1220:
1221: skelout();
1222: if ( ddebug )
1223: {
1224: indent_puts( "if ( yy_flex_debug )" );
1225: indent_up();
1226:
1227: indent_puts( "{" );
1228: indent_puts( "if ( yy_act == 0 )" );
1229: indent_up();
1230: indent_puts( "fprintf( stderr, \"--scanner backtracking\\n\" );" );
1231: indent_down();
1232:
1233: do_indent();
1234: printf( "else if ( yy_act < %d )\n", num_rules );
1235: indent_up();
1236: indent_puts(
1237: "fprintf( stderr, \"--accepting rule at line %d (\\\"%s\\\")\\n\"," );
1238: indent_puts( " yy_rule_linenum[yy_act], yytext );" );
1239: indent_down();
1240:
1241: do_indent();
1242: printf( "else if ( yy_act == %d )\n", num_rules );
1243: indent_up();
1244: indent_puts(
1245: "fprintf( stderr, \"--accepting default rule (\\\"%s\\\")\\n\"," );
1246: indent_puts( " yytext );" );
1247: indent_down();
1248:
1249: do_indent();
1250: printf( "else if ( yy_act == %d )\n", num_rules + 1 );
1251: indent_up();
1252: indent_puts( "fprintf( stderr, \"--(end of buffer or a NUL)\\n\" );" );
1253: indent_down();
1254:
1255: do_indent();
1256: printf( "else\n" );
1257: indent_up();
1258: indent_puts( "fprintf( stderr, \"--EOF\\n\" );" );
1259: indent_down();
1260:
1261: indent_puts( "}" );
1262: indent_down();
1263: }
1264:
1265: /* copy actions from action_file to output file */
1266: skelout();
1267: indent_up();
1268: gen_bt_action();
1269: action_out();
1270:
1271: /* generate cases for any missing EOF rules */
1272: for ( i = 1; i <= lastsc; ++i )
1273: if ( ! sceof[i] )
1274: {
1275: do_indent();
1276: printf( "case YY_STATE_EOF(%s):\n", scname[i] );
1277: did_eof_rule = true;
1278: }
1279:
1280: if ( did_eof_rule )
1281: {
1282: indent_up();
1283: indent_puts( "yyterminate();" );
1284: indent_down();
1285: }
1286:
1287:
1288: /* generate code for handling NUL's, if needed */
1289:
1290: /* first, deal with backtracking and setting up yy_cp if the scanner
1291: * finds that it should JAM on the NUL
1292: */
1293: skelout();
1294: set_indent( 7 );
1295:
1296: if ( fullspd || fulltbl )
1297: indent_puts( "yy_cp = yy_c_buf_p;" );
1298:
1299: else
1300: { /* compressed table */
1301: if ( ! reject && ! interactive )
1302: {
1303: /* do the guaranteed-needed backtrack to figure out the match */
1304: indent_puts( "yy_cp = yy_last_accepting_cpos;" );
1305: indent_puts( "yy_current_state = yy_last_accepting_state;" );
1306: }
1307: }
1308:
1309:
1310: /* generate code for yy_get_previous_state() */
1311: set_indent( 1 );
1312: skelout();
1313:
1314: if ( bol_needed )
1315: indent_puts( "register YY_CHAR *yy_bp = yytext;\n" );
1316:
1317: gen_start_state();
1318:
1319: set_indent( 2 );
1320: skelout();
1321: gen_next_state( true );
1322:
1323: set_indent( 1 );
1324: skelout();
1325: gen_NUL_trans();
1326:
1327: skelout();
1328:
1329: /* copy remainder of input to output */
1330:
1331: line_directive_out( stdout );
1332: (void) flexscan(); /* copy remainder of input to output */
1333: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.