/* gen - actual generation (writing) of flex scanners */

/*  Copyright (c) 1990 The Regents of the University of California. */

/*  All rights reserved. */

/*  This code is derived from software contributed to Berkeley by */

/*  Vern Paxson. */

/*  The United States Government has rights in this work pursuant */

/*  to contract no. DE-AC03-76SF00098 between the United States */

/*  Department of Energy and the University of California. */

/*  This file is part of flex. */

/*  Redistribution and use in source and binary forms, with or without */

/*  modification, are permitted provided that the following conditions */

/*  are met: */

/*  1. Redistributions of source code must retain the above copyright */

/*     notice, this list of conditions and the following disclaimer. */

/*  2. Redistributions in binary form must reproduce the above copyright */

/*     notice, this list of conditions and the following disclaimer in the */

/*     documentation and/or other materials provided with the distribution. */

/*  Neither the name of the University nor the names of its contributors */

/*  may be used to endorse or promote products derived from this software */

/*  without specific prior written permission. */

/*  THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR */

/*  IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED */

/*  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR */

/*  PURPOSE. */

#include "flexdef.h"

#include "tables.h"

/* declare functions that have forward references */

void	genecs(void);

static int indent_level = 0;	/* each level is 8 spaces */

#define set_indent(indent_val) indent_level = indent_val

/* Almost everything is done in terms of arrays starting at 1, so provide

 * a null entry for the zero element of all C arrays.  (The exception

 * to this is that the fast table representation generally uses the

 * 0 elements of its arrays, too.)

 */

static const char *get_int16_decl (void)

{

	return (gentables)

		? "static yyconst flex_int16_t %s[%d] =\n    {   0,\n"

		: "static yyconst flex_int16_t * %s = 0;\n";

}

static const char *get_int32_decl (void)

{

	return (gentables)

		? "static yyconst flex_int32_t %s[%d] =\n    {   0,\n"

		: "static yyconst flex_int32_t * %s = 0;\n";

}

static const char *get_state_decl (void)

{

	return (gentables)

		? "static yyconst yy_state_type %s[%d] =\n    {   0,\n"

		: "static yyconst yy_state_type * %s = 0;\n";

}

static const char *get_uint16_decl (void)

{

	return (gentables)

		? "static yyconst flex_uint16_t %s[%d] =\n    {   0,\n"

		: "static yyconst flex_uint16_t * %s = 0;\n";

}

static const char *get_uint32_decl (void)

{

	return (gentables)

		? "static yyconst flex_uint32_t %s[%d] =\n    {   0,\n"

		: "static yyconst flex_uint32_t * %s = 0;\n";

}

static const char *get_yy_char_decl (void)

{

	return (gentables)

		? "static yyconst YY_CHAR %s[%d] =\n    {   0,\n"

		: "static yyconst YY_CHAR * %s = 0;\n";

}

/* Indent to the current level. */

void do_indent (void)

{

	int i = indent_level * 8;

	while (i >= 8) {

		outc ('\t');

		i -= 8;

	}

	while (i > 0) {

		outc (' ');

		--i;

	}

}

/** Make the table for possible eol matches.

 *  @return the newly allocated rule_can_match_eol table

 */

static struct yytbl_data *mkeoltbl (void)

{

	int     i;

	flex_int8_t *tdata = 0;

	struct yytbl_data *tbl;

	tbl = calloc(1, sizeof (struct yytbl_data));

	yytbl_data_init (tbl, YYTD_ID_RULE_CAN_MATCH_EOL);

	tbl->td_flags = YYTD_DATA8;

	tbl->td_lolen = num_rules + 1;

	tbl->td_data = tdata =

		calloc(tbl->td_lolen, sizeof (flex_int8_t));

	for (i = 1; i <= num_rules; i++)

		tdata[i] = rule_has_nl[i] ? 1 : 0;

	buf_prints (&yydmap_buf,

		    "\t{YYTD_ID_RULE_CAN_MATCH_EOL, (void**)&yy_rule_can_match_eol, sizeof(%s)},\n",

		    "flex_int32_t");

	return tbl;

}

/* Generate the table for possible eol matches. */

static void geneoltbl (void)

{

	int     i;

	outn ("m4_ifdef( [[M4_YY_USE_LINENO]],[[");

	outn ("/* Table of booleans, true if rule could match eol. */");

	out_str_dec (get_int32_decl (), "yy_rule_can_match_eol",

		     num_rules + 1);

	if (gentables) {

		for (i = 1; i <= num_rules; i++) {

			out_dec ("%d, ", rule_has_nl[i] ? 1 : 0);

			/* format nicely, 20 numbers per line. */

			if ((i % 20) == 19)

				out ("\n    ");

		}

		out ("    };\n");

	}

	outn ("]])");

}

