embedaddon/confuse/src/lexer.c - diff

Return to lexer.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / confuse / src

Diff for /embedaddon/confuse/src/lexer.c between versions 1.1.1.1 and 1.1.1.2

version 1.1.1.1, 2017/01/24 14:48:56	version 1.1.1.2, 2021/03/17 00:49:17
Line 2	Line 2

#line 4 "lexer.c"	#line 4 "lexer.c"

	#define HAVE_CONFIG_H 1
#define YY_INT_ALIGNED short int	#define YY_INT_ALIGNED short int

/* A lexical scanner generated by flex */	/* A lexical scanner generated by flex */

#define yy_create_buffer cfg_yy_create_buffer	#define yy_create_buffer cfg_yy_create_buffer
#define yy_delete_buffer cfg_yy_delete_buffer	#define yy_delete_buffer cfg_yy_delete_buffer
#define yy_flex_debug cfg_yy_flex_debug	#define yy_scan_buffer cfg_yy_scan_buffer
	#define yy_scan_string cfg_yy_scan_string
	#define yy_scan_bytes cfg_yy_scan_bytes
#define yy_init_buffer cfg_yy_init_buffer	#define yy_init_buffer cfg_yy_init_buffer
#define yy_flush_buffer cfg_yy_flush_buffer	#define yy_flush_buffer cfg_yy_flush_buffer
#define yy_load_buffer_state cfg_yy_load_buffer_state	#define yy_load_buffer_state cfg_yy_load_buffer_state
#define yy_switch_to_buffer cfg_yy_switch_to_buffer	#define yy_switch_to_buffer cfg_yy_switch_to_buffer
	#define yypush_buffer_state cfg_yypush_buffer_state
	#define yypop_buffer_state cfg_yypop_buffer_state
	#define yyensure_buffer_stack cfg_yyensure_buffer_stack
	#define yy_flex_debug cfg_yy_flex_debug
#define yyin cfg_yyin	#define yyin cfg_yyin
#define yyleng cfg_yyleng	#define yyleng cfg_yyleng
#define yylex cfg_yylex	#define yylex cfg_yylex
Line 27	Line 34

#define FLEX_SCANNER	#define FLEX_SCANNER
#define YY_FLEX_MAJOR_VERSION 2	#define YY_FLEX_MAJOR_VERSION 2
#define YY_FLEX_MINOR_VERSION 5	#define YY_FLEX_MINOR_VERSION 6
#define YY_FLEX_SUBMINOR_VERSION 35	#define YY_FLEX_SUBMINOR_VERSION 4
#if YY_FLEX_SUBMINOR_VERSION > 0	#if YY_FLEX_SUBMINOR_VERSION > 0
#define FLEX_BETA	#define FLEX_BETA
#endif	#endif

	#ifdef yy_create_buffer
	#define cfg_yy_create_buffer_ALREADY_DEFINED
	#else
	#define yy_create_buffer cfg_yy_create_buffer
	#endif

	#ifdef yy_delete_buffer
	#define cfg_yy_delete_buffer_ALREADY_DEFINED
	#else
	#define yy_delete_buffer cfg_yy_delete_buffer
	#endif

	#ifdef yy_scan_buffer
	#define cfg_yy_scan_buffer_ALREADY_DEFINED
	#else
	#define yy_scan_buffer cfg_yy_scan_buffer
	#endif

	#ifdef yy_scan_string
	#define cfg_yy_scan_string_ALREADY_DEFINED
	#else
	#define yy_scan_string cfg_yy_scan_string
	#endif

	#ifdef yy_scan_bytes
	#define cfg_yy_scan_bytes_ALREADY_DEFINED
	#else
	#define yy_scan_bytes cfg_yy_scan_bytes
	#endif

	#ifdef yy_init_buffer
	#define cfg_yy_init_buffer_ALREADY_DEFINED
	#else
	#define yy_init_buffer cfg_yy_init_buffer
	#endif

	#ifdef yy_flush_buffer
	#define cfg_yy_flush_buffer_ALREADY_DEFINED
	#else
	#define yy_flush_buffer cfg_yy_flush_buffer
	#endif

	#ifdef yy_load_buffer_state
	#define cfg_yy_load_buffer_state_ALREADY_DEFINED
	#else
	#define yy_load_buffer_state cfg_yy_load_buffer_state
	#endif

	#ifdef yy_switch_to_buffer
	#define cfg_yy_switch_to_buffer_ALREADY_DEFINED
	#else
	#define yy_switch_to_buffer cfg_yy_switch_to_buffer
	#endif

	#ifdef yypush_buffer_state
	#define cfg_yypush_buffer_state_ALREADY_DEFINED
	#else
	#define yypush_buffer_state cfg_yypush_buffer_state
	#endif

	#ifdef yypop_buffer_state
	#define cfg_yypop_buffer_state_ALREADY_DEFINED
	#else
	#define yypop_buffer_state cfg_yypop_buffer_state
	#endif

	#ifdef yyensure_buffer_stack
	#define cfg_yyensure_buffer_stack_ALREADY_DEFINED
	#else
	#define yyensure_buffer_stack cfg_yyensure_buffer_stack
	#endif

	#ifdef yylex
	#define cfg_yylex_ALREADY_DEFINED
	#else
	#define yylex cfg_yylex
	#endif

	#ifdef yyrestart
	#define cfg_yyrestart_ALREADY_DEFINED
	#else
	#define yyrestart cfg_yyrestart
	#endif

	#ifdef yylex_init
	#define cfg_yylex_init_ALREADY_DEFINED
	#else
	#define yylex_init cfg_yylex_init
	#endif

	#ifdef yylex_init_extra
	#define cfg_yylex_init_extra_ALREADY_DEFINED
	#else
	#define yylex_init_extra cfg_yylex_init_extra
	#endif

	#ifdef yylex_destroy
	#define cfg_yylex_destroy_ALREADY_DEFINED
	#else
	#define yylex_destroy cfg_yylex_destroy
	#endif

	#ifdef yyget_debug
	#define cfg_yyget_debug_ALREADY_DEFINED
	#else
	#define yyget_debug cfg_yyget_debug
	#endif

	#ifdef yyset_debug
	#define cfg_yyset_debug_ALREADY_DEFINED
	#else
	#define yyset_debug cfg_yyset_debug
	#endif

	#ifdef yyget_extra
	#define cfg_yyget_extra_ALREADY_DEFINED
	#else
	#define yyget_extra cfg_yyget_extra
	#endif

	#ifdef yyset_extra
	#define cfg_yyset_extra_ALREADY_DEFINED
	#else
	#define yyset_extra cfg_yyset_extra
	#endif

	#ifdef yyget_in
	#define cfg_yyget_in_ALREADY_DEFINED
	#else
	#define yyget_in cfg_yyget_in
	#endif

	#ifdef yyset_in
	#define cfg_yyset_in_ALREADY_DEFINED
	#else
	#define yyset_in cfg_yyset_in
	#endif

	#ifdef yyget_out
	#define cfg_yyget_out_ALREADY_DEFINED
	#else
	#define yyget_out cfg_yyget_out
	#endif

	#ifdef yyset_out
	#define cfg_yyset_out_ALREADY_DEFINED
	#else
	#define yyset_out cfg_yyset_out
	#endif

	#ifdef yyget_leng
	#define cfg_yyget_leng_ALREADY_DEFINED
	#else
	#define yyget_leng cfg_yyget_leng
	#endif

	#ifdef yyget_text
	#define cfg_yyget_text_ALREADY_DEFINED
	#else
	#define yyget_text cfg_yyget_text
	#endif

	#ifdef yyget_lineno
	#define cfg_yyget_lineno_ALREADY_DEFINED
	#else
	#define yyget_lineno cfg_yyget_lineno
	#endif

	#ifdef yyset_lineno
	#define cfg_yyset_lineno_ALREADY_DEFINED
	#else
	#define yyset_lineno cfg_yyset_lineno
	#endif

	#ifdef yywrap
	#define cfg_yywrap_ALREADY_DEFINED
	#else
	#define yywrap cfg_yywrap
	#endif

	#ifdef yyalloc
	#define cfg_yyalloc_ALREADY_DEFINED
	#else
	#define yyalloc cfg_yyalloc
	#endif

	#ifdef yyrealloc
	#define cfg_yyrealloc_ALREADY_DEFINED
	#else
	#define yyrealloc cfg_yyrealloc
	#endif

	#ifdef yyfree
	#define cfg_yyfree_ALREADY_DEFINED
	#else
	#define yyfree cfg_yyfree
	#endif

	#ifdef yytext
	#define cfg_yytext_ALREADY_DEFINED
	#else
	#define yytext cfg_yytext
	#endif

	#ifdef yyleng
	#define cfg_yyleng_ALREADY_DEFINED
	#else
	#define yyleng cfg_yyleng
	#endif

	#ifdef yyin
	#define cfg_yyin_ALREADY_DEFINED
	#else
	#define yyin cfg_yyin
	#endif

	#ifdef yyout
	#define cfg_yyout_ALREADY_DEFINED
	#else
	#define yyout cfg_yyout
	#endif

	#ifdef yy_flex_debug
	#define cfg_yy_flex_debug_ALREADY_DEFINED
	#else
	#define yy_flex_debug cfg_yy_flex_debug
	#endif

	#ifdef yylineno
	#define cfg_yylineno_ALREADY_DEFINED
	#else
	#define yylineno cfg_yylineno
	#endif

/* First, we deal with platform-specific or compiler-specific issues. */	/* First, we deal with platform-specific or compiler-specific issues. */

/* begin standard C headers. */	/* begin standard C headers. */
Line 73 typedef int flex_int32_t;	Line 314 typedef int flex_int32_t;
typedef unsigned char flex_uint8_t;	typedef unsigned char flex_uint8_t;
typedef unsigned short int flex_uint16_t;	typedef unsigned short int flex_uint16_t;
typedef unsigned int flex_uint32_t;	typedef unsigned int flex_uint32_t;
#endif /* ! C99 */

/* Limits of integral types. */	/* Limits of integral types. */
#ifndef INT8_MIN	#ifndef INT8_MIN
Line 104 typedef unsigned int flex_uint32_t;	Line 344 typedef unsigned int flex_uint32_t;
#define UINT32_MAX (4294967295U)	#define UINT32_MAX (4294967295U)
#endif	#endif

#endif /* ! FLEXINT_H */	#ifndef SIZE_MAX
	#define SIZE_MAX (~(size_t)0)
	#endif

#ifdef __cplusplus	#endif /* ! C99 */

/* The "const" storage-class-modifier is valid. */	#endif /* ! FLEXINT_H */
#define YY_USE_CONST

#else /* ! __cplusplus */	/* begin standard C++ headers. */

/* C99 requires __STDC__ to be defined as 1. */	/* TODO: this is always defined, so inline it */
#if defined (__STDC__)

#define YY_USE_CONST

#endif /* defined (__STDC__) */
#endif /* ! __cplusplus */

#ifdef YY_USE_CONST
#define yyconst const	#define yyconst const

	#if defined(__GNUC__) && __GNUC__ >= 3
	#define yynoreturn __attribute__((__noreturn__))
#else	#else
#define yyconst	#define yynoreturn
#endif	#endif

/* Returned upon end-of-file. */	/* Returned upon end-of-file. */
#define YY_NULL 0	#define YY_NULL 0

/* Promotes a possibly negative, possibly signed char to an unsigned	/* Promotes a possibly negative, possibly signed char to an
* integer for use as an array index. If the signed char is negative,	* integer in range [0..255] for use as an array index.
* we want to instead treat it as an 8-bit unsigned char, hence the
* double cast.
*/	*/
#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)	#define YY_SC_TO_UI(c) ((YY_CHAR) (c))

/* Enter a start condition. This macro really ought to take a parameter,	/* Enter a start condition. This macro really ought to take a parameter,
* but we do it the disgusting crufty way forced on us by the ()-less	* but we do it the disgusting crufty way forced on us by the ()-less
* definition of BEGIN.	* definition of BEGIN.
*/	*/
#define BEGIN (yy_start) = 1 + 2 *	#define BEGIN (yy_start) = 1 + 2 *

/* Translate the current start state into a value that can be later handed	/* Translate the current start state into a value that can be later handed
* to BEGIN to return to the state. The YYSTATE alias is for lex	* to BEGIN to return to the state. The YYSTATE alias is for lex
* compatibility.	* compatibility.
*/	*/
#define YY_START (((yy_start) - 1) / 2)	#define YY_START (((yy_start) - 1) / 2)
#define YYSTATE YY_START	#define YYSTATE YY_START

/* Action number for EOF rule of a given start state. */	/* Action number for EOF rule of a given start state. */
#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)	#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)

/* Special action meaning "start processing a new file". */	/* Special action meaning "start processing a new file". */
#define YY_NEW_FILE cfg_yyrestart(cfg_yyin )	#define YY_NEW_FILE yyrestart( yyin )

#define YY_END_OF_BUFFER_CHAR 0	#define YY_END_OF_BUFFER_CHAR 0

/* Size of default input buffer. */	/* Size of default input buffer. */
#ifndef YY_BUF_SIZE	#ifndef YY_BUF_SIZE
	#ifdef __ia64__
	/* On IA-64, the buffer size is 16k, not 8k.
	* Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
	* Ditto for the __ia64__ case accordingly.
	*/
	#define YY_BUF_SIZE 32768
	#else
#define YY_BUF_SIZE 16384	#define YY_BUF_SIZE 16384
	#endif /* __ia64__ */
#endif	#endif

