#line 17 "glslang.l" // GENERATED FILE - DO NOT EDIT. // Generated by generate_parser.py from glslang.l // // Copyright 2019 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. // // glslang.l: // Lexer for the OpenGL shading language. // Ignore errors in auto-generated code. #if defined(__GNUC__) # pragma GCC diagnostic ignored "-Wswitch-enum" # pragma GCC diagnostic ignored "-Wunused-function" # pragma GCC diagnostic ignored "-Wunused-variable" #elif defined(_MSC_VER) # pragma warning(disable : 4005) # pragma warning(disable : 4065) # pragma warning(disable : 4189) # pragma warning(disable : 4244) # pragma warning(disable : 4505) # pragma warning(disable : 4701) # pragma warning(disable : 4702) #endif #if defined(__clang__) # pragma clang diagnostic ignored "-Wimplicit-fallthrough" # if defined(__APPLE__) // Older clang versions don't have -Wextra-semi-stmt, and detecting Apple clang versions is // difficult because they use different yet overlapping version numbers vs. regular clang. # pragma clang diagnostic ignored "-Wunknown-warning-option" # endif // Flex isn't semi-colon clean. # pragma clang diagnostic ignored "-Wextra-semi-stmt" # pragma clang diagnostic ignored "-Wunreachable-code" #endif #define YY_INT_ALIGNED … /* A lexical scanner generated by flex */ #define FLEX_SCANNER #define YY_FLEX_MAJOR_VERSION … #define YY_FLEX_MINOR_VERSION … #define YY_FLEX_SUBMINOR_VERSION … #if YY_FLEX_SUBMINOR_VERSION > 0 #define FLEX_BETA #endif #ifdef yyget_lval #define yyget_lval_ALREADY_DEFINED #else #define yyget_lval … #endif #ifdef yyset_lval #define yyset_lval_ALREADY_DEFINED #else #define yyset_lval … #endif #ifdef yyget_lloc #define yyget_lloc_ALREADY_DEFINED #else #define yyget_lloc … #endif #ifdef yyset_lloc #define yyset_lloc_ALREADY_DEFINED #else #define yyset_lloc … #endif /* First, we deal with platform-specific or compiler-specific issues. */ /* begin standard C headers. */ #include <errno.h> #include <stdio.h> #include <stdlib.h> #include <string.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 … # 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; # else flex_int8_t; flex_int16_t; flex_int32_t; flex_uint8_t; flex_uint16_t; flex_uint32_t; /* Limits of integral types. */ # ifndef INT8_MIN #define INT8_MIN … # endif # ifndef INT16_MIN #define INT16_MIN … # endif # ifndef INT32_MIN #define INT32_MIN … # endif # ifndef INT8_MAX #define INT8_MAX … # endif # ifndef INT16_MAX #define INT16_MAX … # endif # ifndef INT32_MAX #define INT32_MAX … # endif # ifndef UINT8_MAX #define UINT8_MAX … # endif # ifndef UINT16_MAX #define UINT16_MAX … # endif # ifndef UINT32_MAX #define UINT32_MAX … # endif # ifndef SIZE_MAX #define SIZE_MAX … # endif # endif /* ! C99 */ #endif /* ! FLEXINT_H */ /* begin standard C++ headers. */ /* TODO: this is always defined, so inline it */ #define yyconst … #if defined(__GNUC__) && __GNUC__ >= 3 #define yynoreturn … #else #define yynoreturn #endif /* Returned upon end-of-file. */ #define YY_NULL … /* Promotes a possibly negative, possibly signed char to an * integer in range [0..255] for use as an array index. */ #define YY_SC_TO_UI(c) … /* An opaque pointer. */ #ifndef YY_TYPEDEF_YY_SCANNER_T #define YY_TYPEDEF_YY_SCANNER_T yyscan_t; #endif /* For convenience, these vars (plus the bison vars far below) are macros in the reentrant scanner. */ #define yyin … #define yyout … #define yyextra … #define yyleng … #define yytext … #define yylineno … #define yycolumn … #define yy_flex_debug … /* 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 … /* 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 … #define YYSTATE … /* Action number for EOF rule of a given start state. */ #define YY_STATE_EOF(state) … /* Special action meaning "start processing a new file". */ #define YY_NEW_FILE … #define YY_END_OF_BUFFER_CHAR … /* Size of default input buffer. */ #ifndef YY_BUF_SIZE # ifdef __ia64__ /* On IA-64, the buffer size is 16k, not 8k. * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case. * Ditto for the __ia64__ case accordingly. */ #define YY_BUF_SIZE … # else #define YY_BUF_SIZE … # endif /* __ia64__ */ #endif /* The state buf must be large enough to hold one state per character in the main buffer. */ #define YY_STATE_BUF_SIZE … #ifndef YY_TYPEDEF_YY_BUFFER_STATE #define YY_TYPEDEF_YY_BUFFER_STATE YY_BUFFER_STATE; #endif #ifndef YY_TYPEDEF_YY_SIZE_T #define YY_TYPEDEF_YY_SIZE_T yy_size_t; #endif #define EOB_ACT_CONTINUE_SCAN … #define EOB_ACT_END_OF_FILE … #define EOB_ACT_LAST_MATCH … /* 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) … #define YY_LINENO_REWIND_TO(dst) … /* Return all but the first "n" matched characters back to the input stream. */ #define yyless(n) … #define unput(c) … #ifndef YY_STRUCT_YY_BUFFER_STATE #define YY_STRUCT_YY_BUFFER_STATE struct yy_buffer_state { … }; #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 … /* 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 … 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_BUFFER_STATE yy_scan_buffer(char *base, yy_size_t size, yyscan_t yyscanner); YY_BUFFER_STATE yy_scan_string(const char *yy_str, yyscan_t yyscanner); YY_BUFFER_STATE yy_scan_bytes(const char *bytes, int 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 … #define yy_set_interactive(is_interactive) … #define yy_set_bol(at_bol) … #define YY_AT_BOL() … /* Begin user sect3 */ #define yywrap(yyscanner) … #define YY_SKIP_YYWRAP YY_CHAR; yy_state_type; #define yytext_ptr … 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 yynoreturn yy_fatal_error(const 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 … #define YY_NUM_RULES … #define YY_END_OF_BUFFER … /* This struct is not used in this scanner, but its presence is necessary. */ struct yy_trans_info { … }; static const flex_int16_t yy_accept[982] = …; static const YY_CHAR yy_ec[256] = …; static const YY_CHAR yy_meta[83] = …; static const flex_int16_t yy_base[988] = …; static const flex_int16_t yy_def[988] = …; static const flex_int16_t yy_nxt[1321] = …; static const flex_int16_t yy_chk[1321] = …; /* Table of booleans, true if rule could match eol. */ static const flex_int32_t yy_rule_can_match_eol[260] = …; /* The intent behind this definition is that it'll catch * any uses of REJECT which flex missed. */ #define REJECT … #define yymore() … #define YY_MORE_ADJ … #define YY_RESTORE_YY_MORE_OFFSET /* // // Copyright 2002 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 scripts/run_code_generation.py WHICH GENERATES THE GLSL ES LEXER (glslang_lex_autogen.cpp). */ #include "compiler/preprocessor/Token.h" #include "compiler/translator/ParseContext.h" #include "compiler/translator/glslang.h" #include "compiler/translator/length_limits.h" #include "compiler/translator/util.h" usingnamespacesh; #include "glslang_tab_autogen.h" /* windows only pragma */ #ifdef _MSC_VER # pragma warning(disable : 4102) #endif // Workaround for flex using the register keyword, deprecated in C++11. #ifdef __cplusplus # if __cplusplus > 199711L # define register # endif #endif #define YY_NO_INPUT #define YY_USER_ACTION … #define YY_INPUT(buf, result, max_size) … 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); // Tests if an extension is enabled. If the extension is promoted to core, this function returns // true. static bool is_extension_enabled_or_is_core(TParseContext *context, int extension_version, TExtension extension, int promotion_version); // Helpers to determine if a symbol is reserved, keyword in extension or core, or identifier. // Formatted as: // // [V1_reserved_][V2_extension_][V3_keyword] // // which means in version V1, the symbol is reserved, and remains reserved until V3. From versions // V2 until V3, it's a keyword if the extension is enabled. From version V3 on, it's a keyword in // the spec itself. Prior to V1, the symbol can be used as identifier. static int ES2_extensions_ES3_keyword(TParseContext *context, TExtension extension1, TExtension extension2, TExtension extension3, int token); static int ES2_reserved_ES3_keyword(TParseContext *context, int token); static int ES2_keyword_ES3_reserved(TParseContext *context, int token); static int ES3_keyword(TParseContext *context, int token); static int ES3_reserved_ES3_1_keyword(TParseContext *context, int token); static int ES2_reserved_ES3_1_keyword(TParseContext *context, int token); static int ES3_1_keyword(TParseContext *context, int token); static int ES2_reserved_ES2_extension_ES3_keyword(TParseContext *context, TExtension extension, int token); static int ES3_extension(TParseContext *context, TExtension extension, int token); static int ES3_reserved_ES3_1_extension_ES3_2_keyword(TParseContext *context, TExtension extension, int token); static int ES3_reserved_ES3_1_extension_ES3_2_keyword_2(TParseContext *context, TExtension extension1, TExtension extension2, int token); static int ES3_reserved_ES3_extension(TParseContext *context, TExtension extension, int token); static int ES3_reserved_ES3_extension_ES3_1_keyword(TParseContext *context, TExtension extension, int token); static int ES3_reserved_ES3_extension_ES3_2_keyword(TParseContext *context, TExtension extension, int token); static int ES3_1_reserved_ES3_1_extension_ES3_2_keyword_2(TParseContext *context, TExtension extension1, TExtension extension2, int token1, int token2); static int ES3_and_3_1_reserved_ES3_1_extension_ES3_2_keyword_2(TParseContext *context, TExtension extension1, TExtension extension2, int token1, int token2); static int WEBGL_video_texture_extension(TParseContext *context, int token); static int uint_constant(TParseContext *context); static int int_constant(TParseContext *context); static int float_constant(yyscan_t yyscanner); static int floatsuffix_check(TParseContext *context); static int yuvcscstandardext_constant(TParseContext *context); #define INITIAL … #define FIELDS … #define YY_EXTRA_TYPE … /* Holds the entire state of the reentrant scanner. */ struct yyguts_t { … }; /* 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 … #define yylloc … 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); int 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); int yyget_column(yyscan_t yyscanner); void yyset_column(int _column_no, 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 YY_NO_UNPUT #endif #ifndef yytext_ptr static void yy_flex_strncpy(char *, const char *, int, yyscan_t yyscanner); #endif #ifdef YY_NEED_STRLEN static int yy_flex_strlen(const 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 # ifdef __ia64__ /* On IA-64, the buffer size is 16k, not 8k */ #define YY_READ_BUF_SIZE … # else #define YY_READ_BUF_SIZE … # endif /* __ia64__ */ #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 … #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 … #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() … #endif /* Number of entries by which start-condition stack grows. */ #ifndef YY_START_STACK_INCR #define YY_START_STACK_INCR … #endif /* Report a fatal error. */ #ifndef YY_FATAL_ERROR #define YY_FATAL_ERROR(msg) … #endif /* end tables serialization structures and prototypes */ /* Default declaration of generated scanner - a define so the user can * easily add parameters. */ #ifndef YY_DECL #define YY_DECL_IS_OURS … extern int yylex(YYSTYPE *yylval_param, YYLTYPE *yylloc_param, yyscan_t yyscanner); #define YY_DECL … #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 … #endif #define YY_RULE_SETUP … /** The main scanner function which does all the work. */ YY_DECL { … } /* 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) { … } /* 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) { … } /* 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) { … } #ifndef YY_NO_UNPUT #endif #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 */ int offset = (int)(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 0; 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) { … } /** 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) { … } static void yy_load_buffer_state(yyscan_t yyscanner) { … } /** 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) { … } /** 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) { … } /* 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) { … } /** 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) { … } /** 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) { … } /** 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) { … } /* Allocates the stack if it does not exist. * Guarantees space for at least one push. */ static void yyensure_buffer_stack(yyscan_t yyscanner) { … } /** 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) { … } /** 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(const char *yystr, yyscan_t 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 yybytes the byte buffer to scan * @param _yybytes_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(const char *yybytes, int _yybytes_len, yyscan_t yyscanner) { … } #ifndef YY_EXIT_FAILURE #define YY_EXIT_FAILURE … #endif static void yynoreturn yy_fatal_error(const char *msg, yyscan_t yyscanner) { … } /* Redefine yyless() so it works in section 3 code. */ #undef yyless #define yyless(n) … /* 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) { … } /** Get the current line number. * @param yyscanner The scanner object. */ int yyget_lineno(yyscan_t yyscanner) { … } /** Get the current column number. * @param yyscanner The scanner object. */ int yyget_column(yyscan_t yyscanner) { … } /** Get the input stream. * @param yyscanner The scanner object. */ FILE *yyget_in(yyscan_t yyscanner) { … } /** Get the output stream. * @param yyscanner The scanner object. */ FILE *yyget_out(yyscan_t yyscanner) { … } /** Get the length of the current token. * @param yyscanner The scanner object. */ int yyget_leng(yyscan_t yyscanner) { … } /** Get the current token. * @param yyscanner The scanner object. */ char *yyget_text(yyscan_t yyscanner) { … } /** 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) { … } /** Set the current line number. * @param _line_number line number * @param yyscanner The scanner object. */ void yyset_lineno(int _line_number, yyscan_t yyscanner) { … } /** Set the current column. * @param _column_no column number * @param yyscanner The scanner object. */ void yyset_column(int _column_no, yyscan_t yyscanner) { … } /** 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) { … } void yyset_out(FILE *_out_str, yyscan_t yyscanner) { … } int yyget_debug(yyscan_t yyscanner) { … } void yyset_debug(int _bdebug, yyscan_t yyscanner) { … } /* Accessor methods for yylval and yylloc */ 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) { … } /* 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) { … } /* 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) { … } static int yy_init_globals(yyscan_t yyscanner) { … } /* yylex_destroy is for both reentrant and non-reentrant scanners. */ int yylex_destroy(yyscan_t yyscanner) { … } /* * Internal utility routines. */ #ifndef yytext_ptr static void yy_flex_strncpy(char *s1, const char *s2, int n, yyscan_t yyscanner) { struct yyguts_t *yyg = (struct yyguts_t *)yyscanner; (void)yyg; int i; for (i = 0; i < n; ++i) s1[i] = s2[i]; } #endif #ifdef YY_NEED_STRLEN static int yy_flex_strlen(const char *s, yyscan_t yyscanner) { int n; for (n = 0; s[n]; ++n) ; return n; } #endif void *yyalloc(yy_size_t size, yyscan_t yyscanner) { … } void *yyrealloc(void *ptr, yy_size_t size, yyscan_t yyscanner) { … } void yyfree(void *ptr, yyscan_t yyscanner) { … } #define YYTABLES_NAME … yy_size_t string_input(char *buf, yy_size_t max_size, yyscan_t yyscanner) { … } int check_type(yyscan_t yyscanner) { … } int reserved_word(yyscan_t yyscanner) { … } static bool is_extension_enabled_or_is_core(TParseContext *context, int extension_version, TExtension extension, int promotion_version) { … } int ES2_reserved_ES3_keyword(TParseContext *context, int token) { … } int ES2_keyword_ES3_reserved(TParseContext *context, int token) { … } int ES3_reserved_ES3_1_keyword(TParseContext *context, int token) { … } int ES3_keyword(TParseContext *context, int token) { … } int ES2_reserved_ES3_1_keyword(TParseContext *context, int token) { … } int ES3_1_keyword(TParseContext *context, int token) { … } int WEBGL_video_texture_extension(TParseContext *context, int token) { … } int ES2_extensions_ES3_keyword(TParseContext *context, TExtension extension1, TExtension extension2, TExtension extension3, int token) { … } int ES2_reserved_ES2_extension_ES3_keyword(TParseContext *context, TExtension extension, int token) { … } int ES3_extension(TParseContext *context, TExtension extension, int token) { … } int ES3_reserved_ES3_1_extension_ES3_2_keyword(TParseContext *context, TExtension extension, int token) { … } int ES3_reserved_ES3_1_extension_ES3_2_keyword_2(TParseContext *context, TExtension extension1, TExtension extension2, int token) { … } int ES3_reserved_ES3_extension(TParseContext *context, TExtension extension, int token) { … } int ES3_reserved_ES3_extension_ES3_1_keyword(TParseContext *context, TExtension extension, int token) { … } int ES3_reserved_ES3_extension_ES3_2_keyword(TParseContext *context, TExtension extension, int token) { … } static int ES3_1_reserved_ES3_1_extension_ES3_2_keyword_2(TParseContext *context, TExtension extension1, TExtension extension2, int token1, int token2) { … } static int ES3_and_3_1_reserved_ES3_1_extension_ES3_2_keyword_2(TParseContext *context, TExtension extension1, TExtension extension2, int token1, int token2) { … } int uint_constant(TParseContext *context) { … } int floatsuffix_check(TParseContext *context) { … } void yyerror(YYLTYPE *lloc, TParseContext *context, void *scanner, const char *reason) { … } int int_constant(TParseContext *context) { … } int float_constant(yyscan_t yyscanner) { … } int yuvcscstandardext_constant(TParseContext *context) { … } int glslang_initialize(TParseContext *context) { … } int glslang_finalize(TParseContext *context) { … } int glslang_scan(size_t count, const char *const string[], const int length[], TParseContext *context) { … }
Codebase Browser
chromium