The Tor Browser: gfx/angle/src/compiler/glslang_lex.cpp@129ffea94266 (annotated)

gfx/angle/src/compiler/glslang_lex.cpp@129ffea94266 (annotated)

gfx/angle/src/compiler/glslang_lex.cpp

Sat, 03 Jan 2015 20:18:00 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Sat, 03 Jan 2015 20:18:00 +0100
branch: TOR_BUG_3246
changeset 7: 129ffea94266
permissions: -rw-r--r--

Conditionally enable double key logic according to:
private browsing mode or privacy.thirdparty.isolate preference and
implement in GetCookieStringCommon and FindCookie where it counts...
With some reservations of how to convince FindCookie users to test
condition and pass a nullptr when disabling double key logic.

 #line 17 "./glslang.l"
 //
 // Copyright (c) 2012 The ANGLE Project Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 //
 // This file is auto-generated by generate_parser.sh. DO NOT EDIT!
 // Ignore errors in auto-generated code.
 #if defined(__GNUC__)
 #pragma GCC diagnostic ignored "-Wunused-function"
 #pragma GCC diagnostic ignored "-Wunused-variable"
 #pragma GCC diagnostic ignored "-Wswitch-enum"
 #elif defined(_MSC_VER)
 #pragma warning(disable: 4065)
 #pragma warning(disable: 4189)
 #pragma warning(disable: 4505)
 #pragma warning(disable: 4701)
 #endif
 #line 25 "./glslang_lex.cpp"
 #define  YY_INT_ALIGNED short int
 /* A lexical scanner generated by flex */
 #define FLEX_SCANNER
 #define YY_FLEX_MAJOR_VERSION 2
 #define YY_FLEX_MINOR_VERSION 5
 #define YY_FLEX_SUBMINOR_VERSION 35
 #if YY_FLEX_SUBMINOR_VERSION > 0
 #define FLEX_BETA
 #endif
 /* First, we deal with  platform-specific or compiler-specific issues. */
 /* begin standard C headers. */
 #include <stdio.h>
 #include <string.h>
 #include <errno.h>
 #include <stdlib.h>
 /* end standard C headers. */
 /* flex integer type definitions */
 #ifndef FLEXINT_H
 #define FLEXINT_H
 /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
 #if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
 /* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
  * if you want the limit (max/min) macros for int types.
  */
 #ifndef __STDC_LIMIT_MACROS
 #define __STDC_LIMIT_MACROS 1
 #endif
 #include <inttypes.h>
 typedef int8_t flex_int8_t;
 typedef uint8_t flex_uint8_t;
 typedef int16_t flex_int16_t;
 typedef uint16_t flex_uint16_t;
 typedef int32_t flex_int32_t;
 typedef uint32_t flex_uint32_t;
 typedef uint64_t flex_uint64_t;
 #else
 typedef signed char flex_int8_t;
 typedef short int flex_int16_t;
 typedef int flex_int32_t;
 typedef unsigned char flex_uint8_t;
 typedef unsigned short int flex_uint16_t;
 typedef unsigned int flex_uint32_t;
 #endif /* ! C99 */
 /* Limits of integral types. */
 #ifndef INT8_MIN
 #define INT8_MIN               (-128)
 #endif
 #ifndef INT16_MIN
 #define INT16_MIN              (-32767-1)
 #endif
 #ifndef INT32_MIN
 #define INT32_MIN              (-2147483647-1)
 #endif
 #ifndef INT8_MAX
 #define INT8_MAX               (127)
 #endif
 #ifndef INT16_MAX
 #define INT16_MAX              (32767)
 #endif
 #ifndef INT32_MAX
 #define INT32_MAX              (2147483647)
 #endif
 #ifndef UINT8_MAX
 #define UINT8_MAX              (255U)
 #endif
 #ifndef UINT16_MAX
 #define UINT16_MAX             (65535U)
 #endif
 #ifndef UINT32_MAX
 #define UINT32_MAX             (4294967295U)
 #endif
 #endif /* ! FLEXINT_H */
 #ifdef __cplusplus
 /* The "const" storage-class-modifier is valid. */
 #define YY_USE_CONST
 #else	/* ! __cplusplus */
 /* C99 requires __STDC__ to be defined as 1. */
 #if defined (__STDC__)
 #define YY_USE_CONST
 #endif	/* defined (__STDC__) */
 #endif	/* ! __cplusplus */
 #ifdef YY_USE_CONST
 #define yyconst const
 #else
 #define yyconst
 #endif
 /* Returned upon end-of-file. */
 #define YY_NULL 0
 /* Promotes a possibly negative, possibly signed char to an unsigned
  * integer for use as an array index.  If the signed char is negative,
  * 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)
 /* An opaque pointer. */
 #ifndef YY_TYPEDEF_YY_SCANNER_T
 #define YY_TYPEDEF_YY_SCANNER_T
 typedef void* yyscan_t;
 #endif
 /* For convenience, these vars (plus the bison vars far below)
    are macros in the reentrant scanner. */
 #define yyin yyg->yyin_r
 #define yyout yyg->yyout_r
 #define yyextra yyg->yyextra_r
 #define yyleng yyg->yyleng_r
 #define yytext yyg->yytext_r
 #define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
 #define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
 #define yy_flex_debug yyg->yy_flex_debug_r
 /* 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
  * definition of BEGIN.
  */
 #define BEGIN yyg->yy_start = 1 + 2 *
 /* 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
  * compatibility.
  */
 #define YY_START ((yyg->yy_start - 1) / 2)
 #define YYSTATE YY_START
 /* Action number for EOF rule of a given start state. */
 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
 /* Special action meaning "start processing a new file". */
 #define YY_NEW_FILE yyrestart(yyin ,yyscanner )
 #define YY_END_OF_BUFFER_CHAR 0
 /* Size of default input buffer. */
 #ifndef YY_BUF_SIZE
 #define YY_BUF_SIZE 16384
 #endif
 /* The state buf must be large enough to hold one state per character in the main buffer.
  */
 #define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
 #ifndef YY_TYPEDEF_YY_BUFFER_STATE
 #define YY_TYPEDEF_YY_BUFFER_STATE
 typedef struct yy_buffer_state *YY_BUFFER_STATE;
 #endif
 #ifndef YY_TYPEDEF_YY_SIZE_T
 #define YY_TYPEDEF_YY_SIZE_T
 typedef size_t yy_size_t;
 #endif
 #define EOB_ACT_CONTINUE_SCAN 0
 #define EOB_ACT_END_OF_FILE 1
 #define EOB_ACT_LAST_MATCH 2
     /* Note: We specifically omit the test for yy_rule_can_match_eol because it requires
      *       access to the local variable yy_act. Since yyless() is a macro, it would break
      *       existing scanners that call yyless() from OUTSIDE yylex.
      *       One obvious solution it to make yy_act a global. I tried that, and saw
      *       a 5% performance hit in a non-yylineno scanner, because yy_act is
      *       normally declared as a register variable-- so it is not worth it.
      */
     #define  YY_LESS_LINENO(n) \
             do { \
                 yy_size_t yyl;\
                 for ( yyl = n; yyl < yyleng; ++yyl )\
                     if ( yytext[yyl] == '\n' )\
                         --yylineno;\
             }while(0)
 /* Return all but the first "n" matched characters back to the input stream. */
 #define yyless(n) \
 	do \
 		{ \
 		/* Undo effects of setting up yytext. */ \
         int yyless_macro_arg = (n); \
         YY_LESS_LINENO(yyless_macro_arg);\
 		*yy_cp = yyg->yy_hold_char; \
 		YY_RESTORE_YY_MORE_OFFSET \
 		yyg->yy_c_buf_p = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
 		YY_DO_BEFORE_ACTION; /* set up yytext again */ \
 		} \
 	while ( 0 )
 #define unput(c) yyunput( c, yyg->yytext_ptr , yyscanner )
 #ifndef YY_STRUCT_YY_BUFFER_STATE
 #define YY_STRUCT_YY_BUFFER_STATE
 struct yy_buffer_state
 	{
 	FILE *yy_input_file;
 	char *yy_ch_buf;		/* input buffer */
 	char *yy_buf_pos;		/* current position in input buffer */
 	/* Size of input buffer in bytes, not including room for EOB
 	 * characters.
 	 */
 	yy_size_t yy_buf_size;
 	/* Number of characters read into yy_ch_buf, not including EOB
 	 * characters.
 	 */
 	yy_size_t yy_n_chars;
 	/* Whether we "own" the buffer - i.e., we know we created it,
 	 * and can realloc() it to grow it, and should free() it to
 	 * delete it.
 	 */
 	int yy_is_our_buffer;
 	/* Whether this is an "interactive" input source; if so, and
 	 * if we're using stdio for input, then we want to use getc()
 	 * instead of fread(), to make sure we stop fetching input after
 	 * each newline.
 	 */
 	int yy_is_interactive;
 	/* Whether we're considered to be at the beginning of a line.
 	 * If so, '^' rules will be active on the next match, otherwise
 	 * not.
 	 */
 	int yy_at_bol;
     int yy_bs_lineno; /**< The line count. */
     int yy_bs_column; /**< The column count. */
 	/* Whether to try to fill the input buffer when we reach the
 	 * end of it.
 	 */
 	int yy_fill_buffer;
 	int yy_buffer_status;
 #define YY_BUFFER_NEW 0
 #define YY_BUFFER_NORMAL 1
 	/* When an EOF's been seen but there's still some text to process
 	 * then we mark the buffer as YY_EOF_PENDING, to indicate that we
 	 * shouldn't try reading from the input source any more.  We might
 	 * still have a bunch of tokens to match, though, because of
 	 * possible backing-up.
 	 *
 	 * When we actually see the EOF, we change the status to "new"
 	 * (via yyrestart()), so that the user can continue scanning by
 	 * just pointing yyin at a new input file.
 	 */
 #define YY_BUFFER_EOF_PENDING 2
 	};
 #endif /* !YY_STRUCT_YY_BUFFER_STATE */
 /* We provide macros for accessing buffer states in case in the
  * future we want to put the buffer states in a more general
  * "scanner state".
  *
  * Returns the top of the stack, or NULL.
  */
 #define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
                           ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
                           : NULL)
 /* 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.
  */
 #define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
 void yyrestart (FILE *input_file ,yyscan_t yyscanner );
 void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
 YY_BUFFER_STATE yy_create_buffer (FILE *file,int size ,yyscan_t yyscanner );
 void yy_delete_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
 void yy_flush_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
 void yypush_buffer_state (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
 void yypop_buffer_state (yyscan_t yyscanner );
 static void yyensure_buffer_stack (yyscan_t yyscanner );
 static void yy_load_buffer_state (yyscan_t yyscanner );
 static void yy_init_buffer (YY_BUFFER_STATE b,FILE *file ,yyscan_t yyscanner );
 #define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER ,yyscanner)
 YY_BUFFER_STATE yy_scan_buffer (char *base,yy_size_t size ,yyscan_t yyscanner );
 YY_BUFFER_STATE yy_scan_string (yyconst char *yy_str ,yyscan_t yyscanner );
 YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes,yy_size_t len ,yyscan_t yyscanner );
 void *yyalloc (yy_size_t ,yyscan_t yyscanner );
 void *yyrealloc (void *,yy_size_t ,yyscan_t yyscanner );
 void yyfree (void * ,yyscan_t yyscanner );
 #define yy_new_buffer yy_create_buffer
 #define yy_set_interactive(is_interactive) \
 	{ \
 	if ( ! YY_CURRENT_BUFFER ){ \
         yyensure_buffer_stack (yyscanner); \
 		YY_CURRENT_BUFFER_LVALUE =    \
             yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \
 	} \
 	YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
 	}
 #define yy_set_bol(at_bol) \
 	{ \
 	if ( ! YY_CURRENT_BUFFER ){\
         yyensure_buffer_stack (yyscanner); \
 		YY_CURRENT_BUFFER_LVALUE =    \
             yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \
 	} \
 	YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
 	}
 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
 /* Begin user sect3 */
 #define yywrap(n) 1
 #define YY_SKIP_YYWRAP
 typedef unsigned char YY_CHAR;
 typedef int yy_state_type;
 #define yytext_ptr yytext_r
 static yy_state_type yy_get_previous_state (yyscan_t yyscanner );
 static yy_state_type yy_try_NUL_trans (yy_state_type current_state  ,yyscan_t yyscanner);
 static int yy_get_next_buffer (yyscan_t yyscanner );
 static void yy_fatal_error (yyconst char msg[] ,yyscan_t yyscanner );
 /* Done after the current pattern has been matched and before the
  * corresponding action - sets up yytext.
  */
 #define YY_DO_BEFORE_ACTION \
 	yyg->yytext_ptr = yy_bp; \
 	yyleng = (yy_size_t) (yy_cp - yy_bp); \
 	yyg->yy_hold_char = *yy_cp; \
 	*yy_cp = '\0'; \
 	yyg->yy_c_buf_p = yy_cp;
 #define YY_NUM_RULES 147
 #define YY_END_OF_BUFFER 148
 /* This struct is not used in this scanner,
    but its presence is necessary. */
 struct yy_trans_info
 	{
 	flex_int32_t yy_verify;
 	flex_int32_t yy_nxt;
 	};
 static yyconst flex_int16_t yy_accept[443] =
     {   0,
 ,    0,  148,  146,  145,  145,  132,  138,  143,  127,
 ,  136,  135,  124,  133,  131,  137,   96,   96,  125,
 ,  139,  126,  140,  144,   93,  129,  130,  142,   93,
 ,   93,   93,   93,   93,   93,   93,   93,   93,   93,
 ,   93,   93,   93,   93,   93,   93,   93,   93,  122,
 ,  123,  134,  118,  104,  123,  112,  107,  102,  110,
 ,  111,  101,   99,  103,   98,   95,   96,    0,    0,
 ,  122,  129,  119,  115,  117,  116,  120,   93,  108,
 ,   93,   93,   93,   93,   93,   93,   93,   93,   93,
 ,   12,   93,   93,   93,   93,   93,   93,   93,   93,
 ,   93,   93,   93,   93,   15,   17,   93,   93,   93,
 ,   93,   93,   93,   93,   93,   93,   93,   93,   93,
 ,   93,   93,   93,   93,   93,   93,   93,   93,   93,
 ,   93,   93,   93,  109,  113,    0,   98,    0,    0,
 ,   94,  105,  106,   45,   93,   93,   93,   93,   93,
 ,   93,   93,   93,   93,   93,   93,   93,   93,   93,
 ,   93,   93,   13,   93,   93,   93,   93,   93,   93,
 ,   93,   21,   93,   93,   93,   93,   93,   93,   93,
 ,   18,   93,   93,   93,   93,   93,   93,   93,   93,
 ,   93,   93,   93,   93,   93,   93,   93,   93,   93,
 ,   93,   93,   93,   93,    0,   99,    0,   98,   93,
 ,   93,   93,   90,   93,   93,   93,   93,   93,   93,
 ,   16,   48,   93,   93,   93,   64,   93,   93,   53,
 ,   93,   93,   93,   93,   93,   93,   93,   93,   65,
 ,   28,   29,   30,   93,   93,   93,   93,   93,   93,
 ,   93,   93,   93,   93,   93,   93,   93,   93,   93,
 ,   24,   93,   93,   93,   93,   93,   93,   31,   32,
 ,   22,   93,   93,   93,   10,   37,   38,   39,   46,
 ,   93,   93,   93,   93,   77,   78,   79,   93,   25,
 ,   20,   80,   81,   82,    2,   74,   75,   76,   93,
 ,   72,   93,   93,   34,   35,   36,   93,   93,   93,
 ,   93,   93,   93,   93,   93,   66,   93,   93,   93,
 ,   93,   93,   93,   93,   47,   93,   92,   93,   93,
 ,   93,   93,   93,   93,   67,   61,   56,   93,   93,
 ,   93,   93,   73,   52,   93,   59,   27,   93,   89,
 ,   44,   71,   54,   93,   93,   93,   93,   93,   93,
 ,   93,   55,   26,   93,   93,   93,    3,   93,   93,
 ,   93,   93,   49,    8,   93,    9,   93,   93,   11,
 ,   93,   93,   93,   57,   93,   93,   93,   93,   93,
 ,   50,   70,   58,    6,   63,    1,   91,    5,   83,
 ,   84,   93,   93,   93,   93,   93,   93,   93,   93,
 ,   93,   93,   93,   41,   93,   93,   93,   93,   93,
 ,   93,   43,   93,   87,   93,   93,   93,   93,   93,
 ,   93,   86,   93,   93,   93,   93,   93,   93,   42,
 ,    0
     } ;
 static yyconst flex_int32_t yy_ec[256] =
     {   0,
 ,    1,    1,    1,    1,    1,    1,    1,    2,    3,
 ,    2,    2,    1,    1,    1,    1,    1,    1,    1,
 ,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 ,    2,    4,    1,    1,    1,    5,    6,    1,    7,
 ,    9,   10,   11,   12,   13,   14,   15,   16,   17,
 ,   19,   20,   20,   20,   21,   21,   22,   23,   24,
 ,   26,   27,    1,   28,   28,   29,   30,   31,   28,
 ,   32,   32,   32,   32,   32,   32,   32,   33,   32,
 ,   34,   35,   32,   32,   32,   32,   36,   32,   32,
 ,    1,   38,   39,   32,    1,   40,   41,   42,   43,
 ,   45,   46,   47,   48,   32,   49,   50,   51,   52,
 ,   54,   32,   55,   56,   57,   58,   59,   60,   61,
 ,   63,   64,   65,   66,   67,    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,    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
     } ;
 static yyconst flex_int32_t yy_meta[68] =
     {   0,
 ,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 ,    1,    1,    1,    2,    2,    2,    2,    2,    2,
 ,    1,    1,    1,    1,    1,    1,    2,    2,    2,
 ,    3,    3,    3,    3,    3,    1,    1,    1,    2,
 ,    2,    2,    2,    2,    3,    3,    3,    3,    3,
 ,    3,    3,    3,    3,    3,    3,    3,    3,    3,
 ,    3,    3,    1,    1,    1,    1
     } ;
 static yyconst flex_int16_t yy_base[445] =
     {   0,
 ,    0,  587,  588,  588,  588,  561,   43,   64,  588,
 ,  560,   61,  588,   60,   58,  559,   77,   86,  557,
 ,  104,  557,   55,  588,    0,  588,  588,   75,   26,
 ,   82,   83,   73,   93,  528,   97,   95,  527,   44,
 ,  521,  104,  534,  110,  116,   35,  111,  530,  588,
 ,  588,  588,  588,  588,  588,  588,  588,  588,  588,
 ,  588,  588,  165,  588,  172,  202,  211,  233,    0,
 ,  588,  588,  551,  588,  588,  588,  550,    0,  588,
 ,  523,  516,  519,  527,  526,  513,  528,  515,  521,
 ,  506,  519,  506,  503,  503,  509,  497,  108,  502,
 ,  498,  504,  507,  508,    0,  145,  507,  113,  493,
 ,  497,  499,  489,  503,  500,  502,  485,  490,  487,
 ,  157,  484,  489,  485,  487,  476,  479,  118,  484,
 ,  488,   70,  481,  588,  588,  246,  253,  270,  219,
 ,    0,  588,  588,    0,  473,  477,  486,  483,  467,
 ,  119,  482,  479,  479,  477,  474,  466,  472,  459,
 ,  456,  472,    0,  469,  457,  464,  461,  465,  458,
 ,  446,  459,  462,  459,  454,  445,  188,  450,  453,
 ,  441,  445,  451,  442,  433,  436,  434,  444,  430,
 ,  441,  427,  429,  426,  437,  436,  124,  431,  426,
 ,  258,  433,  435,  424,  290,  297,  304,  311,  425,
 ,  423,  275,    0,  415,  413,  421,  410,  427,  416,
 ,    0,    0,  410,  420,  420,    0,  405,  319,    0,
 ,  407,  322,  408,  402,  401,  402,  401,  325,    0,
 ,    0,    0,    0,  397,  398,  403,  394,  407,  402,
 ,  393,  397,  389,  392,  396,  401,  387,  399,  390,
 ,    0,  396,  385,  385,  390,  389,  386,    0,    0,
 ,    0,  376,  388,  390,    0,    0,    0,    0,    0,
 ,  378,  379,  373,  383,    0,    0,    0,  374,    0,
 ,    0,    0,    0,    0,    0,    0,    0,    0,  381,
 ,    0,  379,  375,    0,    0,    0,  371,  367,  372,
 ,  375,  361,  374,  363,  370,    0,  368,  370,  354,
 ,  362,  368,  363,  351,    0,  353,    0,  352,  355,
 ,  344,  343,  343,  356,    0,  358,    0,  357,  356,
 ,  354,  341,    0,    0,  344,    0,    0,  336,    0,
 ,    0,    0,    0,  333,  344,  337,  343,  340,  335,
 ,  339,    0,    0,  332,  339,  328,    0,  337,  334,
 ,  329,  332,    0,    0,  332,    0,  330,  329,    0,
 ,  328,  314,  326,    0,  317,  338,  337,  336,  307,
 ,    0,    0,    0,    0,    0,    0,    0,    0,  328,
 ,  325,  316,  299,  308,  310,  306,  308,  307,  306,
 ,  306,  256,  253,    0,  228,  238,  222,  235,  203,
 ,  204,  212,  191,    0,  201,  165,  167,  153,  161,
 ,  170,    0,  175,  151,  141,  100,  114,   59,    0,
 ,  588,  359,  113
     } ;
 static yyconst flex_int16_t yy_def[445] =
     {   0,
 ,    1,  442,  442,  442,  442,  442,  442,  442,  442,
 ,  442,  442,  442,  442,  442,  442,  442,  442,  442,
 ,  442,  442,  442,  442,  443,  442,  442,  442,  443,
 ,  443,  443,  443,  443,  443,  443,  443,  443,  443,
 ,  443,  443,  443,  443,  443,  443,  443,  443,  442,
 ,  442,  442,  442,  442,  442,  442,  442,  442,  442,
 ,  442,  442,  442,  442,  442,  442,  442,  442,  444,
 ,  442,  442,  442,  442,  442,  442,  442,  443,  442,
 ,  443,  443,  443,  443,  443,  443,  443,  443,  443,
 ,  443,  443,  443,  443,  443,  443,  443,  443,  443,
 ,  443,  443,  443,  443,  443,  443,  443,  443,  443,
 ,  443,  443,  443,  443,  443,  443,  443,  443,  443,
 ,  443,  443,  443,  443,  443,  443,  443,  443,  443,
 ,  443,  443,  443,  442,  442,  442,  442,  442,  442,
 ,  444,  442,  442,  443,  443,  443,  443,  443,  443,
 ,  443,  443,  443,  443,  443,  443,  443,  443,  443,
 ,  443,  443,  443,  443,  443,  443,  443,  443,  443,
 ,  443,  443,  443,  443,  443,  443,  443,  443,  443,
 ,  443,  443,  443,  443,  443,  443,  443,  443,  443,
 ,  443,  443,  443,  443,  443,  443,  443,  443,  443,
 ,  443,  443,  443,  443,  442,  442,  442,  442,  443,
 ,  443,  443,  443,  443,  443,  443,  443,  443,  443,
 ,  443,  443,  443,  443,  443,  443,  443,  443,  443,
 ,  443,  443,  443,  443,  443,  443,  443,  443,  443,
 ,  443,  443,  443,  443,  443,  443,  443,  443,  443,
 ,  443,  443,  443,  443,  443,  443,  443,  443,  443,
 ,  443,  443,  443,  443,  443,  443,  443,  443,  443,
 ,  443,  443,  443,  443,  443,  443,  443,  443,  443,
 ,  443,  443,  443,  443,  443,  443,  443,  443,  443,
 ,  443,  443,  443,  443,  443,  443,  443,  443,  443,
 ,  443,  443,  443,  443,  443,  443,  443,  443,  443,
 ,  443,  443,  443,  443,  443,  443,  443,  443,  443,
 ,  443,  443,  443,  443,  443,  443,  443,  443,  443,
 ,  443,  443,  443,  443,  443,  443,  443,  443,  443,
 ,  443,  443,  443,  443,  443,  443,  443,  443,  443,
 ,  443,  443,  443,  443,  443,  443,  443,  443,  443,
 ,  443,  443,  443,  443,  443,  443,  443,  443,  443,
 ,  443,  443,  443,  443,  443,  443,  443,  443,  443,
 ,  443,  443,  443,  443,  443,  443,  443,  443,  443,
 ,  443,  443,  443,  443,  443,  443,  443,  443,  443,
 ,  443,  443,  443,  443,  443,  443,  443,  443,  443,
 ,  443,  443,  443,  443,  443,  443,  443,  443,  443,
 ,  443,  443,  443,  443,  443,  443,  443,  443,  443,
 ,  443,  443,  443,  443,  443,  443,  443,  443,  443,
 ,    0,  442,  442
     } ;
 static yyconst flex_int16_t yy_nxt[656] =
     {   0,
 ,    5,    6,    7,    8,    9,   10,   11,   12,   13,
 ,   15,   16,   17,   18,   19,   19,   19,   19,   19,
 ,   20,   21,   22,   23,   24,   25,   26,   26,   26,
 ,   26,   26,   26,   26,   26,   27,   28,   29,   30,
 ,   32,   33,   34,   35,   36,   37,   38,   26,   39,
 ,   41,   42,   43,   44,   45,   46,   47,   48,   49,
 ,   26,   26,   50,   51,   52,   53,   55,   56,   57,
 ,   62,   64,   64,   64,   64,   64,   64,   64,   77,
 ,   82,   83,  110,   63,   61,  129,  111,   58,   66,
 ,   67,   67,   67,   67,   67,   67,   68,   66,   80,
 ,   68,   68,   68,   68,   68,   68,   69,   72,   84,
 ,   85,   70,   81,  142,   86,   69,  203,  441,  204,
 ,   87,   94,  113,   95,   73,   90,   74,   75,   69,
 ,   88,   97,   96,   89,   92,  103,   70,  135,  106,
 ,   93,   99,  115,  104,  100,  107,  162,  440,  119,
 ,  101,  439,  108,  132,  105,  120,  121,  116,  125,
 ,  117,  126,  133,  176,  198,  122,  123,  264,  124,
 ,  438,  177,  199,  216,  217,  265,  128,  136,   64,
 ,   64,   64,   64,   64,   64,  138,  138,  138,  138,
 ,  138,  138,  437,  170,  137,  190,  171,  172,  406,
 ,  173,  139,  174,  242,  243,  244,  436,  137,  435,
 ,  191,  433,  432,   66,  139,   67,   67,   67,   67,
 ,   67,   68,   66,  431,   68,   68,   68,   68,   68,
 ,   68,   69,  141,  141,  141,  141,  141,  141,  141,
 ,   69,  140,  429,  140,   69,  428,  141,  141,  141,
 ,  141,  141,  141,   69,  206,  427,  206,  426,  425,
 ,  207,  207,  207,  207,  207,  207,  138,  138,  138,
 ,  138,  138,  138,  269,  270,  271,  424,  423,  208,
 ,  208,  421,  139,  209,  209,  209,  209,  209,  209,
 ,  277,  278,  279,  420,  419,  139,  141,  141,  141,
 ,  141,  141,  141,  207,  207,  207,  207,  207,  207,
 ,  207,  207,  207,  207,  207,  207,  207,  209,  209,
 ,  209,  209,  209,  209,  209,  209,  209,  209,  209,
 ,  209,  286,  287,  288,  293,  294,  295,  297,  298,
 ,  305,  306,  307,  387,  388,  389,  418,  417,  416,
 ,  414,  413,  412,  411,  410,  409,  390,  408,  391,
 ,   79,  405,  404,  403,  402,  401,  400,  399,  398,
 ,  396,  395,  394,  393,  392,  386,  385,  384,  383,
 ,  381,  380,  379,  378,  377,  376,  375,  374,  373,
 ,  371,  370,  369,  368,  367,  366,  365,  364,  363,
 ,  361,  360,  359,  358,  357,  356,  355,  354,  353,
 ,  351,  350,  349,  348,  347,  346,  345,  344,  343,
 ,  341,  340,  339,  338,  337,  336,  335,  334,  333,
 ,  331,  330,  329,  328,  327,  326,  325,  324,  323,
 ,  321,  320,  319,  318,  317,  316,  315,  314,  313,
 ,  311,  310,  309,  308,  304,  303,  302,  301,  300,
 ,  292,  291,  290,  289,  285,  284,  283,  282,  281,
 ,  276,  275,  274,  273,  272,  268,  267,  266,  263,
 ,  261,  260,  259,  258,  257,  256,  255,  254,  253,
 ,  251,  250,  249,  248,  247,  246,  245,  241,  240,
 ,  238,  237,  236,  235,  234,  233,  232,  231,  230,
 ,  228,  227,  226,  225,  224,  223,  222,  221,  220,
 ,  218,  215,  214,  213,  212,  211,  210,  205,  202,
 ,  200,  197,  196,  195,  194,  193,  192,  189,  188,
 ,  186,  185,  184,  183,  182,  181,  180,  179,  178,
 ,  169,  168,  167,  166,  165,  164,  161,  160,  159,
 ,  157,  156,  155,  154,  153,  152,  151,  150,  149,
 ,  147,  146,  145,  144,  143,  134,  118,  114,  109,
 ,   76,   71,   65,   59,   54,  442,    3,  442,  442,
 ,  442,  442,  442,  442,  442,  442,  442,  442,  442,
 ,  442,  442,  442,  442,  442,  442,  442,  442,  442,
 ,  442,  442,  442,  442,  442,  442,  442,  442,  442,
 ,  442,  442,  442,  442,  442,  442,  442,  442,  442,
 ,  442,  442,  442,  442,  442,  442,  442,  442,  442,
 ,  442,  442,  442,  442,  442,  442,  442,  442,  442,
 ,  442,  442,  442,  442
     } ;
 static yyconst flex_int16_t yy_chk[656] =
     {   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,    8,    8,    9,
 ,   15,   16,   16,   16,   16,   16,   16,   16,   24,
 ,   30,   30,   40,   15,   13,   47,   40,    9,   18,
 ,   18,   18,   18,   18,   18,   18,   18,   19,   29,
 ,   19,   19,   19,   19,   19,   19,   18,   22,   31,
 ,   31,   18,   29,  444,   31,   19,  133,  439,  133,
 ,   32,   34,   41,   34,   22,   33,   22,   22,   19,
 ,   32,   35,   34,   32,   33,   37,   18,   51,   38,
 ,   33,   35,   43,   37,   35,   38,   99,  438,   45,
 ,   35,  437,   38,   48,   37,   45,   45,   43,   46,
 ,   43,   46,   48,  109,  129,   45,   45,  198,   45,
 ,  436,  109,  129,  152,  152,  198,   46,   51,   64,
 ,   64,   64,   64,   64,   64,   66,   66,   66,   66,
 ,   66,   66,  435,  107,   64,  122,  107,  107,  401,
 ,  107,   66,  107,  178,  178,  178,  434,   64,  432,
 ,  122,  429,  428,   67,   66,   67,   67,   67,   67,
 ,   67,   67,   68,  427,   68,   68,   68,   68,   68,
 ,   68,   67,  140,  140,  140,  140,  140,  140,  140,
 ,   68,   69,  424,   69,   67,  423,   69,   69,   69,
 ,   69,   69,   69,   68,  137,  422,  137,  421,  420,
 ,  137,  137,  137,  137,  137,  137,  138,  138,  138,
 ,  138,  138,  138,  202,  202,  202,  419,  418,  139,
 ,  139,  416,  138,  139,  139,  139,  139,  139,  139,
 ,  213,  213,  213,  414,  413,  138,  141,  141,  141,
 ,  141,  141,  141,  206,  206,  206,  206,  206,  206,
 ,  207,  207,  207,  207,  207,  207,  207,  208,  208,
 ,  208,  208,  208,  208,  209,  209,  209,  209,  209,
 ,  209,  221,  221,  221,  229,  229,  229,  233,  233,
 ,  239,  239,  239,  372,  372,  372,  412,  411,  410,
 ,  408,  407,  406,  405,  404,  403,  372,  402,  372,
 ,  443,  400,  391,  390,  389,  388,  387,  386,  384,
 ,  382,  379,  378,  376,  373,  371,  370,  369,  367,
 ,  365,  362,  361,  360,  359,  358,  357,  356,  355,
 ,  346,  343,  342,  341,  340,  339,  337,  335,  334,
 ,  332,  330,  329,  327,  325,  324,  323,  322,  321,
 ,  319,  318,  316,  315,  314,  313,  312,  311,  310,
 ,  308,  304,  303,  300,  289,  285,  284,  283,  282,
 ,  274,  273,  268,  267,  266,  265,  264,  263,  260,
 ,  258,  257,  256,  255,  254,  253,  252,  251,  250,
 ,  248,  247,  246,  245,  238,  237,  236,  235,  234,
 ,  228,  226,  225,  224,  220,  219,  218,  217,  216,
 ,  212,  210,  205,  204,  203,  201,  200,  199,  197,
 ,  195,  194,  193,  192,  191,  190,  189,  188,  187,
 ,  185,  184,  183,  182,  181,  180,  179,  177,  176,
 ,  174,  173,  172,  171,  170,  169,  168,  167,  166,
 ,  163,  162,  161,  160,  159,  158,  157,  156,  155,
 ,  153,  151,  150,  149,  148,  147,  146,  134,  132,
 ,  130,  128,  127,  126,  125,  124,  123,  121,  120,
 ,  118,  117,  116,  115,  114,  113,  112,  111,  110,
 ,  105,  104,  103,  102,  101,  100,   98,   97,   96,
 ,   94,   93,   92,   91,   90,   89,   88,   87,   86,
 ,   84,   83,   82,   78,   74,   49,   44,   42,   39,
 ,   23,   20,   17,   12,    7,    3,  442,  442,  442,
 ,  442,  442,  442,  442,  442,  442,  442,  442,  442,
 ,  442,  442,  442,  442,  442,  442,  442,  442,  442,
 ,  442,  442,  442,  442,  442,  442,  442,  442,  442,
 ,  442,  442,  442,  442,  442,  442,  442,  442,  442,
 ,  442,  442,  442,  442,  442,  442,  442,  442,  442,
 ,  442,  442,  442,  442,  442,  442,  442,  442,  442,
 ,  442,  442,  442,  442
     } ;
 /* Table of booleans, true if rule could match eol. */
 static yyconst flex_int32_t yy_rule_can_match_eol[148] =
     {   0,
 , 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 , 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 , 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 , 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 , 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 , 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 , 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 , 0, 0, 0, 0, 1, 0, 0,     };
 /* The intent behind this definition is that it'll catch
  * any uses of REJECT which flex missed.
  */
 #define REJECT reject_used_but_not_detected
 #define yymore() yymore_used_but_not_detected
 #define YY_MORE_ADJ 0
 #define YY_RESTORE_YY_MORE_OFFSET
 /*
 //
 // Copyright (c) 2002-2012 The ANGLE Project Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 //
 This file contains the Lex specification for GLSL ES.
 Based on ANSI C grammar, Lex specification:
 http://www.lysator.liu.se/c/ANSI-C-grammar-l.html
 IF YOU MODIFY THIS FILE YOU ALSO NEED TO RUN generate_parser.sh,
 WHICH GENERATES THE GLSL ES LEXER (glslang_lex.cpp).
 */
 #include "compiler/glslang.h"
 #include "compiler/ParseHelper.h"
 #include "compiler/preprocessor/Token.h"
 #include "compiler/util.h"
 #include "glslang_tab.h"
 /* windows only pragma */
 #ifdef _MSC_VER
 #pragma warning(disable : 4102)
 #endif
 #define YY_USER_ACTION                                 \
     yylloc->first_file = yylloc->last_file = yycolumn; \
     yylloc->first_line = yylloc->last_line = yylineno;
 #define YY_INPUT(buf, result, max_size) \
     result = string_input(buf, max_size, yyscanner);
 static yy_size_t string_input(char* buf, yy_size_t max_size, yyscan_t yyscanner);
 static int check_type(yyscan_t yyscanner);
 static int reserved_word(yyscan_t yyscanner);
 #define INITIAL 0
 #define YY_EXTRA_TYPE TParseContext*
 /* Holds the entire state of the reentrant scanner. */
 struct yyguts_t
     {
     /* User-defined. Not touched by flex. */
     YY_EXTRA_TYPE yyextra_r;
     /* The rest are the same as the globals declared in the non-reentrant scanner. */
     FILE *yyin_r, *yyout_r;
     size_t yy_buffer_stack_top; /**< index of top of stack. */
     size_t yy_buffer_stack_max; /**< capacity of stack. */
     YY_BUFFER_STATE * yy_buffer_stack; /**< Stack as an array. */
     char yy_hold_char;
     yy_size_t yy_n_chars;
     yy_size_t yyleng_r;
     char *yy_c_buf_p;
     int yy_init;
     int yy_start;
     int yy_did_buffer_switch_on_eof;
     int yy_start_stack_ptr;
     int yy_start_stack_depth;
     int *yy_start_stack;
     yy_state_type yy_last_accepting_state;
     char* yy_last_accepting_cpos;
     int yylineno_r;
     int yy_flex_debug_r;
     char *yytext_r;
     int yy_more_flag;
     int yy_more_len;
     YYSTYPE * yylval_r;
     YYLTYPE * yylloc_r;
     }; /* end struct yyguts_t */
 static int yy_init_globals (yyscan_t yyscanner );
     /* This must go here because YYSTYPE and YYLTYPE are included
      * from bison output in section 1.*/
     #    define yylval yyg->yylval_r
     #    define yylloc yyg->yylloc_r
 int yylex_init (yyscan_t* scanner);
 int yylex_init_extra (YY_EXTRA_TYPE user_defined,yyscan_t* scanner);
 /* Accessor methods to globals.
    These are made visible to non-reentrant scanners for convenience. */
 int yylex_destroy (yyscan_t yyscanner );
 int yyget_debug (yyscan_t yyscanner );
 void yyset_debug (int debug_flag ,yyscan_t yyscanner );
 YY_EXTRA_TYPE yyget_extra (yyscan_t yyscanner );
 void yyset_extra (YY_EXTRA_TYPE user_defined ,yyscan_t yyscanner );
 FILE *yyget_in (yyscan_t yyscanner );
 void yyset_in  (FILE * in_str ,yyscan_t yyscanner );
 FILE *yyget_out (yyscan_t yyscanner );
 void yyset_out  (FILE * out_str ,yyscan_t yyscanner );
 yy_size_t yyget_leng (yyscan_t yyscanner );
 char *yyget_text (yyscan_t yyscanner );
 int yyget_lineno (yyscan_t yyscanner );
 void yyset_lineno (int line_number ,yyscan_t yyscanner );
 YYSTYPE * yyget_lval (yyscan_t yyscanner );
 void yyset_lval (YYSTYPE * yylval_param ,yyscan_t yyscanner );
        YYLTYPE *yyget_lloc (yyscan_t yyscanner );
         void yyset_lloc (YYLTYPE * yylloc_param ,yyscan_t yyscanner );
 /* Macros after this point can all be overridden by user definitions in
  * section 1.
  */
 #ifndef YY_SKIP_YYWRAP
 #ifdef __cplusplus
 extern "C" int yywrap (yyscan_t yyscanner );
 #else
 extern int yywrap (yyscan_t yyscanner );
 #endif
 #endif
 #ifndef yytext_ptr
 static void yy_flex_strncpy (char *,yyconst char *,int ,yyscan_t yyscanner);
 #endif
 #ifdef YY_NEED_STRLEN
 static int yy_flex_strlen (yyconst char * ,yyscan_t yyscanner);
 #endif
 #ifndef YY_NO_INPUT
 #ifdef __cplusplus
 static int yyinput (yyscan_t yyscanner );
 #else
 static int input (yyscan_t yyscanner );
 #endif
 #endif
 /* Amount of stuff to slurp up with each read. */
 #ifndef YY_READ_BUF_SIZE
 #define YY_READ_BUF_SIZE 8192
 #endif
 /* Copy whatever the last rule matched to the standard output. */
 #ifndef ECHO
 /* This used to be an fputs(), but since the string might contain NUL's,
  * we now use fwrite().
  */
 #define ECHO fwrite( yytext, yyleng, 1, yyout )
 #endif
 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
  * is returned in "result".
  */
 #ifndef YY_INPUT
 #define YY_INPUT(buf,result,max_size) \
 	if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
 		{ \
 		int c = '*'; \
 		yy_size_t n; \
 		for ( n = 0; n < max_size && \
 			     (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
 			buf[n] = (char) c; \
 		if ( c == '\n' ) \
 			buf[n++] = (char) c; \
 		if ( c == EOF && ferror( yyin ) ) \
 			YY_FATAL_ERROR( "input in flex scanner failed" ); \
 		result = n; \
 		} \
 	else \
 		{ \
 		errno=0; \
 		while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
 			{ \
 			if( errno != EINTR) \
 				{ \
 				YY_FATAL_ERROR( "input in flex scanner failed" ); \
 				break; \
 				} \
 			errno=0; \
 			clearerr(yyin); \
 			} \
 		}\
 \
 #endif
 /* No semi-colon after return; correct usage is to write "yyterminate();" -
  * we don't want an extra ';' after the "return" because that will cause
  * some compilers to complain about unreachable statements.
  */
 #ifndef yyterminate
 #define yyterminate() return YY_NULL
 #endif
 /* Number of entries by which start-condition stack grows. */
 #ifndef YY_START_STACK_INCR
 #define YY_START_STACK_INCR 25
 #endif
 /* Report a fatal error. */
 #ifndef YY_FATAL_ERROR
 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner)
 #endif
 /* end tables serialization structures and prototypes */
 /* Default declaration of generated scanner - a define so the user can
  * easily add parameters.
  */
 #ifndef YY_DECL
 #define YY_DECL_IS_OURS 1
 extern int yylex \
                (YYSTYPE * yylval_param,YYLTYPE * yylloc_param ,yyscan_t yyscanner);
 #define YY_DECL int yylex \
                (YYSTYPE * yylval_param, YYLTYPE * yylloc_param , yyscan_t yyscanner)
 #endif /* !YY_DECL */
 /* Code executed at the beginning of each rule, after yytext and yyleng
  * have been set up.
  */
 #ifndef YY_USER_ACTION
 #define YY_USER_ACTION
 #endif
 /* Code executed at the end of each rule. */
 #ifndef YY_BREAK
 #define YY_BREAK break;
 #endif
 #define YY_RULE_SETUP \
 	YY_USER_ACTION
 /** The main scanner function which does all the work.
  */
 YY_DECL
 {
 	register yy_state_type yy_current_state;
 	register char *yy_cp, *yy_bp;
 	register int yy_act;
     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
     yylval = yylval_param;
     yylloc = yylloc_param;
 	if ( !yyg->yy_init )
 		{
 		yyg->yy_init = 1;
 #ifdef YY_USER_INIT
 		YY_USER_INIT;
 #endif
 		if ( ! yyg->yy_start )
 			yyg->yy_start = 1;	/* first start state */
 		if ( ! yyin )
 			yyin = stdin;
 		if ( ! yyout )
 			yyout = stdout;
 		if ( ! YY_CURRENT_BUFFER ) {
 			yyensure_buffer_stack (yyscanner);
 			YY_CURRENT_BUFFER_LVALUE =
 				yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
 		}
 		yy_load_buffer_state(yyscanner );
 		}
 	while ( 1 )		/* loops until end-of-file is reached */
 		{
 		yy_cp = yyg->yy_c_buf_p;
 		/* Support of yytext. */
 		*yy_cp = yyg->yy_hold_char;
 		/* yy_bp points to the position in yy_ch_buf of the start of
 		 * the current run.
 		 */
 		yy_bp = yy_cp;
 		yy_current_state = yyg->yy_start;
 yy_match:
 		do
 			{
 			register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
 			if ( yy_accept[yy_current_state] )
 				{
 				yyg->yy_last_accepting_state = yy_current_state;
 				yyg->yy_last_accepting_cpos = yy_cp;
 				}
 			while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
 				{
 				yy_current_state = (int) yy_def[yy_current_state];
 				if ( yy_current_state >= 443 )
 					yy_c = yy_meta[(unsigned int) yy_c];
 				}
 			yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
 			++yy_cp;
 			}
 		while ( yy_current_state != 442 );
 		yy_cp = yyg->yy_last_accepting_cpos;
 		yy_current_state = yyg->yy_last_accepting_state;
 yy_find_action:
 		yy_act = yy_accept[yy_current_state];
 		YY_DO_BEFORE_ACTION;
 		if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] )
 			{
 			yy_size_t yyl;
 			for ( yyl = 0; yyl < yyleng; ++yyl )
 				if ( yytext[yyl] == '\n' )
     do{ yylineno++;
         yycolumn=0;
     }while(0)
 ;
 			}
 do_action:	/* This label is used only to access EOF actions. */
 		switch ( yy_act )
 	{ /* beginning of action switch */
 			case 0: /* must back up */
 			/* undo the effects of YY_DO_BEFORE_ACTION */
 			*yy_cp = yyg->yy_hold_char;
 			yy_cp = yyg->yy_last_accepting_cpos;
 			yy_current_state = yyg->yy_last_accepting_state;
 			goto yy_find_action;
 case 1:
 YY_RULE_SETUP
 { return INVARIANT; }
 	YY_BREAK
 case 2:
 YY_RULE_SETUP
 { return HIGH_PRECISION; }
 	YY_BREAK
 case 3:
 YY_RULE_SETUP
 { return MEDIUM_PRECISION; }
 	YY_BREAK
 case 4:
 YY_RULE_SETUP
 { return LOW_PRECISION; }
 	YY_BREAK
 case 5:
 YY_RULE_SETUP
 { return PRECISION; }
 	YY_BREAK
 case 6:
 YY_RULE_SETUP
 { return ATTRIBUTE; }
 	YY_BREAK
 case 7:
 YY_RULE_SETUP
 { return CONST_QUAL; }
 	YY_BREAK
 case 8:
 YY_RULE_SETUP
 { return UNIFORM; }
 	YY_BREAK
 case 9:
 YY_RULE_SETUP
 { return VARYING; }
 	YY_BREAK
 case 10:
 YY_RULE_SETUP
 { return BREAK; }
 	YY_BREAK
 case 11:
 YY_RULE_SETUP
 { return CONTINUE; }
 	YY_BREAK
 case 12:
 YY_RULE_SETUP
 { return DO; }
 	YY_BREAK
 case 13:
 YY_RULE_SETUP
 { return FOR; }
 	YY_BREAK
 case 14:
 YY_RULE_SETUP
 { return WHILE; }
 	YY_BREAK
 case 15:
 YY_RULE_SETUP
 { return IF; }
 	YY_BREAK
 case 16:
 YY_RULE_SETUP
 { return ELSE; }
 	YY_BREAK
 case 17:
 YY_RULE_SETUP
 { return IN_QUAL; }
 	YY_BREAK
 case 18:
 YY_RULE_SETUP
 { return OUT_QUAL; }
 	YY_BREAK
 case 19:
 YY_RULE_SETUP
 { return INOUT_QUAL; }
 	YY_BREAK
 case 20:
 YY_RULE_SETUP
 { return FLOAT_TYPE; }
 	YY_BREAK
 case 21:
 YY_RULE_SETUP
 { return INT_TYPE; }
 	YY_BREAK
 case 22:
 YY_RULE_SETUP
 { return VOID_TYPE; }
 	YY_BREAK
 case 23:
 YY_RULE_SETUP
 { return BOOL_TYPE; }
 	YY_BREAK
 case 24:
 YY_RULE_SETUP
 { yylval->lex.b = true;  return BOOLCONSTANT; }
 	YY_BREAK
 case 25:
 YY_RULE_SETUP
 { yylval->lex.b = false; return BOOLCONSTANT; }
 	YY_BREAK
 case 26:
 YY_RULE_SETUP
 { return DISCARD; }
 	YY_BREAK
 case 27:
 YY_RULE_SETUP
 { return RETURN; }
 	YY_BREAK
 case 28:
 YY_RULE_SETUP
 { return MATRIX2; }
 	YY_BREAK
 case 29:
 YY_RULE_SETUP
 { return MATRIX3; }
 	YY_BREAK
 case 30:
 YY_RULE_SETUP
 { return MATRIX4; }
 	YY_BREAK
 case 31:
 YY_RULE_SETUP
 { return VEC2; }
 	YY_BREAK
 case 32:
 YY_RULE_SETUP
 { return VEC3; }
 	YY_BREAK
 case 33:
 YY_RULE_SETUP
 { return VEC4; }
 	YY_BREAK
 case 34:
 YY_RULE_SETUP
 { return IVEC2; }
 	YY_BREAK
 case 35:
 YY_RULE_SETUP
 { return IVEC3; }
 	YY_BREAK
 case 36:
 YY_RULE_SETUP
 { return IVEC4; }
 	YY_BREAK
 case 37:
 YY_RULE_SETUP
 { return BVEC2; }
 	YY_BREAK
 case 38:
 YY_RULE_SETUP
 { return BVEC3; }
 	YY_BREAK
 case 39:
 YY_RULE_SETUP
 { return BVEC4; }
 	YY_BREAK
 case 40:
 YY_RULE_SETUP
 { return SAMPLER2D; }
 	YY_BREAK
 case 41:
 YY_RULE_SETUP
 { return SAMPLERCUBE; }
 	YY_BREAK
 case 42:
 YY_RULE_SETUP
 { return SAMPLER_EXTERNAL_OES; }
 	YY_BREAK
 case 43:
 YY_RULE_SETUP
 { return SAMPLER2DRECT; }
 	YY_BREAK
 case 44:
 YY_RULE_SETUP
 { return STRUCT; }
 	YY_BREAK
 case 45:
 YY_RULE_SETUP
 { return reserved_word(yyscanner); }
 	YY_BREAK
 case 46:
 YY_RULE_SETUP
 { return reserved_word(yyscanner); }
 	YY_BREAK
 case 47:
 YY_RULE_SETUP
 { return reserved_word(yyscanner); }
 	YY_BREAK
 case 48:
 YY_RULE_SETUP
 { return reserved_word(yyscanner); }
 	YY_BREAK
 case 49:
 YY_RULE_SETUP
 { return reserved_word(yyscanner); }
 	YY_BREAK
 case 50:
 YY_RULE_SETUP
 { return reserved_word(yyscanner); }
 	YY_BREAK
 case 51:
 YY_RULE_SETUP
 { return reserved_word(yyscanner); }
 	YY_BREAK
 case 52:
 YY_RULE_SETUP
 { return reserved_word(yyscanner); }
 	YY_BREAK
 case 53:
 YY_RULE_SETUP
 { return reserved_word(yyscanner); }
 	YY_BREAK
 case 54:
 YY_RULE_SETUP
 { return reserved_word(yyscanner); }
 	YY_BREAK
 case 55:
 YY_RULE_SETUP
 { return reserved_word(yyscanner); }
 	YY_BREAK
 case 56:
 YY_RULE_SETUP
 { return reserved_word(yyscanner); }
 	YY_BREAK
 case 57:
 YY_RULE_SETUP
 { return reserved_word(yyscanner); }
 	YY_BREAK
 case 58:
 YY_RULE_SETUP
 { return reserved_word(yyscanner); }
 	YY_BREAK
 case 59:
 YY_RULE_SETUP
 { return reserved_word(yyscanner); }
 	YY_BREAK
 case 60:
 YY_RULE_SETUP
 { return reserved_word(yyscanner); }
 	YY_BREAK
 case 61:
 YY_RULE_SETUP
 { return reserved_word(yyscanner); }
 	YY_BREAK
 case 62:
 YY_RULE_SETUP
 { return reserved_word(yyscanner); }
 	YY_BREAK
 case 63:
 YY_RULE_SETUP
 { return reserved_word(yyscanner); }
 	YY_BREAK
 case 64:
 YY_RULE_SETUP
 { return reserved_word(yyscanner); }
 	YY_BREAK
 case 65:
 YY_RULE_SETUP
 { return reserved_word(yyscanner); }
 	YY_BREAK
 case 66:
 YY_RULE_SETUP
 { return reserved_word(yyscanner); }
 	YY_BREAK
 case 67:
 YY_RULE_SETUP
 { return reserved_word(yyscanner); }
 	YY_BREAK
 case 68:
 YY_RULE_SETUP
 { return reserved_word(yyscanner); }
 	YY_BREAK
 case 69:
 YY_RULE_SETUP
 { return reserved_word(yyscanner); }
 	YY_BREAK
 case 70:
 YY_RULE_SETUP
 { return reserved_word(yyscanner); }
 	YY_BREAK
 case 71:
 YY_RULE_SETUP
 { return reserved_word(yyscanner); }
 	YY_BREAK
 case 72:
 YY_RULE_SETUP
 { return reserved_word(yyscanner); }
 	YY_BREAK
 case 73:
 YY_RULE_SETUP
 { return reserved_word(yyscanner); }
 	YY_BREAK
 case 74:
 YY_RULE_SETUP
 { return reserved_word(yyscanner); }
 	YY_BREAK
 case 75:
 YY_RULE_SETUP
 { return reserved_word(yyscanner); }
 	YY_BREAK
 case 76:
 YY_RULE_SETUP
 { return reserved_word(yyscanner); }
 	YY_BREAK
 case 77:
 YY_RULE_SETUP
 { return reserved_word(yyscanner); }
 	YY_BREAK
 case 78:
 YY_RULE_SETUP
 { return reserved_word(yyscanner); }
 	YY_BREAK
 case 79:
 YY_RULE_SETUP
 { return reserved_word(yyscanner); }
 	YY_BREAK
 case 80:
 YY_RULE_SETUP
 { return reserved_word(yyscanner); }
 	YY_BREAK
 case 81:
 YY_RULE_SETUP
 { return reserved_word(yyscanner); }
 	YY_BREAK
 case 82:
 YY_RULE_SETUP
 { return reserved_word(yyscanner); }
 	YY_BREAK
 case 83:
 YY_RULE_SETUP
 { return reserved_word(yyscanner); }
 	YY_BREAK
 case 84:
 YY_RULE_SETUP
 { return reserved_word(yyscanner); }
 	YY_BREAK
 case 85:
 YY_RULE_SETUP
 { return reserved_word(yyscanner); }
 	YY_BREAK
 case 86:
 YY_RULE_SETUP
 { return reserved_word(yyscanner); }
 	YY_BREAK
 case 87:
 YY_RULE_SETUP
 { return reserved_word(yyscanner); }
 	YY_BREAK
 case 88:
 YY_RULE_SETUP
 { return reserved_word(yyscanner); }
 	YY_BREAK
 case 89:
 YY_RULE_SETUP
 { return reserved_word(yyscanner); }
 	YY_BREAK
 case 90:
 YY_RULE_SETUP
 { return reserved_word(yyscanner); }
 	YY_BREAK
 case 91:
 YY_RULE_SETUP
 { return reserved_word(yyscanner); }
 	YY_BREAK
 case 92:
 YY_RULE_SETUP
 { return reserved_word(yyscanner); }
 	YY_BREAK
 case 93:
 YY_RULE_SETUP
 {
    yylval->lex.string = NewPoolTString(yytext);
    return check_type(yyscanner);
 }
 	YY_BREAK
 case 94:
 YY_RULE_SETUP
 { yylval->lex.i = static_cast<int>(strtol(yytext, 0, 0)); return INTCONSTANT; }
 	YY_BREAK
 case 95:
 YY_RULE_SETUP
 { yylval->lex.i = static_cast<int>(strtol(yytext, 0, 0)); return INTCONSTANT; }
 	YY_BREAK
 case 96:
 YY_RULE_SETUP
 { yylval->lex.i = static_cast<int>(strtol(yytext, 0, 0)); return INTCONSTANT; }
 	YY_BREAK
 case 97:
 YY_RULE_SETUP
 { yylval->lex.f = static_cast<float>(atof_dot(yytext)); return FLOATCONSTANT; }
 	YY_BREAK
 case 98:
 YY_RULE_SETUP
 { yylval->lex.f = static_cast<float>(atof_dot(yytext)); return FLOATCONSTANT; }
 	YY_BREAK
 case 99:
 YY_RULE_SETUP
 { yylval->lex.f = static_cast<float>(atof_dot(yytext)); return FLOATCONSTANT; }
 	YY_BREAK
 case 100:
 YY_RULE_SETUP
 { return ADD_ASSIGN; }
 	YY_BREAK
 case 101:
 YY_RULE_SETUP
 { return SUB_ASSIGN; }
 	YY_BREAK
 case 102:
 YY_RULE_SETUP
 { return MUL_ASSIGN; }
 	YY_BREAK
 case 103:
 YY_RULE_SETUP
 { return DIV_ASSIGN; }
 	YY_BREAK
 case 104:
 YY_RULE_SETUP
 { return MOD_ASSIGN; }
 	YY_BREAK
 case 105:
 YY_RULE_SETUP
 { return LEFT_ASSIGN; }
 	YY_BREAK
 case 106:
 YY_RULE_SETUP
 { return RIGHT_ASSIGN; }
 	YY_BREAK
 case 107:
 YY_RULE_SETUP
 { return AND_ASSIGN; }
 	YY_BREAK
 case 108:
 YY_RULE_SETUP
 { return XOR_ASSIGN; }
 	YY_BREAK
 case 109:
 YY_RULE_SETUP
 { return OR_ASSIGN; }
 	YY_BREAK
 case 110:
 YY_RULE_SETUP
 { return INC_OP; }
 	YY_BREAK
 case 111:
 YY_RULE_SETUP
 { return DEC_OP; }
 	YY_BREAK
 case 112:
 YY_RULE_SETUP
 { return AND_OP; }
 	YY_BREAK
 case 113:
 YY_RULE_SETUP
 { return OR_OP; }
 	YY_BREAK
 case 114:
 YY_RULE_SETUP
 { return XOR_OP; }
 	YY_BREAK
 case 115:
 YY_RULE_SETUP
 { return LE_OP; }
 	YY_BREAK
 case 116:
 YY_RULE_SETUP
 { return GE_OP; }
 	YY_BREAK
 case 117:
 YY_RULE_SETUP
 { return EQ_OP; }
 	YY_BREAK
 case 118:
 YY_RULE_SETUP
 { return NE_OP; }
 	YY_BREAK
 case 119:
 YY_RULE_SETUP
 { return LEFT_OP; }
 	YY_BREAK
 case 120:
 YY_RULE_SETUP
 { return RIGHT_OP; }
 	YY_BREAK
 case 121:
 YY_RULE_SETUP
 { return SEMICOLON; }
 	YY_BREAK
 case 122:
 YY_RULE_SETUP
 { return LEFT_BRACE; }
 	YY_BREAK
 case 123:
 YY_RULE_SETUP
 { return RIGHT_BRACE; }
 	YY_BREAK
 case 124:
 YY_RULE_SETUP
 { return COMMA; }
 	YY_BREAK
 case 125:
 YY_RULE_SETUP
 { return COLON; }
 	YY_BREAK
 case 126:
 YY_RULE_SETUP
 { return EQUAL; }
 	YY_BREAK
 case 127:
 YY_RULE_SETUP
 { return LEFT_PAREN; }
 	YY_BREAK
 case 128:
 YY_RULE_SETUP
 { return RIGHT_PAREN; }
 	YY_BREAK
 case 129:
 YY_RULE_SETUP
 { return LEFT_BRACKET; }
 	YY_BREAK
 case 130:
 YY_RULE_SETUP
 { return RIGHT_BRACKET; }
 	YY_BREAK
 case 131:
 YY_RULE_SETUP
 { return DOT; }
 	YY_BREAK
 case 132:
 YY_RULE_SETUP
 { return BANG; }
 	YY_BREAK
 case 133:
 YY_RULE_SETUP
 { return DASH; }
 	YY_BREAK
 case 134:
 YY_RULE_SETUP
 { return TILDE; }
 	YY_BREAK
 case 135:
 YY_RULE_SETUP
 { return PLUS; }
 	YY_BREAK
 case 136:
 YY_RULE_SETUP
 { return STAR; }
 	YY_BREAK
 case 137:
 YY_RULE_SETUP
 { return SLASH; }
 	YY_BREAK
 case 138:
 YY_RULE_SETUP
 { return PERCENT; }
 	YY_BREAK
 case 139:
 YY_RULE_SETUP
 { return LEFT_ANGLE; }
 	YY_BREAK
 case 140:
 YY_RULE_SETUP
 { return RIGHT_ANGLE; }
 	YY_BREAK
 case 141:
 YY_RULE_SETUP
 { return VERTICAL_BAR; }
 	YY_BREAK
 case 142:
 YY_RULE_SETUP
 { return CARET; }
 	YY_BREAK
 case 143:
 YY_RULE_SETUP
 { return AMPERSAND; }
 	YY_BREAK
 case 144:
 YY_RULE_SETUP
 { return QUESTION; }
 	YY_BREAK
 case 145:
 /* rule 145 can match eol */
 YY_RULE_SETUP
 { }
 	YY_BREAK
 case YY_STATE_EOF(INITIAL):
 { yyterminate(); }
 	YY_BREAK
 case 146:
 YY_RULE_SETUP
 { assert(false); return 0; }
 	YY_BREAK
 case 147:
 YY_RULE_SETUP
 ECHO;
 	YY_BREAK
 	case YY_END_OF_BUFFER:
 		{
 		/* Amount of text matched not including the EOB char. */
 		int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1;
 		/* Undo the effects of YY_DO_BEFORE_ACTION. */
 		*yy_cp = yyg->yy_hold_char;
 		YY_RESTORE_YY_MORE_OFFSET
 		if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
 			{
 			/* We're scanning a new file or input source.  It's
 			 * possible that this happened because the user
 			 * just pointed yyin at a new source and called
 			 * yylex().  If so, then we have to assure
 			 * consistency between YY_CURRENT_BUFFER and our
 			 * globals.  Here is the right place to do so, because
 			 * this is the first action (other than possibly a
 			 * back-up) that will match for the new input source.
 			 */
 			yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
 			YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
 			YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
 			}
 		/* Note that here we test for yy_c_buf_p "<=" to the position
 		 * of the first EOB in the buffer, since yy_c_buf_p will
 		 * already have been incremented past the NUL character
 		 * (since all states make transitions on EOB to the
 		 * end-of-buffer state).  Contrast this with the test
 		 * in input().
 		 */
 		if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
 			{ /* This was really a NUL. */
 			yy_state_type yy_next_state;
 			yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text;
 			yy_current_state = yy_get_previous_state( yyscanner );
 			/* Okay, we're now positioned to make the NUL
 			 * transition.  We couldn't have
 			 * yy_get_previous_state() go ahead and do it
 			 * for us because it doesn't know how to deal
 			 * with the possibility of jamming (and we don't
 			 * want to build jamming into it because then it
 			 * will run more slowly).
 			 */
 			yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner);
 			yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
 			if ( yy_next_state )
 				{
 				/* Consume the NUL. */
 				yy_cp = ++yyg->yy_c_buf_p;
 				yy_current_state = yy_next_state;
 				goto yy_match;
 				}
 			else
 				{
 				yy_cp = yyg->yy_last_accepting_cpos;
 				yy_current_state = yyg->yy_last_accepting_state;
 				goto yy_find_action;
 				}
 			}
 		else switch ( yy_get_next_buffer( yyscanner ) )
 			{
 			case EOB_ACT_END_OF_FILE:
 				{
 				yyg->yy_did_buffer_switch_on_eof = 0;
 				if ( yywrap(yyscanner ) )
 					{
 					/* Note: because we've taken care in
 					 * yy_get_next_buffer() to have set up
 					 * yytext, we can now set up
 					 * yy_c_buf_p so that if some total
 					 * hoser (like flex itself) wants to
 					 * call the scanner after we return the
 					 * YY_NULL, it'll still work - another
 					 * YY_NULL will get returned.
 					 */
 					yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;
 					yy_act = YY_STATE_EOF(YY_START);
 					goto do_action;
 					}
 				else
 					{
 					if ( ! yyg->yy_did_buffer_switch_on_eof )
 						YY_NEW_FILE;
 					}
 				break;
 				}
 			case EOB_ACT_CONTINUE_SCAN:
 				yyg->yy_c_buf_p =
 					yyg->yytext_ptr + yy_amount_of_matched_text;
 				yy_current_state = yy_get_previous_state( yyscanner );
 				yy_cp = yyg->yy_c_buf_p;
 				yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
 				goto yy_match;
 			case EOB_ACT_LAST_MATCH:
 				yyg->yy_c_buf_p =
 				&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars];
 				yy_current_state = yy_get_previous_state( yyscanner );
 				yy_cp = yyg->yy_c_buf_p;
 				yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
 				goto yy_find_action;
 			}
 		break;
 		}
 	default:
 		YY_FATAL_ERROR(
 			"fatal flex scanner internal error--no action found" );
 	} /* end of action switch */
 		} /* end of scanning one token */
 } /* end of yylex */
 /* yy_get_next_buffer - try to read in a new buffer
  *
  * Returns a code representing an action:
  *	EOB_ACT_LAST_MATCH -
  *	EOB_ACT_CONTINUE_SCAN - continue scanning from current position
  *	EOB_ACT_END_OF_FILE - end of file
  */
 static int yy_get_next_buffer (yyscan_t yyscanner)
 {
     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
 	register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
 	register char *source = yyg->yytext_ptr;
 	register int number_to_move, i;
 	int ret_val;
 	if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] )
 		YY_FATAL_ERROR(
 		"fatal flex scanner internal error--end of buffer missed" );
 	if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
 		{ /* Don't try to fill the buffer, so this is an EOF. */
 		if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 )
 			{
 			/* We matched a single character, the EOB, so
 			 * treat this as a final EOF.
 			 */
 			return EOB_ACT_END_OF_FILE;
 			}
 		else
 			{
 			/* We matched some text prior to the EOB, first
 			 * process it.
 			 */
 			return EOB_ACT_LAST_MATCH;
 			}
 		}
 	/* Try to read more data. */
 	/* First move last chars to start of buffer. */
 	number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr) - 1;
 	for ( i = 0; i < number_to_move; ++i )
 		*(dest++) = *(source++);
 	if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
 		/* don't do the read, it's not guaranteed to return an EOF,
 		 * just force an EOF
 		 */
 		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0;
 	else
 		{
 			yy_size_t num_to_read =
 			YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
 		while ( num_to_read <= 0 )
 			{ /* Not enough room in the buffer - grow it. */
 			/* just a shorter name for the current buffer */
 			YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
 			int yy_c_buf_p_offset =
 				(int) (yyg->yy_c_buf_p - b->yy_ch_buf);
 			if ( b->yy_is_our_buffer )
 				{
 				yy_size_t new_size = b->yy_buf_size * 2;
 				if ( new_size <= 0 )
 					b->yy_buf_size += b->yy_buf_size / 8;
 				else
 					b->yy_buf_size *= 2;
 				b->yy_ch_buf = (char *)
 					/* Include room in for 2 EOB chars. */
 					yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 ,yyscanner );
 				}
 			else
 				/* Can't grow it, we don't own it. */
 				b->yy_ch_buf = 0;
 			if ( ! b->yy_ch_buf )
 				YY_FATAL_ERROR(
 				"fatal error - scanner input buffer overflow" );
 			yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
 			num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
 						number_to_move - 1;
 			}
 		if ( num_to_read > YY_READ_BUF_SIZE )
 			num_to_read = YY_READ_BUF_SIZE;
 		/* Read in more data. */
 		YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
 			yyg->yy_n_chars, num_to_read );
 		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
 		}
 	if ( yyg->yy_n_chars == 0 )
 		{
 		if ( number_to_move == YY_MORE_ADJ )
 			{
 			ret_val = EOB_ACT_END_OF_FILE;
 			yyrestart(yyin  ,yyscanner);
 			}
 		else
 			{
 			ret_val = EOB_ACT_LAST_MATCH;
 			YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
 				YY_BUFFER_EOF_PENDING;
 			}
 		}
 	else
 		ret_val = EOB_ACT_CONTINUE_SCAN;
 	if ((yy_size_t) (yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
 		/* Extend the array by 50%, plus the number we really need. */
 		yy_size_t new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1);
 		YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size ,yyscanner );
 		if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
 			YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
 	}
 	yyg->yy_n_chars += number_to_move;
 	YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR;
 	YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
 	yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
 	return ret_val;
 }
 /* yy_get_previous_state - get the state just before the EOB char was reached */
     static yy_state_type yy_get_previous_state (yyscan_t yyscanner)
 {
 	register yy_state_type yy_current_state;
 	register char *yy_cp;
     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
 	yy_current_state = yyg->yy_start;
 	for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp )
 		{
 		register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
 		if ( yy_accept[yy_current_state] )
 			{
 			yyg->yy_last_accepting_state = yy_current_state;
 			yyg->yy_last_accepting_cpos = yy_cp;
 			}
 		while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
 			{
 			yy_current_state = (int) yy_def[yy_current_state];
 			if ( yy_current_state >= 443 )
 				yy_c = yy_meta[(unsigned int) yy_c];
 			}
 		yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
 		}
 	return yy_current_state;
 }
 /* yy_try_NUL_trans - try to make a transition on the NUL character
  *
  * synopsis
  *	next_state = yy_try_NUL_trans( current_state );
  */
     static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state , yyscan_t yyscanner)
 {
 	register int yy_is_jam;
     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* This var may be unused depending upon options. */
 	register char *yy_cp = yyg->yy_c_buf_p;
 	register YY_CHAR yy_c = 1;
 	if ( yy_accept[yy_current_state] )
 		{
 		yyg->yy_last_accepting_state = yy_current_state;
 		yyg->yy_last_accepting_cpos = yy_cp;
 		}
 	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
 		{
 		yy_current_state = (int) yy_def[yy_current_state];
 		if ( yy_current_state >= 443 )
 			yy_c = yy_meta[(unsigned int) yy_c];
 		}
 	yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
 	yy_is_jam = (yy_current_state == 442);
 	return yy_is_jam ? 0 : yy_current_state;
 }
 #ifndef YY_NO_INPUT
 #ifdef __cplusplus
     static int yyinput (yyscan_t yyscanner)
 #else
     static int input  (yyscan_t yyscanner)
 #endif
 {
 	int c;
     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
 	*yyg->yy_c_buf_p = yyg->yy_hold_char;
 	if ( *yyg->yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
 		{
 		/* yy_c_buf_p now points to the character we want to return.
 		 * If this occurs *before* the EOB characters, then it's a
 		 * valid NUL; if not, then we've hit the end of the buffer.
 		 */
 		if ( yyg->yy_c_buf_p < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
 			/* This was really a NUL. */
 			*yyg->yy_c_buf_p = '\0';
 		else
 			{ /* need more input */
 			yy_size_t offset = yyg->yy_c_buf_p - yyg->yytext_ptr;
 			++yyg->yy_c_buf_p;
 			switch ( yy_get_next_buffer( yyscanner ) )
 				{
 				case EOB_ACT_LAST_MATCH:
 					/* This happens because yy_g_n_b()
 					 * sees that we've accumulated a
 					 * token and flags that we need to
 					 * try matching the token before
 					 * proceeding.  But for input(),
 					 * there's no matching to consider.
 					 * So convert the EOB_ACT_LAST_MATCH
 					 * to EOB_ACT_END_OF_FILE.
 					 */
 					/* Reset buffer status. */
 					yyrestart(yyin ,yyscanner);
 					/*FALLTHROUGH*/
 				case EOB_ACT_END_OF_FILE:
 					{
 					if ( yywrap(yyscanner ) )
 						return EOF;
 					if ( ! yyg->yy_did_buffer_switch_on_eof )
 						YY_NEW_FILE;
 #ifdef __cplusplus
 					return yyinput(yyscanner);
 #else
 					return input(yyscanner);
 #endif
 					}
 				case EOB_ACT_CONTINUE_SCAN:
 					yyg->yy_c_buf_p = yyg->yytext_ptr + offset;
 					break;
 				}
 			}
 		}
 	c = *(unsigned char *) yyg->yy_c_buf_p;	/* cast for 8-bit char's */
 	*yyg->yy_c_buf_p = '\0';	/* preserve yytext */
 	yyg->yy_hold_char = *++yyg->yy_c_buf_p;
 	if ( c == '\n' )
     do{ yylineno++;
         yycolumn=0;
     }while(0)
 ;
 	return c;
 }
 #endif	/* ifndef YY_NO_INPUT */
 /** Immediately switch to a different input stream.
  * @param input_file A readable stream.
  * @param yyscanner The scanner object.
  * @note This function does not reset the start condition to @c INITIAL .
  */
     void yyrestart  (FILE * input_file , yyscan_t yyscanner)
 {
     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
 	if ( ! YY_CURRENT_BUFFER ){
         yyensure_buffer_stack (yyscanner);
 		YY_CURRENT_BUFFER_LVALUE =
             yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
 	}
 	yy_init_buffer(YY_CURRENT_BUFFER,input_file ,yyscanner);
 	yy_load_buffer_state(yyscanner );
 }
 /** Switch to a different input buffer.
  * @param new_buffer The new input buffer.
  * @param yyscanner The scanner object.
  */
     void yy_switch_to_buffer  (YY_BUFFER_STATE  new_buffer , yyscan_t yyscanner)
 {
     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
 	/* TODO. We should be able to replace this entire function body
 	 * with
 	 *		yypop_buffer_state();
 	 *		yypush_buffer_state(new_buffer);
      */
 	yyensure_buffer_stack (yyscanner);
 	if ( YY_CURRENT_BUFFER == new_buffer )
 		return;
 	if ( YY_CURRENT_BUFFER )
 		{
 		/* Flush out information for old buffer. */
 		*yyg->yy_c_buf_p = yyg->yy_hold_char;
 		YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
 		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
 		}
 	YY_CURRENT_BUFFER_LVALUE = new_buffer;
 	yy_load_buffer_state(yyscanner );
 	/* We don't actually know whether we did this switch during
 	 * EOF (yywrap()) processing, but the only time this flag
 	 * is looked at is after yywrap() is called, so it's safe
 	 * to go ahead and always set it.
 	 */
 	yyg->yy_did_buffer_switch_on_eof = 1;
 }
 static void yy_load_buffer_state  (yyscan_t yyscanner)
 {
     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
 	yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
 	yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
 	yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
 	yyg->yy_hold_char = *yyg->yy_c_buf_p;
 }
 /** Allocate and initialize an input buffer state.
  * @param file A readable stream.
  * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
  * @param yyscanner The scanner object.
  * @return the allocated buffer state.
  */
     YY_BUFFER_STATE yy_create_buffer  (FILE * file, int  size , yyscan_t yyscanner)
 {
 	YY_BUFFER_STATE b;
 	b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state ) ,yyscanner );
 	if ( ! b )
 		YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
 	b->yy_buf_size = size;
 	/* yy_ch_buf has to be 2 characters longer than the size given because
 	 * we need to put in 2 end-of-buffer characters.
 	 */
 	b->yy_ch_buf = (char *) yyalloc(b->yy_buf_size + 2 ,yyscanner );
 	if ( ! b->yy_ch_buf )
 		YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
 	b->yy_is_our_buffer = 1;
 	yy_init_buffer(b,file ,yyscanner);
 	return b;
 }
 /** Destroy the buffer.
  * @param b a buffer created with yy_create_buffer()
  * @param yyscanner The scanner object.
  */
     void yy_delete_buffer (YY_BUFFER_STATE  b , yyscan_t yyscanner)
 {
     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
 	if ( ! b )
 		return;
 	if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
 		YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
 	if ( b->yy_is_our_buffer )
 		yyfree((void *) b->yy_ch_buf ,yyscanner );
 	yyfree((void *) b ,yyscanner );
 }
 /* Initializes or reinitializes a buffer.
  * This function is sometimes called more than once on the same buffer,
  * such as during a yyrestart() or at EOF.
  */
     static void yy_init_buffer  (YY_BUFFER_STATE  b, FILE * file , yyscan_t yyscanner)
 {
 	int oerrno = errno;
     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
 	yy_flush_buffer(b ,yyscanner);
 	b->yy_input_file = file;
 	b->yy_fill_buffer = 1;
     /* If b is the current buffer, then yy_init_buffer was _probably_
      * called from yyrestart() or through yy_get_next_buffer.
      * In that case, we don't want to reset the lineno or column.
      */
     if (b != YY_CURRENT_BUFFER){
         b->yy_bs_lineno = 1;
         b->yy_bs_column = 0;
     }
         b->yy_is_interactive = 0;
 	errno = oerrno;
 }
 /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
  * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
  * @param yyscanner The scanner object.
  */
     void yy_flush_buffer (YY_BUFFER_STATE  b , yyscan_t yyscanner)
 {
     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
 	if ( ! b )
 		return;
 	b->yy_n_chars = 0;
 	/* We always need two end-of-buffer characters.  The first causes
 	 * a transition to the end-of-buffer state.  The second causes
 	 * a jam in that state.
 	 */
 	b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
 	b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
 	b->yy_buf_pos = &b->yy_ch_buf[0];
 	b->yy_at_bol = 1;
 	b->yy_buffer_status = YY_BUFFER_NEW;
 	if ( b == YY_CURRENT_BUFFER )
 		yy_load_buffer_state(yyscanner );
 }
 /** Pushes the new state onto the stack. The new state becomes
  *  the current state. This function will allocate the stack
  *  if necessary.
  *  @param new_buffer The new state.
  *  @param yyscanner The scanner object.
  */
 void yypush_buffer_state (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
 {
     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
 	if (new_buffer == NULL)
 		return;
 	yyensure_buffer_stack(yyscanner);
 	/* This block is copied from yy_switch_to_buffer. */
 	if ( YY_CURRENT_BUFFER )
 		{
 		/* Flush out information for old buffer. */
 		*yyg->yy_c_buf_p = yyg->yy_hold_char;
 		YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
 		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
 		}
 	/* Only push if top exists. Otherwise, replace top. */
 	if (YY_CURRENT_BUFFER)
 		yyg->yy_buffer_stack_top++;
 	YY_CURRENT_BUFFER_LVALUE = new_buffer;
 	/* copied from yy_switch_to_buffer. */
 	yy_load_buffer_state(yyscanner );
 	yyg->yy_did_buffer_switch_on_eof = 1;
 }
 /** Removes and deletes the top of the stack, if present.
  *  The next element becomes the new top.
  *  @param yyscanner The scanner object.
  */
 void yypop_buffer_state (yyscan_t yyscanner)
 {
     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
 	if (!YY_CURRENT_BUFFER)
 		return;
 	yy_delete_buffer(YY_CURRENT_BUFFER ,yyscanner);
 	YY_CURRENT_BUFFER_LVALUE = NULL;
 	if (yyg->yy_buffer_stack_top > 0)
 		--yyg->yy_buffer_stack_top;
 	if (YY_CURRENT_BUFFER) {
 		yy_load_buffer_state(yyscanner );
 		yyg->yy_did_buffer_switch_on_eof = 1;
 	}
 }
 /* Allocates the stack if it does not exist.
  *  Guarantees space for at least one push.
  */
 static void yyensure_buffer_stack (yyscan_t yyscanner)
 {
 	yy_size_t num_to_alloc;
     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
 	if (!yyg->yy_buffer_stack) {
 		/* First allocation is just for 2 elements, since we don't know if this
 		 * scanner will even need a stack. We use 2 instead of 1 to avoid an
 		 * immediate realloc on the next call.
          */
 		num_to_alloc = 1;
 		yyg->yy_buffer_stack = (struct yy_buffer_state**)yyalloc
 								(num_to_alloc * sizeof(struct yy_buffer_state*)
 								, yyscanner);
 		if ( ! yyg->yy_buffer_stack )
 			YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
 		memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*));
 		yyg->yy_buffer_stack_max = num_to_alloc;
 		yyg->yy_buffer_stack_top = 0;
 		return;
 	}
 	if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){
 		/* Increase the buffer to prepare for a possible push. */
 		int grow_size = 8 /* arbitrary grow size */;
 		num_to_alloc = yyg->yy_buffer_stack_max + grow_size;
 		yyg->yy_buffer_stack = (struct yy_buffer_state**)yyrealloc
 								(yyg->yy_buffer_stack,
 								num_to_alloc * sizeof(struct yy_buffer_state*)
 								, yyscanner);
 		if ( ! yyg->yy_buffer_stack )
 			YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
 		/* zero only the new slots.*/
 		memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*));
 		yyg->yy_buffer_stack_max = num_to_alloc;
 	}
 }
 /** Setup the input buffer state to scan directly from a user-specified character buffer.
  * @param base the character buffer
  * @param size the size in bytes of the character buffer
  * @param yyscanner The scanner object.
  * @return the newly allocated buffer state object.
  */
 YY_BUFFER_STATE yy_scan_buffer  (char * base, yy_size_t  size , yyscan_t yyscanner)
 {
 	YY_BUFFER_STATE b;
 	if ( size < 2 ||
 	     base[size-2] != YY_END_OF_BUFFER_CHAR ||
 	     base[size-1] != YY_END_OF_BUFFER_CHAR )
 		/* They forgot to leave room for the EOB's. */
 		return 0;
 	b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state ) ,yyscanner );
 	if ( ! b )
 		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_pos = b->yy_ch_buf = base;
 	b->yy_is_our_buffer = 0;
 	b->yy_input_file = 0;
 	b->yy_n_chars = b->yy_buf_size;
 	b->yy_is_interactive = 0;
 	b->yy_at_bol = 1;
 	b->yy_fill_buffer = 0;
 	b->yy_buffer_status = YY_BUFFER_NEW;
 	yy_switch_to_buffer(b ,yyscanner );
 	return b;
 }
 /** Setup the input buffer state to scan a string. The next call to yylex() will
  * scan from a @e copy of @a str.
  * @param yystr a NUL-terminated string to scan
  * @param yyscanner The scanner object.
  * @return the newly allocated buffer state object.
  * @note If you want to scan bytes that may contain NUL values, then use
  *       yy_scan_bytes() instead.
  */
 YY_BUFFER_STATE yy_scan_string (yyconst char * yystr , yyscan_t yyscanner)
 {
 	return yy_scan_bytes(yystr,strlen(yystr) ,yyscanner);
 }
 /** Setup the input buffer state to scan the given bytes. The next call to yylex() will
  * scan from a @e copy of @a bytes.
  * @param bytes the byte buffer to scan
  * @param len the number of bytes in the buffer pointed to by @a bytes.
  * @param yyscanner The scanner object.
  * @return the newly allocated buffer state object.
  */
 YY_BUFFER_STATE yy_scan_bytes  (yyconst char * yybytes, yy_size_t  _yybytes_len , yyscan_t yyscanner)
 {
 	YY_BUFFER_STATE b;
 	char *buf;
 	yy_size_t n, i;
 	/* Get memory for full buffer, including space for trailing EOB's. */
 	n = _yybytes_len + 2;
 	buf = (char *) yyalloc(n ,yyscanner );
 	if ( ! buf )
 		YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
 	for ( i = 0; i < _yybytes_len; ++i )
 		buf[i] = yybytes[i];
 	buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
 	b = yy_scan_buffer(buf,n ,yyscanner);
 	if ( ! b )
 		YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
 	/* It's okay to grow etc. this buffer, and we should throw it
 	 * away when we're done.
 	 */
 	b->yy_is_our_buffer = 1;
 	return b;
 }
 #ifndef YY_EXIT_FAILURE
 #define YY_EXIT_FAILURE 2
 #endif
 static void yy_fatal_error (yyconst char* msg , yyscan_t yyscanner)
 {
     	(void) fprintf( stderr, "%s\n", msg );
 	exit( YY_EXIT_FAILURE );
 }
 /* Redefine yyless() so it works in section 3 code. */
 #undef yyless
 #define yyless(n) \
 	do \
 		{ \
 		/* Undo effects of setting up yytext. */ \
         int yyless_macro_arg = (n); \
         YY_LESS_LINENO(yyless_macro_arg);\
 		yytext[yyleng] = yyg->yy_hold_char; \
 		yyg->yy_c_buf_p = yytext + yyless_macro_arg; \
 		yyg->yy_hold_char = *yyg->yy_c_buf_p; \
 		*yyg->yy_c_buf_p = '\0'; \
 		yyleng = yyless_macro_arg; \
 		} \
 	while ( 0 )
 /* Accessor  methods (get/set functions) to struct members. */
 /** Get the user-defined data for this scanner.
  * @param yyscanner The scanner object.
  */
 YY_EXTRA_TYPE yyget_extra  (yyscan_t yyscanner)
 {
     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
     return yyextra;
 }
 /** Get the current line number.
  * @param yyscanner The scanner object.
  */
 int yyget_lineno  (yyscan_t yyscanner)
 {
     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
         if (! YY_CURRENT_BUFFER)
             return 0;
     return yylineno;
 }
 /** Get the current column number.
  * @param yyscanner The scanner object.
  */
 int yyget_column  (yyscan_t yyscanner)
 {
     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
         if (! YY_CURRENT_BUFFER)
             return 0;
     return yycolumn;
 }
 /** Get the input stream.
  * @param yyscanner The scanner object.
  */
 FILE *yyget_in  (yyscan_t yyscanner)
 {
     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
     return yyin;
 }
 /** Get the output stream.
  * @param yyscanner The scanner object.
  */
 FILE *yyget_out  (yyscan_t yyscanner)
 {
     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
     return yyout;
 }
 /** Get the length of the current token.
  * @param yyscanner The scanner object.
  */
 yy_size_t yyget_leng  (yyscan_t yyscanner)
 {
     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
     return yyleng;
 }
 /** Get the current token.
  * @param yyscanner The scanner object.
  */
 char *yyget_text  (yyscan_t yyscanner)
 {
     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
     return yytext;
 }
 /** Set the user-defined data. This data is never touched by the scanner.
  * @param user_defined The data to be associated with this scanner.
  * @param yyscanner The scanner object.
  */
 void yyset_extra (YY_EXTRA_TYPE  user_defined , yyscan_t yyscanner)
 {
     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
     yyextra = user_defined ;
 }
 /** Set the current line number.
  * @param line_number
  * @param yyscanner The scanner object.
  */
 void yyset_lineno (int  line_number , yyscan_t yyscanner)
 {
     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
         /* lineno is only valid if an input buffer exists. */
         if (! YY_CURRENT_BUFFER )
            yy_fatal_error( "yyset_lineno called with no buffer" , yyscanner);
     yylineno = line_number;
 }
 /** Set the current column.
  * @param line_number
  * @param yyscanner The scanner object.
  */
 void yyset_column (int  column_no , yyscan_t yyscanner)
 {
     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
         /* column is only valid if an input buffer exists. */
         if (! YY_CURRENT_BUFFER )
            yy_fatal_error( "yyset_column called with no buffer" , yyscanner);
     yycolumn = column_no;
 }
 /** Set the input stream. This does not discard the current
  * input buffer.
  * @param in_str A readable stream.
  * @param yyscanner The scanner object.
  * @see yy_switch_to_buffer
  */
 void yyset_in (FILE *  in_str , yyscan_t yyscanner)
 {
     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
     yyin = in_str ;
 }
 void yyset_out (FILE *  out_str , yyscan_t yyscanner)
 {
     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
     yyout = out_str ;
 }
 int yyget_debug  (yyscan_t yyscanner)
 {
     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
     return yy_flex_debug;
 }
 void yyset_debug (int  bdebug , yyscan_t yyscanner)
 {
     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
     yy_flex_debug = bdebug ;
 }
 /* Accessor methods for yylval and yylloc */
 YYSTYPE * yyget_lval  (yyscan_t yyscanner)
 {
     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
     return yylval;
 }
 void yyset_lval (YYSTYPE *  yylval_param , yyscan_t yyscanner)
 {
     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
     yylval = yylval_param;
 }
 YYLTYPE *yyget_lloc  (yyscan_t yyscanner)
 {
     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
     return yylloc;
 }
 void yyset_lloc (YYLTYPE *  yylloc_param , yyscan_t yyscanner)
 {
     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
     yylloc = yylloc_param;
 }
 /* User-visible API */
 /* yylex_init is special because it creates the scanner itself, so it is
  * the ONLY reentrant function that doesn't take the scanner as the last argument.
  * That's why we explicitly handle the declaration, instead of using our macros.
  */
 int yylex_init(yyscan_t* ptr_yy_globals)
 {
     if (ptr_yy_globals == NULL){
         errno = EINVAL;
         return 1;
     }
     *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), NULL );
     if (*ptr_yy_globals == NULL){
         errno = ENOMEM;
         return 1;
     }
     /* By setting to 0xAA, we expose bugs in yy_init_globals. Leave at 0x00 for releases. */
     memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
     return yy_init_globals ( *ptr_yy_globals );
 }
 /* yylex_init_extra has the same functionality as yylex_init, but follows the
  * convention of taking the scanner as the last argument. Note however, that
  * this is a *pointer* to a scanner, as it will be allocated by this call (and
  * is the reason, too, why this function also must handle its own declaration).
  * The user defined value in the first argument will be available to yyalloc in
  * the yyextra field.
  */
 int yylex_init_extra(YY_EXTRA_TYPE yy_user_defined,yyscan_t* ptr_yy_globals )
 {
     struct yyguts_t dummy_yyguts;
     yyset_extra (yy_user_defined, &dummy_yyguts);
     if (ptr_yy_globals == NULL){
         errno = EINVAL;
         return 1;
     }
     *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), &dummy_yyguts );
     if (*ptr_yy_globals == NULL){
         errno = ENOMEM;
         return 1;
     }
     /* By setting to 0xAA, we expose bugs in
     yy_init_globals. Leave at 0x00 for releases. */
     memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
     yyset_extra (yy_user_defined, *ptr_yy_globals);
     return yy_init_globals ( *ptr_yy_globals );
 }
 static int yy_init_globals (yyscan_t yyscanner)
 {
     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
     /* Initialization is the same as for the non-reentrant scanner.
      * This function is called from yylex_destroy(), so don't allocate here.
      */
     yyg->yy_buffer_stack = 0;
     yyg->yy_buffer_stack_top = 0;
     yyg->yy_buffer_stack_max = 0;
     yyg->yy_c_buf_p = (char *) 0;
     yyg->yy_init = 0;
     yyg->yy_start = 0;
     yyg->yy_start_stack_ptr = 0;
     yyg->yy_start_stack_depth = 0;
     yyg->yy_start_stack =  NULL;
 /* Defined in main.c */
 #ifdef YY_STDINIT
     yyin = stdin;
     yyout = stdout;
 #else
     yyin = (FILE *) 0;
     yyout = (FILE *) 0;
 #endif
     /* For future reference: Set errno on error, since we are called by
      * yylex_init()
      */
     return 0;
 }
 /* yylex_destroy is for both reentrant and non-reentrant scanners. */
 int yylex_destroy  (yyscan_t yyscanner)
 {
     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
     /* Pop the buffer stack, destroying each element. */
 	while(YY_CURRENT_BUFFER){
 		yy_delete_buffer(YY_CURRENT_BUFFER ,yyscanner );
 		YY_CURRENT_BUFFER_LVALUE = NULL;
 		yypop_buffer_state(yyscanner);
 	}
 	/* Destroy the stack itself. */
 	yyfree(yyg->yy_buffer_stack ,yyscanner);
 	yyg->yy_buffer_stack = NULL;
     /* Destroy the start condition stack. */
         yyfree(yyg->yy_start_stack ,yyscanner );
         yyg->yy_start_stack = NULL;
     /* Reset the globals. This is important in a non-reentrant scanner so the next time
      * yylex() is called, initialization will occur. */
     yy_init_globals( yyscanner);
     /* Destroy the main struct (reentrant only). */
     yyfree ( yyscanner , yyscanner );
     yyscanner = NULL;
     return 0;
 }
 /*
  * Internal utility routines.
  */
 #ifndef yytext_ptr
 static void yy_flex_strncpy (char* s1, yyconst char * s2, int n , yyscan_t yyscanner)
 {
 	register int i;
 	for ( i = 0; i < n; ++i )
 		s1[i] = s2[i];
 }
 #endif
 #ifdef YY_NEED_STRLEN
 static int yy_flex_strlen (yyconst char * s , yyscan_t yyscanner)
 {
 	register int n;
 	for ( n = 0; s[n]; ++n )
 		;
 	return n;
 }
 #endif
 void *yyalloc (yy_size_t  size , yyscan_t yyscanner)
 {
 	return (void *) malloc( size );
 }
 void *yyrealloc  (void * ptr, yy_size_t  size , yyscan_t yyscanner)
 {
 	/* The cast to (char *) in the following accommodates both
 	 * implementations that use char* generic pointers, and those
 	 * that use void* generic pointers.  It works with the latter
 	 * because both ANSI C and C++ allow castless assignment from
 	 * any pointer type to void*, and deal with argument conversions
 	 * as though doing an assignment.
 	 */
 	return (void *) realloc( (char *) ptr, size );
 }
 void yyfree (void * ptr , yyscan_t yyscanner)
 {
 	free( (char *) ptr );	/* see yyrealloc() for (char *) cast */
 }
 #define YYTABLES_NAME "yytables"
 yy_size_t string_input(char* buf, yy_size_t max_size, yyscan_t yyscanner) {
     pp::Token token;
     yyget_extra(yyscanner)->preprocessor.lex(&token);
     yy_size_t len = token.type == pp::Token::LAST ? 0 : token.text.size();
     if (len < max_size)
         memcpy(buf, token.text.c_str(), len);
     yyset_column(token.location.file,yyscanner);
     yyset_lineno(token.location.line,yyscanner);
     if (len >= max_size)
         YY_FATAL_ERROR("Input buffer overflow");
     else if (len > 0)
         buf[len++] = ' ';
     return len;
 }
 int check_type(yyscan_t yyscanner) {
     struct yyguts_t* yyg = (struct yyguts_t*) yyscanner;
     int token = IDENTIFIER;
     TSymbol* symbol = yyextra->symbolTable.find(yytext);
     if (symbol && symbol->isVariable()) {
         TVariable* variable = static_cast<TVariable*>(symbol);
         if (variable->isUserType())
             token = TYPE_NAME;
     }
     yylval->lex.symbol = symbol;
     return token;
 }
 int reserved_word(yyscan_t yyscanner) {
     struct yyguts_t* yyg = (struct yyguts_t*) yyscanner;
     yyextra->error(*yylloc, "Illegal use of reserved word", yytext, "");
     yyextra->recover();
     return 0;
 }
 int glslang_initialize(TParseContext* context) {
     yyscan_t scanner = NULL;
     if (yylex_init_extra(context,&scanner))
         return 1;
     context->scanner = scanner;
     return 0;
 }
 int glslang_finalize(TParseContext* context) {
     yyscan_t scanner = context->scanner;
     if (scanner == NULL) return 0;
     context->scanner = NULL;
     yylex_destroy(scanner);
     return 0;
 }
 int glslang_scan(size_t count, const char* const string[], const int length[],
                  TParseContext* context) {
     yyrestart(NULL,context->scanner);
     yyset_column(0,context->scanner);
     yyset_lineno(1,context->scanner);
     // Initialize preprocessor.
     if (!context->preprocessor.init(count, string, length))
         return 1;
     // Define extension macros.
     const TExtensionBehavior& extBehavior = context->extensionBehavior();
     for (TExtensionBehavior::const_iterator iter = extBehavior.begin();
          iter != extBehavior.end(); ++iter) {
         context->preprocessor.predefineMacro(iter->first.c_str(), 1);
     }
     if (context->fragmentPrecisionHigh)
         context->preprocessor.predefineMacro("GL_FRAGMENT_PRECISION_HIGH", 1);
     return 0;
 }

The Tor Browser / annotate

gfx/angle/src/compiler/glslang_lex.cpp@129ffea94266 (annotated)

gfx/angle/src/compiler/glslang_lex.cpp