/* Generate the code to keep backing-up information. */

void gen_backing_up (void)

{

	if (reject || num_backing_up == 0)

		return;

	if (fullspd)

		indent_puts ("if ( yy_current_state[-1].yy_nxt )");

	else

		indent_puts ("if ( yy_accept[yy_current_state] )");

	++indent_level;

	indent_puts ("{");

	indent_puts ("YY_G(yy_last_accepting_state) = yy_current_state;");

	indent_puts ("YY_G(yy_last_accepting_cpos) = yy_cp;");

	indent_puts ("}");

	--indent_level;

}

/* Generate the code to perform the backing up. */

void gen_bu_action (void)

{

	if (reject || num_backing_up == 0)

		return;

	set_indent (3);

	indent_puts ("case 0: /* must back up */");

	indent_puts ("/* undo the effects of YY_DO_BEFORE_ACTION */");

	indent_puts ("*yy_cp = YY_G(yy_hold_char);");

	if (fullspd || fulltbl)

		indent_puts ("yy_cp = YY_G(yy_last_accepting_cpos) + 1;");

	else

		/* Backing-up info for compressed tables is taken \after/

		 * yy_cp has been incremented for the next state.

		 */

		indent_puts ("yy_cp = YY_G(yy_last_accepting_cpos);");

	indent_puts ("yy_current_state = YY_G(yy_last_accepting_state);");

	indent_puts ("goto yy_find_action;");

	outc ('\n');

	set_indent (0);

}

/** mkctbl - make full speed compressed transition table

 * This is an array of structs; each struct a pair of integers.

 * You should call mkssltbl() immediately after this.

 * Then, I think, mkecstbl(). Arrrg.

 * @return the newly allocated trans table

 */

static struct yytbl_data *mkctbl (void)

{

	int i;

	struct yytbl_data *tbl = 0;

	flex_int32_t *tdata = 0, curr = 0;

	int     end_of_buffer_action = num_rules + 1;

	buf_prints (&yydmap_buf,

		    "\t{YYTD_ID_TRANSITION, (void**)&yy_transition, sizeof(%s)},\n",

		    ((tblend + numecs + 1) >= INT16_MAX

		     || long_align) ? "flex_int32_t" : "flex_int16_t");

	tbl = calloc(1, sizeof (struct yytbl_data));

	yytbl_data_init (tbl, YYTD_ID_TRANSITION);

	tbl->td_flags = YYTD_DATA32 | YYTD_STRUCT;

	tbl->td_hilen = 0;

	tbl->td_lolen = tblend + numecs + 1;	/* number of structs */

	tbl->td_data = tdata =

		calloc(tbl->td_lolen * 2, sizeof (flex_int32_t));

	/* We want the transition to be represented as the offset to the

	 * next state, not the actual state number, which is what it currently

	 * is.  The offset is base[nxt[i]] - (base of current state)].  That's

	 * just the difference between the starting points of the two involved

	 * states (to - from).

	 *

	 * First, though, we need to find some way to put in our end-of-buffer

	 * flags and states.  We do this by making a state with absolutely no

	 * transitions.  We put it at the end of the table.

	 */

	/* We need to have room in nxt/chk for two more slots: One for the

	 * action and one for the end-of-buffer transition.  We now *assume*

	 * that we're guaranteed the only character we'll try to index this

	 * nxt/chk pair with is EOB, i.e., 0, so we don't have to make sure

	 * there's room for jam entries for other characters.

	 */

	while (tblend + 2 >= current_max_xpairs)

		expand_nxt_chk ();

	while (lastdfa + 1 >= current_max_dfas)

		increase_max_dfas ();

	base[lastdfa + 1] = tblend + 2;

	nxt[tblend + 1] = end_of_buffer_action;

	chk[tblend + 1] = numecs + 1;

	chk[tblend + 2] = 1;	/* anything but EOB */

	/* So that "make test" won't show arb. differences. */

	nxt[tblend + 2] = 0;

	/* Make sure every state has an end-of-buffer transition and an

	 * action #.

	 */

	for (i = 0; i <= lastdfa; ++i) {

		int     anum = dfaacc[i].dfaacc_state;

		int     offset = base[i];

		chk[offset] = EOB_POSITION;

		chk[offset - 1] = ACTION_POSITION;

		nxt[offset - 1] = anum;	/* action number */

	}

