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