PageRenderTime 1294ms CodeModel.GetById 122ms app.highlight 1029ms RepoModel.GetById 78ms app.codeStats 1ms

/scanner.c

http://github.com/fizx/parsley
C | 2491 lines | 1770 code | 357 blank | 364 comment | 116 complexity | cf46637a87474cf6d651e2943057f5d9 MD5 | raw file
   1
   2#line 3 "scanner.c"
   3
   4#define  YY_INT_ALIGNED short int
   5
   6/* A lexical scanner generated by flex */
   7
   8#define FLEX_SCANNER
   9#define YY_FLEX_MAJOR_VERSION 2
  10#define YY_FLEX_MINOR_VERSION 5
  11#define YY_FLEX_SUBMINOR_VERSION 33
  12#if YY_FLEX_SUBMINOR_VERSION > 0
  13#define FLEX_BETA
  14#endif
  15
  16/* First, we deal with  platform-specific or compiler-specific issues. */
  17
  18/* begin standard C headers. */
  19#include <stdio.h>
  20#include <string.h>
  21#include <errno.h>
  22#include <stdlib.h>
  23
  24/* end standard C headers. */
  25
  26/* flex integer type definitions */
  27
  28#ifndef FLEXINT_H
  29#define FLEXINT_H
  30
  31/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
  32
  33#if __STDC_VERSION__ >= 199901L
  34
  35/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
  36 * if you want the limit (max/min) macros for int types. 
  37 */
  38#ifndef __STDC_LIMIT_MACROS
  39#define __STDC_LIMIT_MACROS 1
  40#endif
  41
  42#include <inttypes.h>
  43typedef int8_t flex_int8_t;
  44typedef uint8_t flex_uint8_t;
  45typedef int16_t flex_int16_t;
  46typedef uint16_t flex_uint16_t;
  47typedef int32_t flex_int32_t;
  48typedef uint32_t flex_uint32_t;
  49#else
  50typedef signed char flex_int8_t;
  51typedef short int flex_int16_t;
  52typedef int flex_int32_t;
  53typedef unsigned char flex_uint8_t; 
  54typedef unsigned short int flex_uint16_t;
  55typedef unsigned int flex_uint32_t;
  56#endif /* ! C99 */
  57
  58/* Limits of integral types. */
  59#ifndef INT8_MIN
  60#define INT8_MIN               (-128)
  61#endif
  62#ifndef INT16_MIN
  63#define INT16_MIN              (-32767-1)
  64#endif
  65#ifndef INT32_MIN
  66#define INT32_MIN              (-2147483647-1)
  67#endif
  68#ifndef INT8_MAX
  69#define INT8_MAX               (127)
  70#endif
  71#ifndef INT16_MAX
  72#define INT16_MAX              (32767)
  73#endif
  74#ifndef INT32_MAX
  75#define INT32_MAX              (2147483647)
  76#endif
  77#ifndef UINT8_MAX
  78#define UINT8_MAX              (255U)
  79#endif
  80#ifndef UINT16_MAX
  81#define UINT16_MAX             (65535U)
  82#endif
  83#ifndef UINT32_MAX
  84#define UINT32_MAX             (4294967295U)
  85#endif
  86
  87#endif /* ! FLEXINT_H */
  88
  89#ifdef __cplusplus
  90
  91/* The "const" storage-class-modifier is valid. */
  92#define YY_USE_CONST
  93
  94#else	/* ! __cplusplus */
  95
  96#if __STDC__
  97
  98#define YY_USE_CONST
  99
 100#endif	/* __STDC__ */
 101#endif	/* ! __cplusplus */
 102
 103#ifdef YY_USE_CONST
 104#define yyconst const
 105#else
 106#define yyconst
 107#endif
 108
 109/* Returned upon end-of-file. */
 110#define YY_NULL 0
 111
 112/* Promotes a possibly negative, possibly signed char to an unsigned
 113 * integer for use as an array index.  If the signed char is negative,
 114 * we want to instead treat it as an 8-bit unsigned char, hence the
 115 * double cast.
 116 */
 117#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
 118
 119/* Enter a start condition.  This macro really ought to take a parameter,
 120 * but we do it the disgusting crufty way forced on us by the ()-less
 121 * definition of BEGIN.
 122 */
 123#define BEGIN (yy_start) = 1 + 2 *
 124
 125/* Translate the current start state into a value that can be later handed
 126 * to BEGIN to return to the state.  The YYSTATE alias is for lex
 127 * compatibility.
 128 */
 129#define YY_START (((yy_start) - 1) / 2)
 130#define YYSTATE YY_START
 131
 132/* Action number for EOF rule of a given start state. */
 133#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
 134
 135/* Special action meaning "start processing a new file". */
 136#define YY_NEW_FILE yyrestart(yyin  )
 137
 138#define YY_END_OF_BUFFER_CHAR 0
 139
 140/* Size of default input buffer. */
 141#ifndef YY_BUF_SIZE
 142#define YY_BUF_SIZE 16384
 143#endif
 144
 145/* The state buf must be large enough to hold one state per character in the main buffer.
 146 */
 147#define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
 148
 149#ifndef YY_TYPEDEF_YY_BUFFER_STATE
 150#define YY_TYPEDEF_YY_BUFFER_STATE
 151typedef struct yy_buffer_state *YY_BUFFER_STATE;
 152#endif
 153
 154extern int yyleng;
 155
 156extern FILE *yyin, *yyout;
 157
 158#define EOB_ACT_CONTINUE_SCAN 0
 159#define EOB_ACT_END_OF_FILE 1
 160#define EOB_ACT_LAST_MATCH 2
 161
 162    #define YY_LESS_LINENO(n)
 163    
 164/* Return all but the first "n" matched characters back to the input stream. */
 165#define yyless(n) \
 166	do \
 167		{ \
 168		/* Undo effects of setting up yytext. */ \
 169        int yyless_macro_arg = (n); \
 170        YY_LESS_LINENO(yyless_macro_arg);\
 171		*yy_cp = (yy_hold_char); \
 172		YY_RESTORE_YY_MORE_OFFSET \
 173		(yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
 174		YY_DO_BEFORE_ACTION; /* set up yytext again */ \
 175		} \
 176	while ( 0 )
 177
 178#define unput(c) yyunput( c, (yytext_ptr)  )
 179
 180/* The following is because we cannot portably get our hands on size_t
 181 * (without autoconf's help, which isn't available because we want
 182 * flex-generated scanners to compile on their own).
 183 */
 184
 185#ifndef YY_TYPEDEF_YY_SIZE_T
 186#define YY_TYPEDEF_YY_SIZE_T
 187typedef unsigned int yy_size_t;
 188#endif
 189
 190#ifndef YY_STRUCT_YY_BUFFER_STATE
 191#define YY_STRUCT_YY_BUFFER_STATE
 192struct yy_buffer_state
 193	{
 194	FILE *yy_input_file;
 195
 196	char *yy_ch_buf;		/* input buffer */
 197	char *yy_buf_pos;		/* current position in input buffer */
 198
 199	/* Size of input buffer in bytes, not including room for EOB
 200	 * characters.
 201	 */
 202	yy_size_t yy_buf_size;
 203
 204	/* Number of characters read into yy_ch_buf, not including EOB
 205	 * characters.
 206	 */
 207	int yy_n_chars;
 208
 209	/* Whether we "own" the buffer - i.e., we know we created it,
 210	 * and can realloc() it to grow it, and should free() it to
 211	 * delete it.
 212	 */
 213	int yy_is_our_buffer;
 214
 215	/* Whether this is an "interactive" input source; if so, and
 216	 * if we're using stdio for input, then we want to use getc()
 217	 * instead of fread(), to make sure we stop fetching input after
 218	 * each newline.
 219	 */
 220	int yy_is_interactive;
 221
 222	/* Whether we're considered to be at the beginning of a line.
 223	 * If so, '^' rules will be active on the next match, otherwise
 224	 * not.
 225	 */
 226	int yy_at_bol;
 227
 228    int yy_bs_lineno; /**< The line count. */
 229    int yy_bs_column; /**< The column count. */
 230    
 231	/* Whether to try to fill the input buffer when we reach the
 232	 * end of it.
 233	 */
 234	int yy_fill_buffer;
 235
 236	int yy_buffer_status;
 237
 238#define YY_BUFFER_NEW 0
 239#define YY_BUFFER_NORMAL 1
 240	/* When an EOF's been seen but there's still some text to process
 241	 * then we mark the buffer as YY_EOF_PENDING, to indicate that we
 242	 * shouldn't try reading from the input source any more.  We might
 243	 * still have a bunch of tokens to match, though, because of
 244	 * possible backing-up.
 245	 *
 246	 * When we actually see the EOF, we change the status to "new"
 247	 * (via yyrestart()), so that the user can continue scanning by
 248	 * just pointing yyin at a new input file.
 249	 */
 250#define YY_BUFFER_EOF_PENDING 2
 251
 252	};
 253#endif /* !YY_STRUCT_YY_BUFFER_STATE */
 254
 255/* Stack of input buffers. */
 256static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
 257static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
 258static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */
 259
 260/* We provide macros for accessing buffer states in case in the
 261 * future we want to put the buffer states in a more general
 262 * "scanner state".
 263 *
 264 * Returns the top of the stack, or NULL.
 265 */
 266#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
 267                          ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
 268                          : NULL)
 269
 270/* Same as previous macro, but useful when we know that the buffer stack is not
 271 * NULL or when we need an lvalue. For internal use only.
 272 */
 273#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
 274
 275/* yy_hold_char holds the character lost when yytext is formed. */
 276static char yy_hold_char;
 277static int yy_n_chars;		/* number of characters read into yy_ch_buf */
 278int yyleng;
 279
 280/* Points to current character in buffer. */
 281static char *yy_c_buf_p = (char *) 0;
 282static int yy_init = 0;		/* whether we need to initialize */
 283static int yy_start = 0;	/* start state number */
 284
 285/* Flag which is used to allow yywrap()'s to do buffer switches
 286 * instead of setting up a fresh yyin.  A bit of a hack ...
 287 */
 288static int yy_did_buffer_switch_on_eof;
 289
 290void yyrestart (FILE *input_file  );
 291void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer  );
 292YY_BUFFER_STATE yy_create_buffer (FILE *file,int size  );
 293void yy_delete_buffer (YY_BUFFER_STATE b  );
 294void yy_flush_buffer (YY_BUFFER_STATE b  );
 295void yypush_buffer_state (YY_BUFFER_STATE new_buffer  );
 296void yypop_buffer_state (void );
 297
 298static void yyensure_buffer_stack (void );
 299static void yy_load_buffer_state (void );
 300static void yy_init_buffer (YY_BUFFER_STATE b,FILE *file  );
 301
 302#define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER )
 303
 304YY_BUFFER_STATE yy_scan_buffer (char *base,yy_size_t size  );
 305YY_BUFFER_STATE yy_scan_string (yyconst char *yy_str  );
 306YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes,int len  );
 307
 308void *yyalloc (yy_size_t  );
 309void *yyrealloc (void *,yy_size_t  );
 310void yyfree (void *  );
 311
 312#define yy_new_buffer yy_create_buffer
 313
 314#define yy_set_interactive(is_interactive) \
 315	{ \
 316	if ( ! YY_CURRENT_BUFFER ){ \
 317        yyensure_buffer_stack (); \
 318		YY_CURRENT_BUFFER_LVALUE =    \
 319            yy_create_buffer(yyin,YY_BUF_SIZE ); \
 320	} \
 321	YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
 322	}
 323
 324#define yy_set_bol(at_bol) \
 325	{ \
 326	if ( ! YY_CURRENT_BUFFER ){\
 327        yyensure_buffer_stack (); \
 328		YY_CURRENT_BUFFER_LVALUE =    \
 329            yy_create_buffer(yyin,YY_BUF_SIZE ); \
 330	} \
 331	YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
 332	}
 333
 334#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
 335
 336typedef unsigned char YY_CHAR;
 337
 338FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
 339
 340typedef int yy_state_type;
 341
 342extern int yylineno;
 343
 344int yylineno = 1;
 345
 346extern char *yytext;
 347#define yytext_ptr yytext
 348
 349static yy_state_type yy_get_previous_state (void );
 350static yy_state_type yy_try_NUL_trans (yy_state_type current_state  );
 351static int yy_get_next_buffer (void );
 352static void yy_fatal_error (yyconst char msg[]  );
 353
 354/* Done after the current pattern has been matched and before the
 355 * corresponding action - sets up yytext.
 356 */
 357#define YY_DO_BEFORE_ACTION \
 358	(yytext_ptr) = yy_bp; \
 359	yyleng = (size_t) (yy_cp - yy_bp); \
 360	(yy_hold_char) = *yy_cp; \
 361	*yy_cp = '\0'; \
 362	(yy_c_buf_p) = yy_cp;
 363
 364#define YY_NUM_RULES 99
 365#define YY_END_OF_BUFFER 100
 366/* This struct is not used in this scanner,
 367   but its presence is necessary. */
 368struct yy_trans_info
 369	{
 370	flex_int32_t yy_verify;
 371	flex_int32_t yy_nxt;
 372	};
 373static yyconst flex_int16_t yy_accept[400] =
 374    {   0,
 375        0,    0,    0,    0,    0,    0,  100,   98,    2,   10,
 376       98,   14,   28,   98,    4,    5,   22,   23,   15,   24,
 377       16,    8,    1,   11,    7,   25,   18,   13,    3,   96,
 378       19,   98,   20,   98,   96,   96,   96,   96,   96,   96,
 379       96,   96,   96,   96,    6,   21,   99,    2,   23,   15,
 380       18,   21,   53,    0,   97,   55,    0,   56,   17,    9,
 381        1,   51,   12,    0,    0,    0,    0,    0,    0,    0,
 382        0,    0,    0,    0,    0,    0,    0,    0,   26,   27,
 383       96,   29,   54,   96,   96,   96,   96,   96,   96,   96,
 384       96,   96,   96,   43,   96,   96,   96,   96,   52,   57,
 385
 386        0,    0,    0,    0,    0,    0,   63,    0,    0,   64,
 387        0,    0,    0,    0,    0,   65,    0,    0,    0,    0,
 388        0,    0,    0,    0,    0,    0,   96,   44,   96,   96,
 389       96,   96,   45,   96,   46,   96,   96,   96,   96,   96,
 390       96,   96,    0,    0,    0,    0,    0,    0,    0,    0,
 391        0,   70,    0,    0,    0,    0,   60,    0,   62,    0,
 392        0,    0,    0,    0,    0,    0,    0,   96,   96,   96,
 393       96,   96,   96,   96,   50,   96,   96,   96,   42,   48,
 394        0,    0,    0,    0,    0,    0,   61,   91,    0,    0,
 395        0,    0,   59,    0,    0,    0,    0,    0,    0,    0,
 396
 397        0,   83,   96,   96,   33,   96,   96,   96,   96,   96,
 398       96,   96,    0,    0,    0,    0,    0,   69,    0,   58,
 399        0,   88,   82,    0,    0,    0,    0,    0,    0,    0,
 400       85,   89,    0,    0,   96,   96,   96,   96,   96,   96,
 401       39,   96,   96,   90,    0,    0,    0,    0,    0,    0,
 402        0,   67,    0,    0,    0,    0,    0,    0,    0,   71,
 403        0,    0,   87,   96,   96,   47,   96,   96,   96,   96,
 404       96,    0,   94,    0,   66,    0,   92,    0,    0,    0,
 405        0,    0,    0,    0,    0,    0,    0,    0,   30,   96,
 406       96,   96,   96,   96,   96,   86,   68,   93,    0,    0,
 407
 408        0,    0,    0,    0,    0,    0,    0,   84,   95,   96,
 409       32,   96,   36,   38,   40,   96,    0,    0,    0,    0,
 410       72,    0,    0,    0,    0,   96,   34,   96,   96,   96,
 411        0,    0,   77,    0,    0,    0,    0,   80,    0,   96,
 412       96,   96,   96,   96,   76,    0,    0,    0,    0,   74,
 413        0,   96,   96,   96,   96,   96,    0,   79,    0,    0,
 414       81,   96,   96,   96,   96,   96,   78,    0,    0,   96,
 415       96,   96,   96,   96,   73,    0,   96,   96,   96,   96,
 416       96,    0,   31,   96,   96,   96,   96,   75,   96,   37,
 417       41,   96,   35,   96,   96,   96,   96,   49,    0
 418
 419    } ;
 420
 421static yyconst flex_int32_t yy_ec[256] =
 422    {   0,
 423        1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
 424        1,    1,    2,    1,    1,    1,    1,    1,    1,    1,
 425        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 426        1,    2,    4,    5,    6,    7,    1,    1,    8,    9,
 427       10,   11,   12,   13,   14,   15,   16,   17,   17,   17,
 428       17,   17,   17,   17,   17,   17,   17,   18,    1,   19,
 429       20,   21,   22,   23,   24,   24,   24,   24,   24,   24,
 430       24,   24,   24,   24,   24,   24,   24,   24,   24,   24,
 431       24,   24,   24,   24,   24,   24,   24,   24,   24,   24,
 432       25,   26,   27,   28,   24,    1,   29,   30,   31,   32,
 433
 434       33,   34,   35,   36,   37,   24,   38,   39,   40,   41,
 435       42,   43,   44,   45,   46,   47,   48,   49,   50,   51,
 436       52,   24,    1,   53,    1,   54,    1,    1,    1,    1,
 437        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 438        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 439        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 440        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 441        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 442        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 443        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 444
 445        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 446        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 447        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 448        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 449        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 450        1,    1,    1,    1,    1
 451    } ;
 452
 453static yyconst flex_int32_t yy_meta[55] =
 454    {   0,
 455        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 456        1,    1,    1,    2,    1,    1,    2,    1,    1,    1,
 457        1,    1,    1,    2,    1,    1,    1,    1,    2,    2,
 458        2,    2,    2,    2,    2,    2,    2,    2,    2,    2,
 459        2,    2,    2,    2,    2,    2,    2,    2,    2,    2,
 460        2,    2,    1,    1
 461    } ;
 462
 463static yyconst flex_int16_t yy_base[405] =
 464    {   0,
 465        0,    0,    0,    0,    0,    0,  423,  424,   53,  402,
 466      416,  424,  400,  411,  424,  424,  398,  424,  424,  424,
 467      402,  400,   40,   90,  395,  424,  394,  424,  424,    0,
 468      424,    0,  424,  393,   17,   25,   26,  370,  369,   31,
 469      365,   33,  376,  375,  387,  386,  424,   74,  424,  424,
 470      424,  424,  424,  400,  424,  424,  396,  424,  424,  424,
 471       51,  424,  424,  355,   33,  365,   39,  364,  353,   56,
 472       30,   43,   49,   52,  370,   65,   49,  365,  424,  424,
 473        0,  424,  424,   68,  350,  359,  355,  348,  344,  353,
 474      359,  350,  357,    0,  343,   68,  348,  335,  424,  424,
 475
 476      338,  351,  342,  336,  338,  351,  424,  346,   64,  424,
 477      332,  348,  347,  332,  328,  424,  326,  336,  339,  331,
 478       59,  337,  322,  328,  336,  314,  331,    0,  318,  323,
 479      321,  329,    0,  320,    0,  325,  324,  323,  324,  323,
 480      319,  305,  304,  319,  302,  319,  300,  316,  304,  311,
 481      297,  424,  310,  306,  292,  292,  424,  324,  424,  285,
 482      303,  289,  297,  300,  299,  291,  283,  283,  291,  295,
 483      293,  292,  282,  277,    0,  281,  288,  287,    0,    0,
 484      277,  280,   73,  287,  264,  276,  424,  424,  267,  280,
 485      279,  264,  296,   99,  295,  267,  257,  264,  258,  273,
 486
 487      266,  424,  255,  271,    0,  259,  258,  248,  254,  249,
 488      263,  248,  252,   81,  255,  250,  251,  424,  256,  274,
 489      242,  424,  424,  103,  250,  256,  250,  108,  236,  240,
 490      424,  424,  234,  233,  237,  230,  230,  244,  238,  245,
 491        0,  236,  226,  424,  229,  238,  228,  221,  234,  234,
 492      109,  424,  229,  230,  226,  216,  247,  224,  225,  424,
 493      213,  224,  424,  211,  208,    0,  225,  212,  221,  210,
 494      213,  198,  424,  202,  424,  215,  424,  210,  211,  207,
 495      229,  203,  194,  193,  202,  224,  205,  204,  221,  201,
 496      192,  197,  198,  195,  188,  424,  424,  424,  191,  213,
 497
 498      187,  178,  192,  209,  170,  182,  173,  424,  424,  177,
 499        0,  171,  203,    0,  202,  180,  175,  166,  180,  159,
 500      424,  111,  167,  177,  156,  162,  192,  159,  158,  189,
 501      170,  149,  424,  157,  163,  164,  164,  424,  153,  181,
 502      152,  156,  155,  154,  424,  147,  156,  151,  173,  424,
 503      153,  139,  139,  153,  152,  140,  147,  424,  140,  131,
 504      424,  144,  162,  136,  135,  127,  424,  140,  119,  131,
 505      123,  131,  130,  119,  424,  122,  130,  130,  121,  111,
 506      104,  115,    0,  108,  111,  109,   95,  424,   85,    0,
 507        0,   87,    0,   70,   79,   73,   72,    0,  424,  153,
 508
 509      155,  157,  110,  159
 510    } ;
 511
 512static yyconst flex_int16_t yy_def[405] =
 513    {   0,
 514      399,    1,  400,  400,  400,  400,  399,  399,  399,  399,
 515      401,  399,  399,  402,  399,  399,  399,  399,  399,  399,
 516      399,  399,  399,  399,  399,  399,  399,  399,  399,  403,
 517      399,  404,  399,  399,  403,  403,  403,  403,  403,  403,
 518      403,  403,  403,  403,  399,  399,  399,  399,  399,  399,
 519      399,  399,  399,  401,  399,  399,  402,  399,  399,  399,
 520      399,  399,  399,  399,  399,  399,  399,  399,  399,  399,
 521      399,  399,  399,  399,  399,  399,  399,  399,  399,  399,
 522      403,  399,  399,  403,  403,  403,  403,  403,  403,  403,
 523      403,  403,  403,  403,  403,  403,  403,  403,  399,  399,
 524
 525      399,  399,  399,  399,  399,  399,  399,  399,  399,  399,
 526      399,  399,  399,  399,  399,  399,  399,  399,  399,  399,
 527      399,  399,  399,  399,  399,  399,  403,  403,  403,  403,
 528      403,  403,  403,  403,  403,  403,  403,  403,  403,  403,
 529      403,  403,  399,  399,  399,  399,  399,  399,  399,  399,
 530      399,  399,  399,  399,  399,  399,  399,  399,  399,  399,
 531      399,  399,  399,  399,  399,  399,  399,  403,  403,  403,
 532      403,  403,  403,  403,  403,  403,  403,  403,  403,  403,
 533      399,  399,  399,  399,  399,  399,  399,  399,  399,  399,
 534      399,  399,  399,  399,  399,  399,  399,  399,  399,  399,
 535
 536      399,  399,  403,  403,  403,  403,  403,  403,  403,  403,
 537      403,  403,  399,  399,  399,  399,  399,  399,  399,  399,
 538      399,  399,  399,  399,  399,  399,  399,  399,  399,  399,
 539      399,  399,  399,  399,  403,  403,  403,  403,  403,  403,
 540      403,  403,  403,  399,  399,  399,  399,  399,  399,  399,
 541      399,  399,  399,  399,  399,  399,  399,  399,  399,  399,
 542      399,  399,  399,  403,  403,  403,  403,  403,  403,  403,
 543      403,  399,  399,  399,  399,  399,  399,  399,  399,  399,
 544      399,  399,  399,  399,  399,  399,  399,  399,  403,  403,
 545      403,  403,  403,  403,  403,  399,  399,  399,  399,  399,
 546
 547      399,  399,  399,  399,  399,  399,  399,  399,  399,  403,
 548      403,  403,  403,  403,  403,  403,  399,  399,  399,  399,
 549      399,  399,  399,  399,  399,  403,  403,  403,  403,  403,
 550      399,  399,  399,  399,  399,  399,  399,  399,  399,  403,
 551      403,  403,  403,  403,  399,  399,  399,  399,  399,  399,
 552      399,  403,  403,  403,  403,  403,  399,  399,  399,  399,
 553      399,  403,  403,  403,  403,  403,  399,  399,  399,  403,
 554      403,  403,  403,  403,  399,  399,  403,  403,  403,  403,
 555      403,  399,  403,  403,  403,  403,  403,  399,  403,  403,
 556      403,  403,  403,  403,  403,  403,  403,  403,    0,  399,
 557
 558      399,  399,  399,  399
 559    } ;
 560
 561static yyconst flex_int16_t yy_nxt[479] =
 562    {   0,
 563        8,    9,    9,   10,   11,   12,   13,   14,   15,   16,
 564       17,   18,   19,   20,   21,   22,   23,   24,   25,   26,
 565       27,   28,   29,   30,   31,   32,   33,   34,   35,   30,
 566       36,   37,   30,   38,   30,   30,   30,   30,   30,   39,
 567       40,   41,   42,   30,   30,   43,   44,   30,   30,   30,
 568       30,   30,   45,   46,   48,   48,   61,   84,   88,   92,
 569       86,   95,   89,   85,   49,   50,   87,   61,  102,  113,
 570      114,  115,   93,   51,  103,   48,   48,   96,  105,  106,
 571       62,  124,  107,  119,  111,   49,   50,  108,  112,  116,
 572      117,   62,  120,  122,   51,  118,  125,  123,  127,  128,
 573
 574      139,  215,  150,  161,  162,  216,   52,   63,  151,  140,
 575      245,   81,  398,  246,  397,  396,  395,  394,  393,   64,
 576       65,   66,   67,   68,   69,   70,   71,   52,   72,  225,
 577       73,   74,   75,  253,   76,   77,   78,  226,  258,  278,
 578      227,  335,  392,  391,  254,  390,  389,  388,  387,  259,
 579      279,  386,  336,   47,   47,   54,   54,   57,   57,   82,
 580       82,  385,  384,  383,  382,  381,  380,  379,  378,  377,
 581      376,  375,  374,  373,  372,  371,  370,  369,  368,  367,
 582      366,  365,  364,  363,  362,  361,  360,  359,  358,  357,
 583      356,  355,  354,  353,  352,  351,  350,  349,  348,  347,
 584
 585      346,  345,  344,  343,  342,  341,  340,  339,  338,  337,
 586      334,  333,  332,  331,  330,  329,  328,  327,  326,  325,
 587      324,  323,  322,  321,  320,  319,  318,  317,  316,  315,
 588      314,  313,  312,  311,  310,  309,  308,  307,  306,  305,
 589      304,  303,  302,  301,  300,  299,  298,  297,  296,  295,
 590      294,  293,  292,  291,  290,  289,  288,  287,  286,  285,
 591      284,  283,  282,  281,  280,  277,  276,  275,  274,  273,
 592      272,  271,  270,  269,  268,  267,  266,  265,  264,  263,
 593      262,  261,  260,  257,  256,  255,  252,  251,  250,  249,
 594      248,  247,  244,  243,  242,  241,  240,  239,  238,  237,
 595
 596      236,  235,  234,  233,  232,  231,  230,  229,  228,  224,
 597      223,  222,  221,  220,  219,  218,  217,  214,  213,  212,
 598      211,  210,  209,  208,  207,  206,  205,  204,  203,  202,
 599      201,  200,  199,  198,  197,  196,  195,  194,  193,  192,
 600      191,  190,  189,  188,  187,  186,  185,  184,  183,  182,
 601      181,  180,  179,  178,  177,  176,  175,  174,  173,  172,
 602      171,  170,  169,  168,  167,  166,  165,  164,  163,  160,
 603      159,  158,  157,  156,  155,  154,  153,  152,  149,  148,
 604      147,  146,  145,  144,  143,  142,  141,  138,  137,  136,
 605      135,  134,  133,  132,  131,  130,  129,  126,  121,  110,
 606
 607      109,  104,  101,   55,   55,  100,   99,   98,   97,   94,
 608       91,   90,   83,   80,   79,   60,   59,   58,   55,   56,
 609       55,   53,  399,    7,  399,  399,  399,  399,  399,  399,
 610      399,  399,  399,  399,  399,  399,  399,  399,  399,  399,
 611      399,  399,  399,  399,  399,  399,  399,  399,  399,  399,
 612      399,  399,  399,  399,  399,  399,  399,  399,  399,  399,
 613      399,  399,  399,  399,  399,  399,  399,  399,  399,  399,
 614      399,  399,  399,  399,  399,  399,  399,  399
 615    } ;
 616
 617static yyconst flex_int16_t yy_chk[479] =
 618    {   0,
 619        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 620        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 621        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 622        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 623        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 624        1,    1,    1,    1,    9,    9,   23,   35,   37,   40,
 625       36,   42,   37,   35,    9,    9,   36,   61,   65,   71,
 626       71,   72,   40,    9,   65,   48,   48,   42,   67,   67,
 627       23,   77,   67,   74,   70,   48,   48,   67,   70,   72,
 628       73,   61,   74,   76,   48,   73,   77,   76,   84,   84,
 629
 630       96,  183,  109,  121,  121,  183,    9,   24,  109,   96,
 631      214,  403,  397,  214,  396,  395,  394,  392,  389,   24,
 632       24,   24,   24,   24,   24,   24,   24,   48,   24,  194,
 633       24,   24,   24,  224,   24,   24,   24,  194,  228,  251,
 634      194,  322,  387,  386,  224,  385,  384,  382,  381,  228,
 635      251,  380,  322,  400,  400,  401,  401,  402,  402,  404,
 636      404,  379,  378,  377,  376,  374,  373,  372,  371,  370,
 637      369,  368,  366,  365,  364,  363,  362,  360,  359,  357,
 638      356,  355,  354,  353,  352,  351,  349,  348,  347,  346,
 639      344,  343,  342,  341,  340,  339,  337,  336,  335,  334,
 640
 641      332,  331,  330,  329,  328,  327,  326,  325,  324,  323,
 642      320,  319,  318,  317,  316,  315,  313,  312,  310,  307,
 643      306,  305,  304,  303,  302,  301,  300,  299,  295,  294,
 644      293,  292,  291,  290,  289,  288,  287,  286,  285,  284,
 645      283,  282,  281,  280,  279,  278,  276,  274,  272,  271,
 646      270,  269,  268,  267,  265,  264,  262,  261,  259,  258,
 647      257,  256,  255,  254,  253,  250,  249,  248,  247,  246,
 648      245,  243,  242,  240,  239,  238,  237,  236,  235,  234,
 649      233,  230,  229,  227,  226,  225,  221,  220,  219,  217,
 650      216,  215,  213,  212,  211,  210,  209,  208,  207,  206,
 651
 652      204,  203,  201,  200,  199,  198,  197,  196,  195,  193,
 653      192,  191,  190,  189,  186,  185,  184,  182,  181,  178,
 654      177,  176,  174,  173,  172,  171,  170,  169,  168,  167,
 655      166,  165,  164,  163,  162,  161,  160,  158,  156,  155,
 656      154,  153,  151,  150,  149,  148,  147,  146,  145,  144,
 657      143,  142,  141,  140,  139,  138,  137,  136,  134,  132,
 658      131,  130,  129,  127,  126,  125,  124,  123,  122,  120,
 659      119,  118,  117,  115,  114,  113,  112,  111,  108,  106,
 660      105,  104,  103,  102,  101,   98,   97,   95,   93,   92,
 661       91,   90,   89,   88,   87,   86,   85,   78,   75,   69,
 662
 663       68,   66,   64,   57,   54,   46,   45,   44,   43,   41,
 664       39,   38,   34,   27,   25,   22,   21,   17,   14,   13,
 665       11,   10,    7,  399,  399,  399,  399,  399,  399,  399,
 666      399,  399,  399,  399,  399,  399,  399,  399,  399,  399,
 667      399,  399,  399,  399,  399,  399,  399,  399,  399,  399,
 668      399,  399,  399,  399,  399,  399,  399,  399,  399,  399,
 669      399,  399,  399,  399,  399,  399,  399,  399,  399,  399,
 670      399,  399,  399,  399,  399,  399,  399,  399
 671    } ;
 672
 673static yy_state_type yy_last_accepting_state;
 674static char *yy_last_accepting_cpos;
 675
 676extern int yy_flex_debug;
 677int yy_flex_debug = 0;
 678
 679/* The intent behind this definition is that it'll catch
 680 * any uses of REJECT which flex missed.
 681 */
 682#define REJECT reject_used_but_not_detected
 683#define yymore() yymore_used_but_not_detected
 684#define YY_MORE_ADJ 0
 685#define YY_RESTORE_YY_MORE_OFFSET
 686char *yytext;
 687#line 1 "scanner.l"
 688#line 2 "scanner.l"
 689#include <stdio.h>
 690#include "parser.h"
 691
 692YY_BUFFER_STATE mybuffer;
 693
 694void prepare_parse(char* msg) {
 695  mybuffer = yy_scan_string(msg);  
 696}
 697
 698void cleanup_parse() {
 699  yy_delete_buffer(mybuffer);  
 700}
 701 
 702
 703
 704#line 705 "scanner.c"
 705
 706#define INITIAL 0
 707#define DSTR 1
 708#define SSTR 2
 709
 710#ifndef YY_NO_UNISTD_H
 711/* Special case for "unistd.h", since it is non-ANSI. We include it way
 712 * down here because we want the user's section 1 to have been scanned first.
 713 * The user has a chance to override it with an option.
 714 */
 715#include <unistd.h>
 716#endif
 717
 718#ifndef YY_EXTRA_TYPE
 719#define YY_EXTRA_TYPE void *
 720#endif
 721
 722static int yy_init_globals (void );
 723
 724/* Macros after this point can all be overridden by user definitions in
 725 * section 1.
 726 */
 727
 728#ifndef YY_SKIP_YYWRAP
 729#ifdef __cplusplus
 730extern "C" int yywrap (void );
 731#else
 732extern int yywrap (void );
 733#endif
 734#endif
 735
 736    static void yyunput (int c,char *buf_ptr  );
 737    
 738#ifndef yytext_ptr
 739static void yy_flex_strncpy (char *,yyconst char *,int );
 740#endif
 741
 742#ifdef YY_NEED_STRLEN
 743static int yy_flex_strlen (yyconst char * );
 744#endif
 745
 746#ifndef YY_NO_INPUT
 747
 748#ifdef __cplusplus
 749static int yyinput (void );
 750#else
 751static int input (void );
 752#endif
 753
 754#endif
 755
 756        static int yy_start_stack_ptr = 0;
 757        static int yy_start_stack_depth = 0;
 758        static int *yy_start_stack = NULL;
 759    
 760    static void yy_push_state (int new_state );
 761    
 762    static void yy_pop_state (void );
 763    
 764    static int yy_top_state (void );
 765    
 766/* Amount of stuff to slurp up with each read. */
 767#ifndef YY_READ_BUF_SIZE
 768#define YY_READ_BUF_SIZE 8192
 769#endif
 770
 771/* Copy whatever the last rule matched to the standard output. */
 772#ifndef ECHO
 773/* This used to be an fputs(), but since the string might contain NUL's,
 774 * we now use fwrite().
 775 */
 776#define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
 777#endif
 778
 779/* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
 780 * is returned in "result".
 781 */
 782#ifndef YY_INPUT
 783#define YY_INPUT(buf,result,max_size) \
 784	if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
 785		{ \
 786		int c = '*'; \
 787		size_t n; \
 788		for ( n = 0; n < max_size && \
 789			     (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
 790			buf[n] = (char) c; \
 791		if ( c == '\n' ) \
 792			buf[n++] = (char) c; \
 793		if ( c == EOF && ferror( yyin ) ) \
 794			YY_FATAL_ERROR( "input in flex scanner failed" ); \
 795		result = n; \
 796		} \
 797	else \
 798		{ \
 799		errno=0; \
 800		while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
 801			{ \
 802			if( errno != EINTR) \
 803				{ \
 804				YY_FATAL_ERROR( "input in flex scanner failed" ); \
 805				break; \
 806				} \
 807			errno=0; \
 808			clearerr(yyin); \
 809			} \
 810		}\
 811\
 812
 813#endif
 814
 815/* No semi-colon after return; correct usage is to write "yyterminate();" -
 816 * we don't want an extra ';' after the "return" because that will cause
 817 * some compilers to complain about unreachable statements.
 818 */
 819#ifndef yyterminate
 820#define yyterminate() return YY_NULL
 821#endif
 822
 823/* Number of entries by which start-condition stack grows. */
 824#ifndef YY_START_STACK_INCR
 825#define YY_START_STACK_INCR 25
 826#endif
 827
 828/* Report a fatal error. */
 829#ifndef YY_FATAL_ERROR
 830#define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
 831#endif
 832
 833/* end tables serialization structures and prototypes */
 834
 835/* Default declaration of generated scanner - a define so the user can
 836 * easily add parameters.
 837 */
 838#ifndef YY_DECL
 839#define YY_DECL_IS_OURS 1
 840
 841extern int yylex (void);
 842
 843#define YY_DECL int yylex (void)
 844#endif /* !YY_DECL */
 845
 846/* Code executed at the beginning of each rule, after yytext and yyleng
 847 * have been set up.
 848 */
 849#ifndef YY_USER_ACTION
 850#define YY_USER_ACTION
 851#endif
 852
 853/* Code executed at the end of each rule. */
 854#ifndef YY_BREAK
 855#define YY_BREAK break;
 856#endif
 857
 858#define YY_RULE_SETUP \
 859	YY_USER_ACTION
 860
 861/** The main scanner function which does all the work.
 862 */
 863YY_DECL
 864{
 865	register yy_state_type yy_current_state;
 866	register char *yy_cp, *yy_bp;
 867	register int yy_act;
 868    
 869#line 123 "scanner.l"
 870
 871#line 872 "scanner.c"
 872
 873	if ( !(yy_init) )
 874		{
 875		(yy_init) = 1;
 876
 877#ifdef YY_USER_INIT
 878		YY_USER_INIT;
 879#endif
 880
 881		if ( ! (yy_start) )
 882			(yy_start) = 1;	/* first start state */
 883
 884		if ( ! yyin )
 885			yyin = stdin;
 886
 887		if ( ! yyout )
 888			yyout = stdout;
 889
 890		if ( ! YY_CURRENT_BUFFER ) {
 891			yyensure_buffer_stack ();
 892			YY_CURRENT_BUFFER_LVALUE =
 893				yy_create_buffer(yyin,YY_BUF_SIZE );
 894		}
 895
 896		yy_load_buffer_state( );
 897		}
 898
 899	while ( 1 )		/* loops until end-of-file is reached */
 900		{
 901		yy_cp = (yy_c_buf_p);
 902
 903		/* Support of yytext. */
 904		*yy_cp = (yy_hold_char);
 905
 906		/* yy_bp points to the position in yy_ch_buf of the start of
 907		 * the current run.
 908		 */
 909		yy_bp = yy_cp;
 910
 911		yy_current_state = (yy_start);
 912yy_match:
 913		do
 914			{
 915			register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
 916			if ( yy_accept[yy_current_state] )
 917				{
 918				(yy_last_accepting_state) = yy_current_state;
 919				(yy_last_accepting_cpos) = yy_cp;
 920				}
 921			while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
 922				{
 923				yy_current_state = (int) yy_def[yy_current_state];
 924				if ( yy_current_state >= 400 )
 925					yy_c = yy_meta[(unsigned int) yy_c];
 926				}
 927			yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
 928			++yy_cp;
 929			}
 930		while ( yy_base[yy_current_state] != 424 );
 931
 932yy_find_action:
 933		yy_act = yy_accept[yy_current_state];
 934		if ( yy_act == 0 )
 935			{ /* have to back up */
 936			yy_cp = (yy_last_accepting_cpos);
 937			yy_current_state = (yy_last_accepting_state);
 938			yy_act = yy_accept[yy_current_state];
 939			}
 940
 941		YY_DO_BEFORE_ACTION;
 942
 943do_action:	/* This label is used only to access EOF actions. */
 944
 945		switch ( yy_act )
 946	{ /* beginning of action switch */
 947			case 0: /* must back up */
 948			/* undo the effects of YY_DO_BEFORE_ACTION */
 949			*yy_cp = (yy_hold_char);
 950			yy_cp = (yy_last_accepting_cpos);
 951			yy_current_state = (yy_last_accepting_state);
 952			goto yy_find_action;
 953
 954case 1:
 955YY_RULE_SETUP
 956#line 124 "scanner.l"
 957yylval.string = strdup(yytext); return NUMBER;
 958	YY_BREAK
 959case 2:
 960/* rule 2 can match eol */
 961YY_RULE_SETUP
 962#line 125 "scanner.l"
 963yylval.string = strdup(yytext); return S;
 964	YY_BREAK
 965case 3:
 966YY_RULE_SETUP
 967#line 126 "scanner.l"
 968yylval.string = strdup(yytext); return AT;
 969	YY_BREAK
 970case 4:
 971YY_RULE_SETUP
 972#line 127 "scanner.l"
 973yylval.string = strdup(yytext); return LPAREN;
 974	YY_BREAK
 975case 5:
 976YY_RULE_SETUP
 977#line 128 "scanner.l"
 978yylval.string = strdup(yytext); return RPAREN;
 979	YY_BREAK
 980case 6:
 981YY_RULE_SETUP
 982#line 129 "scanner.l"
 983yylval.string = strdup(yytext); return PIPE;
 984	YY_BREAK
 985case 7:
 986YY_RULE_SETUP
 987#line 130 "scanner.l"
 988yylval.string = strdup(yytext); return LT;
 989	YY_BREAK
 990case 8:
 991YY_RULE_SETUP
 992#line 131 "scanner.l"
 993yylval.string = strdup(yytext); return SLASH;
 994	YY_BREAK
 995case 9:
 996YY_RULE_SETUP
 997#line 132 "scanner.l"
 998yylval.string = strdup(yytext); return DBLSLASH;
 999	YY_BREAK
1000case 10:
1001YY_RULE_SETUP
1002#line 133 "scanner.l"
1003yylval.string = strdup(yytext); return BANG;
1004	YY_BREAK
1005case 11:
1006YY_RULE_SETUP
1007#line 134 "scanner.l"
1008yylval.string = strdup(yytext); return COLON;
1009	YY_BREAK
1010case 12:
1011YY_RULE_SETUP
1012#line 135 "scanner.l"
1013yylval.string = strdup(yytext); return DBLCOLON;
1014	YY_BREAK
1015case 13:
1016YY_RULE_SETUP
1017#line 136 "scanner.l"
1018yylval.string = strdup(yytext); return QUERY;
1019	YY_BREAK
1020case 14:
1021YY_RULE_SETUP
1022#line 137 "scanner.l"
1023yylval.string = strdup(yytext); return HASH;
1024	YY_BREAK
1025case 15:
1026/* rule 15 can match eol */
1027YY_RULE_SETUP
1028#line 138 "scanner.l"
1029yylval.string = strdup(yytext); return COMMA;
1030	YY_BREAK
1031case 16:
1032YY_RULE_SETUP
1033#line 139 "scanner.l"
1034yylval.string = strdup(yytext); return DOT;
1035	YY_BREAK
1036case 17:
1037YY_RULE_SETUP
1038#line 140 "scanner.l"
1039yylval.string = strdup(yytext); return DBLDOT;
1040	YY_BREAK
1041case 18:
1042/* rule 18 can match eol */
1043YY_RULE_SETUP
1044#line 141 "scanner.l"
1045yylval.string = strdup(yytext); return GT;
1046	YY_BREAK
1047case 19:
1048YY_RULE_SETUP
1049#line 142 "scanner.l"
1050yylval.string = strdup(yytext); return LBRA;
1051	YY_BREAK
1052case 20:
1053YY_RULE_SETUP
1054#line 143 "scanner.l"
1055yylval.string = strdup(yytext); return RBRA;
1056	YY_BREAK
1057case 21:
1058/* rule 21 can match eol */
1059YY_RULE_SETUP
1060#line 144 "scanner.l"
1061yylval.string = strdup(yytext); return TILDE;
1062	YY_BREAK
1063case 22:
1064YY_RULE_SETUP
1065#line 145 "scanner.l"
1066yylval.string = strdup(yytext); return SPLAT;
1067	YY_BREAK
1068case 23:
1069/* rule 23 can match eol */
1070YY_RULE_SETUP
1071#line 146 "scanner.l"
1072yylval.string = strdup(yytext); return PLUS;
1073	YY_BREAK
1074case 24:
1075YY_RULE_SETUP
1076#line 147 "scanner.l"
1077yylval.string = strdup(yytext); return DASH;
1078	YY_BREAK
1079case 25:
1080YY_RULE_SETUP
1081#line 148 "scanner.l"
1082yylval.string = strdup(yytext); return EQ;
1083	YY_BREAK
1084case 26:
1085YY_RULE_SETUP
1086#line 149 "scanner.l"
1087yylval.string = strdup(yytext); return LTE;
1088	YY_BREAK
1089case 27:
1090YY_RULE_SETUP
1091#line 150 "scanner.l"
1092yylval.string = strdup(yytext); return GTE;
1093	YY_BREAK
1094case 28:
1095YY_RULE_SETUP
1096#line 151 "scanner.l"
1097yylval.string = strdup(yytext); return DOLLAR;
1098	YY_BREAK
1099case 29:
1100/* rule 29 can match eol */
1101YY_RULE_SETUP
1102#line 152 "scanner.l"
1103yylval.string = strdup(yytext); return BSLASHLIT;
1104	YY_BREAK
1105case 30:
1106YY_RULE_SETUP
1107#line 153 "scanner.l"
1108yylval.string = strdup(yytext); return XANCESTOR;
1109	YY_BREAK
1110case 31:
1111YY_RULE_SETUP
1112#line 154 "scanner.l"
1113yylval.string = strdup(yytext); return XANCESTORSELF;
1114	YY_BREAK
1115case 32:
1116YY_RULE_SETUP
1117#line 155 "scanner.l"
1118yylval.string = strdup(yytext); return XATTR;
1119	YY_BREAK
1120case 33:
1121YY_RULE_SETUP
1122#line 156 "scanner.l"
1123yylval.string = strdup(yytext); return XCHILD;
1124	YY_BREAK
1125case 34:
1126YY_RULE_SETUP
1127#line 157 "scanner.l"
1128yylval.string = strdup(yytext); return XDESC;
1129	YY_BREAK
1130case 35:
1131YY_RULE_SETUP
1132#line 158 "scanner.l"
1133yylval.string = strdup(yytext); return XDESCSELF;
1134	YY_BREAK
1135case 36:
1136YY_RULE_SETUP
1137#line 159 "scanner.l"
1138yylval.string = strdup(yytext); return XFOLLOW;
1139	YY_BREAK
1140case 37:
1141YY_RULE_SETUP
1142#line 160 "scanner.l"
1143yylval.string = strdup(yytext); return XFOLLOWSIB;
1144	YY_BREAK
1145case 38:
1146YY_RULE_SETUP
1147#line 161 "scanner.l"
1148yylval.string = strdup(yytext); return XNS;
1149	YY_BREAK
1150case 39:
1151YY_RULE_SETUP
1152#line 162 "scanner.l"
1153yylval.string = strdup(yytext); return XPARENT;
1154	YY_BREAK
1155case 40:
1156YY_RULE_SETUP
1157#line 163 "scanner.l"
1158yylval.string = strdup(yytext); return XPRE;
1159	YY_BREAK
1160case 41:
1161YY_RULE_SETUP
1162#line 164 "scanner.l"
1163yylval.string = strdup(yytext); return XPRESIB;
1164	YY_BREAK
1165case 42:
1166YY_RULE_SETUP
1167#line 165 "scanner.l"
1168yylval.string = strdup(yytext); return XSELF;
1169	YY_BREAK
1170case 43:
1171YY_RULE_SETUP
1172#line 166 "scanner.l"
1173yylval.string = strdup(yytext); return XOR;
1174	YY_BREAK
1175case 44:
1176YY_RULE_SETUP
1177#line 167 "scanner.l"
1178yylval.string = strdup(yytext); return XAND;
1179	YY_BREAK
1180case 45:
1181YY_RULE_SETUP
1182#line 168 "scanner.l"
1183yylval.string = strdup(yytext); return XDIV;
1184	YY_BREAK
1185case 46:
1186YY_RULE_SETUP
1187#line 169 "scanner.l"
1188yylval.string = strdup(yytext); return XMOD;
1189	YY_BREAK
1190case 47:
1191YY_RULE_SETUP
1192#line 170 "scanner.l"
1193yylval.string = strdup(yytext); return XCOMMENT;
1194	YY_BREAK
1195case 48:
1196YY_RULE_SETUP
1197#line 171 "scanner.l"
1198yylval.string = strdup(yytext); return XTEXT;
1199	YY_BREAK
1200case 49:
1201YY_RULE_SETUP
1202#line 172 "scanner.l"
1203yylval.string = strdup(yytext); return XPI;
1204	YY_BREAK
1205case 50:
1206YY_RULE_SETUP
1207#line 173 "scanner.l"
1208yylval.string = strdup(yytext); return XNODE;
1209	YY_BREAK
1210case 51:
1211YY_RULE_SETUP
1212#line 174 "scanner.l"
1213yylval.string = strdup(yytext); return CXEQUATION;
1214	YY_BREAK
1215case 52:
1216YY_RULE_SETUP
1217#line 175 "scanner.l"
1218yylval.string = strdup(yytext); return CXOPHE;
1219	YY_BREAK
1220case 53:
1221YY_RULE_SETUP
1222#line 176 "scanner.l"
1223yylval.string = strdup(yytext); return CXOPNE;
1224	YY_BREAK
1225case 54:
1226YY_RULE_SETUP
1227#line 177 "scanner.l"
1228yylval.string = strdup(yytext); return CXOPSTARTEQ;
1229	YY_BREAK
1230case 55:
1231YY_RULE_SETUP
1232#line 178 "scanner.l"
1233yylval.string = strdup(yytext); return CXOPENDEQ;
1234	YY_BREAK
1235case 56:
1236YY_RULE_SETUP
1237#line 179 "scanner.l"
1238yylval.string = strdup(yytext); return CXOPCONTAINS;
1239	YY_BREAK
1240case 57:
1241YY_RULE_SETUP
1242#line 180 "scanner.l"
1243yylval.string = strdup(yytext); return CXOPCONTAINS2;
1244	YY_BREAK
1245case 58:
1246YY_RULE_SETUP
1247#line 181 "scanner.l"
1248yylval.string = strdup(yytext); return CXFIRST;
1249	YY_BREAK
1250case 59:
1251YY_RULE_SETUP
1252#line 182 "scanner.l"
1253yylval.string = strdup(yytext); return CXLAST;
1254	YY_BREAK
1255case 60:
1256YY_RULE_SETUP
1257#line 183 "scanner.l"
1258yylval.string = strdup(yytext); return CXNOT;
1259	YY_BREAK
1260case 61:
1261YY_RULE_SETUP
1262#line 184 "scanner.l"
1263yylval.string = strdup(yytext); return CXEVEN;
1264	YY_BREAK
1265case 62:
1266YY_RULE_SETUP
1267#line 185 "scanner.l"
1268yylval.string = strdup(yytext); return CXODD;
1269	YY_BREAK
1270case 63:
1271YY_RULE_SETUP
1272#line 186 "scanner.l"
1273yylval.string = strdup(yytext); return CXEQ;
1274	YY_BREAK
1275case 64:
1276YY_RULE_SETUP
1277#line 187 "scanner.l"
1278yylval.string = strdup(yytext); return CXGT;
1279	YY_BREAK
1280case 65:
1281YY_RULE_SETUP
1282#line 188 "scanner.l"
1283yylval.string = strdup(yytext); return CXLT;
1284	YY_BREAK
1285case 66:
1286YY_RULE_SETUP
1287#line 189 "scanner.l"
1288yylval.string = strdup(yytext); return CXCONTENT;
1289	YY_BREAK
1290case 67:
1291YY_RULE_SETUP
1292#line 190 "scanner.l"
1293yylval.string = strdup(yytext); return CXHEADER;
1294	YY_BREAK
1295case 68:
1296YY_RULE_SETUP
1297#line 191 "scanner.l"
1298yylval.string = strdup(yytext); return CXCONTAINS;
1299	YY_BREAK
1300case 69:
1301YY_RULE_SETUP
1302#line 192 "scanner.l"
1303yylval.string = strdup(yytext); return CXEMPTY;
1304	YY_BREAK
1305case 70:
1306YY_RULE_SETUP
1307#line 193 "scanner.l"
1308yylval.string = strdup(yytext); return CXHAS;
1309	YY_BREAK
1310case 71:
1311YY_RULE_SETUP
1312#line 194 "scanner.l"
1313yylval.string = strdup(yytext); return CXPARENT;
1314	YY_BREAK
1315case 72:
1316YY_RULE_SETUP
1317#line 195 "scanner.l"
1318yylval.string = strdup(yytext); return CXNTHCH;
1319	YY_BREAK
1320case 73:
1321YY_RULE_SETUP
1322#line 196 "scanner.l"
1323yylval.string = strdup(yytext); return CXNTHLASTCH;
1324	YY_BREAK
1325case 74:
1326YY_RULE_SETUP
1327#line 197 "scanner.l"
1328yylval.string = strdup(yytext); return CXNTHTYPE;
1329	YY_BREAK
1330case 75:
1331YY_RULE_SETUP
1332#line 198 "scanner.l"
1333yylval.string = strdup(yytext); return CXNTHLASTTYPE;
1334	YY_BREAK
1335case 76:
1336YY_RULE_SETUP
1337#line 199 "scanner.l"
1338yylval.string = strdup(yytext); return CXFIRSTCH;
1339	YY_BREAK
1340case 77:
1341YY_RULE_SETUP
1342#line 200 "scanner.l"
1343yylval.string = strdup(yytext); return CXLASTCH;
1344	YY_BREAK
1345case 78:
1346YY_RULE_SETUP
1347#line 201 "scanner.l"
1348yylval.string = strdup(yytext); return CXFIRSTTYPE;
1349	YY_BREAK
1350case 79:
1351YY_RULE_SETUP
1352#line 202 "scanner.l"
1353yylval.string = strdup(yytext); return CXLASTTYPE;
1354	YY_BREAK
1355case 80:
1356YY_RULE_SETUP
1357#line 203 "scanner.l"
1358yylval.string = strdup(yytext); return CXONLYCH;
1359	YY_BREAK
1360case 81:
1361YY_RULE_SETUP
1362#line 204 "scanner.l"
1363yylval.string = strdup(yytext); return CXONLYTYPE;
1364	YY_BREAK
1365case 82:
1366YY_RULE_SETUP
1367#line 205 "scanner.l"
1368yylval.string = strdup(yytext); return CXINPUT;
1369	YY_BREAK
1370case 83:
1371YY_RULE_SETUP
1372#line 206 "scanner.l"
1373yylval.string = strdup(yytext); return CXTEXT;
1374	YY_BREAK
1375case 84:
1376YY_RULE_SETUP
1377#line 207 "scanner.l"
1378yylval.string = strdup(yytext); return CXPASSWORD;
1379	YY_BREAK
1380case 85:
1381YY_RULE_SETUP
1382#line 208 "scanner.l"
1383yylval.string = strdup(yytext); return CXRADIO;
1384	YY_BREAK
1385case 86:
1386YY_RULE_SETUP
1387#line 209 "scanner.l"
1388yylval.string = strdup(yytext); return CXCHECKBOX;
1389	YY_BREAK
1390case 87:
1391YY_RULE_SETUP
1392#line 210 "scanner.l"
1393yylval.string = strdup(yytext); return CXSUBMIT;
1394	YY_BREAK
1395case 88:
1396YY_RULE_SETUP
1397#line 211 "scanner.l"
1398yylval.string = strdup(yytext); return CXIMAGE;
1399	YY_BREAK
1400case 89:
1401YY_RULE_SETUP
1402#line 212 "scanner.l"
1403yylval.string = strdup(yytext); return CXRESET;
1404	YY_BREAK
1405case 90:
1406YY_RULE_SETUP
1407#line 213 "scanner.l"
1408yylval.string = strdup(yytext); return CXBUTTON;
1409	YY_BREAK
1410case 91:
1411YY_RULE_SETUP
1412#line 214 "scanner.l"
1413yylval.string = strdup(yytext); return CXFILE;
1414	YY_BREAK
1415case 92:
1416YY_RULE_SETUP
1417#line 215 "scanner.l"
1418yylval.string = strdup(yytext); return CXENABLED;
1419	YY_BREAK
1420case 93:
1421YY_RULE_SETUP
1422#line 216 "scanner.l"
1423yylval.string = strdup(yytext); return CXDISABLED;
1424	YY_BREAK
1425case 94:
1426YY_RULE_SETUP
1427#line 217 "scanner.l"
1428yylval.string = strdup(yytext); return CXCHECKED;
1429	YY_BREAK
1430case 95:
1431YY_RULE_SETUP
1432#line 218 "scanner.l"
1433yylval.string = strdup(yytext); return CXSELECTED;
1434	YY_BREAK
1435case 96:
1436YY_RULE_SETUP
1437#line 219 "scanner.l"
1438yylval.string = strdup(yytext); return NAME;
1439	YY_BREAK
1440case 97:
1441/* rule 97 can match eol */
1442YY_RULE_SETUP
1443#line 220 "scanner.l"
1444yylval.string = strdup(yytext); return STRING;
1445	YY_BREAK
1446case 98:
1447/* rule 98 can match eol */
1448YY_RULE_SETUP
1449#line 221 "scanner.l"
1450yylval.string = strdup(yytext); return OTHER;
1451	YY_BREAK
1452case 99:
1453YY_RULE_SETUP
1454#line 222 "scanner.l"
1455ECHO;
1456	YY_BREAK
1457#line 1458 "scanner.c"
1458case YY_STATE_EOF(INITIAL):
1459case YY_STATE_EOF(DSTR):
1460case YY_STATE_EOF(SSTR):
1461	yyterminate();
1462
1463	case YY_END_OF_BUFFER:
1464		{
1465		/* Amount of text matched not including the EOB char. */
1466		int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
1467
1468		/* Undo the effects of YY_DO_BEFORE_ACTION. */
1469		*yy_cp = (yy_hold_char);
1470		YY_RESTORE_YY_MORE_OFFSET
1471
1472		if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
1473			{
1474			/* We're scanning a new file or input source.  It's
1475			 * possible that this happened because the user
1476			 * just pointed yyin at a new source and called
1477			 * yylex().  If so, then we have to assure
1478			 * consistency between YY_CURRENT_BUFFER and our
1479			 * globals.  Here is the right place to do so, because
1480			 * this is the first action (other than possibly a
1481			 * back-up) that will match for the new input source.
1482			 */
1483			(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1484			YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
1485			YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
1486			}
1487
1488		/* Note that here we test for yy_c_buf_p "<=" to the position
1489		 * of the first EOB in the buffer, since yy_c_buf_p will
1490		 * already have been incremented past the NUL character
1491		 * (since all states make transitions on EOB to the
1492		 * end-of-buffer state).  Contrast this with the test
1493		 * in input().
1494		 */
1495		if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1496			{ /* This was really a NUL. */
1497			yy_state_type yy_next_state;
1498
1499			(yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
1500
1501			yy_current_state = yy_get_previous_state(  );
1502
1503			/* Okay, we're now positioned to make the NUL
1504			 * transition.  We couldn't have
1505			 * yy_get_previous_state() go ahead and do it
1506			 * for us because it doesn't know how to deal
1507			 * with the possibility of jamming (and we don't
1508			 * want to build jamming into it because then it
1509			 * will run more slowly).
1510			 */
1511
1512			yy_next_state = yy_try_NUL_trans( yy_current_state );
1513
1514			yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1515
1516			if ( yy_next_state )
1517				{
1518				/* Consume the NUL. */
1519				yy_cp = ++(yy_c_buf_p);
1520				yy_current_state = yy_next_state;
1521				goto yy_match;
1522				}
1523
1524			else
1525				{
1526				yy_cp = (yy_c_buf_p);
1527				goto yy_find_action;
1528				}
1529			}
1530
1531		else switch ( yy_get_next_buffer(  ) )
1532			{
1533			case EOB_ACT_END_OF_FILE:
1534				{
1535				(yy_did_buffer_switch_on_eof) = 0;
1536
1537				if ( yywrap( ) )
1538					{
1539					/* Note: because we've taken care in
1540					 * yy_get_next_buffer() to have set up
1541					 * yytext, we can now set up
1542					 * yy_c_buf_p so that if some total
1543					 * hoser (like flex itself) wants to
1544					 * call the scanner after we return the
1545					 * YY_NULL, it'll still work - another
1546					 * YY_NULL will get returned.
1547					 */
1548					(yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
1549
1550					yy_act = YY_STATE_EOF(YY_START);
1551					goto do_action;
1552					}
1553
1554				else
1555					{
1556					if ( ! (yy_did_buffer_switch_on_eof) )
1557						YY_NEW_FILE;
1558					}
1559				break;
1560				}
1561
1562			case EOB_ACT_CONTINUE_SCAN:
1563				(yy_c_buf_p) =
1564					(yytext_ptr) + yy_amount_of_matched_text;
1565
1566				yy_current_state = yy_get_previous_state(  );
1567
1568				yy_cp = (yy_c_buf_p);
1569				yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1570				goto yy_match;
1571
1572			case EOB_ACT_LAST_MATCH:
1573				(yy_c_buf_p) =
1574				&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
1575
1576				yy_current_state = yy_get_previous_state(  );
1577
1578				yy_cp = (yy_c_buf_p);
1579				yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1580				goto yy_find_action;
1581			}
1582		break;
1583		}
1584
1585	default:
1586		YY_FATAL_ERROR(
1587			"fatal flex scanner internal error--no action found" );
1588	} /* end of action switch */
1589		} /* end of scanning one token */
1590} /* end of yylex */
1591
1592/* yy_get_next_buffer - try to read in a new buffer
1593 *
1594 * Returns a code representing an action:
1595 *	EOB_ACT_LAST_MATCH -
1596 *	EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1597 *	EOB_ACT_END_OF_FILE - end of file
1598 */
1599static int yy_get_next_buffer (void)
1600{
1601    	register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1602	register char *source = (yytext_ptr);
1603	register int number_to_move, i;
1604	int ret_val;
1605
1606	if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
1607		YY_FATAL_ERROR(
1608		"fatal flex scanner internal error--end of buffer missed" );
1609
1610	if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1611		{ /* Don't try to fill the buffer, so this is an EOF. */
1612		if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
1613			{
1614			/* We matched a single character, the EOB, so
1615			 * treat this as a final EOF.
1616			 */
1617			return EOB_ACT_END_OF_FILE;
1618			}
1619
1620		else
1621			{
1622			/* We matched some text prior to the EOB, first
1623			 * process it.
1624			 */
1625			return EOB_ACT_LAST_MATCH;
1626			}
1627		}
1628
1629	/* Try to read more data. */
1630
1631	/* First move last chars to start of buffer. */
1632	number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
1633
1634	for ( i = 0; i < number_to_move; ++i )
1635		*(dest++) = *(source++);
1636
1637	if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1638		/* don't do the read, it's not guaranteed to return an EOF,
1639		 * just force an EOF
1640		 */
1641		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
1642
1643	else
1644		{
1645			int num_to_read =
1646			YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1647
1648		while ( num_to_read <= 0 )
1649			{ /* Not enough room in the buffer - grow it. */
1650
1651			/* just a shorter name for the current buffer */
1652			YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
1653
1654			int yy_c_buf_p_offset =
1655				(int) ((yy_c_buf_p) - b->yy_ch_buf);
1656
1657			if ( b->yy_is_our_buffer )
1658				{
1659				int new_size = b->yy_buf_size * 2;
1660
1661				if ( new_size <= 0 )
1662					b->yy_buf_size += b->yy_buf_size / 8;
1663				else
1664					b->yy_buf_size *= 2;
1665
1666				b->yy_ch_buf = (char *)
1667					/* Include room in for 2 EOB chars. */
1668					yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2  );
1669				}
1670			else
1671				/* Can't grow it, we don't own it. */
1672				b->yy_ch_buf = 0;
1673
1674			if ( ! b->yy_ch_buf )
1675				YY_FATAL_ERROR(
1676				"fatal error - scanner input buffer overflow" );
1677
1678			(yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
1679
1680			num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1681						number_to_move - 1;
1682
1683			}
1684
1685		if ( num_to_read > YY_READ_BUF_SIZE )
1686			num_to_read = YY_READ_BUF_SIZE;
1687
1688		/* Read in more data. */
1689		YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1690			(yy_n_chars), num_to_read );
1691
1692		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1693		}
1694
1695	if ( (yy_n_chars) == 0 )
1696		{
1697		if ( number_to_move == YY_MORE_ADJ )
1698			{
1699			ret_val = EOB_ACT_END_OF_FILE;
1700			yyrestart(yyin  );
1701			}
1702
1703		else
1704			{
1705			ret_val = EOB_ACT_LAST_MATCH;
1706			YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1707				YY_BUFFER_EOF_PENDING;
1708			}
1709		}
1710
1711	else
1712		ret_val = EOB_ACT_CONTINUE_SCAN;
1713
1714	(yy_n_chars) += number_to_move;
1715	YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
1716	YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
1717
1718	(yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1719
1720	return ret_val;
1721}
1722
1723/* yy_get_previous_state - get the state just before the EOB char was reached */
1724
1725    static yy_state_type yy_get_previous_state (void)
1726{
1727	register yy_state_type yy_current_state;
1728	register char *yy_cp;
1729    
1730	yy_current_state = (yy_start);
1731
1732	for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
1733		{
1734		register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1735		if ( yy_accept[yy_current_state] )
1736			{
1737			(yy_last_accepting_state) = yy_current_state;
1738			(yy_last_accepting_cpos) = yy_cp;
1739			}
1740		while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1741			{
1742			yy_current_state = (int) yy_def[yy_current_state];
1743			if ( yy_current_state >= 400 )
1744				yy_c = yy_meta[(unsigned int) yy_c];
1745			}
1746		yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1747		}
1748
1749	return yy_current_state;
1750}
1751
1752/* yy_try_NUL_trans - try to make a transition on the NUL character
1753 *
1754 * synopsis
1755 *	next_state = yy_try_NUL_trans( current_state );
1756 */
1757    static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
1758{
1759	register int yy_is_jam;
1760    	register char *yy_cp = (yy_c_buf_p);
1761
1762	register YY_CHAR yy_c = 1;
1763	if ( yy_accept[yy_current_state] )
1764		{
1765		(yy_last_accepting_state) = yy_current_state;
1766		(yy_last_accepting_cpos) = yy_cp;
1767		}
1768	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1769		{
1770		yy_current_state = (int) yy_def[yy_current_state];
1771		if ( yy_current_state >= 400 )
1772			yy_c = yy_meta[(unsigned int) yy_c];
1773		}
1774	yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1775	yy_is_jam = (yy_current_state == 399);
1776
1777	return yy_is_jam ? 0 : yy_current_state;
1778}
1779
1780    static void yyunput (int c, register char * yy_bp )
1781{
1782	register char *yy_cp;
1783    
1784    yy_cp = (yy_c_buf_p);
1785
1786	/* undo effects of setting up yytext */
1787	*yy_cp = (yy_hold_char);
1788
1789	if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1790		{ /* need to shift things up to make room */
1791		/* +2 for EOB chars. */
1792		register int number_to_move = (yy_n_chars) + 2;
1793		register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
1794					YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
1795		register char *source =
1796				&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
1797
1798		while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1799			*--dest = *--source;
1800
1801		yy_cp += (int) (dest - source);
1802		yy_bp += (int) (dest - source);
1803		YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
1804			(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
1805
1806		if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1807			YY_FATAL_ERROR( "flex scanner push-back overflow" );
1808		}
1809
1810	*--yy_cp = (char) c;
1811
1812	(yytext_ptr) = yy_bp;
1813	(yy_hold_char) = *yy_cp;
1814	(yy_c_buf_p) = yy_cp;
1815}
1816
1817#ifndef YY_NO_INPUT
1818#ifdef __cplusplus
1819    static int yyinput (void)
1820#else
1821    static int input  (void)
1822#endif
1823
1824{
1825	int c;
1826    
1827	*(yy_c_buf_p) = (yy_hold_char);
1828
1829	if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
1830		{
1831		/* yy_c_buf_p now points to the character we want to return.
1832		 * If this occurs *before* the EOB characters, then it's a
1833		 * valid NUL; if not, then we've hit the end of the buffer.
1834		 */
1835		if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1836			/* This was really a NUL. */
1837			*(yy_c_buf_p) = '\0';
1838
1839		else
1840			{ /* need more input */
1841			int offset = (yy_c_buf_p) - (yytext_ptr);
1842			++(yy_c_buf_p);
1843
1844			switch ( yy_get_next_buffer(  ) )
1845				{
1846				case EOB_ACT_LAST_MATCH:
1847					/* This happens because yy_g_n_b()
1848					 * sees that we've accumulated a
1849					 * token and flags that we need to
1850					 * try matching the token before
1851					 * proceeding.  But for input(),
1852					 * there's no matching to consider.
1853					 * So convert the EOB_ACT_LAST_MATCH
1854					 * to EOB_ACT_END_OF_FILE.
1855					 */
1856
1857					/* Reset buffer status. */
1858					yyrestart(yyin );
1859
1860					/*FALLTHROUGH*/
1861
1862				case EOB_ACT_END_OF_FILE:
1863					{
1864					if ( yywrap( ) )
1865						return 0;
1866
1867					if ( ! (yy_did_buffer_switch_on_eof) )
1868						YY_NEW_FILE;
1869#ifdef __cplusplus
1870					return yyinput();
1871#else
1872					return input();
1873#endif
1874					}
1875
1876				case EOB_ACT_CONTINUE_SCAN:
1877					(yy_c_buf_p) = (yytext_ptr) + offset;
1878					break;
1879				}
1880			}
1881		}
1882
1883	c = *(unsigned char *) (yy_c_buf_p);	/* cast for 8-bit char's */
1884	*(yy_c_buf_p) = '\0';	/* preserve yytext */
1885	(yy_hold_char) = *++(yy_c_buf_p);
1886
1887	return c;
1888}
1889#endif	/* ifndef YY_NO_INPUT */
1890
1891/** Immediately switch to a different input stream.
1892 * @param input_file A readable stream.
1893 * 
1894 * @note This function does not reset the start condition to @c INITIAL .
1895 */
1896    void yyrestart  (FILE * input_file )
1897{
1898    
1899	if ( ! YY_CURRENT_BUFFER ){
1900        yyensure_buffer_stack ();
1901		YY_CURRENT_BUFFER_LVALUE =
1902            yy_create_buffer(yyin,YY_BUF_SIZE );
1903	}
1904
1905	yy_init_buffer(YY_CURRENT_BUFFER,input_file );
1906	yy_load_buffer_state( );
1907}
1908
1909/** Switch to a different input buffer.
1910 * @param new_buffer The new input buffer.
1911 * 
1912 */
1913    void yy_switch_to_buffer  (YY_BUFFER_STATE  new_buffer )
1914{
1915    
1916	/* TODO. We should be able to replace this entire function body
1917	 * with
1918	 *		yypop_buffer_state();
1919	 *		yypush_buffer_state(new_buffer);
1920     */
1921	yyensure_buffer_stack ();
1922	if ( YY_CURRENT_BUFFER == new_buffer )
1923		return;
1924
1925	if ( YY_CURRENT_BUFFER )
1926		{
1927		/* Flush out information for old buffer. */
1928		*(yy_c_buf_p) = (yy_hold_char);
1929		YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1930		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1931		}
1932
1933	YY_CURRENT_BUFFER_LVALUE = new_buffer;
1934	yy_load_buffer_state( );
1935
1936	/* We don't actually know whether we did this switch during
1937	 * EOF (yywrap()) processing, but the only time this flag
1938	 * is looked at is after yywrap() is called, so it's safe
1939	 * to go ahead and always set it.
1940	 */
1941	(yy_did_buffer_switch_on_eof) = 1;
1942}
1943
1944static void yy_load_buffer_state  (void)
1945{
1946    	(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1947	(yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
1948	yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
1949	(yy_hold_char) = *(yy_c_buf_p);
1950}
1951
1952/** Allocate and initialize an input buffer state.
1953 * @param file A readable stream.
1954 * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
1955 * 
1956 * @return the allocated buffer state.
1957 */
1958    YY_BUFFER_STATE yy_create_buffer  (FILE * file, int  size )
1959{
1960	YY_BUFFER_STATE b;
1961    
1962	b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state )  );
1963	if ( ! b )
1964		YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1965
1966	b->yy_buf_size = size;
1967
1968	/* yy_ch_buf has to be 2 characters longer than the size given because
1969	 * we need to put in 2 end-of-buffer characters.
1970	 */
1971	b->yy_ch_buf = (char *) yyalloc(b->yy_buf_size + 2  );
1972	if ( ! b->yy_ch_buf )
1973		YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1974
1975	b->yy_is_our_buffer = 1;
1976
1977	yy_init_buffer(b,file );
1978
1979	return b;
1980}
1981
1982/** Destroy the buffer.
1983 * @param b a buffer created with yy_create_buffer()
1984 * 
1985 */
1986    void yy_delete_buffer (YY_BUFFER_STATE  b )
1987{
1988    
1989	if ( ! b )
1990		return;
1991
1992	if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
1993		YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
1994
1995	if ( b->yy_is_our_buffer )
1996		yyfree((void *) b->yy_ch_buf  );
1997
1998	yyfree((void *) b  );
1999}
2000
2001#ifndef __cplusplus
2002extern int isatty (int );
2003#endif /* __cplusplus */
2004    
2005/* Initializes or reinitializes a buffer.
2006 * This function is sometimes called more than once on the same buffer,
2007 * such as during a yyrestart() or at EOF.
2008 */
2009    static void yy_init_buffer  (YY_BUFFER_STATE  b, FILE * file )
2010
2011{
2012	int oerrno = errno;
2013    
2014	yy_flush_buffer(b );
2015
2016	b->yy_input_file = file;
2017	b->yy_fill_buffer = 1;
2018
2019    /* If b is the current buffer, then yy_init_buffer was _probably_
2020     * called from yyrestart() or through yy_get_next_buffer.
2021     * In that case, we don't want to reset the lineno or column.
2022     */
2023    if (b != YY_CURRENT_BUFFER){
2024        b->yy_bs_lineno = 1;
2025        b->yy_bs_column = 0;
2026    }
2027
2028        b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
2029    
2030	errno = oerrno;
2031}
2032
2033/** Discard all buffered characters. On the next scan, YY_INPUT will be called.
2034 * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
2035 * 
2036 */
2037    void yy_flush_buffer (YY_BUFFER_STATE  b )
2038{
2039    	if ( ! b )
2040		return;
2041
2042	b->yy_n_chars = 0;
2043
2044	/* We always need two end-of-buffer characters.  The first causes
2045	 * a transition to the end-of-buffer state.  The second causes
2046	 * a jam in that state.
2047	 */
2048	b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
2049	b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
2050
2051	b->yy_buf_pos = &b->yy_ch_buf[0];
2052
2053	b->yy_at_bol = 1;
2054	b->yy_buffer_status = YY_BUFFER_NEW;
2055
2056	if ( b == YY_CURRENT_BUFFER )
2057		yy_load_buffer_state( );
2058}
2059
2060/** Pushes the new state onto the stack. The new state becomes
2061 *  the current state. This function will allocate the stack
2062 *  if necessary.
2063 *  @param new_buffer The new state.
2064 *  
2065 */
2066void yypush_buffer_state (YY_BUFFER_STATE new_buffer )
2067{
2068    	if (new_buffer == NULL)
2069		return;
2070
2071	yyensure_buffer_stack();
2072
2073	/* This block is copied from yy_switch_to_buffer. */
2074	if ( YY_CURRENT_BUFFER )
2075		{
2076		/* Flush out information for old buffer. */
2077		*(yy_c_buf_p) = (yy_hold_char);
2078		YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
2079		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
2080		}
2081
2082	/* Only push if top exists. Otherwise, replace top. */
2083	if (YY_CURRENT_BUFFER)
2084		(yy_buffer_stack_top)++;
2085	YY_CURRENT_BUFFER_LVALUE = new_buffer;
2086
2087	/* copied from yy_switch_to_buffer. */
2088	yy_load_buffer_state( );
2089	(yy_did_buffer_switch_on_eof) = 1;
2090}
2091
2092/** Removes and deletes the top of the stack, if present.
2093 *  The next element becomes the new top.
2094 *  
2095 */
2096void yypop_buffer_state (void)
2097{
2098    	if (!YY_CURRENT_BUFFER)
2099		return;
2100
2101	yy_delete_buffer(YY_CURRENT_BUFFER );
2102	YY_CURRENT_BUFFER_LVALUE = NULL;
2103	if ((yy_buffer_stack_top) > 0)
2104		--(yy_buffer_stack_top);
2105
2106	if (YY_CURRENT_BUFFER) {
2107		yy_load_buffer_state( );
2108		(yy_did_buffer_switch_on_eof) = 1;
2109	}
2110}
2111
2112/* Allocates the stack if it does not exist.
2113 *  Guarantees space for at least one push.
2114 */
2115static void yyensure_buffer_stack (void)
2116{
2117	int num_to_alloc;
2118    
2119	if (!(yy_buffer_stack)) {
2120
2121		/* First allocation is just for 2 elements, since we don't know if this
2122		 * scanner will even need a stack. We use 2 instead of 1 to avoid an
2123		 * immediate realloc on the next call.
2124         */
2125		num_to_alloc = 1;
2126		(yy_buffer_stack) = (struct yy_buffer_state**)yyalloc
2127								(num_to_alloc * sizeof(struct yy_buffer_state*)
2128								);
2129		
2130		memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
2131				
2132		(yy_buffer_stack_max) = num_to_alloc;
2133		(yy_buffer_stack_top) = 0;
2134		return;
2135	}
2136
2137	if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
2138
2139		/* Increase the buffer to prepare for a possible push. */
2140		int grow_size = 8 /* arbitrary grow size */;
2141
2142		num_to_alloc = (yy_buffer_stack_max) + grow_size;
2143		(yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc
2144								((yy_buffer_stack),
2145								num_to_alloc * sizeof(struct yy_buffer_state*)
2146								);
2147
2148		/* zero only the new slots.*/
2149		memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
2150		(yy_buffer_stack_max) = num_to_alloc;
2151	}
2152}
2153
2154/** Setup the input buffer state to scan directly from a user-specified character buffer.
2155 * @param base the character buffer
2156 * @param size the size in bytes of the character buffer
2157 * 
2158 * @return the newly allocated buffer state object. 
2159 */
2160YY_BUFFER_STATE yy_scan_buffer  (char * base, yy_size_t  size )
2161{
2162	YY_BUFFER_STATE b;
2163    
2164	if ( size < 2 ||
2165	     base[size-2] != YY_END_OF_BUFFER_CHAR ||
2166	     base[size-1] != YY_END_OF_BUFFER_CHAR )
2167		/* They forgot to leave room for the EOB's. */
2168		return 0;
2169
2170	b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state )  );
2171	if ( ! b )
2172		YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
2173
2174	b->yy_buf_size = size - 2;	/* "- 2" to take care of EOB's */
2175	b->yy_buf_pos = b->yy_ch_buf = base;
2176	b->yy_is_our_buffer = 0;
2177	b->yy_input_file = 0;
2178	b->yy_n_chars = b->yy_buf_size;
2179	b->yy_is_interactive = 0;
2180	b->yy_at_bol = 1;
2181	b->yy_fill_buffer = 0;
2182	b->yy_buffer_status = YY_BUFFER_NEW;
2183
2184	yy_switch_to_buffer(b  );
2185
2186	return b;
2187}
2188
2189/** Setup the input buffer state to scan a string. The next call to yylex() will
2190 * scan from a @e copy of @a str.
2191 * @param str a NUL-terminated string to scan
2192 * 
2193 * @return the newly allocated buffer state object.
2194 * @note If you want to scan bytes that may contain NUL values, then use
2195 *       yy_scan_bytes() instead.
2196 */
2197YY_BUFFER_STATE yy_scan_string (yyconst char * yystr )
2198{
2199    
2200	return yy_scan_bytes(yystr,strlen(yystr) );
2201}
2202
2203/** Setup the input buffer state to scan the given bytes. The next call to yylex() will
2204 * scan from a @e copy of @a bytes.
2205 * @param bytes the byte buffer to scan
2206 * @param len the number of bytes in the buffer pointed to by @a bytes.
2207 * 
2208 * @return the newly allocated buffer state object.
2209 */
2210YY_BUFFER_STATE yy_scan_bytes  (yyconst char * yybytes, int  _yybytes_len )
2211{
2212	YY_BUFFER_STATE b;
2213	char *buf;
2214	yy_size_t n;
2215	int i;
2216    
2217	/* Get memory for full buffer, including space for trailing EOB's. */
2218	n = _yybytes_len + 2;
2219	buf = (char *) yyalloc(n  );
2220	if ( ! buf )
2221		YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
2222
2223	for ( i = 0; i < _yybytes_len; ++i )
2224		buf[i] = yybytes[i];
2225
2226	buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
2227
2228	b = yy_scan_buffer(buf,n );
2229	if ( ! b )
2230		YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
2231
2232	/* It's okay to grow etc. this buffer, and we should throw it
2233	 * away when we're done.
2234	 */
2235	b->yy_is_our_buffer = 1;
2236
2237	return b;
2238}
2239
2240    static void yy_push_state (int  new_state )
2241{
2242    	if ( (yy_start_stack_ptr) >= (yy_start_stack_depth) )
2243		{
2244		yy_size_t new_size;
2245
2246		(yy_start_stack_depth) += YY_START_STACK_INCR;
2247		new_size = (yy_start_stack_depth) * sizeof( int );
2248
2249		if ( ! (yy_start_stack) )
2250			(yy_start_stack) = (int *) yyalloc(new_size  );
2251
2252		else
2253			(yy_start_stack) = (int *) yyrealloc((void *) (yy_start_stack),new_size  );
2254
2255		if ( ! (yy_start_stack) )
2256			YY_FATAL_ERROR(
2257			"out of memory expanding start-condition stack" );
2258		}
2259
2260	(yy_start_stack)[(yy_start_stack_ptr)++] = YY_START;
2261
2262	BEGIN(new_state);
2263}
2264
2265    static void yy_pop_state  (void)
2266{
2267    	if ( --(yy_start_stack_ptr) < 0 )
2268		YY_FATAL_ERROR( "start-condition stack underflow" );
2269
2270	BEGIN((yy_start_stack)[(yy_start_stack_ptr)]);
2271}
2272
2273    static int yy_top_state  (void)
2274{
2275    	return (yy_start_stack)[(yy_start_stack_ptr) - 1];
2276}
2277
2278#ifndef YY_EXIT_FAILURE
2279#define YY_EXIT_FAILURE 2
2280#endif
2281
2282static void yy_fatal_error (yyconst char* msg )
2283{
2284    	(void) fprintf( stderr, "%s\n", msg );
2285	exit( YY_EXIT_FAILURE );
2286}
2287
2288/* Redefine yyless() so it works in section 3 code. */
2289
2290#undef yyless
2291#define yyless(n) \
2292	do \
2293		{ \
2294		/* Undo effects of setting up yytext. */ \
2295        int yyless_macro_arg = (n); \
2296        YY_LESS_LINENO(yyless_macro_arg);\
2297		yytext[yyleng] = (yy_hold_char); \
2298		(yy_c_buf_p) = yytext + yyless_macro_arg; \
2299		(yy_hold_char) = *(yy_c_buf_p); \
2300		*(yy_c_buf_p) = '\0'; \
2301		yyleng = yyless_macro_arg; \
2302		} \
2303	while ( 0 )
2304
2305/* Accessor  methods (get/set functions) to struct members. */
2306
2307/** Get the current line number.
2308 * 
2309 */
2310int yyget_lineno  (void)
2311{
2312        
2313    return yylineno;
2314}
2315
2316/** Get the input stream.
2317 * 
2318 */
2319FILE *yyget_in  (void)
2320{
2321        return yyin;
2322}
2323
2324/** Get the output stream.
2325 * 
2326 */
2327FILE *yyget_out  (void)
2328{
2329        return yyout;
2330}
2331
2332/** Get the length of the current token.
2333 * 
2334 */
2335int yyget_leng  (void)
2336{
2337        return yyleng;
2338}
2339
2340/** Get the current token.
2341 * 
2342 */
2343
2344char *yyget_text  (void)
2345{
2346        return yytext;
2347}
2348
2349/** Set the current line number.
2350 * @param line_number
2351 * 
2352 */
2353void yyset_lineno (int  line_number )
2354{
2355    
2356    yylineno = line_number;
2357}
2358
2359/** Set the input stream. This does not discard the current
2360 * input buffer.
2361 * @param in_str A readable stream.
2362 * 
2363 * @see yy_switch_to_buffer
2364 */
2365void yyset_in (FILE *  in_str )
2366{
2367        yyin = in_str ;
2368}
2369
2370void yyset_out (FILE *  out_str )
2371{
2372        yyout = out_str ;
2373}
2374
2375int yyget_debug  (void)
2376{
2377        return yy_flex_debug;
2378}
2379
2380void yyset_debug (int  bdebug )
2381{
2382        yy_flex_debug = bdebug ;
2383}
2384
2385static int yy_init_globals (void)
2386{
2387        /* Initialization is the same as for the non-reentrant scanner.
2388     * This function is called from yylex_destroy(), so don't allocate here.
2389     */
2390
2391    (yy_buffer_stack) = 0;
2392    (yy_buffer_stack_top) = 0;
2393    (yy_buffer_stack_max) = 0;
2394    (yy_c_buf_p) = (char *) 0;
2395    (yy_init) = 0;
2396    (yy_start) = 0;
2397
2398    (yy_start_stack_ptr) = 0;
2399    (yy_start_stack_depth) = 0;
2400    (yy_start_stack) =  NULL;
2401
2402/* Defined in main.c */
2403#ifdef YY_STDINIT
2404    yyin = stdin;
2405    yyout = stdout;
2406#else
2407    yyin = (FILE *) 0;
2408    yyout = (FILE *) 0;
2409#endif
2410
2411    /* For future reference: Set errno on error, since we are called by
2412     * yylex_init()
2413     */
2414    return 0;
2415}
2416
2417/* yylex_destroy is for both reentrant and non-reentrant scanners. */
2418int yylex_destroy  (void)
2419{
2420    
2421    /* Pop the buffer stack, destroying each element. */
2422	while(YY_CURRENT_BUFFER){
2423		yy_delete_buffer(YY_CURRENT_BUFFER  );
2424		YY_CURRENT_BUFFER_LVALUE = NULL;
2425		yypop_buffer_state();
2426	}
2427
2428	/* Destroy the stack itself. */
2429	yyfree((yy_buffer_stack) );
2430	(yy_buffer_stack) = NULL;
2431
2432    /* Destroy the start condition stack. */
2433        yyfree((yy_start_stack)  );
2434        (yy_start_stack) = NULL;
2435
2436    /* Reset the globals. This is important in a non-reentrant scanner so the next time
2437     * yylex() is called, initialization will occur. */
2438    yy_init_globals( );
2439
2440    return 0;
2441}
2442
2443/*
2444 * Internal utility routines.
2445 */
2446
2447#ifndef yytext_ptr
2448static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
2449{
2450	register int i;
2451	for ( i = 0; i < n; ++i )
2452		s1[i] = s2[i];
2453}
2454#endif
2455
2456#ifdef YY_NEED_STRLEN
2457static int yy_flex_strlen (yyconst char * s )
2458{
2459	register int n;
2460	for ( n = 0; s[n]; ++n )
2461		;
2462
2463	return n;
2464}
2465#endif
2466
2467void *yyalloc (yy_size_t  size )
2468{
2469	return (void *) malloc( size );
2470}
2471
2472void *yyrealloc  (void * ptr, yy_size_t  size )
2473{
2474	/* The cast to (char *) in the following accommodates both
2475	 * implementations that use char* generic pointers, and those
2476	 * that use void* generic pointers.  It works with the latter
2477	 * because both ANSI C and C++ allow castless assignment from
2478	 * any pointer type to void*, and deal with argument conversions
2479	 * as though doing an assignment.
2480	 */
2481	return (void *) realloc( (char *) ptr, size );
2482}
2483
2484void yyfree (void * ptr )
2485{
2486	free( (char *) ptr );	/* see yyrealloc() for (char *) cast */
2487}
2488
2489#define YYTABLES_NAME "yytables"
2490
2491#line 222 "scanner.l"