	for (i = 0; i <= tblend; ++i) {

		if (chk[i] == EOB_POSITION) {

			tdata[curr++] = 0;

			tdata[curr++] = base[lastdfa + 1] - i;

		}

		else if (chk[i] == ACTION_POSITION) {

			tdata[curr++] = 0;

			tdata[curr++] = nxt[i];

		}

		else if (chk[i] > numecs || chk[i] == 0) {

			tdata[curr++] = 0;

			tdata[curr++] = 0;

		}

		else {		/* verify, transition */

			tdata[curr++] = chk[i];

			tdata[curr++] = base[nxt[i]] - (i - chk[i]);

		}

	}

	/* Here's the final, end-of-buffer state. */

	tdata[curr++] = chk[tblend + 1];

	tdata[curr++] = nxt[tblend + 1];

	tdata[curr++] = chk[tblend + 2];

	tdata[curr++] = nxt[tblend + 2];

	return tbl;

}

/** Make start_state_list table.

 *  @return the newly allocated start_state_list table

 */

static struct yytbl_data *mkssltbl (void)

{

	struct yytbl_data *tbl = 0;

	flex_int32_t *tdata = 0;

	flex_int32_t i;

	tbl = calloc(1, sizeof (struct yytbl_data));

	yytbl_data_init (tbl, YYTD_ID_START_STATE_LIST);

	tbl->td_flags = YYTD_DATA32 | YYTD_PTRANS;

	tbl->td_hilen = 0;

	tbl->td_lolen = lastsc * 2 + 1;

	tbl->td_data = tdata =

		calloc(tbl->td_lolen, sizeof (flex_int32_t));

	for (i = 0; i <= lastsc * 2; ++i)

		tdata[i] = base[i];

	buf_prints (&yydmap_buf,

		    "\t{YYTD_ID_START_STATE_LIST, (void**)&yy_start_state_list, sizeof(%s)},\n",

		    "struct yy_trans_info*");

	return tbl;

}

/* genctbl - generates full speed compressed transition table */

void genctbl (void)

{

	int i;

	int     end_of_buffer_action = num_rules + 1;

	/* Table of verify for transition and offset to next state. */

	if (gentables)

		out_dec ("static yyconst struct yy_trans_info yy_transition[%d] =\n    {\n", tblend + numecs + 1);

	else

		outn ("static yyconst struct yy_trans_info *yy_transition = 0;");

	/* We want the transition to be represented as the offset to the

	 * next state, not the actual state number, which is what it currently

	 * is.  The offset is base[nxt[i]] - (base of current state)].  That's

	 * just the difference between the starting points of the two involved

	 * states (to - from).

	 *

	 * First, though, we need to find some way to put in our end-of-buffer

	 * flags and states.  We do this by making a state with absolutely no

	 * transitions.  We put it at the end of the table.

	 */

	/* We need to have room in nxt/chk for two more slots: One for the

	 * action and one for the end-of-buffer transition.  We now *assume*

	 * that we're guaranteed the only character we'll try to index this

	 * nxt/chk pair with is EOB, i.e., 0, so we don't have to make sure

	 * there's room for jam entries for other characters.

	 */

	while (tblend + 2 >= current_max_xpairs)

		expand_nxt_chk ();

	while (lastdfa + 1 >= current_max_dfas)

		increase_max_dfas ();

	base[lastdfa + 1] = tblend + 2;

	nxt[tblend + 1] = end_of_buffer_action;

	chk[tblend + 1] = numecs + 1;

	chk[tblend + 2] = 1;	/* anything but EOB */

	/* So that "make test" won't show arb. differences. */

	nxt[tblend + 2] = 0;

	/* Make sure every state has an end-of-buffer transition and an

	 * action #.

	 */

	for (i = 0; i <= lastdfa; ++i) {

		int     anum = dfaacc[i].dfaacc_state;

		int     offset = base[i];

		chk[offset] = EOB_POSITION;

		chk[offset - 1] = ACTION_POSITION;

		nxt[offset - 1] = anum;	/* action number */

	}

	for (i = 0; i <= tblend; ++i) {

		if (chk[i] == EOB_POSITION)

			transition_struct_out (0, base[lastdfa + 1] - i);

		else if (chk[i] == ACTION_POSITION)

			transition_struct_out (0, nxt[i]);

		else if (chk[i] > numecs || chk[i] == 0)

			transition_struct_out (0, 0);	/* unused slot */

		else		/* verify, transition */

			transition_struct_out (chk[i],

					       base[nxt[i]] - (i -

							       chk[i]));

	}

	/* Here's the final, end-of-buffer state. */

	transition_struct_out (chk[tblend + 1], nxt[tblend + 1]);

	transition_struct_out (chk[tblend + 2], nxt[tblend + 2]);

	if (gentables)

		outn ("    };\n");

	/* Table of pointers to start states. */

	if (gentables)

		out_dec ("static yyconst struct yy_trans_info *yy_start_state_list[%d] =\n", lastsc * 2 + 1);

	else

		outn ("static yyconst struct yy_trans_info **yy_start_state_list =0;");

	if (gentables) {

		outn ("    {");

		for (i = 0; i <= lastsc * 2; ++i)

			out_dec ("    &yy_transition[%d],\n", base[i]);

		dataend ();

	}

	if (useecs)

		genecs ();

}

