#endif/* No semi-colon after return; correct usage is to write "yyterminate();" - * we don't want an extra ';' after the "return" because that will cause * some compilers to complain about unreachable statements. */#ifndef yyterminate#define yyterminate() return YY_NULL#endif/* Number of entries by which start-condition stack grows. */#ifndef YY_START_STACK_INCR#define YY_START_STACK_INCR 25#endif/* Report a fatal error. */#ifndef YY_FATAL_ERROR#define YY_FATAL_ERROR(msg) yy_fatal_error( msg )#endif/* end tables serialization structures and prototypes *//* Default declaration of generated scanner - a define so the user can * easily add parameters. */#ifndef YY_DECL#define YY_DECL_IS_OURS 1extern int yylex (void);#define YY_DECL int yylex (void)#endif /* !YY_DECL *//* Code executed at the beginning of each rule, after yytext and yyleng * have been set up. */#ifndef YY_USER_ACTION#define YY_USER_ACTION#endif/* Code executed at the end of each rule. */#ifndef YY_BREAK#define YY_BREAK break;#endif#define YY_RULE_SETUP \	if ( yyleng > 0 ) \		YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \				(yytext[yyleng - 1] == '\n'); \	YY_USER_ACTION/** The main scanner function which does all the work. */YY_DECL{	register yy_state_type yy_current_state;	register char *yy_cp, *yy_bp;	register int yy_act;    #line 31 "conf/tokens.l"#line 662 "tokens.c"	if ( (yy_init) )		{		(yy_init) = 0;#ifdef YY_USER_INIT		YY_USER_INIT;#endif		if ( ! (yy_start) )			(yy_start) = 1;	/* first start state */		if ( ! yyin )			yyin = stdin;		if ( ! yyout )			yyout = stdout;		if ( ! YY_CURRENT_BUFFER ) {			yyensure_buffer_stack ();			YY_CURRENT_BUFFER_LVALUE =				yy_create_buffer(yyin,YY_BUF_SIZE );		}		yy_load_buffer_state( );		}	while ( 1 )		/* loops until end-of-file is reached */		{		yy_cp = (yy_c_buf_p);		/* Support of yytext. */		*yy_cp = (yy_hold_char);		/* yy_bp points to the position in yy_ch_buf of the start of		 * the current run.		 */		yy_bp = yy_cp;		yy_current_state = (yy_start);		yy_current_state += YY_AT_BOL();yy_match:		do			{			register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];			if ( yy_accept[yy_current_state] )				{				(yy_last_accepting_state) = yy_current_state;				(yy_last_accepting_cpos) = yy_cp;				}			while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )				{				yy_current_state = (int) yy_def[yy_current_state];				if ( yy_current_state >= 31 )					yy_c = yy_meta[(unsigned int) yy_c];				}			yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];			++yy_cp;			}		while ( yy_base[yy_current_state] != 78 );yy_find_action:		yy_act = yy_accept[yy_current_state];		if ( yy_act == 0 )			{ /* have to back up */			yy_cp = (yy_last_accepting_cpos);			yy_current_state = (yy_last_accepting_state);			yy_act = yy_accept[yy_current_state];			}		YY_DO_BEFORE_ACTION;		if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] )			{			int yyl;			for ( yyl = 0; yyl < yyleng; ++yyl )				if ( yytext[yyl] == '\n' )					       yylineno++;;			}do_action:	/* This label is used only to access EOF actions. */		switch ( yy_act )	{ /* beginning of action switch */			case 0: /* must back up */			/* undo the effects of YY_DO_BEFORE_ACTION */			*yy_cp = (yy_hold_char);			yy_cp = (yy_last_accepting_cpos);			yy_current_state = (yy_last_accepting_state);			goto yy_find_action;case 1:YY_RULE_SETUP#line 33 "conf/tokens.l"{/* printf("%s", yytext); */}	YY_BREAKcase 2:/* rule 2 can match eol */YY_RULE_SETUP#line 35 "conf/tokens.l"{/* printf("%s", yytext); */}	YY_BREAKcase 3:YY_RULE_SETUP#line 37 "conf/tokens.l"{/* printf("SET "); */                 return SET;}	YY_BREAKcase 4:YY_RULE_SETUP#line 40 "conf/tokens.l"{/* printf(" EQU "); */                 return EQU;}	YY_BREAKcase 5:/* rule 5 can match eol */YY_RULE_SETUP#line 43 "conf/tokens.l"{yylval.str = strdup(yytext);  /* XXX - Check for NULL */                 /* printf("ID(%s)", yylval.str); */                 return ID;}	YY_BREAKcase 6:YY_RULE_SETUP#line 47 "conf/tokens.l"{yylval.str = strdup(yytext);  /* XXX - Check for NULL */                 /* printf("ARG(%s)", yylval.str); */                 return ARG;}	YY_BREAKcase 7:YY_RULE_SETUP#line 51 "conf/tokens.l"{yylval.str = strdup(yytext);  /* XXX - Check for NULL */                 /* printf("ARG(%s)", yylval.str); */                 return ARG;}	YY_BREAKcase 8:YY_RULE_SETUP#line 55 "conf/tokens.l"ECHO;	YY_BREAK#line 806 "tokens.c"case YY_STATE_EOF(INITIAL):	yyterminate();	case YY_END_OF_BUFFER:		{		/* Amount of text matched not including the EOB char. */		int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;		/* Undo the effects of YY_DO_BEFORE_ACTION. */		*yy_cp = (yy_hold_char);		YY_RESTORE_YY_MORE_OFFSET		if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )			{			/* We're scanning a new file or input source.  It's			 * possible that this happened because the user			 * just pointed yyin at a new source and called			 * yylex().  If so, then we have to assure			 * consistency between YY_CURRENT_BUFFER and our			 * globals.  Here is the right place to do so, because			 * this is the first action (other than possibly a			 * back-up) that will match for the new input source.			 */			(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;			YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;			YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;			}		/* Note that here we test for yy_c_buf_p "<=" to the position		 * of the first EOB in the buffer, since yy_c_buf_p will		 * already have been incremented past the NUL character		 * (since all states make transitions on EOB to the		 * end-of-buffer state).  Contrast this with the test		 * in input().		 */		if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )			{ /* This was really a NUL. */			yy_state_type yy_next_state;			(yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;			yy_current_state = yy_get_previous_state(  );			/* Okay, we're now positioned to make the NUL			 * transition.  We couldn't have			 * yy_get_previous_state() go ahead and do it			 * for us because it doesn't know how to deal			 * with the possibility of jamming (and we don't			 * want to build jamming into it because then it			 * will run more slowly).			 */			yy_next_state = yy_try_NUL_trans( yy_current_state );			yy_bp = (yytext_ptr) + YY_MORE_ADJ;			if ( yy_next_state )				{				/* Consume the NUL. */				yy_cp = ++(yy_c_buf_p);				yy_current_state = yy_next_state;				goto yy_match;				}			else				{				yy_cp = (yy_c_buf_p);				goto yy_find_action;				}			}		else switch ( yy_get_next_buffer(  ) )			{			case EOB_ACT_END_OF_FILE:				{				(yy_did_buffer_switch_on_eof) = 0;				if ( yywrap( ) )					{					/* Note: because we've taken care in					 * yy_get_next_buffer() to have set up					 * yytext, we can now set up					 * yy_c_buf_p so that if some total					 * hoser (like flex itself) wants to					 * call the scanner after we return the					 * YY_NULL, it'll still work - another					 * YY_NULL will get returned.					 */					(yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;					yy_act = YY_STATE_EOF(YY_START);					goto do_action;					}				else					{					if ( ! (yy_did_buffer_switch_on_eof) )						YY_NEW_FILE;					}				break;				}			case EOB_ACT_CONTINUE_SCAN:				(yy_c_buf_p) =					(yytext_ptr) + yy_amount_of_matched_text;				yy_current_state = yy_get_previous_state(  );				yy_cp = (yy_c_buf_p);				yy_bp = (yytext_ptr) + YY_MORE_ADJ;				goto yy_match;			case EOB_ACT_LAST_MATCH:				(yy_c_buf_p) =				&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];				yy_current_state = yy_get_previous_state(  );				yy_cp = (yy_c_buf_p);				yy_bp = (yytext_ptr) + YY_MORE_ADJ;				goto yy_find_action;			}		break;		}	default:		YY_FATAL_ERROR(			"fatal flex scanner internal error--no action found" );	} /* end of action switch */		} /* end of scanning one token */} /* end of yylex *//* yy_get_next_buffer - try to read in a new buffer * * Returns a code representing an action: *	EOB_ACT_LAST_MATCH - *	EOB_ACT_CONTINUE_SCAN - continue scanning from current position *	EOB_ACT_END_OF_FILE - end of file */static int yy_get_next_buffer (void){    	register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;	register char *source = (yytext_ptr);	register int number_to_move, i;	int ret_val;	if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )		YY_FATAL_ERROR(		"fatal flex scanner internal error--end of buffer missed" );	if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )		{ /* Don't try to fill the buffer, so this is an EOF. */		if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )			{			/* We matched a single character, the EOB, so			 * treat this as a final EOF.			 */			return EOB_ACT_END_OF_FILE;			}		else			{			/* We matched some text prior to the EOB, first			 * process it.			 */			return EOB_ACT_LAST_MATCH;			}		}	/* Try to read more data. */	/* First move last chars to start of buffer. */	number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;	for ( i = 0; i < number_to_move; ++i )		*(dest++) = *(source++);	if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )		/* don't do the read, it's not guaranteed to return an EOF,		 * just force an EOF		 */		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;	else		{			size_t num_to_read =			YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;		while ( num_to_read <= 0 )			{ /* Not enough room in the buffer - grow it. */			/* just a shorter name for the current buffer */			YY_BUFFER_STATE b = YY_CURRENT_BUFFER;			int yy_c_buf_p_offset =				(int) ((yy_c_buf_p) - b->yy_ch_buf);			if ( b->yy_is_our_buffer )				{				int new_size = b->yy_buf_size * 2;				if ( new_size <= 0 )					b->yy_buf_size += b->yy_buf_size / 8;				else					b->yy_buf_size *= 2;				b->yy_ch_buf = (char *)					/* Include room in for 2 EOB chars. */					yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2  );				}			else				/* Can't grow it, we don't own it. */				b->yy_ch_buf = 0;			if ( ! b->yy_ch_buf )				YY_FATAL_ERROR(				"fatal error - scanner input buffer overflow" );			(yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];			num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -						number_to_move - 1;			}		if ( num_to_read > YY_READ_BUF_SIZE )			num_to_read = YY_READ_BUF_SIZE;		/* Read in more data. */		YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),			(yy_n_chars), num_to_read );		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);		}	if ( (yy_n_chars) == 0 )		{		if ( number_to_move == YY_MORE_ADJ )			{			ret_val = EOB_ACT_END_OF_FILE;			yyrestart(yyin  );			}		else			{			ret_val = EOB_ACT_LAST_MATCH;			YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =				YY_BUFFER_EOF_PENDING;			}		}	else		ret_val = EOB_ACT_CONTINUE_SCAN;	(yy_n_chars) += number_to_move;	YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;	YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;	(yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];	return ret_val;}/* yy_get_previous_state - get the state just before the EOB char was reached */    static yy_state_type yy_get_previous_state (void){	register yy_state_type yy_current_state;	register char *yy_cp;    	yy_current_state = (yy_start);	yy_current_state += YY_AT_BOL();	for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )		{		register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);		if ( yy_accept[yy_current_state] )			{			(yy_last_accepting_state) = yy_current_state;			(yy_last_accepting_cpos) = yy_cp;			}		while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )			{			yy_current_state = (int) yy_def[yy_current_state];			if ( yy_current_state >= 31 )				yy_c = yy_meta[(unsigned int) yy_c];			}		yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];		}	return yy_current_state;}/* yy_try_NUL_trans - try to make a transition on the NUL character * * synopsis *	next_state = yy_try_NUL_trans( current_state ); */    static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state ){	register int yy_is_jam;    	register char *yy_cp = (yy_c_buf_p);	register YY_CHAR yy_c = 1;	if ( yy_accept[yy_current_state] )		{		(yy_last_accepting_state) = yy_current_state;		(yy_last_accepting_cpos) = yy_cp;		}	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )		{		yy_current_state = (int) yy_def[yy_current_state];		if ( yy_current_state >= 31 )			yy_c = yy_meta[(unsigned int) yy_c];		}	yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];	yy_is_jam = (yy_current_state == 30);	return yy_is_jam ? 0 : yy_current_state;}    static void yyunput (int c, register char * yy_bp ){	register char *yy_cp;        yy_cp = (yy_c_buf_p);	/* undo effects of setting up yytext */	*yy_cp = (yy_hold_char);	if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )		{ /* need to shift things up to make room */		/* +2 for EOB chars. */		register int number_to_move = (yy_n_chars) + 2;		register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[					YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];		register char *source =				&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];		while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )			*--dest = *--source;		yy_cp += (int) (dest - source);		yy_bp += (int) (dest - source);		YY_CURRENT_BUFFER_LVALUE->yy_n_chars =			(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;		if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )			YY_FATAL_ERROR( "flex scanner push-back overflow" );		}	*--yy_cp = (char) c;    if ( c == '\n' ){        --yylineno;    }	(yytext_ptr) = yy_bp;	(yy_hold_char) = *yy_cp;	(yy_c_buf_p) = yy_cp;}#ifndef YY_NO_INPUT#ifdef __cplusplus    static int yyinput (void)#else    static int input  (void)#endif{	int c;    	*(yy_c_buf_p) = (yy_hold_char);	if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )		{		/* yy_c_buf_p now points to the character we want to return.		 * If this occurs *before* the EOB characters, then it's a		 * valid NUL; if not, then we've hit the end of the buffer.		 */		if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )			/* This was really a NUL. */			*(yy_c_buf_p) = '\0';		else			{ /* need more input */			int offset = (yy_c_buf_p) - (yytext_ptr);			++(yy_c_buf_p);			switch ( yy_get_next_buffer(  ) )				{