/* The state buf must be large enough to hold one state per character in the main buffer.	/* The state buf must be large enough to hold one state per character in the main buffer.
Line 172 typedef unsigned int flex_uint32_t;	Line 410 typedef unsigned int flex_uint32_t;
typedef struct yy_buffer_state *YY_BUFFER_STATE;	typedef struct yy_buffer_state *YY_BUFFER_STATE;
#endif	#endif

extern int cfg_yyleng;	#ifndef YY_TYPEDEF_YY_SIZE_T
	#define YY_TYPEDEF_YY_SIZE_T
	typedef size_t yy_size_t;
	#endif

extern FILE cfg_yyin, cfg_yyout;	extern int yyleng;

	extern FILE yyin, yyout;

#define EOB_ACT_CONTINUE_SCAN 0	#define EOB_ACT_CONTINUE_SCAN 0
#define EOB_ACT_END_OF_FILE 1	#define EOB_ACT_END_OF_FILE 1
#define EOB_ACT_LAST_MATCH 2	#define EOB_ACT_LAST_MATCH 2

#define YY_LESS_LINENO(n)	#define YY_LESS_LINENO(n)
	#define YY_LINENO_REWIND_TO(ptr)

/* Return all but the first "n" matched characters back to the input stream. */	/* Return all but the first "n" matched characters back to the input stream. */
#define yyless(n) \	#define yyless(n) \
do \	do \
{ \	{ \
/* Undo effects of setting up cfg_yytext. */ \	/* Undo effects of setting up yytext. */ \
int yyless_macro_arg = (n); \	int yyless_macro_arg = (n); \
YY_LESS_LINENO(yyless_macro_arg);\	YY_LESS_LINENO(yyless_macro_arg);\
*yy_cp = (yy_hold_char); \	*yy_cp = (yy_hold_char); \
YY_RESTORE_YY_MORE_OFFSET \	YY_RESTORE_YY_MORE_OFFSET \
(yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \	(yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
YY_DO_BEFORE_ACTION; /* set up cfg_yytext again */ \	YY_DO_BEFORE_ACTION; /* set up yytext again */ \
} \	} \
while ( 0 )	while ( 0 )

#define unput(c) yyunput( c, (yytext_ptr) )	#define unput(c) yyunput( c, (yytext_ptr) )

#ifndef YY_TYPEDEF_YY_SIZE_T
#define YY_TYPEDEF_YY_SIZE_T
typedef size_t yy_size_t;
#endif

#ifndef YY_STRUCT_YY_BUFFER_STATE	#ifndef YY_STRUCT_YY_BUFFER_STATE
#define YY_STRUCT_YY_BUFFER_STATE	#define YY_STRUCT_YY_BUFFER_STATE
struct yy_buffer_state	struct yy_buffer_state
Line 215 struct yy_buffer_state	Line 453 struct yy_buffer_state
/* Size of input buffer in bytes, not including room for EOB	/* Size of input buffer in bytes, not including room for EOB
* characters.	* characters.
*/	*/
yy_size_t yy_buf_size;	int yy_buf_size;

/* Number of characters read into yy_ch_buf, not including EOB	/* Number of characters read into yy_ch_buf, not including EOB
* characters.	* characters.
Line 243 struct yy_buffer_state	Line 481 struct yy_buffer_state

int yy_bs_lineno; /*< The line count. /	int yy_bs_lineno; /*< The line count. /
int yy_bs_column; /*< The column count. /	int yy_bs_column; /*< The column count. /

/* Whether to try to fill the input buffer when we reach the	/* Whether to try to fill the input buffer when we reach the
* end of it.	* end of it.
*/	*/
Line 260 struct yy_buffer_state	Line 498 struct yy_buffer_state
* possible backing-up.	* possible backing-up.
*	*
* When we actually see the EOF, we change the status to "new"	* When we actually see the EOF, we change the status to "new"
* (via cfg_yyrestart()), so that the user can continue scanning by	* (via yyrestart()), so that the user can continue scanning by
* just pointing cfg_yyin at a new input file.	* just pointing yyin at a new input file.
*/	*/
#define YY_BUFFER_EOF_PENDING 2	#define YY_BUFFER_EOF_PENDING 2

Line 271 struct yy_buffer_state	Line 509 struct yy_buffer_state
/* Stack of input buffers. */	/* Stack of input buffers. */
static size_t yy_buffer_stack_top = 0; /*< index of top of stack. /	static size_t yy_buffer_stack_top = 0; /*< index of top of stack. /
static size_t yy_buffer_stack_max = 0; /*< capacity of stack. /	static size_t yy_buffer_stack_max = 0; /*< capacity of stack. /
static YY_BUFFER_STATE * yy_buffer_stack = 0; /*< Stack as an array. /	static YY_BUFFER_STATE * yy_buffer_stack = NULL; /*< Stack as an array. /

/* We provide macros for accessing buffer states in case in the	/* We provide macros for accessing buffer states in case in the
* future we want to put the buffer states in a more general	* future we want to put the buffer states in a more general
Line 282 static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Sta	Line 520 static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Sta
#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \	#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
? (yy_buffer_stack)[(yy_buffer_stack_top)] \	? (yy_buffer_stack)[(yy_buffer_stack_top)] \
: NULL)	: NULL)

/* Same as previous macro, but useful when we know that the buffer stack is not	/* Same as previous macro, but useful when we know that the buffer stack is not
* NULL or when we need an lvalue. For internal use only.	* NULL or when we need an lvalue. For internal use only.
*/	*/
#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]	#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]

/* yy_hold_char holds the character lost when cfg_yytext is formed. */	/* yy_hold_char holds the character lost when yytext is formed. */
static char yy_hold_char;	static char yy_hold_char;
static int yy_n_chars; /* number of characters read into yy_ch_buf */	static int yy_n_chars; /* number of characters read into yy_ch_buf */
int cfg_yyleng;	int yyleng;

/* Points to current character in buffer. */	/* Points to current character in buffer. */
static char yy_c_buf_p = (char ) 0;	static char *yy_c_buf_p = NULL;
static int yy_init = 0; /* whether we need to initialize */	static int yy_init = 0; /* whether we need to initialize */
static int yy_start = 0; /* start state number */	static int yy_start = 0; /* start state number */

/* Flag which is used to allow cfg_yywrap()'s to do buffer switches	/* Flag which is used to allow yywrap()'s to do buffer switches
* instead of setting up a fresh cfg_yyin. A bit of a hack ...	* instead of setting up a fresh yyin. A bit of a hack ...
*/	*/
static int yy_did_buffer_switch_on_eof;	static int yy_did_buffer_switch_on_eof;

void cfg_yyrestart (FILE *input_file );	void yyrestart ( FILE *input_file );
void cfg_yy_switch_to_buffer (YY_BUFFER_STATE new_buffer );	void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer );
YY_BUFFER_STATE cfg_yy_create_buffer (FILE *file,int size );	YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size );
void cfg_yy_delete_buffer (YY_BUFFER_STATE b );	void yy_delete_buffer ( YY_BUFFER_STATE b );
void cfg_yy_flush_buffer (YY_BUFFER_STATE b );	void yy_flush_buffer ( YY_BUFFER_STATE b );
void cfg_yypush_buffer_state (YY_BUFFER_STATE new_buffer );	void yypush_buffer_state ( YY_BUFFER_STATE new_buffer );
void cfg_yypop_buffer_state (void );	void yypop_buffer_state ( void );

static void cfg_yyensure_buffer_stack (void );	static void yyensure_buffer_stack ( void );
static void cfg_yy_load_buffer_state (void );	static void yy_load_buffer_state ( void );
static void cfg_yy_init_buffer (YY_BUFFER_STATE b,FILE *file );	static void yy_init_buffer ( YY_BUFFER_STATE b, FILE *file );
	#define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER )

#define YY_FLUSH_BUFFER cfg_yy_flush_buffer(YY_CURRENT_BUFFER )	YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size );
	YY_BUFFER_STATE yy_scan_string ( const char *yy_str );
	YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len );

YY_BUFFER_STATE cfg_yy_scan_buffer (char *base,yy_size_t size );	void *yyalloc ( yy_size_t );
YY_BUFFER_STATE cfg_yy_scan_string (yyconst char *yy_str );	void yyrealloc ( void , yy_size_t );
YY_BUFFER_STATE cfg_yy_scan_bytes (yyconst char *bytes,int len );	void yyfree ( void * );

void *cfg_yyalloc (yy_size_t );	#define yy_new_buffer yy_create_buffer
void cfg_yyrealloc (void ,yy_size_t );
void cfg_yyfree (void * );

#define yy_new_buffer cfg_yy_create_buffer

#define yy_set_interactive(is_interactive) \	#define yy_set_interactive(is_interactive) \
{ \	{ \
if ( ! YY_CURRENT_BUFFER ){ \	if ( ! YY_CURRENT_BUFFER ){ \
cfg_yyensure_buffer_stack (); \	yyensure_buffer_stack (); \
YY_CURRENT_BUFFER_LVALUE = \	YY_CURRENT_BUFFER_LVALUE = \
cfg_yy_create_buffer(cfg_yyin,YY_BUF_SIZE ); \	yy_create_buffer( yyin, YY_BUF_SIZE ); \
} \	} \
YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \	YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
}	}

#define yy_set_bol(at_bol) \	#define yy_set_bol(at_bol) \
{ \	{ \
if ( ! YY_CURRENT_BUFFER ){\	if ( ! YY_CURRENT_BUFFER ){\
cfg_yyensure_buffer_stack (); \	yyensure_buffer_stack (); \
YY_CURRENT_BUFFER_LVALUE = \	YY_CURRENT_BUFFER_LVALUE = \
cfg_yy_create_buffer(cfg_yyin,YY_BUF_SIZE ); \	yy_create_buffer( yyin, YY_BUF_SIZE ); \
} \	} \
YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \	YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
}	}

#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)	#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)

/* Begin user sect3 */	/* Begin user sect3 */

#define cfg_yywrap(n) 1	#define cfg_yywrap() (/CONSTCOND/1)
#define YY_SKIP_YYWRAP	#define YY_SKIP_YYWRAP
	typedef flex_uint8_t YY_CHAR;

typedef unsigned char YY_CHAR;	FILE yyin = NULL, yyout = NULL;

FILE cfg_yyin = (FILE ) 0, cfg_yyout = (FILE ) 0;

typedef int yy_state_type;	typedef int yy_state_type;

extern int cfg_yylineno;	extern int yylineno;
	int yylineno = 1;

int cfg_yylineno = 1;	extern char *yytext;
	#ifdef yytext_ptr
	#undef yytext_ptr
	#endif
	#define yytext_ptr yytext

extern char *cfg_yytext;	static yy_state_type yy_get_previous_state ( void );
#define yytext_ptr cfg_yytext	static yy_state_type yy_try_NUL_trans ( yy_state_type current_state );
	static int yy_get_next_buffer ( void );
	static void yynoreturn yy_fatal_error ( const char* msg );

static yy_state_type yy_get_previous_state (void );
static yy_state_type yy_try_NUL_trans (yy_state_type current_state );
static int yy_get_next_buffer (void );
static void yy_fatal_error (yyconst char msg[] );

/* Done after the current pattern has been matched and before the	/* Done after the current pattern has been matched and before the
* corresponding action - sets up cfg_yytext.	* corresponding action - sets up yytext.
*/	*/
#define YY_DO_BEFORE_ACTION \	#define YY_DO_BEFORE_ACTION \
(yytext_ptr) = yy_bp; \	(yytext_ptr) = yy_bp; \
cfg_yyleng = (size_t) (yy_cp - yy_bp); \	yyleng = (int) (yy_cp - yy_bp); \
(yy_hold_char) = *yy_cp; \	(yy_hold_char) = *yy_cp; \
*yy_cp = '\0'; \	*yy_cp = '\0'; \
(yy_c_buf_p) = yy_cp;	(yy_c_buf_p) = yy_cp;
	#define YY_NUM_RULES 45
#define YY_NUM_RULES 44	#define YY_END_OF_BUFFER 46
#define YY_END_OF_BUFFER 45
/* This struct is not used in this scanner,	/* This struct is not used in this scanner,
but its presence is necessary. */	but its presence is necessary. */
struct yy_trans_info	struct yy_trans_info
Line 391 struct yy_trans_info	Line 624 struct yy_trans_info
flex_int32_t yy_verify;	flex_int32_t yy_verify;
flex_int32_t yy_nxt;	flex_int32_t yy_nxt;
};	};
static yyconst flex_int16_t yy_accept[85] =	static const flex_int16_t yy_accept[88] =
{ 0,	{ 0,
0, 0, 12, 12, 0, 0, 0, 0, 45, 42,	0, 0, 13, 13, 0, 0, 0, 0, 46, 43,
1, 2, 43, 16, 3, 42, 34, 6, 7, 43,	1, 2, 44, 17, 3, 43, 35, 7, 8, 44,
10, 42, 8, 4, 5, 12, 14, 13, 33, 19,	11, 43, 9, 5, 6, 13, 13, 15, 14, 34,
17, 33, 44, 40, 36, 35, 44, 42, 42, 1,	20, 18, 34, 45, 41, 37, 36, 45, 43, 43,
3, 0, 9, 42, 11, 3, 12, 13, 13, 15,	1, 3, 3, 0, 10, 43, 12, 4, 13, 13,
33, 33, 32, 20, 21, 22, 28, 26, 29, 27,	0, 14, 14, 16, 0, 33, 21, 22, 23, 29,
24, 25, 30, 31, 32, 40, 39, 37, 38, 0,	27, 30, 28, 25, 26, 31, 32, 33, 41, 40,
41, 3, 3, 33, 0, 18, 21, 22, 23, 3,	38, 39, 0, 42, 4, 4, 4, 0, 19, 22,
18, 21, 23, 0	23, 24, 4, 4, 22, 24, 0
} ;	} ;

static yyconst flex_int32_t yy_ec[256] =	static const YY_CHAR yy_ec[256] =
{ 0,	{ 0,
1, 1, 1, 1, 1, 1, 1, 1, 2, 3,	1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
1, 1, 4, 1, 1, 1, 1, 1, 1, 1,	1, 1, 4, 1, 1, 1, 1, 1, 1, 1,
Line 436 static yyconst flex_int32_t yy_ec[256] =	Line 669 static yyconst flex_int32_t yy_ec[256] =
1, 1, 1, 1, 1	1, 1, 1, 1, 1
} ;	} ;

static yyconst flex_int32_t yy_meta[31] =	static const YY_CHAR yy_meta[31] =
{ 0,	{ 0,
1, 2, 3, 2, 4, 2, 1, 5, 2, 2,	1, 2, 3, 2, 2, 2, 1, 4, 2, 2,
6, 2, 2, 1, 7, 7, 2, 7, 8, 7,	5, 2, 2, 1, 6, 6, 2, 6, 7, 6,
7, 7, 7, 1, 1, 1, 1, 1, 2, 2	6, 6, 6, 1, 1, 1, 1, 1, 2, 2
} ;	} ;

static yyconst flex_int16_t yy_base[102] =	static const flex_int16_t yy_base[104] =
{ 0,	{ 0,
0, 0, 28, 29, 30, 31, 38, 39, 131, 116,	0, 0, 29, 31, 32, 38, 41, 44, 194, 175,
127, 293, 293, 293, 0, 30, 293, 293, 293, 111,	186, 261, 261, 261, 181, 24, 261, 261, 261, 169,
293, 34, 293, 293, 293, 0, 293, 40, 0, 293,	261, 44, 261, 261, 261, 0, 48, 261, 50, 261,
293, 98, 57, 0, 293, 293, 67, 107, 41, 116,	261, 261, 101, 62, 0, 261, 261, 72, 80, 55,
0, 59, 293, 62, 293, 86, 0, 42, 50, 293,	79, 0, 73, 44, 261, 58, 261, 91, 0, 60,
0, 114, 293, 293, 47, 50, 293, 293, 293, 293,	56, 62, 111, 261, 38, 261, 261, 108, 111, 261,
293, 293, 293, 293, 0, 0, 293, 293, 293, 44,	261, 261, 261, 261, 261, 261, 261, 0, 0, 261,
293, 144, 0, 117, 41, 0, 52, 108, 0, 0,	261, 261, 26, 261, 127, 0, 0, 24, 261, 143,
293, 110, 293, 293, 174, 182, 190, 198, 206, 214,	145, 0, 0, 34, 147, 261, 261, 163, 170, 177,
222, 230, 238, 245, 253, 260, 268, 276, 62, 284,	184, 191, 198, 205, 212, 219, 226, 232, 239, 246,

36	40, 253, 30
} ;	} ;