/* mkecstbl - Make equivalence-class tables.  */

static struct yytbl_data *mkecstbl (void)

{

	int i;

	struct yytbl_data *tbl = 0;

	flex_int32_t *tdata = 0;

	tbl = calloc(1, sizeof (struct yytbl_data));

	yytbl_data_init (tbl, YYTD_ID_EC);

	tbl->td_flags |= YYTD_DATA32;

	tbl->td_hilen = 0;

	tbl->td_lolen = csize;

	tbl->td_data = tdata =

		calloc(tbl->td_lolen, sizeof (flex_int32_t));

	for (i = 1; i < csize; ++i) {

		ecgroup[i] = ABS (ecgroup[i]);

		tdata[i] = ecgroup[i];

	}

	buf_prints (&yydmap_buf,

		    "\t{YYTD_ID_EC, (void**)&yy_ec, sizeof(%s)},\n",

		    "YY_CHAR");

	return tbl;

}

/* Generate equivalence-class tables. */

void genecs (void)

{

	int i, j;

	int     numrows;

	out_str_dec (get_yy_char_decl (), "yy_ec", csize);

	for (i = 1; i < csize; ++i) {

		ecgroup[i] = ABS (ecgroup[i]);

		mkdata (ecgroup[i]);

	}

	dataend ();

	if (trace) {

		fputs (_("\n\nEquivalence Classes:\n\n"), stderr);

		numrows = csize / 8;

		for (j = 0; j < numrows; ++j) {

			for (i = j; i < csize; i = i + numrows) {

				fprintf (stderr, "%4s = %-2d",

					 readable_form (i), ecgroup[i]);

				putc (' ', stderr);

			}

			putc ('\n', stderr);

		}

	}

}

/* Generate the code to find the action number. */

void gen_find_action (void)

