1 /* gen - actual generation (writing) of flex scanners */
4 * Copyright (c) 1990 The Regents of the University of California.
7 * This code is derived from software contributed to Berkeley by
10 * The United States Government has rights in this work pursuant
11 * to contract no. DE-AC03-76SF00098 between the United States
12 * Department of Energy and the University of California.
14 * Redistribution and use in source and binary forms are permitted provided
15 * that: (1) source distributions retain this entire copyright notice and
16 * comment, and (2) distributions including binaries display the following
17 * acknowledgement: ``This product includes software developed by the
18 * University of California, Berkeley and its contributors'' in the
19 * documentation or other materials provided with the distribution and in
20 * all advertising materials mentioning features or use of this software.
21 * Neither the name of the University nor the names of its contributors may
22 * be used to endorse or promote products derived from this software without
23 * specific prior written permission.
24 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
25 * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
26 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
29 /* $Header: /home/daffy/u0/vern/flex/RCS/gen.c,v 2.56 96/05/25 20:43:38 vern Exp $ */
30 /* $FreeBSD: src/usr.bin/lex/gen.c,v 1.5 1999/10/27 07:56:44 obrien Exp $ */
31 /* $DragonFly: src/usr.bin/lex/gen.c,v 1.4 2005/08/04 17:31:22 drhodus Exp $ */
36 /* declare functions that have forward references */
38 void gen_next_state
PROTO((int));
39 void genecs
PROTO((void));
40 void indent_put2s
PROTO((char [], char []));
41 void indent_puts
PROTO((char []));
44 static int indent_level
= 0; /* each level is 8 spaces */
46 #define indent_up() (++indent_level)
47 #define indent_down() (--indent_level)
48 #define set_indent(indent_val) indent_level = indent_val
50 /* Almost everything is done in terms of arrays starting at 1, so provide
51 * a null entry for the zero element of all C arrays. (The exception
52 * to this is that the fast table representation generally uses the
53 * 0 elements of its arrays, too.)
55 static char C_int_decl
[] = "static yyconst int %s[%d] =\n { 0,\n";
56 static char C_short_decl
[] = "static yyconst short int %s[%d] =\n { 0,\n";
57 static char C_long_decl
[] = "static yyconst long int %s[%d] =\n { 0,\n";
58 static char C_state_decl
[] =
59 "static yyconst yy_state_type %s[%d] =\n { 0,\n";
62 /* Indent to the current level. */
66 int i
= indent_level
* 8;
82 /* Generate the code to keep backing-up information. */
84 void gen_backing_up(void)
86 if ( reject
|| num_backing_up
== 0 )
90 indent_puts( "if ( yy_current_state[-1].yy_nxt )" );
92 indent_puts( "if ( yy_accept[yy_current_state] )" );
96 indent_puts( "yy_last_accepting_state = yy_current_state;" );
97 indent_puts( "yy_last_accepting_cpos = yy_cp;" );
103 /* Generate the code to perform the backing up. */
105 void gen_bu_action(void)
107 if ( reject
|| num_backing_up
== 0 )
112 indent_puts( "case 0: /* must back up */" );
113 indent_puts( "/* undo the effects of YY_DO_BEFORE_ACTION */" );
114 indent_puts( "*yy_cp = yy_hold_char;" );
116 if ( fullspd
|| fulltbl
)
117 indent_puts( "yy_cp = yy_last_accepting_cpos + 1;" );
119 /* Backing-up info for compressed tables is taken \after/
120 * yy_cp has been incremented for the next state.
122 indent_puts( "yy_cp = yy_last_accepting_cpos;" );
124 indent_puts( "yy_current_state = yy_last_accepting_state;" );
125 indent_puts( "goto yy_find_action;" );
132 /* genctbl - generates full speed compressed transition table */
137 int end_of_buffer_action
= num_rules
+ 1;
139 /* Table of verify for transition and offset to next state. */
140 out_dec( "static yyconst struct yy_trans_info yy_transition[%d] =\n",
141 tblend
+ numecs
+ 1 );
144 /* We want the transition to be represented as the offset to the
145 * next state, not the actual state number, which is what it currently
146 * is. The offset is base[nxt[i]] - (base of current state)]. That's
147 * just the difference between the starting points of the two involved
148 * states (to - from).
150 * First, though, we need to find some way to put in our end-of-buffer
151 * flags and states. We do this by making a state with absolutely no
152 * transitions. We put it at the end of the table.
155 /* We need to have room in nxt/chk for two more slots: One for the
156 * action and one for the end-of-buffer transition. We now *assume*
157 * that we're guaranteed the only character we'll try to index this
158 * nxt/chk pair with is EOB, i.e., 0, so we don't have to make sure
159 * there's room for jam entries for other characters.
162 while ( tblend
+ 2 >= current_max_xpairs
)
165 while ( lastdfa
+ 1 >= current_max_dfas
)
168 base
[lastdfa
+ 1] = tblend
+ 2;
169 nxt
[tblend
+ 1] = end_of_buffer_action
;
170 chk
[tblend
+ 1] = numecs
+ 1;
171 chk
[tblend
+ 2] = 1; /* anything but EOB */
173 /* So that "make test" won't show arb. differences. */
176 /* Make sure every state has an end-of-buffer transition and an
179 for ( i
= 0; i
<= lastdfa
; ++i
)
181 int anum
= dfaacc
[i
].dfaacc_state
;
182 int offset
= base
[i
];
184 chk
[offset
] = EOB_POSITION
;
185 chk
[offset
- 1] = ACTION_POSITION
;
186 nxt
[offset
- 1] = anum
; /* action number */
189 for ( i
= 0; i
<= tblend
; ++i
)
191 if ( chk
[i
] == EOB_POSITION
)
192 transition_struct_out( 0, base
[lastdfa
+ 1] - i
);
194 else if ( chk
[i
] == ACTION_POSITION
)
195 transition_struct_out( 0, nxt
[i
] );
197 else if ( chk
[i
] > numecs
|| chk
[i
] == 0 )
198 transition_struct_out( 0, 0 ); /* unused slot */
200 else /* verify, transition */
201 transition_struct_out( chk
[i
],
202 base
[nxt
[i
]] - (i
- chk
[i
]) );
206 /* Here's the final, end-of-buffer state. */
207 transition_struct_out( chk
[tblend
+ 1], nxt
[tblend
+ 1] );
208 transition_struct_out( chk
[tblend
+ 2], nxt
[tblend
+ 2] );
212 /* Table of pointers to start states. */
214 "static yyconst struct yy_trans_info *yy_start_state_list[%d] =\n",
216 outn( " {" ); /* } so vi doesn't get confused */
218 for ( i
= 0; i
<= lastsc
* 2; ++i
)
219 out_dec( " &yy_transition[%d],\n", base
[i
] );
228 /* Generate equivalence-class tables. */
235 out_str_dec( C_int_decl
, "yy_ec", csize
);
237 for ( i
= 1; i
< csize
; ++i
)
239 if ( caseins
&& (i
>= 'A') && (i
<= 'Z') )
240 ecgroup
[i
] = ecgroup
[clower( i
)];
242 ecgroup
[i
] = ABS( ecgroup
[i
] );
243 mkdata( ecgroup
[i
] );
250 fputs( _( "\n\nEquivalence Classes:\n\n" ), stderr
);
254 for ( j
= 0; j
< numrows
; ++j
)
256 for ( i
= j
; i
< csize
; i
= i
+ numrows
)
258 fprintf( stderr
, "%4s = %-2d",
259 readable_form( i
), ecgroup
[i
] );
264 putc( '\n', stderr
);
270 /* Generate the code to find the action number. */
272 void gen_find_action(void)
275 indent_puts( "yy_act = yy_current_state[-1].yy_nxt;" );
278 indent_puts( "yy_act = yy_accept[yy_current_state];" );
282 indent_puts( "yy_current_state = *--yy_state_ptr;" );
283 indent_puts( "yy_lp = yy_accept[yy_current_state];" );
286 "find_rule: /* we branch to this label when backing up */" );
289 "for ( ; ; ) /* until we find what rule we matched */" );
296 "if ( yy_lp && yy_lp < yy_accept[yy_current_state + 1] )" );
299 indent_puts( "yy_act = yy_acclist[yy_lp];" );
301 if ( variable_trailing_context_rules
)
303 indent_puts( "if ( yy_act & YY_TRAILING_HEAD_MASK ||" );
304 indent_puts( " yy_looking_for_trail_begin )" );
309 "if ( yy_act == yy_looking_for_trail_begin )" );
312 indent_puts( "yy_looking_for_trail_begin = 0;" );
313 indent_puts( "yy_act &= ~YY_TRAILING_HEAD_MASK;" );
314 indent_puts( "break;" );
321 indent_puts( "else if ( yy_act & YY_TRAILING_MASK )" );
325 "yy_looking_for_trail_begin = yy_act & ~YY_TRAILING_MASK;" );
327 "yy_looking_for_trail_begin |= YY_TRAILING_HEAD_MASK;" );
331 /* Remember matched text in case we back up
334 indent_puts( "yy_full_match = yy_cp;" );
335 indent_puts( "yy_full_state = yy_state_ptr;" );
336 indent_puts( "yy_full_lp = yy_lp;" );
342 indent_puts( "else" );
345 indent_puts( "yy_full_match = yy_cp;" );
346 indent_puts( "yy_full_state = yy_state_ptr;" );
347 indent_puts( "yy_full_lp = yy_lp;" );
348 indent_puts( "break;" );
352 indent_puts( "++yy_lp;" );
353 indent_puts( "goto find_rule;" );
358 /* Remember matched text in case we back up due to
359 * trailing context plus REJECT.
363 indent_puts( "yy_full_match = yy_cp;" );
364 indent_puts( "break;" );
372 indent_puts( "--yy_cp;" );
374 /* We could consolidate the following two lines with those at
375 * the beginning, but at the cost of complaints that we're
376 * branching inside a loop.
378 indent_puts( "yy_current_state = *--yy_state_ptr;" );
379 indent_puts( "yy_lp = yy_accept[yy_current_state];" );
388 indent_puts( "yy_act = yy_accept[yy_current_state];" );
390 if ( interactive
&& ! reject
)
392 /* Do the guaranteed-needed backing up to figure out
395 indent_puts( "if ( yy_act == 0 )" );
397 indent_puts( "{ /* have to back up */" );
398 indent_puts( "yy_cp = yy_last_accepting_cpos;" );
400 "yy_current_state = yy_last_accepting_state;" );
401 indent_puts( "yy_act = yy_accept[yy_current_state];" );
409 /* genftbl - generate full transition table */
414 int end_of_buffer_action
= num_rules
+ 1;
416 out_str_dec( long_align
? C_long_decl
: C_short_decl
,
417 "yy_accept", lastdfa
+ 1 );
419 dfaacc
[end_of_buffer_state
].dfaacc_state
= end_of_buffer_action
;
421 for ( i
= 1; i
<= lastdfa
; ++i
)
423 int anum
= dfaacc
[i
].dfaacc_state
;
428 fprintf( stderr
, _( "state # %d accepts: [%d]\n" ),
437 /* Don't have to dump the actual full table entries - they were
438 * created on-the-fly.
443 /* Generate the code to find the next compressed-table state. */
445 void gen_next_compressed_state(char *char_map
)
447 indent_put2s( "register YY_CHAR yy_c = %s;", char_map
);
449 /* Save the backing-up info \before/ computing the next state
450 * because we always compute one more state than needed - we
451 * always proceed until we reach a jam state
456 "while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )" );
459 indent_puts( "yy_current_state = (int) yy_def[yy_current_state];" );
463 /* We've arrange it so that templates are never chained
464 * to one another. This means we can afford to make a
465 * very simple test to see if we need to convert to
466 * yy_c's meta-equivalence class without worrying
467 * about erroneously looking up the meta-equivalence
472 /* lastdfa + 2 is the beginning of the templates */
473 out_dec( "if ( yy_current_state >= %d )\n", lastdfa
+ 2 );
476 indent_puts( "yy_c = yy_meta[(unsigned int) yy_c];" );
484 "yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];" );
488 /* Generate the code to find the next match. */
490 void gen_next_match(void)
492 /* NOTE - changes in here should be reflected in gen_next_state() and
495 char *char_map
= useecs
?
496 "yy_ec[YY_SC_TO_UI(*yy_cp)]" :
497 "YY_SC_TO_UI(*yy_cp)";
499 char *char_map_2
= useecs
?
500 "yy_ec[YY_SC_TO_UI(*++yy_cp)]" :
501 "YY_SC_TO_UI(*++yy_cp)";
506 "while ( (yy_current_state = yy_nxt[yy_current_state][%s]) > 0 )",
511 if ( num_backing_up
> 0 )
513 indent_puts( "{" ); /* } for vi */
518 indent_puts( "++yy_cp;" );
520 if ( num_backing_up
> 0 )
527 indent_puts( "yy_current_state = -yy_current_state;" );
532 indent_puts( "{" ); /* } for vi */
534 "register yyconst struct yy_trans_info *yy_trans_info;\n" );
535 indent_puts( "register YY_CHAR yy_c;\n" );
536 indent_put2s( "for ( yy_c = %s;", char_map
);
538 " (yy_trans_info = &yy_current_state[(unsigned int) yy_c])->" );
539 indent_puts( "yy_verify == yy_c;" );
540 indent_put2s( " yy_c = %s )", char_map_2
);
544 if ( num_backing_up
> 0 )
545 indent_puts( "{" ); /* } for vi */
547 indent_puts( "yy_current_state += yy_trans_info->yy_nxt;" );
549 if ( num_backing_up
> 0 )
552 gen_backing_up(); /* { for vi */
556 indent_down(); /* { for vi */
565 indent_puts( "{" ); /* } for vi */
567 gen_next_state( false );
569 indent_puts( "++yy_cp;" );
578 out_dec( "while ( yy_base[yy_current_state] != %d );\n",
581 out_dec( "while ( yy_current_state != %d );\n",
584 if ( ! reject
&& ! interactive
)
586 /* Do the guaranteed-needed backing up to figure out
589 indent_puts( "yy_cp = yy_last_accepting_cpos;" );
591 "yy_current_state = yy_last_accepting_state;" );
597 /* Generate the code to find the next state. */
599 void gen_next_state(int worry_about_NULs
)
600 { /* NOTE - changes in here should be reflected in gen_next_match() */
603 if ( worry_about_NULs
&& ! nultrans
)
606 (void) sprintf( char_map
,
607 "(*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : %d)",
610 (void) sprintf( char_map
,
611 "(*yy_cp ? YY_SC_TO_UI(*yy_cp) : %d)", NUL_ec
);
615 strcpy( char_map
, useecs
?
616 "yy_ec[YY_SC_TO_UI(*yy_cp)]" : "YY_SC_TO_UI(*yy_cp)" );
618 if ( worry_about_NULs
&& nultrans
)
620 if ( ! fulltbl
&& ! fullspd
)
621 /* Compressed tables back up *before* they match. */
624 indent_puts( "if ( *yy_cp )" );
626 indent_puts( "{" ); /* } for vi */
631 "yy_current_state = yy_nxt[yy_current_state][%s];",
636 "yy_current_state += yy_current_state[%s].yy_nxt;",
640 gen_next_compressed_state( char_map
);
642 if ( worry_about_NULs
&& nultrans
)
647 indent_puts( "else" );
650 "yy_current_state = yy_NUL_trans[yy_current_state];" );
654 if ( fullspd
|| fulltbl
)
658 indent_puts( "*yy_state_ptr++ = yy_current_state;" );
662 /* Generate the code to make a NUL transition. */
664 void gen_NUL_trans(void)
665 { /* NOTE - changes in here should be reflected in gen_next_match() */
666 /* Only generate a definition for "yy_cp" if we'll generate code
667 * that uses it. Otherwise lint and the like complain.
669 int need_backing_up
= (num_backing_up
> 0 && ! reject
);
671 if ( need_backing_up
&& (! nultrans
|| fullspd
|| fulltbl
) )
672 /* We're going to need yy_cp lying around for the call
673 * below to gen_backing_up().
675 indent_puts( "register char *yy_cp = yy_c_buf_p;" );
682 "yy_current_state = yy_NUL_trans[yy_current_state];" );
683 indent_puts( "yy_is_jam = (yy_current_state == 0);" );
689 out_dec( "yy_current_state = yy_nxt[yy_current_state][%d];\n",
691 indent_puts( "yy_is_jam = (yy_current_state <= 0);" );
697 out_dec( "register int yy_c = %d;\n", NUL_ec
);
700 "register yyconst struct yy_trans_info *yy_trans_info;\n" );
702 "yy_trans_info = &yy_current_state[(unsigned int) yy_c];" );
703 indent_puts( "yy_current_state += yy_trans_info->yy_nxt;" );
706 "yy_is_jam = (yy_trans_info->yy_verify != yy_c);" );
713 (void) sprintf( NUL_ec_str
, "%d", NUL_ec
);
714 gen_next_compressed_state( NUL_ec_str
);
717 out_dec( "yy_is_jam = (yy_current_state == %d);\n", jamstate
);
721 /* Only stack this state if it's a transition we
722 * actually make. If we stack it on a jam, then
723 * the state stack and yy_c_buf_p get out of sync.
725 indent_puts( "if ( ! yy_is_jam )" );
727 indent_puts( "*yy_state_ptr++ = yy_current_state;" );
732 /* If we've entered an accepting state, back up; note that
733 * compressed tables have *already* done such backing up, so
734 * we needn't bother with it again.
736 if ( need_backing_up
&& (fullspd
|| fulltbl
) )
739 indent_puts( "if ( ! yy_is_jam )" );
749 /* Generate the code to find the start state. */
751 void gen_start_state(void)
758 "yy_current_state = yy_start_state_list[yy_start + YY_AT_BOL()];" );
762 "yy_current_state = yy_start_state_list[yy_start];" );
767 indent_puts( "yy_current_state = yy_start;" );
770 indent_puts( "yy_current_state += YY_AT_BOL();" );
774 /* Set up for storing up states. */
775 indent_puts( "yy_state_ptr = yy_state_buf;" );
776 indent_puts( "*yy_state_ptr++ = yy_current_state;" );
782 /* gentabs - generate data statements for the transition tables */
786 int i
, j
, k
, *accset
, nacc
, *acc_array
, total_states
;
787 int end_of_buffer_action
= num_rules
+ 1;
789 acc_array
= allocate_integer_array( current_max_dfas
);
792 /* The compressed table format jams by entering the "jam state",
793 * losing information about the previous state in the process.
794 * In order to recover the previous state, we effectively need
795 * to keep backing-up information.
801 /* Write out accepting list and pointer list.
803 * First we generate the "yy_acclist" array. In the process,
804 * we compute the indices that will go into the "yy_accept"
805 * array, and save the indices in the dfaacc array.
807 int EOB_accepting_list
[2];
809 /* Set up accepting structures for the End Of Buffer state. */
810 EOB_accepting_list
[0] = 0;
811 EOB_accepting_list
[1] = end_of_buffer_action
;
812 accsiz
[end_of_buffer_state
] = 1;
813 dfaacc
[end_of_buffer_state
].dfaacc_set
= EOB_accepting_list
;
815 out_str_dec( long_align
? C_long_decl
: C_short_decl
,
816 "yy_acclist", MAX( numas
, 1 ) + 1 );
818 j
= 1; /* index into "yy_acclist" array */
820 for ( i
= 1; i
<= lastdfa
; ++i
)
824 if ( accsiz
[i
] != 0 )
826 accset
= dfaacc
[i
].dfaacc_set
;
831 _( "state # %d accepts: " ),
834 for ( k
= 1; k
<= nacc
; ++k
)
836 int accnum
= accset
[k
];
840 if ( variable_trailing_context_rules
&&
841 ! (accnum
& YY_TRAILING_HEAD_MASK
) &&
842 accnum
> 0 && accnum
<= num_rules
&&
843 rule_type
[accnum
] == RULE_VARIABLE
)
845 /* Special hack to flag
846 * accepting number as part
847 * of trailing context rule.
849 accnum
|= YY_TRAILING_MASK
;
856 fprintf( stderr
, "[%d]",
860 fputs( ", ", stderr
);
862 putc( '\n', stderr
);
868 /* add accepting number for the "jam" state */
876 dfaacc
[end_of_buffer_state
].dfaacc_state
= end_of_buffer_action
;
878 for ( i
= 1; i
<= lastdfa
; ++i
)
879 acc_array
[i
] = dfaacc
[i
].dfaacc_state
;
881 /* add accepting number for jam state */
885 /* Spit out "yy_accept" array. If we're doing "reject", it'll be
886 * pointers into the "yy_acclist" array. Otherwise it's actual
887 * accepting numbers. In either case, we just dump the numbers.
890 /* "lastdfa + 2" is the size of "yy_accept"; includes room for C arrays
891 * beginning at 0 and for "jam" state.
896 /* We put a "cap" on the table associating lists of accepting
897 * numbers with state numbers. This is needed because we tell
898 * where the end of an accepting list is by looking at where
899 * the list for the next state starts.
903 out_str_dec( long_align
? C_long_decl
: C_short_decl
, "yy_accept", k
);
905 for ( i
= 1; i
<= lastdfa
; ++i
)
907 mkdata( acc_array
[i
] );
909 if ( ! reject
&& trace
&& acc_array
[i
] )
910 fprintf( stderr
, _( "state # %d accepts: [%d]\n" ),
914 /* Add entry for "jam" state. */
915 mkdata( acc_array
[i
] );
918 /* Add "cap" for the list. */
919 mkdata( acc_array
[i
] );
928 /* Write out meta-equivalence classes (used to index
933 fputs( _( "\n\nMeta-Equivalence Classes:\n" ),
936 out_str_dec( C_int_decl
, "yy_meta", numecs
+ 1 );
938 for ( i
= 1; i
<= numecs
; ++i
)
941 fprintf( stderr
, "%d = %d\n",
942 i
, ABS( tecbck
[i
] ) );
944 mkdata( ABS( tecbck
[i
] ) );
950 total_states
= lastdfa
+ numtemps
;
952 out_str_dec( (tblend
>= MAX_SHORT
|| long_align
) ?
953 C_long_decl
: C_short_decl
,
954 "yy_base", total_states
+ 1 );
956 for ( i
= 1; i
<= lastdfa
; ++i
)
960 if ( base
[i
] == JAMSTATE
)
968 /* Template reference. */
970 def
[i
] = lastdfa
- d
+ 1;
976 /* Generate jam state's base index. */
979 for ( ++i
/* skip jam state */; i
<= total_states
; ++i
)
987 out_str_dec( (total_states
>= MAX_SHORT
|| long_align
) ?
988 C_long_decl
: C_short_decl
,
989 "yy_def", total_states
+ 1 );
991 for ( i
= 1; i
<= total_states
; ++i
)
996 out_str_dec( (total_states
>= MAX_SHORT
|| long_align
) ?
997 C_long_decl
: C_short_decl
,
998 "yy_nxt", tblend
+ 1 );
1000 for ( i
= 1; i
<= tblend
; ++i
)
1002 /* Note, the order of the following test is important.
1003 * If chk[i] is 0, then nxt[i] is undefined.
1005 if ( chk
[i
] == 0 || nxt
[i
] == 0 )
1006 nxt
[i
] = jamstate
; /* new state is the JAM state */
1013 out_str_dec( (total_states
>= MAX_SHORT
|| long_align
) ?
1014 C_long_decl
: C_short_decl
,
1015 "yy_chk", tblend
+ 1 );
1017 for ( i
= 1; i
<= tblend
; ++i
)
1029 /* Write out a formatted string (with a secondary string argument) at the
1030 * current indentation level, adding a final newline.
1033 void indent_put2s(char *fmt
, char *arg
)
1036 out_str( fmt
, arg
);
1041 /* Write out a string at the current indentation level, adding a final
1045 void indent_puts(char *str
)
1052 /* make_tables - generate transition tables and finishes generating output file
1055 void make_tables(void)
1058 int did_eof_rule
= false;
1062 /* First, take care of YY_DO_BEFORE_ACTION depending on yymore
1067 if ( yymore_used
&& ! yytext_is_array
)
1069 indent_puts( "yytext_ptr -= yy_more_len; \\" );
1070 indent_puts( "yyleng = (int) (yy_cp - yytext_ptr); \\" );
1074 indent_puts( "yyleng = (int) (yy_cp - yy_bp); \\" );
1076 /* Now also deal with copying yytext_ptr to yytext if needed. */
1078 if ( yytext_is_array
)
1082 "if ( yyleng + yy_more_offset >= YYLMAX ) \\" );
1084 indent_puts( "if ( yyleng >= YYLMAX ) \\" );
1088 "YY_FATAL_ERROR( \"token too large, exceeds YYLMAX\" ); \\" );
1094 "yy_flex_strncpy( &yytext[yy_more_offset], yytext_ptr, yyleng + 1 ); \\" );
1095 indent_puts( "yyleng += yy_more_offset; \\" );
1097 "yy_prev_more_offset = yy_more_offset; \\" );
1098 indent_puts( "yy_more_offset = 0; \\" );
1103 "yy_flex_strncpy( yytext, yytext_ptr, yyleng + 1 ); \\" );
1112 out_dec( "#define YY_NUM_RULES %d\n", num_rules
);
1113 out_dec( "#define YY_END_OF_BUFFER %d\n", num_rules
+ 1 );
1117 /* Need to define the transet type as a size large
1118 * enough to hold the biggest offset.
1120 int total_table_size
= tblend
+ numecs
+ 1;
1121 char *trans_offset_type
=
1122 (total_table_size
>= MAX_SHORT
|| long_align
) ?
1126 indent_puts( "struct yy_trans_info" );
1128 indent_puts( "{" ); /* } for vi */
1131 indent_puts( "long yy_verify;" );
1133 indent_puts( "short yy_verify;" );
1135 /* In cases where its sister yy_verify *is* a "yes, there is
1136 * a transition", yy_nxt is the offset (in records) to the
1137 * next state. In most cases where there is no transition,
1138 * the value of yy_nxt is irrelevant. If yy_nxt is the -1th
1139 * record of a state, though, then yy_nxt is the action number
1143 indent_put2s( "%s yy_nxt;", trans_offset_type
);
1144 indent_puts( "};" );
1155 /* Definitions for backing up. We don't need them if REJECT
1156 * is being used because then we use an alternative backin-up
1157 * technique instead.
1159 if ( num_backing_up
> 0 && ! reject
)
1161 if ( ! C_plus_plus
)
1164 "static yy_state_type yy_last_accepting_state;" );
1166 "static char *yy_last_accepting_cpos;\n" );
1172 out_str_dec( C_state_decl
, "yy_NUL_trans", lastdfa
+ 1 );
1174 for ( i
= 1; i
<= lastdfa
; ++i
)
1177 out_dec( " &yy_transition[%d],\n", base
[i
] );
1179 mkdata( nultrans
[i
] );
1186 { /* Spit out table mapping rules to line numbers. */
1187 if ( ! C_plus_plus
)
1189 indent_puts( "extern int yy_flex_debug;" );
1190 indent_puts( "int yy_flex_debug = 1;\n" );
1193 out_str_dec( long_align
? C_long_decl
: C_short_decl
,
1194 "yy_rule_linenum", num_rules
);
1195 for ( i
= 1; i
< num_rules
; ++i
)
1196 mkdata( rule_linenum
[i
] );
1202 /* Declare state buffer variables. */
1203 if ( ! C_plus_plus
)
1206 "static yy_state_type yy_state_buf[YY_BUF_SIZE + 2], *yy_state_ptr;" );
1207 outn( "static char *yy_full_match;" );
1208 outn( "static int yy_lp;" );
1211 if ( variable_trailing_context_rules
)
1213 if ( ! C_plus_plus
)
1216 "static int yy_looking_for_trail_begin = 0;" );
1217 outn( "static int yy_full_lp;" );
1218 outn( "static int *yy_full_state;" );
1221 out_hex( "#define YY_TRAILING_MASK 0x%x\n",
1222 (unsigned int) YY_TRAILING_MASK
);
1223 out_hex( "#define YY_TRAILING_HEAD_MASK 0x%x\n",
1224 (unsigned int) YY_TRAILING_HEAD_MASK
);
1227 outn( "#define REJECT \\" );
1228 outn( "{ \\" ); /* } for vi */
1230 "*yy_cp = yy_hold_char; /* undo effects of setting up yytext */ \\" );
1232 "yy_cp = yy_full_match; /* restore poss. backed-over text */ \\" );
1234 if ( variable_trailing_context_rules
)
1237 "yy_lp = yy_full_lp; /* restore orig. accepting pos. */ \\" );
1239 "yy_state_ptr = yy_full_state; /* restore orig. state */ \\" );
1241 "yy_current_state = *yy_state_ptr; /* restore curr. state */ \\" );
1244 outn( "++yy_lp; \\" );
1245 outn( "goto find_rule; \\" );
1253 "/* The intent behind this definition is that it'll catch" );
1254 outn( " * any uses of REJECT which flex missed." );
1256 outn( "#define REJECT reject_used_but_not_detected" );
1261 if ( ! C_plus_plus
)
1263 if ( yytext_is_array
)
1265 indent_puts( "static int yy_more_offset = 0;" );
1267 "static int yy_prev_more_offset = 0;" );
1271 indent_puts( "static int yy_more_flag = 0;" );
1272 indent_puts( "static int yy_more_len = 0;" );
1276 if ( yytext_is_array
)
1279 "#define yymore() (yy_more_offset = yy_flex_strlen( yytext ))" );
1280 indent_puts( "#define YY_NEED_STRLEN" );
1281 indent_puts( "#define YY_MORE_ADJ 0" );
1282 indent_puts( "#define YY_RESTORE_YY_MORE_OFFSET \\" );
1284 indent_puts( "{ \\" );
1285 indent_puts( "yy_more_offset = yy_prev_more_offset; \\" );
1286 indent_puts( "yyleng -= yy_more_offset; \\" );
1292 indent_puts( "#define yymore() (yy_more_flag = 1)" );
1293 indent_puts( "#define YY_MORE_ADJ yy_more_len" );
1294 indent_puts( "#define YY_RESTORE_YY_MORE_OFFSET" );
1300 indent_puts( "#define yymore() yymore_used_but_not_detected" );
1301 indent_puts( "#define YY_MORE_ADJ 0" );
1302 indent_puts( "#define YY_RESTORE_YY_MORE_OFFSET" );
1305 if ( ! C_plus_plus
)
1307 if ( yytext_is_array
)
1309 outn( "#ifndef YYLMAX" );
1310 outn( "#define YYLMAX 8192" );
1312 outn( "char yytext[YYLMAX];" );
1313 outn( "char *yytext_ptr;" );
1317 outn( "char *yytext;" );
1320 out( &action_array
[defs1_offset
] );
1322 line_directive_out( stdout
, 0 );
1326 if ( ! C_plus_plus
)
1331 "\tif ( (result = read( fileno(yyin), (char *) buf, max_size )) < 0 ) \\" );
1333 "\t\tYY_FATAL_ERROR( \"input in flex scanner failed\" );" );
1339 "\tif ( yy_current_buffer->yy_is_interactive ) \\" );
1341 outn( "\t\tint c = '*', n; \\" );
1342 outn( "\t\tfor ( n = 0; n < max_size && \\" );
1343 outn( "\t\t\t (c = getc( yyin )) != EOF && c != '\\n'; ++n ) \\" );
1344 outn( "\t\t\tbuf[n] = (char) c; \\" );
1345 outn( "\t\tif ( c == '\\n' ) \\" );
1346 outn( "\t\t\tbuf[n++] = (char) c; \\" );
1347 outn( "\t\tif ( c == EOF && ferror( yyin ) ) \\" );
1349 "\t\t\tYY_FATAL_ERROR( \"input in flex scanner failed\" ); \\" );
1350 outn( "\t\tresult = n; \\" );
1353 "\telse if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \\" );
1354 outn( "\t\t && ferror( yyin ) ) \\" );
1356 "\t\tYY_FATAL_ERROR( \"input in flex scanner failed\" );" );
1362 indent_puts( "#define YY_RULE_SETUP \\" );
1366 indent_puts( "if ( yyleng > 0 ) \\" );
1368 indent_puts( "yy_current_buffer->yy_at_bol = \\" );
1369 indent_puts( "\t\t(yytext[yyleng - 1] == '\\n'); \\" );
1372 indent_puts( "YY_USER_ACTION" );
1377 /* Copy prolog to output file. */
1378 out( &action_array
[prolog_offset
] );
1380 line_directive_out( stdout
, 0 );
1386 if ( yymore_used
&& ! yytext_is_array
)
1388 indent_puts( "yy_more_len = 0;" );
1389 indent_puts( "if ( yy_more_flag )" );
1392 indent_puts( "yy_more_len = yy_c_buf_p - yytext_ptr;" );
1393 indent_puts( "yy_more_flag = 0;" );
1402 /* Note, don't use any indentation. */
1403 outn( "yy_match:" );
1413 indent_puts( "if ( yy_act != YY_END_OF_BUFFER )" );
1416 indent_puts( "int yyl;" );
1417 indent_puts( "for ( yyl = 0; yyl < yyleng; ++yyl )" );
1419 indent_puts( "if ( yytext[yyl] == '\\n' )" );
1421 indent_puts( "++yylineno;" );
1431 indent_puts( "if ( yy_flex_debug )" );
1435 indent_puts( "if ( yy_act == 0 )" );
1437 indent_puts( C_plus_plus
?
1438 "cerr << \"--scanner backing up\\n\";" :
1439 "fprintf( stderr, \"--scanner backing up\\n\" );" );
1443 out_dec( "else if ( yy_act < %d )\n", num_rules
);
1449 "cerr << \"--accepting rule at line \" << yy_rule_linenum[yy_act] <<" );
1451 " \"(\\\"\" << yytext << \"\\\")\\n\";" );
1456 "fprintf( stderr, \"--accepting rule at line %d (\\\"%s\\\")\\n\"," );
1459 " yy_rule_linenum[yy_act], yytext );" );
1465 out_dec( "else if ( yy_act == %d )\n", num_rules
);
1471 "cerr << \"--accepting default rule (\\\"\" << yytext << \"\\\")\\n\";" );
1476 "fprintf( stderr, \"--accepting default rule (\\\"%s\\\")\\n\"," );
1477 indent_puts( " yytext );" );
1483 out_dec( "else if ( yy_act == %d )\n", num_rules
+ 1 );
1486 indent_puts( C_plus_plus
?
1487 "cerr << \"--(end of buffer or a NUL)\\n\";" :
1488 "fprintf( stderr, \"--(end of buffer or a NUL)\\n\" );" );
1499 "cerr << \"--EOF (start condition \" << YY_START << \")\\n\";" );
1504 "fprintf( stderr, \"--EOF (start condition %d)\\n\", YY_START );" );
1513 /* Copy actions to output file. */
1517 out( &action_array
[action_offset
] );
1519 line_directive_out( stdout
, 0 );
1521 /* generate cases for any missing EOF rules */
1522 for ( i
= 1; i
<= lastsc
; ++i
)
1526 out_str( "case YY_STATE_EOF(%s):\n", scname
[i
] );
1527 did_eof_rule
= true;
1533 indent_puts( "yyterminate();" );
1538 /* Generate code for handling NUL's, if needed. */
1540 /* First, deal with backing up and setting up yy_cp if the scanner
1541 * finds that it should JAM on the NUL.
1546 if ( fullspd
|| fulltbl
)
1547 indent_puts( "yy_cp = yy_c_buf_p;" );
1550 { /* compressed table */
1551 if ( ! reject
&& ! interactive
)
1553 /* Do the guaranteed-needed backing up to figure
1556 indent_puts( "yy_cp = yy_last_accepting_cpos;" );
1558 "yy_current_state = yy_last_accepting_state;" );
1562 /* Still need to initialize yy_cp, though
1563 * yy_current_state was set up by
1564 * yy_get_previous_state().
1566 indent_puts( "yy_cp = yy_c_buf_p;" );
1570 /* Generate code for yy_get_previous_state(). */
1578 gen_next_state( true );
1586 { /* update yylineno inside of unput() */
1587 indent_puts( "if ( c == '\\n' )" );
1589 indent_puts( "--yylineno;" );
1594 /* Update BOL and yylineno inside of input(). */
1597 indent_puts( "yy_current_buffer->yy_at_bol = (c == '\\n');" );
1600 indent_puts( "if ( yy_current_buffer->yy_at_bol )" );
1602 indent_puts( "++yylineno;" );
1607 else if ( do_yylineno
)
1609 indent_puts( "if ( c == '\\n' )" );
1611 indent_puts( "++yylineno;" );
1617 /* Copy remainder of input to output. */
1619 line_directive_out( stdout
, 1 );
1622 (void) flexscan(); /* copy remainder of input to output */