static yyconst flex_int16_t yy_def[102] =	static const flex_int16_t yy_def[104] =
{ 0,	{ 0,
84, 1, 85, 85, 86, 86, 87, 87, 84, 88,	87, 1, 88, 88, 89, 89, 90, 90, 87, 91,
84, 84, 84, 84, 89, 88, 84, 84, 84, 84,	87, 87, 87, 87, 92, 91, 87, 87, 87, 87,
84, 90, 84, 84, 84, 91, 84, 92, 93, 84,	87, 93, 87, 87, 87, 94, 94, 87, 95, 87,
84, 93, 94, 95, 84, 84, 96, 88, 90, 84,	87, 87, 87, 96, 97, 87, 87, 98, 91, 93,
89, 97, 84, 88, 84, 84, 91, 92, 92, 84,	87, 92, 92, 99, 87, 91, 87, 87, 94, 94,
93, 98, 84, 84, 84, 84, 84, 84, 84, 84,	87, 95, 95, 87, 100, 87, 87, 87, 87, 87,
84, 84, 84, 84, 99, 95, 84, 84, 84, 97,	87, 87, 87, 87, 87, 87, 87, 101, 97, 87,
84, 84, 46, 98, 100, 93, 84, 84, 101, 72,	87, 87, 99, 87, 87, 102, 48, 100, 87, 87,
84, 84, 84, 0, 84, 84, 84, 84, 84, 84,	87, 103, 75, 48, 87, 87, 0, 87, 87, 87,
84, 84, 84, 84, 84, 84, 84, 84, 84, 84,	87, 87, 87, 87, 87, 87, 87, 87, 87, 87,

84	87, 87, 87
} ;	} ;

static yyconst flex_int16_t yy_nxt[324] =	static const flex_int16_t yy_nxt[292] =
{ 0,	{ 0,
10, 11, 12, 13, 14, 15, 16, 17, 18, 19,	10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
13, 20, 21, 22, 10, 10, 23, 10, 10, 10,	13, 20, 21, 22, 10, 10, 23, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10, 10, 24, 25,	10, 10, 10, 10, 10, 10, 10, 10, 24, 25,
27, 27, 30, 30, 31, 31, 32, 32, 28, 28,	27, 28, 27, 28, 31, 86, 32, 40, 33, 29,
35, 35, 83, 39, 45, 36, 36, 46, 33, 33,	31, 29, 32, 36, 33, 82, 36, 84, 37, 50,
49, 84, 84, 50, 39, 84, 37, 37, 42, 54,	34, 37, 44, 79, 47, 74, 34, 48, 51, 38,
49, 77, 78, 50, 78, 78, 82, 78, 79, 68,	53, 50, 38, 54, 57, 87, 51, 79, 40, 54,
81, 55, 56, 71, 69, 39, 57, 58, 59, 60,	51, 40, 87, 74, 71, 87, 58, 59, 43, 72,
61, 62, 63, 64, 65, 69, 72, 41, 71, 41,	41, 60, 61, 62, 63, 64, 65, 66, 67, 68,
41, 41, 72, 41, 41, 41, 41, 41, 41, 73,	72, 75, 76, 40, 76, 76, 76, 75, 76, 76,

72, 72, 41, 72, 72, 72, 72, 72, 72, 72,	76, 76, 76, 76, 77, 75, 75, 76, 75, 75,
72, 72, 72, 72, 41, 41, 75, 40, 75, 75,	75, 75, 75, 75, 75, 75, 75, 75, 75, 76,
39, 75, 78, 78, 78, 78, 52, 43, 40, 39,	76, 53, 80, 81, 54, 81, 81, 83, 76, 55,
84, 84, 75, 84, 84, 75, 84, 84, 84, 84,	76, 76, 76, 83, 76, 76, 76, 76, 76, 76,
84, 84, 84, 76, 80, 41, 76, 41, 41, 41,	84, 83, 83, 76, 83, 83, 83, 83, 83, 83,
80, 41, 41, 41, 41, 41, 41, 73, 80, 80,	83, 83, 83, 83, 83, 76, 76, 85, 81, 81,
41, 80, 80, 80, 80, 80, 80, 80, 80, 80,	81, 81, 81, 26, 26, 26, 26, 26, 26, 26,
80, 80, 41, 41, 26, 26, 26, 26, 26, 26,	30, 30, 30, 30, 30, 30, 30, 35, 35, 35,
26, 26, 29, 29, 29, 29, 29, 29, 29, 29,	35, 35, 35, 35, 39, 45, 43, 41, 40, 39,
34, 34, 34, 34, 34, 34, 34, 34, 38, 84,	39, 42, 42, 87, 42, 42, 42, 42, 46, 87,

84, 84, 84, 84, 38, 38, 41, 41, 84, 41,	87, 87, 46, 46, 46, 49, 49, 87, 49, 87,
41, 41, 41, 41, 44, 84, 84, 84, 84, 44,	49, 49, 52, 52, 87, 52, 52, 52, 52, 56,
44, 44, 47, 47, 84, 47, 47, 84, 47, 47,	56, 56, 56, 56, 56, 56, 69, 69, 87, 87,
48, 48, 84, 48, 48, 48, 48, 48, 51, 51,	69, 69, 70, 70, 70, 70, 70, 70, 70, 73,
84, 84, 51, 51, 51, 53, 53, 53, 53, 53,	73, 73, 73, 73, 73, 73, 78, 78, 78, 78,
53, 53, 53, 66, 66, 84, 66, 84, 66, 66,	78, 78, 78, 76, 76, 87, 76, 76, 76, 76,
67, 67, 67, 67, 67, 67, 67, 67, 70, 70,	9, 87, 87, 87, 87, 87, 87, 87, 87, 87,
70, 70, 70, 70, 70, 70, 74, 74, 74, 74,	87, 87, 87, 87, 87, 87, 87, 87, 87, 87,
74, 74, 74, 74, 75, 75, 75, 75, 75, 75,	87, 87, 87, 87, 87, 87, 87, 87, 87, 87,
75, 75, 9, 84, 84, 84, 84, 84, 84, 84,	87

84, 84, 84, 84, 84, 84, 84, 84, 84, 84,
84, 84, 84, 84, 84, 84, 84, 84, 84, 84,
84, 84, 84
} ;	} ;

static yyconst flex_int16_t yy_chk[324] =	static const flex_int16_t yy_chk[292] =
{ 0,	{ 0,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
3, 4, 5, 6, 5, 6, 5, 6, 3, 4,	3, 3, 4, 4, 5, 103, 5, 16, 5, 3,
7, 8, 101, 16, 22, 7, 8, 22, 5, 6,	6, 4, 6, 7, 6, 101, 8, 84, 7, 27,
28, 39, 48, 28, 39, 48, 7, 8, 16, 33,	5, 8, 16, 78, 22, 73, 6, 22, 27, 7,
49, 55, 55, 49, 56, 56, 77, 77, 99, 37,	29, 50, 8, 29, 34, 40, 51, 55, 40, 51,
75, 33, 33, 70, 37, 44, 33, 33, 33, 33,	50, 46, 52, 44, 38, 52, 34, 34, 43, 38,
33, 33, 33, 33, 33, 37, 46, 46, 42, 46,	41, 34, 34, 34, 34, 34, 34, 34, 34, 34,
46, 46, 46, 46, 46, 46, 46, 46, 46, 46,	38, 48, 48, 39, 48, 48, 48, 48, 48, 48,

46, 46, 46, 46, 46, 46, 46, 46, 46, 46,	48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
46, 46, 46, 46, 46, 46, 52, 40, 52, 74,	48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
38, 74, 78, 78, 82, 82, 32, 20, 11, 10,	48, 53, 58, 58, 53, 59, 59, 75, 75, 33,
9, 0, 52, 0, 0, 74, 0, 0, 0, 0,	75, 75, 75, 75, 75, 75, 75, 75, 75, 75,
0, 0, 0, 52, 72, 72, 74, 72, 72, 72,	75, 75, 75, 75, 75, 75, 75, 75, 75, 75,
72, 72, 72, 72, 72, 72, 72, 72, 72, 72,	75, 75, 75, 75, 75, 75, 75, 80, 80, 81,
72, 72, 72, 72, 72, 72, 72, 72, 72, 72,	81, 85, 85, 88, 88, 88, 88, 88, 88, 88,
72, 72, 72, 72, 85, 85, 85, 85, 85, 85,	89, 89, 89, 89, 89, 89, 89, 90, 90, 90,
85, 85, 86, 86, 86, 86, 86, 86, 86, 86,	90, 90, 90, 90, 91, 20, 15, 11, 10, 91,
87, 87, 87, 87, 87, 87, 87, 87, 88, 0,	91, 92, 92, 9, 92, 92, 92, 92, 93, 0,

0, 0, 0, 0, 88, 88, 89, 89, 0, 89,	0, 0, 93, 93, 93, 94, 94, 0, 94, 0,
89, 89, 89, 89, 90, 0, 0, 0, 0, 90,	94, 94, 95, 95, 0, 95, 95, 95, 95, 96,
90, 90, 91, 91, 0, 91, 91, 0, 91, 91,	96, 96, 96, 96, 96, 96, 97, 97, 0, 0,
92, 92, 0, 92, 92, 92, 92, 92, 93, 93,	97, 97, 98, 98, 98, 98, 98, 98, 98, 99,
0, 0, 93, 93, 93, 94, 94, 94, 94, 94,	99, 99, 99, 99, 99, 99, 100, 100, 100, 100,
94, 94, 94, 95, 95, 0, 95, 0, 95, 95,	100, 100, 100, 102, 102, 0, 102, 102, 102, 102,
96, 96, 96, 96, 96, 96, 96, 96, 97, 97,	87, 87, 87, 87, 87, 87, 87, 87, 87, 87,
97, 97, 97, 97, 97, 97, 98, 98, 98, 98,	87, 87, 87, 87, 87, 87, 87, 87, 87, 87,
98, 98, 98, 98, 100, 100, 100, 100, 100, 100,	87, 87, 87, 87, 87, 87, 87, 87, 87, 87,
100, 100, 84, 84, 84, 84, 84, 84, 84, 84,	87

84, 84, 84, 84, 84, 84, 84, 84, 84, 84,
84, 84, 84, 84, 84, 84, 84, 84, 84, 84,
84, 84, 84
} ;	} ;

static yy_state_type yy_last_accepting_state;	static yy_state_type yy_last_accepting_state;
static char *yy_last_accepting_cpos;	static char *yy_last_accepting_cpos;

extern int cfg_yy_flex_debug;	extern int yy_flex_debug;
int cfg_yy_flex_debug = 0;	int yy_flex_debug = 0;

/* The intent behind this definition is that it'll catch	/* The intent behind this definition is that it'll catch
* any uses of REJECT which flex missed.	* any uses of REJECT which flex missed.
Line 568 int cfg_yy_flex_debug = 0;	Line 795 int cfg_yy_flex_debug = 0;
#define yymore() yymore_used_but_not_detected	#define yymore() yymore_used_but_not_detected
#define YY_MORE_ADJ 0	#define YY_MORE_ADJ 0
#define YY_RESTORE_YY_MORE_OFFSET	#define YY_RESTORE_YY_MORE_OFFSET
char *cfg_yytext;	char *yytext;
#line 1 "lexer.l"	#line 1 "lexer.l"
#line 2 "lexer.l"	#line 2 "lexer.l"
/*	/*
* Copyright (c) 2002,2003,2007 Martin Hedenfalk <martin@bzero.se>	* Copyright (c) 2002-2017 Martin Hedenfalk <martin@bzero.se>
*	*
* Permission to use, copy, modify, and distribute this software for any	* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above	* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.	* copyright notice and this permission notice appear in all copies.
*	*
Line 587 char *cfg_yytext;	Line 814 char *cfg_yytext;
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.	* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/	*/

	#include <assert.h>
	#include <ctype.h>
	#include <errno.h>

#ifdef HAVE_CONFIG_H	#ifdef HAVE_CONFIG_H
# include <config.h>	# include <config.h>
#endif	#endif

#include <assert.h>	#ifndef HAVE_UNISTD_H
	# define YY_NO_UNISTD_H
	#else
	# include <unistd.h> /* isatty() */
	#endif

#ifdef HAVE_STRING_H	#ifdef HAVE_STRING_H
# include <string.h>	# include <string.h>
#endif	#endif

	/* Defines isatty() for non UNIX systems */
#include "confuse.h"	#include "confuse.h"

#include <errno.h>

#if defined(ENABLE_NLS) && defined(HAVE_GETTEXT)	#if defined(ENABLE_NLS) && defined(HAVE_GETTEXT)
# include <libintl.h>	# include <libintl.h>
# define _(str) dgettext(PACKAGE, str)	# define _(str) dgettext(PACKAGE, str)
Line 621 extern YYSTYPE cfg_yylval;	Line 856 extern YYSTYPE cfg_yylval;

/* temporary buffer for the quoted strings scanner	/* temporary buffer for the quoted strings scanner
*/	*/
	#define CFG_QSTRING_BUFSIZ 32
char *cfg_qstring = NULL;	char *cfg_qstring = NULL;
static unsigned int qstring_index = 0;	static size_t qstring_index = 0;
static unsigned int qstring_len = 0;	static size_t qstring_len = 0;
static void qputc(char ch);	static void qputc(char ch);
#define CFG_QSTRING_BUFSIZ 32	static void qput(cfg_t *cfg, char skip);
	static void qbeg(int state);
	static int qend(cfg_t *cfg, int trim, int ret);
	static int qstr(cfg_t *cfg, char skip, int ret);

#define MAX_INCLUDE_DEPTH 10	#define MAX_INCLUDE_DEPTH 10
struct {	struct {
YY_BUFFER_STATE state;	FILE *fp;
char *filename;	char *filename;
unsigned int line;	unsigned int line;
} cfg_include_stack[MAX_INCLUDE_DEPTH];	} cfg_include_stack[MAX_INCLUDE_DEPTH];
int cfg_include_stack_ptr = 0;	int cfg_include_stack_ptr = 0;

static YY_BUFFER_STATE pre_string_scan_state = 0;	void cfg_scan_fp_begin(FILE *fp);
static YY_BUFFER_STATE string_scan_state = 0;	void cfg_scan_fp_end(void);

/* start conditions	#line 881 "lexer.c"
*/	#line 86 "lexer.l"
	/* start conditions
	*/