{

	if (fullspd)

		indent_puts ("yy_act = yy_current_state[-1].yy_nxt;");

	else if (fulltbl)

		indent_puts ("yy_act = yy_accept[yy_current_state];");

	else if (reject) {

		indent_puts ("yy_current_state = *--YY_G(yy_state_ptr);");

		indent_puts ("YY_G(yy_lp) = yy_accept[yy_current_state];");

		if(reject_really_used)

			outn ("find_rule: /* we branch to this label when backing up */");

		indent_puts

			("for ( ; ; ) /* until we find what rule we matched */");

		++indent_level;

		indent_puts ("{");

		indent_puts

			("if ( YY_G(yy_lp) && YY_G(yy_lp) < yy_accept[yy_current_state + 1] )");

		++indent_level;

		indent_puts ("{");

		indent_puts ("yy_act = yy_acclist[YY_G(yy_lp)];");

		if (variable_trailing_context_rules) {

			indent_puts

				("if ( yy_act & YY_TRAILING_HEAD_MASK ||");

			indent_puts ("     YY_G(yy_looking_for_trail_begin) )");

			++indent_level;

			indent_puts ("{");

			indent_puts

				("if ( yy_act == YY_G(yy_looking_for_trail_begin) )");

			++indent_level;

			indent_puts ("{");

			indent_puts ("YY_G(yy_looking_for_trail_begin) = 0;");

			indent_puts ("yy_act &= ~YY_TRAILING_HEAD_MASK;");

			indent_puts ("break;");

			indent_puts ("}");

			--indent_level;

			indent_puts ("}");

			--indent_level;

			indent_puts

				("else if ( yy_act & YY_TRAILING_MASK )");

			++indent_level;

			indent_puts ("{");

			indent_puts

				("YY_G(yy_looking_for_trail_begin) = yy_act & ~YY_TRAILING_MASK;");

			indent_puts

				("YY_G(yy_looking_for_trail_begin) |= YY_TRAILING_HEAD_MASK;");

			if (real_reject) {

				/* Remember matched text in case we back up

				 * due to REJECT.

				 */

				indent_puts

					("YY_G(yy_full_match) = yy_cp;");

				indent_puts

					("YY_G(yy_full_state) = YY_G(yy_state_ptr);");

				indent_puts ("YY_G(yy_full_lp) = YY_G(yy_lp);");

			}

			indent_puts ("}");

			--indent_level;

			indent_puts ("else");

			++indent_level;

			indent_puts ("{");

			indent_puts ("YY_G(yy_full_match) = yy_cp;");

			indent_puts

				("YY_G(yy_full_state) = YY_G(yy_state_ptr);");

			indent_puts ("YY_G(yy_full_lp) = YY_G(yy_lp);");

			indent_puts ("break;");

			indent_puts ("}");

			--indent_level;

			indent_puts ("++YY_G(yy_lp);");

			indent_puts ("goto find_rule;");

		}

		else {

			/* Remember matched text in case we back up due to

			 * trailing context plus REJECT.

			 */

			++indent_level;

			indent_puts ("{");

			indent_puts ("YY_G(yy_full_match) = yy_cp;");

			indent_puts ("break;");

			indent_puts ("}");

			--indent_level;

		}

		indent_puts ("}");

		--indent_level;

		indent_puts ("--yy_cp;");

		/* We could consolidate the following two lines with those at

		 * the beginning, but at the cost of complaints that we're

		 * branching inside a loop.

		 */

		indent_puts ("yy_current_state = *--YY_G(yy_state_ptr);");

		indent_puts ("YY_G(yy_lp) = yy_accept[yy_current_state];");

		indent_puts ("}");

		--indent_level;

	}

	else {			/* compressed */

		indent_puts ("yy_act = yy_accept[yy_current_state];");

		if (interactive && !reject) {

			/* Do the guaranteed-needed backing up to figure out

			 * the match.

			 */

			indent_puts ("if ( yy_act == 0 )");

			++indent_level;

			indent_puts ("{ /* have to back up */");

			indent_puts

				("yy_cp = YY_G(yy_last_accepting_cpos);");

			indent_puts

				("yy_current_state = YY_G(yy_last_accepting_state);");

			indent_puts

				("yy_act = yy_accept[yy_current_state];");

			indent_puts ("}");

			--indent_level;

		}

	}

}

/* mkftbl - make the full table and return the struct .

 * you should call mkecstbl() after this.

 */

struct yytbl_data *mkftbl (void)

{

	int i;

	int     end_of_buffer_action = num_rules + 1;

	struct yytbl_data *tbl;

	flex_int32_t *tdata = 0;

	tbl = calloc(1, sizeof (struct yytbl_data));

	yytbl_data_init (tbl, YYTD_ID_ACCEPT);

	tbl->td_flags |= YYTD_DATA32;

	tbl->td_hilen = 0;	/* it's a one-dimensional array */

	tbl->td_lolen = lastdfa + 1;

	tbl->td_data = tdata =

		calloc(tbl->td_lolen, sizeof (flex_int32_t));

	dfaacc[end_of_buffer_state].dfaacc_state = end_of_buffer_action;

	for (i = 1; i <= lastdfa; ++i) {

		int anum = dfaacc[i].dfaacc_state;

		tdata[i] = anum;

		if (trace && anum)

			fprintf (stderr, _("state # %d accepts: [%d]\n"),

				 i, anum);

	}

	buf_prints (&yydmap_buf,

		    "\t{YYTD_ID_ACCEPT, (void**)&yy_accept, sizeof(%s)},\n",

		    long_align ? "flex_int32_t" : "flex_int16_t");

	return tbl;

}

/* genftbl - generate full transition table */

void genftbl (void)

{

	int i;

	int     end_of_buffer_action = num_rules + 1;

	out_str_dec (long_align ? get_int32_decl () : get_int16_decl (),

		     "yy_accept", lastdfa + 1);

	dfaacc[end_of_buffer_state].dfaacc_state = end_of_buffer_action;

	for (i = 1; i <= lastdfa; ++i) {

		int anum = dfaacc[i].dfaacc_state;

		mkdata (anum);

		if (trace && anum)

			fprintf (stderr, _("state # %d accepts: [%d]\n"),

				 i, anum);

	}

	dataend ();

	if (useecs)

		genecs ();

	/* Don't have to dump the actual full table entries - they were

	 * created on-the-fly.

	 */

}