#line 647 "lexer.c"	#line 888 "lexer.c"

#define INITIAL 0	#define INITIAL 0
#define comment 1	#define comment 1
Line 662 static YY_BUFFER_STATE string_scan_state = 0;	Line 903 static YY_BUFFER_STATE string_scan_state = 0;
#define YY_EXTRA_TYPE void *	#define YY_EXTRA_TYPE void *
#endif	#endif

static int yy_init_globals (void );	static int yy_init_globals ( void );

/* Accessor methods to globals.	/* Accessor methods to globals.
These are made visible to non-reentrant scanners for convenience. */	These are made visible to non-reentrant scanners for convenience. */

int cfg_yylex_destroy (void );	int yylex_destroy ( void );

int cfg_yyget_debug (void );	int yyget_debug ( void );

void cfg_yyset_debug (int debug_flag );	void yyset_debug ( int debug_flag );

YY_EXTRA_TYPE cfg_yyget_extra (void );	YY_EXTRA_TYPE yyget_extra ( void );

void cfg_yyset_extra (YY_EXTRA_TYPE user_defined );	void yyset_extra ( YY_EXTRA_TYPE user_defined );

FILE *cfg_yyget_in (void );	FILE *yyget_in ( void );

void cfg_yyset_in (FILE * in_str );	void yyset_in ( FILE * _in_str );

FILE *cfg_yyget_out (void );	FILE *yyget_out ( void );

void cfg_yyset_out (FILE * out_str );	void yyset_out ( FILE * _out_str );

int cfg_yyget_leng (void );	int yyget_leng ( void );

char *cfg_yyget_text (void );	char *yyget_text ( void );

int cfg_yyget_lineno (void );	int yyget_lineno ( void );

void cfg_yyset_lineno (int line_number );	void yyset_lineno ( int _line_number );

/* Macros after this point can all be overridden by user definitions in	/* Macros after this point can all be overridden by user definitions in
* section 1.	* section 1.
Line 699 void cfg_yyset_lineno (int line_number );	Line 940 void cfg_yyset_lineno (int line_number );

#ifndef YY_SKIP_YYWRAP	#ifndef YY_SKIP_YYWRAP
#ifdef __cplusplus	#ifdef __cplusplus
extern "C" int cfg_yywrap (void );	extern "C" int yywrap ( void );
#else	#else
extern int cfg_yywrap (void );	extern int yywrap ( void );
#endif	#endif
#endif	#endif

static void yyunput (int c,char *buf_ptr );	#ifndef YY_NO_UNPUT

	static void yyunput ( int c, char *buf_ptr );

	#endif

#ifndef yytext_ptr	#ifndef yytext_ptr
static void yy_flex_strncpy (char ,yyconst char ,int );	static void yy_flex_strncpy ( char , const char , int );
#endif	#endif

#ifdef YY_NEED_STRLEN	#ifdef YY_NEED_STRLEN
static int yy_flex_strlen (yyconst char * );	static int yy_flex_strlen ( const char * );
#endif	#endif

#ifndef YY_NO_INPUT	#ifndef YY_NO_INPUT

#ifdef __cplusplus	#ifdef __cplusplus
static int yyinput (void );	static int yyinput ( void );
#else	#else
static int input (void );	static int input ( void );
#endif	#endif

#endif	#endif

/* Amount of stuff to slurp up with each read. */	/* Amount of stuff to slurp up with each read. */
#ifndef YY_READ_BUF_SIZE	#ifndef YY_READ_BUF_SIZE
	#ifdef __ia64__
	/* On IA-64, the buffer size is 16k, not 8k */
	#define YY_READ_BUF_SIZE 16384
	#else
#define YY_READ_BUF_SIZE 8192	#define YY_READ_BUF_SIZE 8192
	#endif /* __ia64__ */
#endif	#endif

/* Copy whatever the last rule matched to the standard output. */	/* Copy whatever the last rule matched to the standard output. */
Line 735 static int input (void );	Line 984 static int input (void );
/* This used to be an fputs(), but since the string might contain NUL's,	/* This used to be an fputs(), but since the string might contain NUL's,
* we now use fwrite().	* we now use fwrite().
*/	*/
#define ECHO fwrite( cfg_yytext, cfg_yyleng, 1, cfg_yyout )	#define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0)
#endif	#endif

/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,	/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
Line 748 static int input (void );	Line 997 static int input (void );
int c = '*'; \	int c = '*'; \
int n; \	int n; \
for ( n = 0; n < max_size && \	for ( n = 0; n < max_size && \
(c = getc( cfg_yyin )) != EOF && c != '\n'; ++n ) \	(c = getc( yyin )) != EOF && c != '\n'; ++n ) \
buf[n] = (char) c; \	buf[n] = (char) c; \
if ( c == '\n' ) \	if ( c == '\n' ) \
buf[n++] = (char) c; \	buf[n++] = (char) c; \
if ( c == EOF && ferror( cfg_yyin ) ) \	if ( c == EOF && ferror( yyin ) ) \
YY_FATAL_ERROR( "input in flex scanner failed" ); \	YY_FATAL_ERROR( "input in flex scanner failed" ); \
result = n; \	result = n; \
} \	} \
else \	else \
{ \	{ \
errno=0; \	errno=0; \
while ( (result = fread(buf, 1, max_size, cfg_yyin))==0 && ferror(cfg_yyin)) \	while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \
{ \	{ \
if( errno != EINTR) \	if( errno != EINTR) \
{ \	{ \
Line 767 static int input (void );	Line 1016 static int input (void );
break; \	break; \
} \	} \
errno=0; \	errno=0; \
clearerr(cfg_yyin); \	clearerr(yyin); \
} \	} \
}\	}\
\	\
Line 800 static int input (void );	Line 1049 static int input (void );
#ifndef YY_DECL	#ifndef YY_DECL
#define YY_DECL_IS_OURS 1	#define YY_DECL_IS_OURS 1

extern int cfg_yylex (void);	extern int yylex (void);

#define YY_DECL int cfg_yylex (void)	#define YY_DECL int yylex (void)
#endif /* !YY_DECL */	#endif /* !YY_DECL */

/* Code executed at the beginning of each rule, after cfg_yytext and cfg_yyleng	/* Code executed at the beginning of each rule, after yytext and yyleng
* have been set up.	* have been set up.
*/	*/
#ifndef YY_USER_ACTION	#ifndef YY_USER_ACTION
Line 814 extern int cfg_yylex (void);	Line 1063 extern int cfg_yylex (void);

/* Code executed at the end of each rule. */	/* Code executed at the end of each rule. */
#ifndef YY_BREAK	#ifndef YY_BREAK
#define YY_BREAK break;	#define YY_BREAK /LINTED/break;
#endif	#endif

#define YY_RULE_SETUP \	#define YY_RULE_SETUP \
Line 824 extern int cfg_yylex (void);	Line 1073 extern int cfg_yylex (void);
*/	*/
YY_DECL	YY_DECL
{	{
register yy_state_type yy_current_state;	yy_state_type yy_current_state;
register char yy_cp, yy_bp;	char yy_cp, yy_bp;
register int yy_act;	int yy_act;

#line 79 "lexer.l"


#line 835 "lexer.c"

if ( !(yy_init) )	if ( !(yy_init) )
{	{
(yy_init) = 1;	(yy_init) = 1;
Line 844 YY_DECL	Line 1088 YY_DECL
if ( ! (yy_start) )	if ( ! (yy_start) )
(yy_start) = 1; /* first start state */	(yy_start) = 1; /* first start state */

if ( ! cfg_yyin )	if ( ! yyin )
cfg_yyin = stdin;	yyin = stdin;

if ( ! cfg_yyout )	if ( ! yyout )
cfg_yyout = stdout;	yyout = stdout;

if ( ! YY_CURRENT_BUFFER ) {	if ( ! YY_CURRENT_BUFFER ) {
cfg_yyensure_buffer_stack ();	yyensure_buffer_stack ();
YY_CURRENT_BUFFER_LVALUE =	YY_CURRENT_BUFFER_LVALUE =
cfg_yy_create_buffer(cfg_yyin,YY_BUF_SIZE );	yy_create_buffer( yyin, YY_BUF_SIZE );
}	}

cfg_yy_load_buffer_state( );	yy_load_buffer_state( );
}	}

while ( 1 ) /* loops until end-of-file is reached */	{
	#line 92 "lexer.l"


	#line 1111 "lexer.c"

	while ( /CONSTCOND/1 ) /* loops until end-of-file is reached */
{	{
yy_cp = (yy_c_buf_p);	yy_cp = (yy_c_buf_p);

/* Support of cfg_yytext. */	/* Support of yytext. */
*yy_cp = (yy_hold_char);	*yy_cp = (yy_hold_char);

/* yy_bp points to the position in yy_ch_buf of the start of	/* yy_bp points to the position in yy_ch_buf of the start of
Line 875 YY_DECL	Line 1125 YY_DECL
yy_match:	yy_match:
do	do
{	{
register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];	YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
if ( yy_accept[yy_current_state] )	if ( yy_accept[yy_current_state] )
{	{
(yy_last_accepting_state) = yy_current_state;	(yy_last_accepting_state) = yy_current_state;
Line 884 yy_match:	Line 1134 yy_match:
while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
{	{
yy_current_state = (int) yy_def[yy_current_state];	yy_current_state = (int) yy_def[yy_current_state];
if ( yy_current_state >= 85 )	if ( yy_current_state >= 88 )
yy_c = yy_meta[(unsigned int) yy_c];	yy_c = yy_meta[yy_c];
}	}
yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];	yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
++yy_cp;	++yy_cp;
}	}
while ( yy_base[yy_current_state] != 293 );	while ( yy_base[yy_current_state] != 261 );

yy_find_action:	yy_find_action:
yy_act = yy_accept[yy_current_state];	yy_act = yy_accept[yy_current_state];
Line 916 do_action: /* This label is used only to access EOF ac	Line 1166 do_action: /* This label is used only to access EOF ac

case 1:	case 1:
YY_RULE_SETUP	YY_RULE_SETUP
#line 81 "lexer.l"	#line 94 "lexer.l"
/* eat up whitespace */	/* eat up whitespace */
YY_BREAK	YY_BREAK
case 2:	case 2:
/* rule 2 can match eol */	/* rule 2 can match eol */
YY_RULE_SETUP	YY_RULE_SETUP
#line 83 "lexer.l"	#line 96 "lexer.l"
cfg->line++; /* keep track of line number */	cfg->line++; /* keep track of line number */
YY_BREAK	YY_BREAK
	/*
	* handle one-line comments
	*
	* Note: Comments with lots of leading #### or //// are fully
	* consumed and are not included in CFGT_COMMENT yylval
	*/
case 3:	case 3:
YY_RULE_SETUP	YY_RULE_SETUP
#line 85 "lexer.l"	#line 104 "lexer.l"
/* eat up one-line comments */	return qstr(cfg, '#', CFGT_COMMENT);
YY_BREAK	YY_BREAK
/* special keywords/symbols
*/
case 4:	case 4:
YY_RULE_SETUP	YY_RULE_SETUP
#line 89 "lexer.l"	#line 105 "lexer.l"
{ cfg_yylval = cfg_yytext; return '{'; }	return qstr(cfg, '/', CFGT_COMMENT);
YY_BREAK	YY_BREAK
	/* special keywords/symbols
	*/
case 5:	case 5:
YY_RULE_SETUP	YY_RULE_SETUP
#line 90 "lexer.l"	#line 109 "lexer.l"
{ cfg_yylval = cfg_yytext; return '}'; }	{ cfg_yylval = yytext; return '{'; }
YY_BREAK	YY_BREAK
case 6:	case 6:
YY_RULE_SETUP	YY_RULE_SETUP
#line 91 "lexer.l"	#line 110 "lexer.l"
{ cfg_yylval = cfg_yytext; return '('; }	{ cfg_yylval = yytext; return '}'; }
YY_BREAK	YY_BREAK
case 7:	case 7:
YY_RULE_SETUP	YY_RULE_SETUP
#line 92 "lexer.l"	#line 111 "lexer.l"
{ cfg_yylval = cfg_yytext; return ')'; }	{ cfg_yylval = yytext; return '('; }
YY_BREAK	YY_BREAK
case 8:	case 8:
YY_RULE_SETUP	YY_RULE_SETUP
#line 93 "lexer.l"	#line 112 "lexer.l"
{ cfg_yylval = cfg_yytext; return '='; }	{ cfg_yylval = yytext; return ')'; }
YY_BREAK	YY_BREAK
case 9:	case 9:
YY_RULE_SETUP	YY_RULE_SETUP
#line 94 "lexer.l"	#line 113 "lexer.l"
{ cfg_yylval = cfg_yytext; return '+'; }	{ cfg_yylval = yytext; return '='; }
YY_BREAK	YY_BREAK
case 10:	case 10:
YY_RULE_SETUP	YY_RULE_SETUP
#line 95 "lexer.l"	#line 114 "lexer.l"
{ cfg_yylval = cfg_yytext; return ','; }	{ cfg_yylval = yytext; return '+'; }
YY_BREAK	YY_BREAK
/* handle multi-line C-style comments
*/
case 11:	case 11:
YY_RULE_SETUP	YY_RULE_SETUP
#line 99 "lexer.l"	#line 115 "lexer.l"
BEGIN(comment);	{ cfg_yylval = yytext; return ','; }
YY_BREAK	YY_BREAK
	/* handle multi-line C-style comments
	*/
case 12:	case 12:
YY_RULE_SETUP	YY_RULE_SETUP
#line 100 "lexer.l"	#line 119 "lexer.l"
/* eat anything that's not a '' /	qbeg(comment);
YY_BREAK	YY_BREAK
case 13:	case 13:
YY_RULE_SETUP	YY_RULE_SETUP
#line 101 "lexer.l"	#line 120 "lexer.l"
/* eat up ''s not followed by '/'s /	qput(NULL, 0); /* anything that's not a '' /
YY_BREAK	YY_BREAK
case 14:	case 14:
/* rule 14 can match eol */
YY_RULE_SETUP	YY_RULE_SETUP
#line 102 "lexer.l"	#line 121 "lexer.l"
cfg->line++;	qput(NULL, 0); /* ''s not followed by '/'s /
YY_BREAK	YY_BREAK
case 15:	case 15:
	/* rule 15 can match eol */
YY_RULE_SETUP	YY_RULE_SETUP
#line 103 "lexer.l"	#line 122 "lexer.l"
BEGIN(INITIAL);	qput(cfg, 0);
YY_BREAK	YY_BREAK
	case 16:
	YY_RULE_SETUP
	#line 123 "lexer.l"
	return qend(cfg, 1, CFGT_COMMENT);
	YY_BREAK
/* handle C-style strings	/* handle C-style strings
*/	*/
case 16:	case 17:
YY_RULE_SETUP	YY_RULE_SETUP
#line 107 "lexer.l"	#line 127 "lexer.l"
{	{
qstring_index = 0;	qstring_index = 0;
BEGIN(dq_str);	BEGIN(dq_str);
}	}
YY_BREAK	YY_BREAK
case 17:	case 18:
YY_RULE_SETUP	YY_RULE_SETUP
#line 111 "lexer.l"	#line 131 "lexer.l"
{ /* saw closing quote - all done */	{ /* saw closing quote - all done */
BEGIN(INITIAL);	BEGIN(INITIAL);
qputc('\0');	qputc('\0');
cfg_yylval = cfg_qstring;	cfg_yylval = cfg_qstring;
return CFGT_STR;	return CFGT_STR;
}	}
YY_BREAK	YY_BREAK
case 18:	case 19:
/* rule 18 can match eol */	/* rule 19 can match eol */
YY_RULE_SETUP	YY_RULE_SETUP
#line 117 "lexer.l"	#line 137 "lexer.l"
{ /* environment variable substitution */	{ /* environment variable substitution */
char *var;	char *var;
char *e;	char *e;
cfg_yytext[strlen(cfg_yytext) - 1] = 0;	yytext[strlen(yytext) - 1] = 0;
e = strchr(cfg_yytext+2, ':');	e = strchr(yytext+2, ':');
if(e && e[1] == '-')	if(e && e[1] == '-')
*e = 0;	*e = 0;
else	else
e = 0;	e = 0;
var = getenv(cfg_yytext+2);	var = getenv(yytext+2);
if(!var && e)	if(!var && e)
var = e+2;	var = e+2;
while(var && *var)	while(var && *var)
qputc(*var++);	qputc(*var++);
}	}
YY_BREAK	YY_BREAK
case 19:	case 20:
/* rule 19 can match eol */	/* rule 20 can match eol */
YY_RULE_SETUP	YY_RULE_SETUP
#line 132 "lexer.l"	#line 152 "lexer.l"
{	{
qputc('\n');	qputc('\n');
cfg->line++;	cfg->line++;
}	}
YY_BREAK	YY_BREAK
case 20:	case 21:
/* rule 20 can match eol */	/* rule 21 can match eol */
YY_RULE_SETUP	YY_RULE_SETUP
#line 136 "lexer.l"	#line 156 "lexer.l"
{ /* allow continuing on next line */	{ /* allow continuing on next line */
/* no-op */	/* no-op */
cfg->line++;	cfg->line++;
}	}
YY_BREAK	YY_BREAK
case 21:	case 22:
YY_RULE_SETUP	YY_RULE_SETUP
#line 140 "lexer.l"	#line 160 "lexer.l"
{ /* octal escape sequence */	{ /* octal escape sequence */
unsigned int result;	unsigned int result;
sscanf(cfg_yytext + 1, "%o", &result);	sscanf(yytext + 1, "%o", &result);
if(result > 0xFF) {	if(result > 0xFF) {
cfg_error(cfg, _("invalid octal number '%s'"), cfg_yytext);	cfg_error(cfg, _("invalid octal number '%s'"), yytext);
return 0;	return 0;
}	}
qputc(result);	qputc(result);
}	}
YY_BREAK	YY_BREAK
case 22:	case 23:
YY_RULE_SETUP	YY_RULE_SETUP
#line 149 "lexer.l"	#line 169 "lexer.l"
{	{
cfg_error(cfg, _("bad escape sequence '%s'"), cfg_yytext);	cfg_error(cfg, _("bad escape sequence '%s'"), yytext);
return 0;	return 0;
}	}
YY_BREAK	YY_BREAK
case 23:	case 24:
YY_RULE_SETUP	YY_RULE_SETUP
#line 153 "lexer.l"	#line 173 "lexer.l"
{ /* hexadecimal escape sequence */	{ /* hexadecimal escape sequence */
unsigned int result;	unsigned int result;
sscanf(cfg_yytext + 2, "%x", &result);	sscanf(yytext + 2, "%x", &result);
qputc(result);	qputc(result);
}	}
YY_BREAK	YY_BREAK
case 24:	case 25:
YY_RULE_SETUP	YY_RULE_SETUP
#line 158 "lexer.l"	#line 178 "lexer.l"
{	{
qputc('\n');	qputc('\n');
}	}
YY_BREAK	YY_BREAK
case 25:	case 26:
YY_RULE_SETUP	YY_RULE_SETUP
#line 161 "lexer.l"	#line 181 "lexer.l"
{	{
qputc('\r');	qputc('\r');
}	}
YY_BREAK	YY_BREAK
case 26:	case 27:
YY_RULE_SETUP	YY_RULE_SETUP
#line 164 "lexer.l"	#line 184 "lexer.l"
{	{
qputc('\b');	qputc('\b');
}	}
YY_BREAK	YY_BREAK
case 27:	case 28:
YY_RULE_SETUP	YY_RULE_SETUP
#line 167 "lexer.l"	#line 187 "lexer.l"
{	{
qputc('\f');	qputc('\f');
}	}
YY_BREAK	YY_BREAK
case 28:	case 29:
YY_RULE_SETUP	YY_RULE_SETUP
#line 170 "lexer.l"	#line 190 "lexer.l"
{	{
qputc('\007');	qputc('\007');
}	}
YY_BREAK	YY_BREAK
case 29:	case 30:
YY_RULE_SETUP	YY_RULE_SETUP
#line 173 "lexer.l"	#line 193 "lexer.l"
{	{
qputc('\033');	qputc('\033');
}	}
YY_BREAK	YY_BREAK
case 30:	case 31:
YY_RULE_SETUP	YY_RULE_SETUP
#line 176 "lexer.l"	#line 196 "lexer.l"
{	{
qputc('\t');	qputc('\t');
}	}
YY_BREAK	YY_BREAK
case 31:	case 32:
YY_RULE_SETUP	YY_RULE_SETUP
#line 179 "lexer.l"	#line 199 "lexer.l"
{	{
qputc('\v');	qputc('\v');
}	}
YY_BREAK	YY_BREAK
case 32:	case 33:
YY_RULE_SETUP	YY_RULE_SETUP
#line 182 "lexer.l"	#line 202 "lexer.l"
{	{
qputc(cfg_yytext[1]);	qputc(yytext[1]);
}	}
YY_BREAK	YY_BREAK
case 33:	case 34:
YY_RULE_SETUP	YY_RULE_SETUP
#line 185 "lexer.l"	#line 205 "lexer.l"
{	{
char *yptr = cfg_yytext;	qputc(yytext[0]);
while(*yptr) {
qputc(*yptr++);
}
}	}
YY_BREAK	YY_BREAK
/* single-quoted string ('...') */	/* single-quoted string ('...') */
case 34:	case 35:
YY_RULE_SETUP	YY_RULE_SETUP
#line 193 "lexer.l"	#line 210 "lexer.l"
{	{
qstring_index = 0;	qstring_index = 0;
BEGIN(sq_str);	BEGIN(sq_str);
}	}
YY_BREAK	YY_BREAK
case 35:	case 36:
YY_RULE_SETUP	YY_RULE_SETUP
#line 197 "lexer.l"	#line 214 "lexer.l"
{ /* saw closing quote - all done */	{ /* saw closing quote - all done */
BEGIN(INITIAL);	BEGIN(INITIAL);
qputc('\0');	qputc('\0');
Line 1175 YY_RULE_SETUP	Line 1433 YY_RULE_SETUP
return CFGT_STR;	return CFGT_STR;
}	}
YY_BREAK	YY_BREAK
case 36:	case 37:
/* rule 36 can match eol */	/* rule 37 can match eol */
YY_RULE_SETUP	YY_RULE_SETUP
#line 203 "lexer.l"	#line 220 "lexer.l"
{	{
qputc('\n');	qputc('\n');
cfg->line++;	cfg->line++;
}	}
YY_BREAK	YY_BREAK
case 37:	case 38:
/* rule 37 can match eol */	/* rule 38 can match eol */
YY_RULE_SETUP	YY_RULE_SETUP
#line 207 "lexer.l"	#line 224 "lexer.l"
{ /* allow continuing on next line */	{ /* allow continuing on next line */
/* no-op */	/* no-op */
cfg->line++;	cfg->line++;
}	}
YY_BREAK	YY_BREAK
case 38:	case 39:
YY_RULE_SETUP	YY_RULE_SETUP
#line 211 "lexer.l"	#line 228 "lexer.l"
{	{
qputc(cfg_yytext[1]);	qputc(yytext[1]);
}	}
YY_BREAK	YY_BREAK
case 39:	case 40:
/* rule 39 can match eol */	/* rule 40 can match eol */
YY_RULE_SETUP	YY_RULE_SETUP
#line 214 "lexer.l"	#line 231 "lexer.l"
{	{
qputc(cfg_yytext[0]);	qputc(yytext[0]);
qputc(cfg_yytext[1]);	qputc(yytext[1]);
}	}
YY_BREAK	YY_BREAK
case 40:	case 41:
YY_RULE_SETUP	YY_RULE_SETUP
#line 218 "lexer.l"	#line 235 "lexer.l"
{	{
char *cp = cfg_yytext;	char *cp = yytext;
while(*cp != '\0') {	while (*cp != '\0')
qputc(*cp++);	qputc(*cp++);
}
}	}
YY_BREAK	YY_BREAK
case YY_STATE_EOF(sq_str):	case YY_STATE_EOF(sq_str):
#line 224 "lexer.l"	#line 240 "lexer.l"
{	{
cfg_error(cfg, _("unterminated string constant"));	cfg_error(cfg, _("unterminated string constant"));
return 0;	return 0;
Line 1229 case YY_STATE_EOF(sq_str):	Line 1486 case YY_STATE_EOF(sq_str):
case YY_STATE_EOF(INITIAL):	case YY_STATE_EOF(INITIAL):
case YY_STATE_EOF(comment):	case YY_STATE_EOF(comment):
case YY_STATE_EOF(dq_str):	case YY_STATE_EOF(dq_str):
#line 229 "lexer.l"	#line 245 "lexer.l"
{	{
if (cfg_include_stack_ptr <= 0)	if (cfg_include_stack_ptr > 0)
{	{
return EOF;	--cfg_include_stack_ptr;
}	/* fp opened by cfg_lexer_include()? */
else	if (cfg_include_stack[cfg_include_stack_ptr].fp != cfg_yyin) {
{	++cfg_include_stack_ptr;
cfg_yy_delete_buffer(YY_CURRENT_BUFFER );	return EOF;
fclose(cfg_yyin);	}
cfg_yyin = 0;	free(cfg->filename);
--cfg_include_stack_ptr;	cfg->filename = cfg_include_stack[cfg_include_stack_ptr].filename;
cfg_yy_switch_to_buffer(cfg_include_stack[cfg_include_stack_ptr].state );	cfg->line = cfg_include_stack[cfg_include_stack_ptr].line;
free(cfg->filename);	fclose(cfg_yyin);
cfg->filename = cfg_include_stack[cfg_include_stack_ptr].filename;	cfg_scan_fp_end();
cfg->line = cfg_include_stack[cfg_include_stack_ptr].line;	}
}	else
	{
	return EOF;
	}
}	}
YY_BREAK	YY_BREAK
case 41:	case 42:
/* rule 41 can match eol */	/* rule 42 can match eol */
YY_RULE_SETUP	YY_RULE_SETUP
#line 248 "lexer.l"	#line 266 "lexer.l"
{	{
char *var;	char *var;
char *e;	char *e;
cfg_yytext[strlen(cfg_yytext) - 1] = 0;
e = strchr(cfg_yytext+2, ':');	yytext[strlen(yytext) - 1] = 0;
if(e && e[1] == '-')	e = strchr(yytext+2, ':');
	if (e && e[1] == '-')
*e = 0;	*e = 0;
else	else
e = 0;	e = 0;
var = getenv(cfg_yytext+2);	var = getenv(yytext+2);
if(!var && e)	if (!var && e)
var = e+2;	var = e+2;
if(!var)	if (!var)
var = "";	var = "";
cfg_yylval = var;	cfg_yylval = var;

return CFGT_STR;	return CFGT_STR;
}	}
YY_BREAK	YY_BREAK
Line 1274 YY_RULE_SETUP	Line 1536 YY_RULE_SETUP
* a slash can't be followed by another slash (c++	* a slash can't be followed by another slash (c++
* comment) or an asterisk (C multi-line comment)	* comment) or an asterisk (C multi-line comment)
*/	*/
case 42:	case 43:
YY_RULE_SETUP	YY_RULE_SETUP
#line 270 "lexer.l"	#line 290 "lexer.l"
{	{
cfg_yylval = cfg_yytext;	cfg_yylval = yytext;
return CFGT_STR;	return CFGT_STR;
}	}
YY_BREAK	YY_BREAK
case 43:	case 44:
YY_RULE_SETUP	YY_RULE_SETUP
#line 275 "lexer.l"	#line 295 "lexer.l"
/* eat any non-matching characters */	/* eat any non-matching characters */
YY_BREAK	YY_BREAK
case 44:	case 45:
YY_RULE_SETUP	YY_RULE_SETUP
#line 277 "lexer.l"	#line 297 "lexer.l"
ECHO;	ECHO;
YY_BREAK	YY_BREAK
#line 1296 "lexer.c"	#line 1558 "lexer.c"

case YY_END_OF_BUFFER:	case YY_END_OF_BUFFER:
{	{
Line 1307 ECHO;	Line 1569 ECHO;
{	{
/* We're scanning a new file or input source. It's	/* We're scanning a new file or input source. It's
* possible that this happened because the user	* possible that this happened because the user
* just pointed cfg_yyin at a new source and called	* just pointed yyin at a new source and called
* cfg_yylex(). If so, then we have to assure	* yylex(). If so, then we have to assure
* consistency between YY_CURRENT_BUFFER and our	* consistency between YY_CURRENT_BUFFER and our
* globals. Here is the right place to do so, because	* globals. Here is the right place to do so, because
* this is the first action (other than possibly a	* this is the first action (other than possibly a
* back-up) that will match for the new input source.	* back-up) that will match for the new input source.
*/	*/
(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;	(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
YY_CURRENT_BUFFER_LVALUE->yy_input_file = cfg_yyin;	YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;	YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
}	}

Line 1368 ECHO;	Line 1630 ECHO;
{	{
(yy_did_buffer_switch_on_eof) = 0;	(yy_did_buffer_switch_on_eof) = 0;

if ( cfg_yywrap( ) )	if ( yywrap( ) )
{	{
/* Note: because we've taken care in	/* Note: because we've taken care in
* yy_get_next_buffer() to have set up	* yy_get_next_buffer() to have set up
* cfg_yytext, we can now set up	* yytext, we can now set up
* yy_c_buf_p so that if some total	* yy_c_buf_p so that if some total
* hoser (like flex itself) wants to	* hoser (like flex itself) wants to
* call the scanner after we return the	* call the scanner after we return the
Line 1421 ECHO;	Line 1683 ECHO;
"fatal flex scanner internal error--no action found" );	"fatal flex scanner internal error--no action found" );
} /* end of action switch */	} /* end of action switch */
} /* end of scanning one token */	} /* end of scanning one token */
} /* end of cfg_yylex */	} /* end of user's declarations */
	} /* end of yylex */

/* yy_get_next_buffer - try to read in a new buffer	/* yy_get_next_buffer - try to read in a new buffer
*	*
Line 1432 ECHO;	Line 1695 ECHO;
*/	*/
static int yy_get_next_buffer (void)	static int yy_get_next_buffer (void)
{	{
register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;	char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
register char *source = (yytext_ptr);	char *source = (yytext_ptr);
register int number_to_move, i;	int number_to_move, i;
int ret_val;	int ret_val;

if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )	if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
Line 1463 static int yy_get_next_buffer (void)	Line 1726 static int yy_get_next_buffer (void)
/* Try to read more data. */	/* Try to read more data. */

/* First move last chars to start of buffer. */	/* First move last chars to start of buffer. */
number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;	number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr) - 1);

for ( i = 0; i < number_to_move; ++i )	for ( i = 0; i < number_to_move; ++i )
(dest++) = (source++);	(dest++) = (source++);
Line 1483 static int yy_get_next_buffer (void)	Line 1746 static int yy_get_next_buffer (void)
{ /* Not enough room in the buffer - grow it. */	{ /* Not enough room in the buffer - grow it. */

/* just a shorter name for the current buffer */	/* just a shorter name for the current buffer */
YY_BUFFER_STATE b = YY_CURRENT_BUFFER;	YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;

int yy_c_buf_p_offset =	int yy_c_buf_p_offset =
(int) ((yy_c_buf_p) - b->yy_ch_buf);	(int) ((yy_c_buf_p) - b->yy_ch_buf);
Line 1499 static int yy_get_next_buffer (void)	Line 1762 static int yy_get_next_buffer (void)

b->yy_ch_buf = (char *)	b->yy_ch_buf = (char *)
/* Include room in for 2 EOB chars. */	/* Include room in for 2 EOB chars. */
cfg_yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 );	yyrealloc( (void *) b->yy_ch_buf,
	(yy_size_t) (b->yy_buf_size + 2) );
}	}
else	else
/* Can't grow it, we don't own it. */	/* Can't grow it, we don't own it. */
b->yy_ch_buf = 0;	b->yy_ch_buf = NULL;

if ( ! b->yy_ch_buf )	if ( ! b->yy_ch_buf )
YY_FATAL_ERROR(	YY_FATAL_ERROR(
Line 1521 static int yy_get_next_buffer (void)	Line 1785 static int yy_get_next_buffer (void)

/* Read in more data. */	/* Read in more data. */
YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),	YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
(yy_n_chars), (size_t) num_to_read );	(yy_n_chars), num_to_read );

YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);	YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
}	}
Line 1531 static int yy_get_next_buffer (void)	Line 1795 static int yy_get_next_buffer (void)
if ( number_to_move == YY_MORE_ADJ )	if ( number_to_move == YY_MORE_ADJ )
{	{
ret_val = EOB_ACT_END_OF_FILE;	ret_val = EOB_ACT_END_OF_FILE;
cfg_yyrestart(cfg_yyin );	yyrestart( yyin );
}	}

else	else
Line 1545 static int yy_get_next_buffer (void)	Line 1809 static int yy_get_next_buffer (void)
else	else
ret_val = EOB_ACT_CONTINUE_SCAN;	ret_val = EOB_ACT_CONTINUE_SCAN;

if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {	if (((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
/* Extend the array by 50%, plus the number we really need. */	/* Extend the array by 50%, plus the number we really need. */
yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);	int new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char ) cfg_yyrealloc((void ) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size );	YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc(
	(void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size );
if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )	if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );	YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
	/* "- 2" to take care of EOB's */
	YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2);
}	}