/* Generate the code to find the next compressed-table state. */

void gen_next_compressed_state (char *char_map)

{

	indent_put2s ("YY_CHAR yy_c = %s;", char_map);

	/* Save the backing-up info \before/ computing the next state

	 * because we always compute one more state than needed - we

	 * always proceed until we reach a jam state

	 */

	gen_backing_up ();

	indent_puts

		("while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )");

	++indent_level;

	indent_puts ("{");

	indent_puts ("yy_current_state = (int) yy_def[yy_current_state];");

	if (usemecs) {

		/* We've arrange it so that templates are never chained

		 * to one another.  This means we can afford to make a

		 * very simple test to see if we need to convert to

		 * yy_c's meta-equivalence class without worrying

		 * about erroneously looking up the meta-equivalence

		 * class twice

		 */

		do_indent ();

		/* lastdfa + 2 is the beginning of the templates */

		out_dec ("if ( yy_current_state >= %d )\n", lastdfa + 2);

		++indent_level;

		indent_puts ("yy_c = yy_meta[(unsigned int) yy_c];");

		--indent_level;

	}

	indent_puts ("}");

	--indent_level;

	indent_puts

		("yy_current_state = yy_nxt[yy_base[yy_current_state] + (flex_int16_t) yy_c];");

}

/* Generate the code to find the next match. */

void gen_next_match (void)

{

	/* NOTE - changes in here should be reflected in gen_next_state() and

	 * gen_NUL_trans().

	 */

	char   *char_map = useecs ?

		"yy_ec[YY_SC_TO_UI(*yy_cp)] " : "YY_SC_TO_UI(*yy_cp)";

	char   *char_map_2 = useecs ?

		"yy_ec[YY_SC_TO_UI(*++yy_cp)] " : "YY_SC_TO_UI(*++yy_cp)";

	if (fulltbl) {

		if (gentables)

			indent_put2s

				("while ( (yy_current_state = yy_nxt[yy_current_state][ %s ]) > 0 )",

				 char_map);

		else

			indent_put2s

				("while ( (yy_current_state = yy_nxt[yy_current_state*YY_NXT_LOLEN +  %s ]) > 0 )",

				 char_map);

		++indent_level;

		if (num_backing_up > 0) {

			indent_puts ("{");

			gen_backing_up ();

			outc ('\n');

		}

		indent_puts ("++yy_cp;");

		if (num_backing_up > 0)

			indent_puts ("}");

		--indent_level;

		outc ('\n');

		indent_puts ("yy_current_state = -yy_current_state;");

	}

	else if (fullspd) {

		indent_puts ("{");

		indent_puts

			("yyconst struct yy_trans_info *yy_trans_info;\n");

		indent_puts ("YY_CHAR yy_c;\n");

		indent_put2s ("for ( yy_c = %s;", char_map);

		indent_puts

			("      (yy_trans_info = &yy_current_state[(unsigned int) yy_c])->");

		indent_puts ("yy_verify == yy_c;");

		indent_put2s ("      yy_c = %s )", char_map_2);

		++indent_level;

		if (num_backing_up > 0)

			indent_puts ("{");

		indent_puts ("yy_current_state += yy_trans_info->yy_nxt;");

		if (num_backing_up > 0) {

			outc ('\n');

			gen_backing_up ();

			indent_puts ("}");

		}

		--indent_level;

		indent_puts ("}");

	}

	else {			/* compressed */

		indent_puts ("do");

		++indent_level;

		indent_puts ("{");

		gen_next_state (false);

		indent_puts ("++yy_cp;");

		indent_puts ("}");

		--indent_level;

		do_indent ();

		if (interactive)

			out_dec ("while ( yy_base[yy_current_state] != %d );\n", jambase);

		else

			out_dec ("while ( yy_current_state != %d );\n",

				 jamstate);

		if (!reject && !interactive) {

			/* Do the guaranteed-needed backing up to figure out

			 * the match.

			 */

			indent_puts

				("yy_cp = YY_G(yy_last_accepting_cpos);");

			indent_puts

				("yy_current_state = YY_G(yy_last_accepting_state);");

		}

	}

}

/* Generate the code to find the next state. */

void gen_next_state (int worry_about_NULs)

{				/* NOTE - changes in here should be reflected in gen_next_match() */

	char    char_map[256];

	if (worry_about_NULs && !nultrans) {

		if (useecs)