(yy_n_chars) += number_to_move;	(yy_n_chars) += number_to_move;
Line 1566 static int yy_get_next_buffer (void)	Line 1833 static int yy_get_next_buffer (void)

static yy_state_type yy_get_previous_state (void)	static yy_state_type yy_get_previous_state (void)
{	{
register yy_state_type yy_current_state;	yy_state_type yy_current_state;
register char *yy_cp;	char *yy_cp;

yy_current_state = (yy_start);	yy_current_state = (yy_start);

for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )	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);	YY_CHAR yy_c = (yy_cp ? yy_ec[YY_SC_TO_UI(yy_cp)] : 1);
if ( yy_accept[yy_current_state] )	if ( yy_accept[yy_current_state] )
{	{
(yy_last_accepting_state) = yy_current_state;	(yy_last_accepting_state) = yy_current_state;
Line 1582 static int yy_get_next_buffer (void)	Line 1849 static int yy_get_next_buffer (void)
while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
{	{
yy_current_state = (int) yy_def[yy_current_state];	yy_current_state = (int) yy_def[yy_current_state];
if ( yy_current_state >= 85 )	if ( yy_current_state >= 88 )
yy_c = yy_meta[(unsigned int) yy_c];	yy_c = yy_meta[yy_c];
}	}
yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];	yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
}	}

return yy_current_state;	return yy_current_state;
Line 1598 static int yy_get_next_buffer (void)	Line 1865 static int yy_get_next_buffer (void)
*/	*/
static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state )	static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state )
{	{
register int yy_is_jam;	int yy_is_jam;
register char *yy_cp = (yy_c_buf_p);	char *yy_cp = (yy_c_buf_p);

register YY_CHAR yy_c = 1;	YY_CHAR yy_c = 1;
if ( yy_accept[yy_current_state] )	if ( yy_accept[yy_current_state] )
{	{
(yy_last_accepting_state) = yy_current_state;	(yy_last_accepting_state) = yy_current_state;
Line 1610 static int yy_get_next_buffer (void)	Line 1877 static int yy_get_next_buffer (void)
while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
{	{
yy_current_state = (int) yy_def[yy_current_state];	yy_current_state = (int) yy_def[yy_current_state];
if ( yy_current_state >= 85 )	if ( yy_current_state >= 88 )
yy_c = yy_meta[(unsigned int) yy_c];	yy_c = yy_meta[yy_c];
}	}
yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];	yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
yy_is_jam = (yy_current_state == 84);	yy_is_jam = (yy_current_state == 87);

return yy_is_jam ? 0 : yy_current_state;	return yy_is_jam ? 0 : yy_current_state;
}	}

static void yyunput (int c, register char * yy_bp )	#ifndef YY_NO_UNPUT

	static void yyunput (int c, char * yy_bp )
{	{
register char *yy_cp;	char *yy_cp;

yy_cp = (yy_c_buf_p);	yy_cp = (yy_c_buf_p);

/* undo effects of setting up cfg_yytext */	/* undo effects of setting up yytext */
*yy_cp = (yy_hold_char);	*yy_cp = (yy_hold_char);

if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )	if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
{ /* need to shift things up to make room */	{ /* need to shift things up to make room */
/* +2 for EOB chars. */	/* +2 for EOB chars. */
register int number_to_move = (yy_n_chars) + 2;	int number_to_move = (yy_n_chars) + 2;
register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[	char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];	YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
register char *source =	char *source =
&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];	&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];

while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )	while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
Line 1643 static int yy_get_next_buffer (void)	Line 1912 static int yy_get_next_buffer (void)
yy_cp += (int) (dest - source);	yy_cp += (int) (dest - source);
yy_bp += (int) (dest - source);	yy_bp += (int) (dest - source);
YY_CURRENT_BUFFER_LVALUE->yy_n_chars =	YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;	(yy_n_chars) = (int) YY_CURRENT_BUFFER_LVALUE->yy_buf_size;

if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )	if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
YY_FATAL_ERROR( "flex scanner push-back overflow" );	YY_FATAL_ERROR( "flex scanner push-back overflow" );
Line 1656 static int yy_get_next_buffer (void)	Line 1925 static int yy_get_next_buffer (void)
(yy_c_buf_p) = yy_cp;	(yy_c_buf_p) = yy_cp;
}	}

	#endif

#ifndef YY_NO_INPUT	#ifndef YY_NO_INPUT
#ifdef __cplusplus	#ifdef __cplusplus
static int yyinput (void)	static int yyinput (void)
Line 1680 static int yy_get_next_buffer (void)	Line 1951 static int yy_get_next_buffer (void)

else	else
{ /* need more input */	{ /* need more input */
int offset = (yy_c_buf_p) - (yytext_ptr);	int offset = (int) ((yy_c_buf_p) - (yytext_ptr));
++(yy_c_buf_p);	++(yy_c_buf_p);

switch ( yy_get_next_buffer( ) )	switch ( yy_get_next_buffer( ) )
Line 1697 static int yy_get_next_buffer (void)	Line 1968 static int yy_get_next_buffer (void)
*/	*/

/* Reset buffer status. */	/* Reset buffer status. */
cfg_yyrestart(cfg_yyin );	yyrestart( yyin );

/FALLTHROUGH/	/FALLTHROUGH/

case EOB_ACT_END_OF_FILE:	case EOB_ACT_END_OF_FILE:
{	{
if ( cfg_yywrap( ) )	if ( yywrap( ) )
return EOF;	return 0;

if ( ! (yy_did_buffer_switch_on_eof) )	if ( ! (yy_did_buffer_switch_on_eof) )
YY_NEW_FILE;	YY_NEW_FILE;
Line 1723 static int yy_get_next_buffer (void)	Line 1994 static int yy_get_next_buffer (void)
}	}

c = (unsigned char ) (yy_c_buf_p); /* cast for 8-bit char's */	c = (unsigned char ) (yy_c_buf_p); /* cast for 8-bit char's */
(yy_c_buf_p) = '\0'; / preserve cfg_yytext */	(yy_c_buf_p) = '\0'; / preserve yytext */
(yy_hold_char) = *++(yy_c_buf_p);	(yy_hold_char) = *++(yy_c_buf_p);

return c;	return c;
Line 1735 static int yy_get_next_buffer (void)	Line 2006 static int yy_get_next_buffer (void)
*	*
* @note This function does not reset the start condition to @c INITIAL .	* @note This function does not reset the start condition to @c INITIAL .
*/	*/
void cfg_yyrestart (FILE * input_file )	void yyrestart (FILE * input_file )
{	{

if ( ! YY_CURRENT_BUFFER ){	if ( ! YY_CURRENT_BUFFER ){
cfg_yyensure_buffer_stack ();	yyensure_buffer_stack ();
YY_CURRENT_BUFFER_LVALUE =	YY_CURRENT_BUFFER_LVALUE =
cfg_yy_create_buffer(cfg_yyin,YY_BUF_SIZE );	yy_create_buffer( yyin, YY_BUF_SIZE );
}	}

cfg_yy_init_buffer(YY_CURRENT_BUFFER,input_file );	yy_init_buffer( YY_CURRENT_BUFFER, input_file );
cfg_yy_load_buffer_state( );	yy_load_buffer_state( );
}	}

/** Switch to a different input buffer.	/** Switch to a different input buffer.
* @param new_buffer The new input buffer.	* @param new_buffer The new input buffer.
*	*
*/	*/
void cfg_yy_switch_to_buffer (YY_BUFFER_STATE new_buffer )	void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer )
{	{

/* TODO. We should be able to replace this entire function body	/* TODO. We should be able to replace this entire function body
* with	* with
* cfg_yypop_buffer_state();	* yypop_buffer_state();
* cfg_yypush_buffer_state(new_buffer);	* yypush_buffer_state(new_buffer);
*/	*/
cfg_yyensure_buffer_stack ();	yyensure_buffer_stack ();
if ( YY_CURRENT_BUFFER == new_buffer )	if ( YY_CURRENT_BUFFER == new_buffer )
return;	return;

Line 1773 static int yy_get_next_buffer (void)	Line 2044 static int yy_get_next_buffer (void)
}	}

YY_CURRENT_BUFFER_LVALUE = new_buffer;	YY_CURRENT_BUFFER_LVALUE = new_buffer;
cfg_yy_load_buffer_state( );	yy_load_buffer_state( );

/* We don't actually know whether we did this switch during	/* We don't actually know whether we did this switch during
* EOF (cfg_yywrap()) processing, but the only time this flag	* EOF (yywrap()) processing, but the only time this flag
* is looked at is after cfg_yywrap() is called, so it's safe	* is looked at is after yywrap() is called, so it's safe
* to go ahead and always set it.	* to go ahead and always set it.
*/	*/
(yy_did_buffer_switch_on_eof) = 1;	(yy_did_buffer_switch_on_eof) = 1;
}	}

static void cfg_yy_load_buffer_state (void)	static void yy_load_buffer_state (void)
{	{
(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;	(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
(yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;	(yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
cfg_yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;	yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
(yy_hold_char) = *(yy_c_buf_p);	(yy_hold_char) = *(yy_c_buf_p);
}	}

Line 1797 static void cfg_yy_load_buffer_state (void)	Line 2068 static void cfg_yy_load_buffer_state (void)
*	*
* @return the allocated buffer state.	* @return the allocated buffer state.
*/	*/
YY_BUFFER_STATE cfg_yy_create_buffer (FILE * file, int size )	YY_BUFFER_STATE yy_create_buffer (FILE * file, int size )
{	{
YY_BUFFER_STATE b;	YY_BUFFER_STATE b;

b = (YY_BUFFER_STATE) cfg_yyalloc(sizeof( struct yy_buffer_state ) );	b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) );
if ( ! b )	if ( ! b )
YY_FATAL_ERROR( "out of dynamic memory in cfg_yy_create_buffer()" );	YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );

b->yy_buf_size = size;	b->yy_buf_size = size;

/* yy_ch_buf has to be 2 characters longer than the size given because	/* yy_ch_buf has to be 2 characters longer than the size given because
* we need to put in 2 end-of-buffer characters.	* we need to put in 2 end-of-buffer characters.
*/	*/
b->yy_ch_buf = (char *) cfg_yyalloc(b->yy_buf_size + 2 );	b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) );
if ( ! b->yy_ch_buf )	if ( ! b->yy_ch_buf )
YY_FATAL_ERROR( "out of dynamic memory in cfg_yy_create_buffer()" );	YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );

b->yy_is_our_buffer = 1;	b->yy_is_our_buffer = 1;

cfg_yy_init_buffer(b,file );	yy_init_buffer( b, file );

return b;	return b;
}	}

/** Destroy the buffer.	/** Destroy the buffer.
* @param b a buffer created with cfg_yy_create_buffer()	* @param b a buffer created with yy_create_buffer()
*	*
*/	*/
void cfg_yy_delete_buffer (YY_BUFFER_STATE b )	void yy_delete_buffer (YY_BUFFER_STATE b )
{	{

if ( ! b )	if ( ! b )
Line 1835 static void cfg_yy_load_buffer_state (void)	Line 2106 static void cfg_yy_load_buffer_state (void)
YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;	YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;

if ( b->yy_is_our_buffer )	if ( b->yy_is_our_buffer )
cfg_yyfree((void *) b->yy_ch_buf );	yyfree( (void *) b->yy_ch_buf );

cfg_yyfree((void *) b );	yyfree( (void *) b );
}	}

#ifndef _UNISTD_H /* assume unistd.h has isatty() for us */
#ifdef __cplusplus
extern "C" {
#endif
#ifdef __THROW /* this is a gnuism */
extern int isatty (int ) __THROW;
#else
extern int isatty (int );
#endif
#ifdef __cplusplus
}
#endif
#endif

/* Initializes or reinitializes a buffer.	/* Initializes or reinitializes a buffer.
* This function is sometimes called more than once on the same buffer,	* This function is sometimes called more than once on the same buffer,
* such as during a cfg_yyrestart() or at EOF.	* such as during a yyrestart() or at EOF.
*/	*/
static void cfg_yy_init_buffer (YY_BUFFER_STATE b, FILE * file )	static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file )

{	{
int oerrno = errno;	int oerrno = errno;

cfg_yy_flush_buffer(b );	yy_flush_buffer( b );

b->yy_input_file = file;	b->yy_input_file = file;
b->yy_fill_buffer = 1;	b->yy_fill_buffer = 1;

/* If b is the current buffer, then cfg_yy_init_buffer was _probably_	/* If b is the current buffer, then yy_init_buffer was _probably_
* called from cfg_yyrestart() or through yy_get_next_buffer.	* called from yyrestart() or through yy_get_next_buffer.
* In that case, we don't want to reset the lineno or column.	* In that case, we don't want to reset the lineno or column.
*/	*/
if (b != YY_CURRENT_BUFFER){	if (b != YY_CURRENT_BUFFER){
Line 1886 extern int isatty (int );	Line 2143 extern int isatty (int );
* @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.	* @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
*	*
*/	*/
void cfg_yy_flush_buffer (YY_BUFFER_STATE b )	void yy_flush_buffer (YY_BUFFER_STATE b )
{	{
if ( ! b )	if ( ! b )
return;	return;
Line 1906 extern int isatty (int );	Line 2163 extern int isatty (int );
b->yy_buffer_status = YY_BUFFER_NEW;	b->yy_buffer_status = YY_BUFFER_NEW;

if ( b == YY_CURRENT_BUFFER )	if ( b == YY_CURRENT_BUFFER )
cfg_yy_load_buffer_state( );	yy_load_buffer_state( );
}	}

/** Pushes the new state onto the stack. The new state becomes	/** Pushes the new state onto the stack. The new state becomes
Line 1915 extern int isatty (int );	Line 2172 extern int isatty (int );
* @param new_buffer The new state.	* @param new_buffer The new state.
*	*
*/	*/
void cfg_yypush_buffer_state (YY_BUFFER_STATE new_buffer )	void yypush_buffer_state (YY_BUFFER_STATE new_buffer )
{	{
if (new_buffer == NULL)	if (new_buffer == NULL)
return;	return;

cfg_yyensure_buffer_stack();	yyensure_buffer_stack();

/* This block is copied from cfg_yy_switch_to_buffer. */	/* This block is copied from yy_switch_to_buffer. */
if ( YY_CURRENT_BUFFER )	if ( YY_CURRENT_BUFFER )
{	{
/* Flush out information for old buffer. */	/* Flush out information for old buffer. */
Line 1936 void cfg_yypush_buffer_state (YY_BUFFER_STATE new_buff	Line 2193 void cfg_yypush_buffer_state (YY_BUFFER_STATE new_buff
(yy_buffer_stack_top)++;	(yy_buffer_stack_top)++;
YY_CURRENT_BUFFER_LVALUE = new_buffer;	YY_CURRENT_BUFFER_LVALUE = new_buffer;

/* copied from cfg_yy_switch_to_buffer. */	/* copied from yy_switch_to_buffer. */
cfg_yy_load_buffer_state( );	yy_load_buffer_state( );
(yy_did_buffer_switch_on_eof) = 1;	(yy_did_buffer_switch_on_eof) = 1;
}	}

Line 1945 void cfg_yypush_buffer_state (YY_BUFFER_STATE new_buff	Line 2202 void cfg_yypush_buffer_state (YY_BUFFER_STATE new_buff
* The next element becomes the new top.	* The next element becomes the new top.
*	*
*/	*/
void cfg_yypop_buffer_state (void)	void yypop_buffer_state (void)
{	{
if (!YY_CURRENT_BUFFER)	if (!YY_CURRENT_BUFFER)
return;	return;

cfg_yy_delete_buffer(YY_CURRENT_BUFFER );	yy_delete_buffer(YY_CURRENT_BUFFER );
YY_CURRENT_BUFFER_LVALUE = NULL;	YY_CURRENT_BUFFER_LVALUE = NULL;
if ((yy_buffer_stack_top) > 0)	if ((yy_buffer_stack_top) > 0)
--(yy_buffer_stack_top);	--(yy_buffer_stack_top);

if (YY_CURRENT_BUFFER) {	if (YY_CURRENT_BUFFER) {
cfg_yy_load_buffer_state( );	yy_load_buffer_state( );
(yy_did_buffer_switch_on_eof) = 1;	(yy_did_buffer_switch_on_eof) = 1;
}	}
}	}
Line 1964 void cfg_yypop_buffer_state (void)	Line 2221 void cfg_yypop_buffer_state (void)
/* Allocates the stack if it does not exist.	/* Allocates the stack if it does not exist.
* Guarantees space for at least one push.	* Guarantees space for at least one push.
*/	*/
static void cfg_yyensure_buffer_stack (void)	static void yyensure_buffer_stack (void)
{	{
int num_to_alloc;	yy_size_t num_to_alloc;

if (!(yy_buffer_stack)) {	if (!(yy_buffer_stack)) {

Line 1974 static void cfg_yyensure_buffer_stack (void)	Line 2231 static void cfg_yyensure_buffer_stack (void)
* scanner will even need a stack. We use 2 instead of 1 to avoid an	* scanner will even need a stack. We use 2 instead of 1 to avoid an
* immediate realloc on the next call.	* immediate realloc on the next call.
*/	*/
num_to_alloc = 1;	num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */
(yy_buffer_stack) = (struct yy_buffer_state**)cfg_yyalloc	(yy_buffer_stack) = (struct yy_buffer_state**)yyalloc
(num_to_alloc * sizeof(struct yy_buffer_state*)	(num_to_alloc * sizeof(struct yy_buffer_state*)
);	);
if ( ! (yy_buffer_stack) )	if ( ! (yy_buffer_stack) )
YY_FATAL_ERROR( "out of dynamic memory in cfg_yyensure_buffer_stack()" );	YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );

memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));	memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));

(yy_buffer_stack_max) = num_to_alloc;	(yy_buffer_stack_max) = num_to_alloc;
(yy_buffer_stack_top) = 0;	(yy_buffer_stack_top) = 0;
return;	return;
Line 1991 static void cfg_yyensure_buffer_stack (void)	Line 2248 static void cfg_yyensure_buffer_stack (void)
if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){	if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){

/* Increase the buffer to prepare for a possible push. */	/* Increase the buffer to prepare for a possible push. */
int grow_size = 8 /* arbitrary grow size */;	yy_size_t grow_size = 8 /* arbitrary grow size */;

num_to_alloc = (yy_buffer_stack_max) + grow_size;	num_to_alloc = (yy_buffer_stack_max) + grow_size;
(yy_buffer_stack) = (struct yy_buffer_state**)cfg_yyrealloc	(yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc
((yy_buffer_stack),	((yy_buffer_stack),
num_to_alloc * sizeof(struct yy_buffer_state*)	num_to_alloc * sizeof(struct yy_buffer_state*)
);	);
if ( ! (yy_buffer_stack) )	if ( ! (yy_buffer_stack) )
YY_FATAL_ERROR( "out of dynamic memory in cfg_yyensure_buffer_stack()" );	YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );

/* zero only the new slots.*/	/* zero only the new slots.*/
memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));	memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
Line 2011 static void cfg_yyensure_buffer_stack (void)	Line 2268 static void cfg_yyensure_buffer_stack (void)
* @param base the character buffer	* @param base the character buffer
* @param size the size in bytes of the character buffer	* @param size the size in bytes of the character buffer
*	*
* @return the newly allocated buffer state object.	* @return the newly allocated buffer state object.
*/	*/
YY_BUFFER_STATE cfg_yy_scan_buffer (char * base, yy_size_t size )	YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size )
{	{
YY_BUFFER_STATE b;	YY_BUFFER_STATE b;

Line 2021 YY_BUFFER_STATE cfg_yy_scan_buffer (char * base, yy_s	Line 2278 YY_BUFFER_STATE cfg_yy_scan_buffer (char * base, yy_s
base[size-2] != YY_END_OF_BUFFER_CHAR \|\|	base[size-2] != YY_END_OF_BUFFER_CHAR \|\|
base[size-1] != YY_END_OF_BUFFER_CHAR )	base[size-1] != YY_END_OF_BUFFER_CHAR )
/* They forgot to leave room for the EOB's. */	/* They forgot to leave room for the EOB's. */
return 0;	return NULL;

b = (YY_BUFFER_STATE) cfg_yyalloc(sizeof( struct yy_buffer_state ) );	b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) );
if ( ! b )	if ( ! b )
YY_FATAL_ERROR( "out of dynamic memory in cfg_yy_scan_buffer()" );	YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );

b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */	b->yy_buf_size = (int) (size - 2); /* "- 2" to take care of EOB's */
b->yy_buf_pos = b->yy_ch_buf = base;	b->yy_buf_pos = b->yy_ch_buf = base;
b->yy_is_our_buffer = 0;	b->yy_is_our_buffer = 0;
b->yy_input_file = 0;	b->yy_input_file = NULL;
b->yy_n_chars = b->yy_buf_size;	b->yy_n_chars = b->yy_buf_size;
b->yy_is_interactive = 0;	b->yy_is_interactive = 0;
b->yy_at_bol = 1;	b->yy_at_bol = 1;
b->yy_fill_buffer = 0;	b->yy_fill_buffer = 0;
b->yy_buffer_status = YY_BUFFER_NEW;	b->yy_buffer_status = YY_BUFFER_NEW;

cfg_yy_switch_to_buffer(b );	yy_switch_to_buffer( b );

return b;	return b;
}	}

/** Setup the input buffer state to scan a string. The next call to cfg_yylex() will	/** Setup the input buffer state to scan a string. The next call to yylex() will
* scan from a @e copy of @a str.	* scan from a @e copy of @a str.
* @param yystr a NUL-terminated string to scan	* @param yystr a NUL-terminated string to scan
*	*
* @return the newly allocated buffer state object.	* @return the newly allocated buffer state object.
* @note If you want to scan bytes that may contain NUL values, then use	* @note If you want to scan bytes that may contain NUL values, then use
* cfg_yy_scan_bytes() instead.	* yy_scan_bytes() instead.
*/	*/
YY_BUFFER_STATE cfg_yy_scan_string (yyconst char * yystr )	YY_BUFFER_STATE yy_scan_string (const char * yystr )
{	{

return cfg_yy_scan_bytes(yystr,strlen(yystr) );	return yy_scan_bytes( yystr, (int) strlen(yystr) );
}	}

/** Setup the input buffer state to scan the given bytes. The next call to cfg_yylex() will	/** Setup the input buffer state to scan the given bytes. The next call to yylex() will
* scan from a @e copy of @a bytes.	* scan from a @e copy of @a bytes.
* @param bytes the byte buffer to scan	* @param yybytes the byte buffer to scan
* @param len the number of bytes in the buffer pointed to by @a bytes.	* @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
*	*
* @return the newly allocated buffer state object.	* @return the newly allocated buffer state object.
*/	*/
YY_BUFFER_STATE cfg_yy_scan_bytes (yyconst char * yybytes, int _yybytes_len )	YY_BUFFER_STATE yy_scan_bytes (const char * yybytes, int _yybytes_len )
{	{
YY_BUFFER_STATE b;	YY_BUFFER_STATE b;
char *buf;	char *buf;
Line 2071 YY_BUFFER_STATE cfg_yy_scan_bytes (yyconst char * yyb	Line 2328 YY_BUFFER_STATE cfg_yy_scan_bytes (yyconst char * yyb
int i;	int i;

/* Get memory for full buffer, including space for trailing EOB's. */	/* Get memory for full buffer, including space for trailing EOB's. */
n = _yybytes_len + 2;	n = (yy_size_t) (_yybytes_len + 2);
buf = (char *) cfg_yyalloc(n );	buf = (char *) yyalloc( n );
if ( ! buf )	if ( ! buf )
YY_FATAL_ERROR( "out of dynamic memory in cfg_yy_scan_bytes()" );	YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );

for ( i = 0; i < _yybytes_len; ++i )	for ( i = 0; i < _yybytes_len; ++i )
buf[i] = yybytes[i];	buf[i] = yybytes[i];

buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;	buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;

b = cfg_yy_scan_buffer(buf,n );	b = yy_scan_buffer( buf, n );
if ( ! b )	if ( ! b )
YY_FATAL_ERROR( "bad buffer in cfg_yy_scan_bytes()" );	YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );

/* It's okay to grow etc. this buffer, and we should throw it	/* It's okay to grow etc. this buffer, and we should throw it
* away when we're done.	* away when we're done.
Line 2097 YY_BUFFER_STATE cfg_yy_scan_bytes (yyconst char * yyb	Line 2354 YY_BUFFER_STATE cfg_yy_scan_bytes (yyconst char * yyb
#define YY_EXIT_FAILURE 2	#define YY_EXIT_FAILURE 2
#endif	#endif

static void yy_fatal_error (yyconst char* msg )	static void yynoreturn yy_fatal_error (const char* msg )
{	{
(void) fprintf( stderr, "%s\n", msg );	fprintf( stderr, "%s\n", msg );
exit( YY_EXIT_FAILURE );	exit( YY_EXIT_FAILURE );
}	}

Line 2109 static void yy_fatal_error (yyconst char* msg )	Line 2366 static void yy_fatal_error (yyconst char* msg )
#define yyless(n) \	#define yyless(n) \
do \	do \
{ \	{ \
/* Undo effects of setting up cfg_yytext. */ \	/* Undo effects of setting up yytext. */ \
int yyless_macro_arg = (n); \	int yyless_macro_arg = (n); \
YY_LESS_LINENO(yyless_macro_arg);\	YY_LESS_LINENO(yyless_macro_arg);\
cfg_yytext[cfg_yyleng] = (yy_hold_char); \	yytext[yyleng] = (yy_hold_char); \
(yy_c_buf_p) = cfg_yytext + yyless_macro_arg; \	(yy_c_buf_p) = yytext + yyless_macro_arg; \
(yy_hold_char) = *(yy_c_buf_p); \	(yy_hold_char) = *(yy_c_buf_p); \
*(yy_c_buf_p) = '\0'; \	*(yy_c_buf_p) = '\0'; \
cfg_yyleng = yyless_macro_arg; \	yyleng = yyless_macro_arg; \
} \	} \
while ( 0 )	while ( 0 )

Line 2125 static void yy_fatal_error (yyconst char* msg )	Line 2382 static void yy_fatal_error (yyconst char* msg )
/** Get the current line number.	/** Get the current line number.
*	*
*/	*/
int cfg_yyget_lineno (void)	int yyget_lineno (void)
{	{

return cfg_yylineno;	return yylineno;
}	}

/** Get the input stream.	/** Get the input stream.
*	*
*/	*/
FILE *cfg_yyget_in (void)	FILE *yyget_in (void)
{	{
return cfg_yyin;	return yyin;
}	}

/** Get the output stream.	/** Get the output stream.
*	*
*/	*/
FILE *cfg_yyget_out (void)	FILE *yyget_out (void)
{	{
return cfg_yyout;	return yyout;
}	}

/** Get the length of the current token.	/** Get the length of the current token.
*	*
*/	*/
int cfg_yyget_leng (void)	int yyget_leng (void)
{	{
return cfg_yyleng;	return yyleng;
}	}

/** Get the current token.	/** Get the current token.
*	*
*/	*/

char *cfg_yyget_text (void)	char *yyget_text (void)
{	{
return cfg_yytext;	return yytext;
}	}

/** Set the current line number.	/** Set the current line number.
* @param line_number	* @param _line_number line number
*	*
*/	*/
void cfg_yyset_lineno (int line_number )	void yyset_lineno (int _line_number )
{	{

cfg_yylineno = line_number;	yylineno = _line_number;
}	}

/** Set the input stream. This does not discard the current	/** Set the input stream. This does not discard the current
* input buffer.	* input buffer.
* @param in_str A readable stream.	* @param _in_str A readable stream.
*	*
* @see cfg_yy_switch_to_buffer	* @see yy_switch_to_buffer
*/	*/
void cfg_yyset_in (FILE * in_str )	void yyset_in (FILE * _in_str )
{	{
cfg_yyin = in_str ;	yyin = _in_str ;
}	}

void cfg_yyset_out (FILE * out_str )	void yyset_out (FILE * _out_str )
{	{
cfg_yyout = out_str ;	yyout = _out_str ;
}	}

int cfg_yyget_debug (void)	int yyget_debug (void)
{	{
return cfg_yy_flex_debug;	return yy_flex_debug;
}	}

void cfg_yyset_debug (int bdebug )	void yyset_debug (int _bdebug )
{	{
cfg_yy_flex_debug = bdebug ;	yy_flex_debug = _bdebug ;
}	}

static int yy_init_globals (void)	static int yy_init_globals (void)
{	{
/* Initialization is the same as for the non-reentrant scanner.	/* Initialization is the same as for the non-reentrant scanner.
* This function is called from cfg_yylex_destroy(), so don't allocate here.	* This function is called from yylex_destroy(), so don't allocate here.
*/	*/

(yy_buffer_stack) = 0;	(yy_buffer_stack) = NULL;
(yy_buffer_stack_top) = 0;	(yy_buffer_stack_top) = 0;
(yy_buffer_stack_max) = 0;	(yy_buffer_stack_max) = 0;
(yy_c_buf_p) = (char *) 0;	(yy_c_buf_p) = NULL;
(yy_init) = 0;	(yy_init) = 0;
(yy_start) = 0;	(yy_start) = 0;

/* Defined in main.c */	/* Defined in main.c */
#ifdef YY_STDINIT	#ifdef YY_STDINIT
cfg_yyin = stdin;	yyin = stdin;
cfg_yyout = stdout;	yyout = stdout;
#else	#else
cfg_yyin = (FILE *) 0;	yyin = NULL;
cfg_yyout = (FILE *) 0;	yyout = NULL;
#endif	#endif

/* For future reference: Set errno on error, since we are called by	/* For future reference: Set errno on error, since we are called by
* cfg_yylex_init()	* yylex_init()
*/	*/
return 0;	return 0;
}	}

/* cfg_yylex_destroy is for both reentrant and non-reentrant scanners. */	/* yylex_destroy is for both reentrant and non-reentrant scanners. */
int cfg_yylex_destroy (void)	int yylex_destroy (void)
{	{

/* Pop the buffer stack, destroying each element. */	/* Pop the buffer stack, destroying each element. */
while(YY_CURRENT_BUFFER){	while(YY_CURRENT_BUFFER){
cfg_yy_delete_buffer(YY_CURRENT_BUFFER );	yy_delete_buffer( YY_CURRENT_BUFFER );
YY_CURRENT_BUFFER_LVALUE = NULL;	YY_CURRENT_BUFFER_LVALUE = NULL;
cfg_yypop_buffer_state();	yypop_buffer_state();
}	}

/* Destroy the stack itself. */	/* Destroy the stack itself. */
cfg_yyfree((yy_buffer_stack) );	yyfree((yy_buffer_stack) );
(yy_buffer_stack) = NULL;	(yy_buffer_stack) = NULL;

/* Reset the globals. This is important in a non-reentrant scanner so the next time	/* Reset the globals. This is important in a non-reentrant scanner so the next time
* cfg_yylex() is called, initialization will occur. */	* yylex() is called, initialization will occur. */
yy_init_globals( );	yy_init_globals( );

return 0;	return 0;
Line 2255 int cfg_yylex_destroy (void)	Line 2512 int cfg_yylex_destroy (void)
*/	*/

#ifndef yytext_ptr	#ifndef yytext_ptr
static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )	static void yy_flex_strncpy (char* s1, const char * s2, int n )
{	{
register int i;
	int i;
for ( i = 0; i < n; ++i )	for ( i = 0; i < n; ++i )
s1[i] = s2[i];	s1[i] = s2[i];
}	}
#endif	#endif

#ifdef YY_NEED_STRLEN	#ifdef YY_NEED_STRLEN
static int yy_flex_strlen (yyconst char * s )	static int yy_flex_strlen (const char * s )
{	{
register int n;	int n;
for ( n = 0; s[n]; ++n )	for ( n = 0; s[n]; ++n )
;	;

Line 2274 static int yy_flex_strlen (yyconst char * s )	Line 2532 static int yy_flex_strlen (yyconst char * s )
}	}
#endif	#endif

void *cfg_yyalloc (yy_size_t size )	void *yyalloc (yy_size_t size )
{	{
return (void *) malloc( size );	return malloc(size);
}	}

void cfg_yyrealloc (void ptr, yy_size_t size )	void yyrealloc (void ptr, yy_size_t size )
{	{

/* The cast to (char *) in the following accommodates both	/* The cast to (char *) in the following accommodates both
* implementations that use char* generic pointers, and those	* implementations that use char* generic pointers, and those
* that use void* generic pointers. It works with the latter	* that use void* generic pointers. It works with the latter
Line 2288 void cfg_yyrealloc (void ptr, yy_size_t size )	Line 2547 void cfg_yyrealloc (void ptr, yy_size_t size )
* any pointer type to void*, and deal with argument conversions	* any pointer type to void*, and deal with argument conversions
* as though doing an assignment.	* as though doing an assignment.
*/	*/
return (void ) realloc( (char ) ptr, size );	return realloc(ptr, size);
}	}

void cfg_yyfree (void * ptr )	void yyfree (void * ptr )
{	{
free( (char ) ptr ); / see cfg_yyrealloc() for (char ) cast /	free( (char ) ptr ); / see yyrealloc() for (char ) cast /
}	}

#define YYTABLES_NAME "yytables"	#define YYTABLES_NAME "yytables"

#line 277 "lexer.l"	#line 297 "lexer.l"



void cfg_dummy_function(void)	void cfg_dummy_function(void)
{	{
/* please compiler :-)	/* please compiler :-)
Line 2312 void cfg_dummy_function(void)	Line 2570 void cfg_dummy_function(void)

int cfg_lexer_include(cfg_t cfg, const char filename)	int cfg_lexer_include(cfg_t cfg, const char filename)
{	{
	FILE *fp;
char *xfilename;	char *xfilename;

if(cfg_include_stack_ptr >= MAX_INCLUDE_DEPTH) {	if (cfg_include_stack_ptr >= MAX_INCLUDE_DEPTH)
	{
cfg_error(cfg, _("includes nested too deeply"));	cfg_error(cfg, _("includes nested too deeply"));
return 1;	return CFG_PARSE_ERROR;
}	}

cfg_include_stack[cfg_include_stack_ptr].state = YY_CURRENT_BUFFER;
cfg_include_stack[cfg_include_stack_ptr].filename = cfg->filename;	cfg_include_stack[cfg_include_stack_ptr].filename = cfg->filename;
cfg_include_stack[cfg_include_stack_ptr].line = cfg->line;	cfg_include_stack[cfg_include_stack_ptr].line = cfg->line;
cfg_include_stack_ptr++;

xfilename = cfg_tilde_expand(filename);	if (cfg->path)
	{
	xfilename = cfg_searchpath(cfg->path, filename);
	if (!xfilename)
	{
	cfg_error(cfg, _("%s: Not found in search path"), filename);
	return CFG_PARSE_ERROR;
	}
	}
	else
	{
	xfilename = cfg_tilde_expand(filename);
	if (!xfilename)
	{
	cfg_error(cfg, _("%s: Failed tilde expand"), filename);
	return CFG_PARSE_ERROR;
	}
	}

cfg_yyin = fopen(xfilename, "r");	fp = fopen(xfilename, "r");
	if (!fp)
if(!cfg_yyin) {	{
cfg_error(cfg, "%s: %s", xfilename, strerror(errno));	cfg_error(cfg, "%s: %s", xfilename, strerror(errno));
free(xfilename);	free(xfilename);
return 1;	return CFG_PARSE_ERROR;
}	}

	cfg_include_stack[cfg_include_stack_ptr].fp = fp;
	cfg_include_stack_ptr++;
cfg->filename = xfilename;	cfg->filename = xfilename;
cfg->line = 1;	cfg->line = 1;
	cfg_scan_fp_begin(fp);

cfg_yy_switch_to_buffer(cfg_yy_create_buffer(cfg_yyin,YY_BUF_SIZE));	return CFG_SUCCESS;
return 0;
}	}

/* write a character to the quoted string buffer, and reallocate as	/* write a character to the quoted string buffer, and reallocate as
Line 2346 int cfg_lexer_include(cfg_t cfg, const char filename	Line 2623 int cfg_lexer_include(cfg_t cfg, const char filename
*/	*/
static void qputc(char ch)	static void qputc(char ch)
{	{
if(qstring_index >= qstring_len) {	if (qstring_index >= qstring_len) {
qstring_len += CFG_QSTRING_BUFSIZ;	qstring_len += CFG_QSTRING_BUFSIZ;
cfg_qstring = (char *)realloc(cfg_qstring, qstring_len);	cfg_qstring = (char *)realloc(cfg_qstring, qstring_len + 1);
assert(cfg_qstring);	assert(cfg_qstring);
memset(cfg_qstring + qstring_index, 0, CFG_QSTRING_BUFSIZ);	memset(cfg_qstring + qstring_index, 0, CFG_QSTRING_BUFSIZ + 1);
}	}
cfg_qstring[qstring_index++] = ch;	cfg_qstring[qstring_index++] = ch;
}	}

void cfg_scan_string_begin(const char *buf)	static void qput(cfg_t *cfg, char skip)
{	{
pre_string_scan_state = YY_CURRENT_BUFFER;	char *cp;

/* cfg_yy_scan_string does a cfg_yy_switch_to_buffer call for us	if (cfg)
*/	cfg->line++;
string_scan_state = cfg_yy_scan_string(buf);
	cp = yytext;

	while (skip && *cp == skip)
	cp++;

	while (*cp)
	qputc(*cp++);
}	}

void cfg_scan_string_end(void)	static void qbeg(int state)
{	{
/* restore to previous state	BEGIN(state);
*/	qstring_index = 0;
cfg_yy_delete_buffer(string_scan_state);	if (cfg_qstring)
if (pre_string_scan_state)	memset(cfg_qstring, 0, qstring_len);
cfg_yy_switch_to_buffer(pre_string_scan_state);
free(cfg_qstring);
cfg_qstring = 0;
qstring_index = qstring_len = 0;
string_scan_state = 0;
}	}

static YY_BUFFER_STATE pre_fp_scan_state;	static char trim_whitespace(char str, unsigned int len)
static YY_BUFFER_STATE fp_scan_state;	{
	if (!str \|\| !str[0])
	return str;

	while (len > 1) {
	if ((str[len] == 0 \|\| isspace(str[len])) && isspace(str[len - 1]))
	len--;
	else
	break;
	}
	str[len] = 0;

	while (isspace(*str))
	str++;

	return str;
	}

	static int qend(cfg_t *cfg, int trim, int ret)
	{
	char *ptr = cfg_qstring;

	BEGIN(INITIAL);
	if (cfg)
	cfg->line++;

	if (trim)
	ptr = trim_whitespace(cfg_qstring, qstring_index);
	else
	qputc('\0');

	cfg_yylval = ptr;

	return ret;
	}

	static int qstr(cfg_t *cfg, char skip, int ret)
	{
	qbeg(comment);
	qput(cfg, skip);

	return qend(cfg, 1, ret);
	}

void cfg_scan_fp_begin(FILE *fp)	void cfg_scan_fp_begin(FILE *fp)
{	{
pre_fp_scan_state = YY_CURRENT_BUFFER;	cfg_yypush_buffer_state(cfg_yy_create_buffer(fp, YY_BUF_SIZE));
fp_scan_state = cfg_yy_create_buffer(fp,YY_BUF_SIZE);
cfg_yy_switch_to_buffer(fp_scan_state);
}	}

void cfg_scan_fp_end(void)	void cfg_scan_fp_end(void)
{	{
/* restore to previous state	if (cfg_qstring)
*/	free(cfg_qstring);
cfg_yy_delete_buffer(fp_scan_state);	cfg_qstring = NULL;
if(pre_fp_scan_state)
cfg_yy_switch_to_buffer(pre_fp_scan_state);
free(cfg_qstring);
cfg_qstring = 0;
qstring_index = qstring_len = 0;	qstring_index = qstring_len = 0;
	cfg_yypop_buffer_state();
}	}

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>

Removed from v.1.1.1.1
changed lines
	Added in v.1.1.1.2