diff --git a/src/Makefile.am b/src/Makefile.am index ce2b1622..9bbd6c3b 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -48,10 +48,15 @@ liblol_a_SOURCES = \ gpu/indexbuffer.cpp gpu/indexbuffer.h \ gpu/vertexbuffer.cpp gpu/vertexbuffer.h \ gpu/framebuffer.cpp gpu/framebuffer.h \ + \ gpu/defaultmaterial.lolfx \ gpu/emptymaterial.lolfx \ gpu/testmaterial.lolfx \ \ + gpu/lolfx-compiler.cpp gpu/lolfx-compiler.h \ + generated/lolfx-parser.cpp generated/lolfx-parser.h \ + generated/lolfx-scanner.cpp \ + \ image/image.cpp image/image.h image/image-private.h \ image/codec/gdiplus-image.cpp \ image/codec/ios-image.cpp \ @@ -74,10 +79,14 @@ generated: .FORCE flex -o generated/easymesh-scanner.cpp easymesh/easymesh-scanner.l bison -o generated/easymesh-parser.cpp --defines=generated/easymesh-parser.h \ -d -b generated/easymesh easymesh/easymesh-parser.y + flex -o generated/lolfx-scanner.cpp gpu/lolfx-scanner.l + bison -o generated/lolfx-parser.cpp --defines=generated/lolfx-parser.h \ + -d -b generated/lolfx gpu/lolfx-parser.y .FORCE: endif -EXTRA_DIST = easymesh/easymesh-scanner.l easymesh/easymesh-parser.y +EXTRA_DIST = easymesh/easymesh-scanner.l easymesh/easymesh-parser.y \ + gpu/lolfx-scanner.l gpu/lolfx-parser.y sdl_sources = \ image/codec/sdl-image.cpp \ diff --git a/src/generated/lolfx-parser.cpp b/src/generated/lolfx-parser.cpp new file mode 100644 index 00000000..6db4d4fb --- /dev/null +++ b/src/generated/lolfx-parser.cpp @@ -0,0 +1,2560 @@ +/* A Bison parser, made by GNU Bison 2.5. */ + +/* Skeleton implementation for Bison LALR(1) parsers in C++ + + Copyright (C) 2002-2011 Free Software Foundation, Inc. + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . */ + +/* As a special exception, you may create a larger work that contains + part or all of the Bison parser skeleton and distribute that work + under terms of your choice, so long as that work isn't itself a + parser generator using the skeleton or a modified version thereof + as a parser skeleton. Alternatively, if you modify or redistribute + the parser skeleton itself, you may (at your option) remove this + special exception, which will cause the skeleton and the resulting + Bison output files to be licensed under the GNU General Public + License without this special exception. + + This special exception was added by the Free Software Foundation in + version 2.2 of Bison. */ + +// Take the name prefix into account. +#define yylex lollex + +/* First part of user declarations. */ + +/* Line 293 of lalr1.cc */ +#line 1 "gpu/lolfx-parser.y" + +// +// Lol Engine +// +// Copyright: (c) 2010-2012 Sam Hocevar +// This program is free software; you can redistribute it and/or +// modify it under the terms of the Do What The Fuck You Want To +// Public License, Version 2, as published by Sam Hocevar. See +// http://sam.zoy.org/projects/COPYING.WTFPL for more details. +// + +#if defined HAVE_CONFIG_H +# include "config.h" +#endif + +#include "core.h" + +#include + + + +/* Line 293 of lalr1.cc */ +#line 63 "generated/lolfx-parser.cpp" + + +#include "lolfx-parser.h" + +/* User implementation prologue. */ + +/* Line 299 of lalr1.cc */ +#line 243 "gpu/lolfx-parser.y" + +#include "gpu/lolfx-compiler.h" + +#undef yylex +#define yylex mc.m_lexer->lex + + +/* Line 299 of lalr1.cc */ +#line 80 "generated/lolfx-parser.cpp" + +#ifndef YY_ +# if defined YYENABLE_NLS && YYENABLE_NLS +# if ENABLE_NLS +# include /* FIXME: INFRINGES ON USER NAME SPACE */ +# define YY_(msgid) dgettext ("bison-runtime", msgid) +# endif +# endif +# ifndef YY_ +# define YY_(msgid) msgid +# endif +#endif + +/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. + If N is 0, then set CURRENT to the empty location which ends + the previous symbol: RHS[0] (always defined). */ + +#define YYRHSLOC(Rhs, K) ((Rhs)[K]) +#ifndef YYLLOC_DEFAULT +# define YYLLOC_DEFAULT(Current, Rhs, N) \ + do \ + if (N) \ + { \ + (Current).begin = YYRHSLOC (Rhs, 1).begin; \ + (Current).end = YYRHSLOC (Rhs, N).end; \ + } \ + else \ + { \ + (Current).begin = (Current).end = YYRHSLOC (Rhs, 0).end; \ + } \ + while (false) +#endif + +/* Suppress unused-variable warnings by "using" E. */ +#define YYUSE(e) ((void) (e)) + +/* Enable debugging if requested. */ +#if YYDEBUG + +/* A pseudo ostream that takes yydebug_ into account. */ +# define YYCDEBUG if (yydebug_) (*yycdebug_) + +# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ +do { \ + if (yydebug_) \ + { \ + *yycdebug_ << Title << ' '; \ + yy_symbol_print_ ((Type), (Value), (Location)); \ + *yycdebug_ << std::endl; \ + } \ +} while (false) + +# define YY_REDUCE_PRINT(Rule) \ +do { \ + if (yydebug_) \ + yy_reduce_print_ (Rule); \ +} while (false) + +# define YY_STACK_PRINT() \ +do { \ + if (yydebug_) \ + yystack_print_ (); \ +} while (false) + +#else /* !YYDEBUG */ + +# define YYCDEBUG if (false) std::cerr +# define YY_SYMBOL_PRINT(Title, Type, Value, Location) +# define YY_REDUCE_PRINT(Rule) +# define YY_STACK_PRINT() + +#endif /* !YYDEBUG */ + +#define yyerrok (yyerrstatus_ = 0) +#define yyclearin (yychar = yyempty_) + +#define YYACCEPT goto yyacceptlab +#define YYABORT goto yyabortlab +#define YYERROR goto yyerrorlab +#define YYRECOVERING() (!!yyerrstatus_) + + +namespace lol { + +/* Line 382 of lalr1.cc */ +#line 166 "generated/lolfx-parser.cpp" + + /* Return YYSTR after stripping away unnecessary quotes and + backslashes, so that it's suitable for yyerror. The heuristic is + that double-quoting is unnecessary unless the string contains an + apostrophe, a comma, or backslash (other than backslash-backslash). + YYSTR is taken from yytname. */ + std::string + LolFxParser::yytnamerr_ (const char *yystr) + { + if (*yystr == '"') + { + std::string yyr = ""; + char const *yyp = yystr; + + for (;;) + switch (*++yyp) + { + case '\'': + case ',': + goto do_not_strip_quotes; + + case '\\': + if (*++yyp != '\\') + goto do_not_strip_quotes; + /* Fall through. */ + default: + yyr += *yyp; + break; + + case '"': + return yyr; + } + do_not_strip_quotes: ; + } + + return yystr; + } + + + /// Build a parser object. + LolFxParser::LolFxParser (class LolFxCompiler& mc_yyarg) + : +#if YYDEBUG + yydebug_ (false), + yycdebug_ (&std::cerr), +#endif + mc (mc_yyarg) + { + } + + LolFxParser::~LolFxParser () + { + } + +#if YYDEBUG + /*--------------------------------. + | Print this symbol on YYOUTPUT. | + `--------------------------------*/ + + inline void + LolFxParser::yy_symbol_value_print_ (int yytype, + const semantic_type* yyvaluep, const location_type* yylocationp) + { + YYUSE (yylocationp); + YYUSE (yyvaluep); + switch (yytype) + { + default: + break; + } + } + + + void + LolFxParser::yy_symbol_print_ (int yytype, + const semantic_type* yyvaluep, const location_type* yylocationp) + { + *yycdebug_ << (yytype < yyntokens_ ? "token" : "nterm") + << ' ' << yytname_[yytype] << " (" + << *yylocationp << ": "; + yy_symbol_value_print_ (yytype, yyvaluep, yylocationp); + *yycdebug_ << ')'; + } +#endif + + void + LolFxParser::yydestruct_ (const char* yymsg, + int yytype, semantic_type* yyvaluep, location_type* yylocationp) + { + YYUSE (yylocationp); + YYUSE (yymsg); + YYUSE (yyvaluep); + + YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); + + switch (yytype) + { + + default: + break; + } + } + + void + LolFxParser::yypop_ (unsigned int n) + { + yystate_stack_.pop (n); + yysemantic_stack_.pop (n); + yylocation_stack_.pop (n); + } + +#if YYDEBUG + std::ostream& + LolFxParser::debug_stream () const + { + return *yycdebug_; + } + + void + LolFxParser::set_debug_stream (std::ostream& o) + { + yycdebug_ = &o; + } + + + LolFxParser::debug_level_type + LolFxParser::debug_level () const + { + return yydebug_; + } + + void + LolFxParser::set_debug_level (debug_level_type l) + { + yydebug_ = l; + } +#endif + + inline bool + LolFxParser::yy_pact_value_is_default_ (int yyvalue) + { + return yyvalue == yypact_ninf_; + } + + inline bool + LolFxParser::yy_table_value_is_error_ (int yyvalue) + { + return yyvalue == yytable_ninf_; + } + + int + LolFxParser::parse () + { + /// Lookahead and lookahead in internal form. + int yychar = yyempty_; + int yytoken = 0; + + /* State. */ + int yyn; + int yylen = 0; + int yystate = 0; + + /* Error handling. */ + int yynerrs_ = 0; + int yyerrstatus_ = 0; + + /// Semantic value of the lookahead. + semantic_type yylval; + /// Location of the lookahead. + location_type yylloc; + /// The locations where the error started and ended. + location_type yyerror_range[3]; + + /// $$. + semantic_type yyval; + /// @$. + location_type yyloc; + + int yyresult; + + YYCDEBUG << "Starting parse" << std::endl; + + + /* Initialize the stacks. The initial state will be pushed in + yynewstate, since the latter expects the semantical and the + location values to have been already stored, initialize these + stacks with a primary value. */ + yystate_stack_ = state_stack_type (0); + yysemantic_stack_ = semantic_stack_type (0); + yylocation_stack_ = location_stack_type (0); + yysemantic_stack_.push (yylval); + yylocation_stack_.push (yylloc); + + /* New state. */ + yynewstate: + yystate_stack_.push (yystate); + YYCDEBUG << "Entering state " << yystate << std::endl; + + /* Accept? */ + if (yystate == yyfinal_) + goto yyacceptlab; + + goto yybackup; + + /* Backup. */ + yybackup: + + /* Try to take a decision without lookahead. */ + yyn = yypact_[yystate]; + if (yy_pact_value_is_default_ (yyn)) + goto yydefault; + + /* Read a lookahead token. */ + if (yychar == yyempty_) + { + YYCDEBUG << "Reading a token: "; + yychar = yylex (&yylval, &yylloc); + } + + + /* Convert token to internal form. */ + if (yychar <= yyeof_) + { + yychar = yytoken = yyeof_; + YYCDEBUG << "Now at end of input." << std::endl; + } + else + { + yytoken = yytranslate_ (yychar); + YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); + } + + /* If the proper action on seeing token YYTOKEN is to reduce or to + detect an error, take that action. */ + yyn += yytoken; + if (yyn < 0 || yylast_ < yyn || yycheck_[yyn] != yytoken) + goto yydefault; + + /* Reduce or error. */ + yyn = yytable_[yyn]; + if (yyn <= 0) + { + if (yy_table_value_is_error_ (yyn)) + goto yyerrlab; + yyn = -yyn; + goto yyreduce; + } + + /* Shift the lookahead token. */ + YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); + + /* Discard the token being shifted. */ + yychar = yyempty_; + + yysemantic_stack_.push (yylval); + yylocation_stack_.push (yylloc); + + /* Count tokens shifted since error; after three, turn off error + status. */ + if (yyerrstatus_) + --yyerrstatus_; + + yystate = yyn; + goto yynewstate; + + /*-----------------------------------------------------------. + | yydefault -- do the default action for the current state. | + `-----------------------------------------------------------*/ + yydefault: + yyn = yydefact_[yystate]; + if (yyn == 0) + goto yyerrlab; + goto yyreduce; + + /*-----------------------------. + | yyreduce -- Do a reduction. | + `-----------------------------*/ + yyreduce: + yylen = yyr2_[yyn]; + /* If YYLEN is nonzero, implement the default value of the action: + `$$ = $1'. Otherwise, use the top of the stack. + + Otherwise, the following line sets YYVAL to garbage. + This behavior is undocumented and Bison + users should not rely upon it. */ + if (yylen) + yyval = yysemantic_stack_[yylen - 1]; + else + yyval = yysemantic_stack_[0]; + + { + slice slice (yylocation_stack_, yylen); + YYLLOC_DEFAULT (yyloc, slice, yylen); + } + YY_REDUCE_PRINT (yyn); + switch (yyn) + { + case 7: + +/* Line 690 of lalr1.cc */ +#line 729 "gpu/lolfx-parser.y" + { std::cout << "New tech " << (yysemantic_stack_[(5) - (2)].sval) << std::endl; } + break; + + case 10: + +/* Line 690 of lalr1.cc */ +#line 742 "gpu/lolfx-parser.y" + { std::cout << "New pass " << (yysemantic_stack_[(5) - (2)].sval) << std::endl; } + break; + + case 29: + +/* Line 690 of lalr1.cc */ +#line 778 "gpu/lolfx-parser.y" + { std::cout << "new shader" << std::endl; } + break; + + + +/* Line 690 of lalr1.cc */ +#line 488 "generated/lolfx-parser.cpp" + default: + break; + } + /* User semantic actions sometimes alter yychar, and that requires + that yytoken be updated with the new translation. We take the + approach of translating immediately before every use of yytoken. + One alternative is translating here after every semantic action, + but that translation would be missed if the semantic action + invokes YYABORT, YYACCEPT, or YYERROR immediately after altering + yychar. In the case of YYABORT or YYACCEPT, an incorrect + destructor might then be invoked immediately. In the case of + YYERROR, subsequent parser actions might lead to an incorrect + destructor call or verbose syntax error message before the + lookahead is translated. */ + YY_SYMBOL_PRINT ("-> $$ =", yyr1_[yyn], &yyval, &yyloc); + + yypop_ (yylen); + yylen = 0; + YY_STACK_PRINT (); + + yysemantic_stack_.push (yyval); + yylocation_stack_.push (yyloc); + + /* Shift the result of the reduction. */ + yyn = yyr1_[yyn]; + yystate = yypgoto_[yyn - yyntokens_] + yystate_stack_[0]; + if (0 <= yystate && yystate <= yylast_ + && yycheck_[yystate] == yystate_stack_[0]) + yystate = yytable_[yystate]; + else + yystate = yydefgoto_[yyn - yyntokens_]; + goto yynewstate; + + /*------------------------------------. + | yyerrlab -- here on detecting error | + `------------------------------------*/ + yyerrlab: + /* Make sure we have latest lookahead translation. See comments at + user semantic actions for why this is necessary. */ + yytoken = yytranslate_ (yychar); + + /* If not already recovering from an error, report this error. */ + if (!yyerrstatus_) + { + ++yynerrs_; + if (yychar == yyempty_) + yytoken = yyempty_; + error (yylloc, yysyntax_error_ (yystate, yytoken)); + } + + yyerror_range[1] = yylloc; + if (yyerrstatus_ == 3) + { + /* If just tried and failed to reuse lookahead token after an + error, discard it. */ + + if (yychar <= yyeof_) + { + /* Return failure if at end of input. */ + if (yychar == yyeof_) + YYABORT; + } + else + { + yydestruct_ ("Error: discarding", yytoken, &yylval, &yylloc); + yychar = yyempty_; + } + } + + /* Else will try to reuse lookahead token after shifting the error + token. */ + goto yyerrlab1; + + + /*---------------------------------------------------. + | yyerrorlab -- error raised explicitly by YYERROR. | + `---------------------------------------------------*/ + yyerrorlab: + + /* Pacify compilers like GCC when the user code never invokes + YYERROR and the label yyerrorlab therefore never appears in user + code. */ + if (false) + goto yyerrorlab; + + yyerror_range[1] = yylocation_stack_[yylen - 1]; + /* Do not reclaim the symbols of the rule which action triggered + this YYERROR. */ + yypop_ (yylen); + yylen = 0; + yystate = yystate_stack_[0]; + goto yyerrlab1; + + /*-------------------------------------------------------------. + | yyerrlab1 -- common code for both syntax error and YYERROR. | + `-------------------------------------------------------------*/ + yyerrlab1: + yyerrstatus_ = 3; /* Each real token shifted decrements this. */ + + for (;;) + { + yyn = yypact_[yystate]; + if (!yy_pact_value_is_default_ (yyn)) + { + yyn += yyterror_; + if (0 <= yyn && yyn <= yylast_ && yycheck_[yyn] == yyterror_) + { + yyn = yytable_[yyn]; + if (0 < yyn) + break; + } + } + + /* Pop the current state because it cannot handle the error token. */ + if (yystate_stack_.height () == 1) + YYABORT; + + yyerror_range[1] = yylocation_stack_[0]; + yydestruct_ ("Error: popping", + yystos_[yystate], + &yysemantic_stack_[0], &yylocation_stack_[0]); + yypop_ (); + yystate = yystate_stack_[0]; + YY_STACK_PRINT (); + } + + yyerror_range[2] = yylloc; + // Using YYLLOC is tempting, but would change the location of + // the lookahead. YYLOC is available though. + YYLLOC_DEFAULT (yyloc, yyerror_range, 2); + yysemantic_stack_.push (yylval); + yylocation_stack_.push (yyloc); + + /* Shift the error token. */ + YY_SYMBOL_PRINT ("Shifting", yystos_[yyn], + &yysemantic_stack_[0], &yylocation_stack_[0]); + + yystate = yyn; + goto yynewstate; + + /* Accept. */ + yyacceptlab: + yyresult = 0; + goto yyreturn; + + /* Abort. */ + yyabortlab: + yyresult = 1; + goto yyreturn; + + yyreturn: + if (yychar != yyempty_) + { + /* Make sure we have latest lookahead translation. See comments + at user semantic actions for why this is necessary. */ + yytoken = yytranslate_ (yychar); + yydestruct_ ("Cleanup: discarding lookahead", yytoken, &yylval, + &yylloc); + } + + /* Do not reclaim the symbols of the rule which action triggered + this YYABORT or YYACCEPT. */ + yypop_ (yylen); + while (yystate_stack_.height () != 1) + { + yydestruct_ ("Cleanup: popping", + yystos_[yystate_stack_[0]], + &yysemantic_stack_[0], + &yylocation_stack_[0]); + yypop_ (); + } + + return yyresult; + } + + // Generate an error message. + std::string + LolFxParser::yysyntax_error_ (int yystate, int yytoken) + { + std::string yyres; + // Number of reported tokens (one for the "unexpected", one per + // "expected"). + size_t yycount = 0; + // Its maximum. + enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; + // Arguments of yyformat. + char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; + + /* There are many possibilities here to consider: + - If this state is a consistent state with a default action, then + the only way this function was invoked is if the default action + is an error action. In that case, don't check for expected + tokens because there are none. + - The only way there can be no lookahead present (in yytoken) is + if this state is a consistent state with a default action. + Thus, detecting the absence of a lookahead is sufficient to + determine that there is no unexpected or expected token to + report. In that case, just report a simple "syntax error". + - Don't assume there isn't a lookahead just because this state is + a consistent state with a default action. There might have + been a previous inconsistent state, consistent state with a + non-default action, or user semantic action that manipulated + yychar. + - Of course, the expected token list depends on states to have + correct lookahead information, and it depends on the parser not + to perform extra reductions after fetching a lookahead from the + scanner and before detecting a syntax error. Thus, state + merging (from LALR or IELR) and default reductions corrupt the + expected token list. However, the list is correct for + canonical LR with one exception: it will still contain any + token that will not be accepted due to an error action in a + later state. + */ + if (yytoken != yyempty_) + { + yyarg[yycount++] = yytname_[yytoken]; + int yyn = yypact_[yystate]; + if (!yy_pact_value_is_default_ (yyn)) + { + /* Start YYX at -YYN if negative to avoid negative indexes in + YYCHECK. In other words, skip the first -YYN actions for + this state because they are default actions. */ + int yyxbegin = yyn < 0 ? -yyn : 0; + /* Stay within bounds of both yycheck and yytname. */ + int yychecklim = yylast_ - yyn + 1; + int yyxend = yychecklim < yyntokens_ ? yychecklim : yyntokens_; + for (int yyx = yyxbegin; yyx < yyxend; ++yyx) + if (yycheck_[yyx + yyn] == yyx && yyx != yyterror_ + && !yy_table_value_is_error_ (yytable_[yyx + yyn])) + { + if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) + { + yycount = 1; + break; + } + else + yyarg[yycount++] = yytname_[yyx]; + } + } + } + + char const* yyformat = 0; + switch (yycount) + { +#define YYCASE_(N, S) \ + case N: \ + yyformat = S; \ + break + YYCASE_(0, YY_("syntax error")); + YYCASE_(1, YY_("syntax error, unexpected %s")); + YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s")); + YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s")); + YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s")); + YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s")); +#undef YYCASE_ + } + + // Argument number. + size_t yyi = 0; + for (char const* yyp = yyformat; *yyp; ++yyp) + if (yyp[0] == '%' && yyp[1] == 's' && yyi < yycount) + { + yyres += yytnamerr_ (yyarg[yyi++]); + ++yyp; + } + else + yyres += *yyp; + return yyres; + } + + + /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing + STATE-NUM. */ + const short int LolFxParser::yypact_ninf_ = -432; + const short int + LolFxParser::yypact_[] = + { + -216, 132, -76, 143, -432, -216, -432, -432, 4397, -281, + -432, -432, -276, -432, -432, -432, 107, 115, -432, -432, + -248, 191, -432, -432, -432, 158, -432, -432, -432, -432, + -432, -432, -432, -432, -432, -432, -432, -432, -432, -432, + -432, -432, -432, -432, -432, -432, -432, -432, -432, -432, + -432, -432, -432, -432, -432, -432, -432, -432, -432, -432, + -432, -432, -432, -432, -432, -432, -432, -432, -432, -432, + -432, -432, -432, -432, -432, -432, -432, -432, -432, -432, + -432, -432, -432, -432, -432, -432, -432, -432, -432, -432, + -432, -432, -432, -432, -432, -432, -432, -432, -432, -432, + -432, -432, -432, 120, -432, -432, -432, -432, -432, -432, + -432, -432, -432, -432, -432, -3, -432, -432, -432, -432, + -426, -241, -229, 184, -431, -432, 217, 336, 279, 279, + 3716, -432, -432, -432, -214, 1052, -432, 4397, -432, -432, + 42, 231, -432, -432, -432, -432, 237, -432, 1052, -432, + -432, -157, 4555, 495, -432, -432, -432, 131, -432, -432, + -432, -432, -432, -432, 931, 150, -432, 248, -192, 279, + -432, -432, -432, -152, -432, -432, 2012, -432, -432, 276, + -147, 42, -144, -151, -145, -128, -186, -432, -130, 4555, + -432, 931, 343, 3968, -432, -432, -432, -432, -432, -432, + -83, -78, 3402, -77, -96, -73, 1316, -71, -70, 2135, + -69, -67, 3402, 3402, 619, -432, -432, 3402, -432, -432, + -432, -432, -432, -432, -252, -432, -432, -432, -74, -167, + 3525, -66, -13, 3402, -182, -166, -131, -262, -113, -85, + -90, -75, -40, -38, -297, -432, -432, -243, -432, -57, + -58, -432, -432, -432, -432, 743, -432, -432, -432, -432, + -432, -432, -432, -432, -432, 379, 931, -135, 3402, 2584, + -432, -432, 4555, -432, -432, -432, -55, -432, -47, -432, + -432, 384, -432, 231, 391, -432, 237, -432, 4136, 343, + -45, -238, -432, -432, -432, -432, -311, -432, -432, -432, + 272, 13, 3402, -432, -227, 3402, 1889, -432, -432, -432, + 1192, -137, -432, -432, 3402, 1630, -432, -432, 3402, -46, + -432, -432, -432, -432, -432, -432, -432, -432, -432, -432, + -432, -432, -432, 3402, -432, 3402, 3402, 3402, 3402, 3402, + 3402, 3402, 3402, 3402, 3402, 3402, 3402, 3402, 3402, 3402, + 3402, 3402, 3402, 3402, 3402, -432, 3402, -432, -432, -42, + -432, -432, 3402, 2707, -432, -432, -39, -37, 4253, -432, + -7, 398, -432, -432, -432, -432, -219, 2830, -432, 343, + -432, -36, -432, -432, 1889, -134, -432, -107, -41, 399, + 931, -24, -432, -432, -20, -41, -19, -432, -432, -432, + -432, -432, -432, -432, -182, -182, -166, -166, -131, -131, + -131, -131, -262, -262, -113, -85, -90, -75, -40, -38, + -287, -432, 3402, -432, -17, -14, 3402, -11, -6, -101, + -10, -2, 0, 1, 4, 8, -432, -1, -7, -432, + -432, -432, 9, -432, 3402, -432, 15, 11, 1316, 6, + 17, 1440, -432, 3402, 16, 3402, 24, -432, 3402, -256, + -432, 3, 441, 446, 460, 462, 463, 468, 465, -432, + -432, -432, -102, 3402, 1440, 367, -432, 1316, 3402, -432, + -432, -432, -432, -432, -432, 3402, -432, -432, 3279, 35, + 36, 37, 38, 39, 40, 41, 44, 45, 46, 47, + 48, 49, -41, -432, 1316, 1316, 43, -432, -432, 51, + 50, -432, -432, -432, -432, -432, 53, -432, -432, -432, + -432, 54, -432, -432, -432, -432, -432, 52, 229, -4, + -432, 65, 162, 167, 286, -432, -432, -432, -432 + }; + + /* YYDEFACT[S] -- default reduction number in state S. Performed when + YYTABLE doesn't specify something else to do. Zero means the + default is an error. */ + const unsigned short int + LolFxParser::yydefact_[] = + { + 0, 0, 0, 0, 2, 3, 5, 6, 0, 0, + 31, 30, 0, 1, 4, 282, 0, 0, 164, 163, + 0, 162, 283, 284, 285, 0, 190, 202, 203, 204, + 208, 209, 210, 205, 206, 207, 211, 212, 213, 214, + 215, 216, 217, 220, 221, 222, 218, 223, 224, 225, + 219, 226, 227, 228, 229, 232, 233, 234, 230, 235, + 236, 237, 231, 238, 239, 240, 245, 248, 250, 246, + 249, 251, 268, 269, 275, 278, 247, 252, 253, 272, + 254, 258, 255, 259, 270, 276, 279, 256, 257, 260, + 273, 261, 265, 262, 266, 271, 277, 280, 263, 264, + 267, 274, 201, 0, 180, 198, 197, 181, 199, 165, + 182, 241, 242, 243, 244, 0, 200, 189, 196, 345, + 0, 0, 129, 139, 0, 145, 152, 179, 176, 173, + 0, 172, 160, 191, 193, 0, 281, 28, 342, 344, + 0, 0, 185, 186, 187, 188, 0, 159, 0, 183, + 184, 0, 0, 0, 119, 346, 127, 139, 143, 171, + 140, 142, 141, 130, 0, 139, 120, 0, 153, 0, + 177, 175, 174, 0, 126, 161, 0, 192, 343, 0, + 0, 8, 0, 0, 33, 169, 0, 167, 0, 0, + 162, 0, 0, 0, 288, 41, 38, 39, 40, 62, + 36, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 312, 316, 0, 67, 68, + 69, 70, 37, 43, 63, 45, 50, 51, 0, 0, + 56, 0, 71, 0, 75, 78, 81, 86, 89, 91, + 93, 95, 97, 99, 101, 103, 116, 0, 298, 0, + 160, 301, 314, 300, 299, 0, 302, 303, 304, 305, + 306, 307, 131, 136, 138, 144, 0, 146, 0, 0, + 132, 178, 0, 194, 71, 118, 0, 60, 0, 7, + 9, 0, 29, 0, 0, 166, 0, 121, 0, 0, + 294, 0, 292, 287, 289, 338, 0, 337, 327, 341, + 0, 0, 0, 339, 0, 0, 0, 64, 65, 308, + 0, 0, 47, 48, 0, 0, 54, 53, 0, 196, + 57, 59, 106, 107, 108, 109, 110, 111, 112, 113, + 114, 115, 105, 0, 66, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 317, 0, 313, 315, 133, + 135, 137, 0, 0, 297, 158, 154, 0, 0, 195, + 0, 35, 32, 170, 168, 286, 0, 0, 290, 0, + 326, 0, 332, 331, 334, 0, 340, 0, 321, 0, + 0, 0, 309, 42, 0, 49, 46, 61, 52, 58, + 104, 72, 73, 74, 76, 77, 79, 80, 84, 85, + 82, 83, 87, 88, 90, 92, 94, 96, 98, 100, + 0, 117, 0, 151, 147, 0, 0, 155, 0, 0, + 0, 0, 0, 0, 0, 0, 13, 0, 11, 34, + 291, 295, 0, 293, 0, 333, 0, 0, 0, 0, + 0, 0, 44, 0, 0, 0, 148, 156, 0, 0, + 122, 0, 0, 0, 0, 0, 0, 0, 0, 10, + 12, 296, 0, 335, 0, 320, 318, 324, 0, 311, + 328, 310, 102, 134, 149, 0, 157, 123, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 336, 330, 0, 325, 0, 322, 150, 0, + 0, 16, 15, 14, 17, 18, 0, 23, 24, 25, + 26, 0, 27, 329, 319, 323, 124, 0, 0, 0, + 125, 0, 0, 0, 0, 20, 19, 21, 22 + }; + + /* YYPGOTO[NTERM-NUM]. */ + const short int + LolFxParser::yypgoto_[] = + { + -432, -432, 475, -432, -432, 306, -432, 293, -432, -432, + -432, -432, -432, 470, -432, -432, -432, -432, -432, -432, + 535, -432, -432, -432, -432, -21, -432, 7, 14, -68, + 12, 507, 521, 522, 520, 523, 524, -432, -153, -89, + -432, -51, -154, 2, 5, -432, -432, -432, 607, 717, + 711, 612, -432, -432, -183, -432, 752, -432, -432, 594, + -432, 64, 19, -8, 32, -432, 856, -432, -72, -81, + 593, 504, -244, 583, -95, -302, -432, 411, 766, -211, + 586, -432, -432, 505, -432, -432, -432, -432, -432, -432, + -432, -432, -432, 751, -432 + }; + + /* YYDEFGOTO[NTERM-NUM]. */ + const short int + LolFxParser::yydefgoto_[] = + { + -1, 3, 4, 5, 6, 180, 181, 437, 438, 7, + 8, 12, 183, 184, 222, 223, 224, 394, 225, 226, + 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, + 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, + 333, 247, 276, 248, 249, 121, 122, 123, 263, 163, + 164, 264, 124, 125, 126, 127, 128, 129, 186, 187, + 165, 130, 131, 277, 133, 134, 135, 136, 193, 194, + 291, 292, 365, 251, 252, 253, 254, 480, 481, 255, + 256, 257, 476, 391, 258, 506, 259, 260, 384, 446, + 447, 261, 137, 138, 139 + }; + + /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If + positive, shift that token. If negative, reduce the rule which + number is the opposite. If YYTABLE_NINF_, syntax error. */ + const short int LolFxParser::yytable_ninf_ = -129; + const short int + LolFxParser::yytable_[] = + { + 132, 429, 459, 310, 533, 151, 489, 490, 1, 166, + 119, 491, 153, 120, 154, 167, 195, 196, 197, 198, + 199, 200, 15, 275, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, + 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, + 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, + 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, + 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, + 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, + 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, + 102, 300, 294, 103, 104, 367, 275, 288, 423, 105, + 10, 106, 175, 389, 107, 353, 108, 109, 110, 132, + 111, 112, 113, 114, 115, 356, 116, 117, 118, 119, + 9, 320, 120, 13, 192, 250, 170, 171, 172, 479, + 380, 296, 158, 342, 343, 274, 265, 140, 304, 356, + 358, 312, 313, 354, 2, 430, 311, 177, 141, 11, + 431, 158, 479, 432, 453, 22, 23, 24, 492, 364, + 188, 192, 457, 289, 487, 192, 488, 534, 271, 433, + 314, 307, 308, 344, 345, 315, 146, 355, 250, 147, + 368, 389, 378, 356, 156, 158, 250, 294, 379, 425, + 275, 484, 334, 386, 486, 358, 191, 157, 142, 356, + 434, 440, 143, 442, 275, 168, 144, 379, 176, 399, + 145, 149, 159, 531, 507, 150, 179, 532, 435, 182, + 493, 508, 160, 161, 400, 185, 162, 250, 274, 268, + 269, 385, 270, 191, 387, 388, 267, 191, 265, 285, + 286, 160, 161, 395, 192, 162, 505, 421, 454, 275, + 335, 336, 337, 364, 408, 409, 410, 411, 317, 318, + 192, 189, 338, 339, 278, 159, 272, 294, 340, 341, + 16, 17, 279, 250, 282, 160, 161, 281, 250, 162, + 26, 283, 250, 420, 346, 347, 362, 363, 393, 356, + 287, 448, 356, 284, 401, 402, 403, 274, 274, 274, + 274, 274, 274, 274, 274, 274, 274, 274, 274, 274, + 274, 274, 274, 388, 510, 275, 191, 364, 449, 356, + 461, 462, 274, 501, 356, 404, 405, 16, 17, 18, + 19, 290, 191, 475, 406, 407, 274, 26, 412, 413, + 192, -61, 295, 297, 482, 298, 364, 299, 349, 364, + 390, 316, 348, 301, 302, 305, 250, 306, 321, 103, + 104, 351, 175, 154, 350, 352, -60, 359, 369, 364, + 107, 370, 371, 472, 110, 373, 364, 377, 381, -55, + 422, 274, 426, 117, 439, 356, 427, 450, 444, 524, + 358, 322, 323, 324, 325, 326, 327, 328, 329, 330, + 331, 451, 502, 452, 455, -62, 212, 213, 332, 456, + 458, 463, 191, 436, 460, 152, 103, 104, 469, 464, + 250, 465, 466, 250, 477, 494, 467, 107, 390, 468, + 109, 110, 471, 216, 495, 473, 474, 217, 478, 483, + 117, 218, 219, 220, 221, 485, 250, 274, 496, 250, + 497, 498, 499, 500, 504, 511, 512, 513, 514, 515, + 14, 517, 525, 516, 518, 519, 520, 280, 522, 523, + 521, 526, 530, 527, 528, 529, 250, 250, 195, 196, + 197, 198, 199, 200, 15, 535, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, + 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, + 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, + 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, + 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, + 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, + 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, + 100, 101, 102, 201, 202, 103, 104, 203, 204, 205, + 206, 105, 536, 106, 207, 208, 107, 537, 108, 109, + 110, 209, 111, 112, 113, 114, 115, 210, 116, 117, + 118, 211, 195, 196, 197, 198, 199, 200, 15, -128, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, + 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, + 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, + 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, + 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, + 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, + 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 201, 202, 103, + 104, 203, 204, 205, 206, 105, 538, 106, 207, 208, + 107, 470, 108, 109, 110, 209, 111, 112, 113, 114, + 115, 210, 116, 117, 118, 211, 195, 196, 197, 198, + 199, 200, 15, 372, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, + 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, + 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, + 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, + 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, + 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, + 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, + 102, 201, 202, 103, 104, 203, 204, 205, 206, 105, + 398, 106, 207, 208, 107, 414, 108, 109, 110, 209, + 111, 112, 113, 114, 115, 210, 116, 117, 118, 211, + 415, 417, 416, 360, 262, 418, 266, 419, 361, 169, + 374, 148, 376, 443, 382, 503, 155, 383, 178, 445, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 212, 213, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 214, 215, 216, 0, 0, 0, 217, + 15, 0, 0, 218, 219, 220, 221, 0, 22, 23, + 24, 0, 0, 27, 28, 29, 30, 31, 32, 33, + 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, + 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, + 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, + 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, + 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, + 94, 95, 96, 97, 98, 99, 100, 101, 102, 0, + 0, 0, 212, 213, 0, 0, 0, 105, 0, 106, + 0, 0, 0, 0, 108, 0, 0, 0, 111, 112, + 113, 114, 115, 0, 116, 0, 118, 214, 309, 216, + 0, 15, 0, 217, 0, 0, 0, 218, 219, 220, + 221, 0, 0, 0, 27, 28, 29, 30, 31, 32, + 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, + 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, + 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, + 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, + 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, + 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, + 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, + 0, 0, 0, 0, 0, 0, 212, 213, 105, 0, + 106, 0, 0, 0, 0, 108, 0, 0, 0, 111, + 112, 113, 114, 115, 0, 116, 0, 118, 0, 0, + 0, 214, 357, 216, 0, 0, 0, 217, 0, 0, + 0, 218, 219, 220, 221, 195, 196, 197, 198, 199, + 200, 15, 0, 16, 17, 18, 19, 20, 21, 22, + 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, + 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, + 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, + 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, + 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, + 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, + 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, + 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, + 201, 202, 103, 104, 203, 204, 205, 206, 105, 0, + 106, 207, 208, 107, 0, 108, 109, 110, 209, 111, + 112, 113, 114, 115, 210, 116, 117, 118, 211, 195, + 196, 197, 198, 199, 200, 15, 0, 16, 17, 18, + 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, + 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, + 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, + 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, + 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, + 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, + 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, + 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, + 99, 100, 101, 102, 201, 202, 103, 104, 203, 204, + 205, 206, 105, 0, 106, 207, 208, 107, 0, 108, + 109, 110, 209, 111, 112, 113, 114, 115, 210, 116, + 117, 118, 211, 195, 196, 197, 198, 199, 200, 15, + 0, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, + 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, + 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, + 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, + 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, + 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, + 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, + 95, 96, 97, 98, 99, 100, 101, 102, 201, 202, + 103, 104, 203, 204, 205, 206, 105, 0, 106, 207, + 208, 107, 0, 108, 109, 110, 209, 111, 112, 113, + 114, 115, 210, 116, 117, 118, 211, 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, 212, 213, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 214, 392, 216, 0, 0, 0, 217, 396, 397, 15, + 218, 219, 220, 221, 0, 0, 0, 22, 23, 24, + 0, 0, 27, 28, 29, 30, 31, 32, 33, 34, + 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, + 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, + 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, + 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, + 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, + 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, + 95, 96, 97, 98, 99, 100, 101, 102, 0, 212, + 213, 0, 0, 0, 0, 0, 105, 0, 106, 0, + 0, 0, 0, 108, 0, 0, 0, 111, 112, 113, + 114, 115, 0, 116, 214, 118, 216, 0, 0, 0, + 217, 0, 0, 0, 218, 219, 220, 221, 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, 212, 213, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 153, 0, + 216, 0, 0, 0, 217, 0, 0, 0, 218, 219, + 220, 221, 195, 196, 197, 198, 199, 200, 15, 0, + 16, 17, 18, 19, 20, 190, 22, 23, 24, 0, + 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, + 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, + 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, + 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, + 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, + 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, + 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 0, 0, 103, + 104, 0, 0, 0, 0, 105, 0, 106, 0, 0, + 107, 0, 108, 109, 110, 0, 111, 112, 113, 114, + 115, 0, 116, 117, 118, 195, 196, 197, 198, 199, + 200, 15, 0, 0, 0, 0, 0, 0, 0, 22, + 23, 24, 0, 0, 27, 28, 29, 30, 31, 32, + 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, + 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, + 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, + 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, + 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, + 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, + 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, + 0, 0, 0, 0, 0, 0, 0, 0, 105, 0, + 106, 0, 0, 0, 0, 108, 0, 0, 0, 111, + 112, 113, 114, 115, 0, 116, 0, 118, 195, 196, + 197, 198, 199, 200, 15, 0, 0, 0, 0, 0, + 0, 0, 22, 23, 24, 0, 0, 27, 28, 29, + 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, + 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, + 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, + 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, + 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, + 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, + 100, 101, 102, 0, 0, 0, 0, 0, 0, 0, + 0, 105, 0, 106, 0, 0, 0, 0, 108, 0, + 0, 0, 111, 112, 113, 114, 115, 0, 116, 0, + 118, 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, 212, 213, 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, 217, 0, 0, 0, 218, 219, 220, + 221, 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, 212, 213, 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, 273, 217, 0, 0, 0, + 218, 219, 220, 221, 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, 212, 213, + 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, 303, 0, 0, 0, 217, + 0, 0, 0, 218, 219, 220, 221, 195, 196, 197, + 198, 199, 200, 15, 0, 0, 0, 0, 0, 0, + 0, 22, 23, 24, 0, 0, 27, 28, 29, 30, + 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, + 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, + 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, + 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, + 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, + 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, + 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, + 101, 102, 0, 0, 0, 0, 0, 0, 0, 0, + 105, 0, 106, 0, 0, 0, 0, 108, 0, 0, + 0, 111, 112, 113, 114, 115, 0, 116, 0, 118, + 195, 196, 197, 198, 199, 200, 15, 0, 0, 0, + 0, 0, 0, 0, 22, 23, 24, 0, 0, 27, + 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, + 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, + 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, + 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, + 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, + 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, + 98, 99, 100, 101, 102, 0, 0, 0, 0, 0, + 0, 0, 0, 105, 0, 106, 0, 0, 0, 0, + 108, 0, 0, 0, 111, 112, 113, 114, 115, 0, + 116, 0, 118, 195, 196, 197, 198, 199, 200, 15, + 0, 0, 0, 0, 0, 0, 0, 22, 23, 24, + 0, 0, 27, 28, 29, 30, 31, 32, 33, 34, + 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, + 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, + 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, + 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, + 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, + 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, + 95, 96, 97, 98, 99, 100, 101, 102, 0, 0, + 0, 0, 0, 0, 0, 0, 105, 0, 106, 0, + 0, 0, 0, 108, 0, 0, 0, 111, 112, 113, + 114, 115, 0, 116, 0, 118, 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, 212, 213, 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, 366, 217, 0, + 0, 0, 218, 219, 220, 221, 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, + 212, 213, 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, + 424, 217, 0, 0, 0, 218, 219, 220, 221, 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, 212, 213, 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, 441, 217, 0, 0, 0, 218, 219, + 220, 221, 195, 196, 197, 198, 199, 200, 15, 0, + 0, 0, 0, 0, 0, 0, 22, 23, 24, 0, + 0, 27, 28, 29, 30, 31, 32, 33, 34, 35, + 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, + 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, + 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, + 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, + 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, + 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 0, 0, 0, + 0, 0, 0, 0, 0, 105, 0, 106, 0, 0, + 0, 0, 108, 0, 0, 0, 111, 112, 113, 114, + 115, 0, 116, 0, 118, 195, 196, 197, 198, 199, + 200, 15, 0, 0, 0, 0, 0, 0, 0, 22, + 23, 24, 0, 0, 27, 28, 29, 30, 31, 32, + 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, + 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, + 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, + 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, + 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, + 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, + 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, + 0, 0, 0, 0, 0, 0, 0, 0, 105, 0, + 106, 0, 0, 0, 0, 108, 0, 0, 0, 111, + 112, 113, 114, 115, 0, 116, 0, 118, 195, 196, + 197, 198, 199, 200, 15, 0, 0, 0, 0, 0, + 0, 0, 22, 23, 24, 0, 0, 27, 28, 29, + 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, + 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, + 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, + 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, + 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, + 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, + 100, 101, 102, 0, 0, 0, 0, 0, 0, 0, + 0, 105, 0, 106, 0, 0, 0, 0, 108, 0, + 0, 0, 111, 112, 113, 114, 115, 0, 116, 0, + 319, 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, 212, 213, 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, 509, 217, 173, 15, 0, 218, 219, 220, + 221, 0, 0, 22, 23, 24, 0, 0, 27, 28, + 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, + 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, + 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, + 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, + 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, + 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, + 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, + 99, 100, 101, 102, 0, 212, 213, 0, 0, 0, + 0, 0, 105, 0, 106, 0, 0, 0, 0, 108, + 0, 0, 0, 111, 112, 113, 114, 115, 0, 116, + 0, 118, 0, 0, 0, 0, 217, 0, 0, 0, + 218, 219, 220, 221, 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, 212, 213, + 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, 217, + 0, 0, 0, 218, 219, 220, 221, 15, 0, 16, + 17, 18, 19, 20, 190, 22, 23, 24, 0, 26, + 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, + 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, + 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, + 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, + 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, + 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, + 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, + 97, 98, 99, 100, 101, 102, 0, 0, 103, 104, + 0, 0, 0, 0, 105, 0, 106, 0, 0, 107, + 0, 108, 109, 110, 0, 111, 112, 113, 114, 115, + 0, 116, 117, 118, 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, 15, 0, 16, 17, 18, + 19, 20, 190, 22, 23, 24, 174, 26, 27, 28, + 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, + 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, + 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, + 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, + 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, + 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, + 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, + 99, 100, 101, 102, 0, 0, 103, 104, 0, 0, + 0, 0, 105, 0, 106, 0, 0, 107, 0, 108, + 109, 110, 0, 111, 112, 113, 114, 115, 0, 116, + 117, 118, 15, 0, 16, 17, 18, 19, 20, 190, + 22, 23, 24, 0, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, + 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, + 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, + 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, + 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, + 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, + 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, + 102, 0, 0, 103, 104, 0, 0, 0, 0, 105, + 0, 106, 0, 0, 107, 0, 108, 109, 110, 0, + 111, 112, 113, 114, 115, 0, 116, 117, 118, 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, 15, 293, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, + 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, + 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, + 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, + 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, + 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, + 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, + 98, 99, 100, 101, 102, 0, 0, 103, 104, 0, + 0, 0, 0, 105, 0, 106, 0, 0, 107, 0, + 108, 109, 110, 0, 111, 112, 113, 114, 115, 0, + 116, 117, 118, 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, 15, 0, 16, 17, 18, 19, + 20, 190, 22, 23, 24, 375, 26, 27, 28, 29, + 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, + 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, + 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, + 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, + 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, + 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, + 100, 101, 102, 0, 0, 103, 104, 0, 0, 0, + 0, 105, 0, 106, 0, 0, 107, 0, 108, 109, + 110, 0, 111, 112, 113, 114, 115, 0, 116, 117, + 118, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 428 + }; + + /* YYCHECK. */ + const short int + LolFxParser::yycheck_[] = + { + 8, 8, 8, 214, 8, 8, 3, 4, 224, 440, + 8, 8, 438, 8, 440, 446, 3, 4, 5, 6, + 7, 8, 9, 176, 11, 12, 13, 14, 15, 16, + 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, + 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, + 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, + 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, + 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, + 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, + 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, + 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, + 97, 206, 193, 100, 101, 269, 269, 189, 362, 106, + 196, 108, 130, 306, 111, 422, 113, 114, 115, 137, + 117, 118, 119, 120, 121, 446, 123, 124, 125, 137, + 8, 230, 137, 0, 152, 153, 127, 128, 129, 451, + 461, 202, 21, 415, 416, 176, 164, 438, 209, 446, + 255, 413, 414, 460, 380, 172, 217, 135, 444, 245, + 177, 21, 474, 180, 461, 17, 18, 19, 175, 268, + 148, 189, 426, 191, 440, 193, 442, 191, 169, 196, + 442, 212, 213, 455, 456, 447, 444, 440, 206, 8, + 272, 384, 440, 446, 445, 21, 214, 288, 446, 363, + 363, 455, 233, 440, 458, 310, 152, 446, 111, 446, + 227, 440, 115, 377, 377, 8, 111, 446, 442, 318, + 115, 111, 101, 4, 478, 115, 194, 8, 245, 8, + 237, 485, 111, 112, 333, 8, 115, 255, 269, 441, + 442, 302, 444, 189, 305, 306, 8, 193, 266, 445, + 446, 111, 112, 314, 272, 115, 477, 356, 422, 422, + 452, 453, 454, 362, 342, 343, 344, 345, 445, 446, + 288, 438, 448, 449, 8, 101, 438, 368, 419, 420, + 11, 12, 439, 301, 445, 111, 112, 441, 306, 115, + 21, 446, 310, 354, 417, 418, 441, 442, 445, 446, + 440, 445, 446, 441, 335, 336, 337, 338, 339, 340, + 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, + 351, 352, 353, 384, 488, 488, 272, 426, 445, 446, + 441, 442, 363, 445, 446, 338, 339, 11, 12, 13, + 14, 8, 288, 448, 340, 341, 377, 21, 346, 347, + 368, 444, 440, 440, 453, 461, 455, 440, 458, 458, + 306, 445, 457, 444, 444, 444, 384, 444, 444, 100, + 101, 421, 390, 440, 459, 423, 444, 8, 443, 478, + 111, 438, 8, 444, 115, 4, 485, 442, 126, 445, + 442, 422, 441, 124, 6, 446, 443, 8, 444, 504, + 505, 424, 425, 426, 427, 428, 429, 430, 431, 432, + 433, 445, 473, 443, 441, 444, 413, 414, 441, 443, + 441, 441, 368, 440, 440, 438, 100, 101, 439, 441, + 448, 441, 441, 451, 438, 4, 442, 111, 384, 441, + 114, 115, 443, 440, 8, 440, 445, 444, 441, 443, + 124, 448, 449, 450, 451, 441, 474, 488, 8, 477, + 8, 8, 4, 8, 107, 440, 440, 440, 440, 440, + 5, 440, 439, 443, 440, 440, 440, 181, 440, 440, + 443, 440, 440, 443, 441, 441, 504, 505, 3, 4, + 5, 6, 7, 8, 9, 440, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, + 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, + 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, + 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, + 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, + 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, + 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, + 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, + 105, 106, 440, 108, 109, 110, 111, 440, 113, 114, + 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, + 125, 126, 3, 4, 5, 6, 7, 8, 9, 445, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, + 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, + 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, + 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, + 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, + 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, + 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, + 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, + 101, 102, 103, 104, 105, 106, 440, 108, 109, 110, + 111, 438, 113, 114, 115, 116, 117, 118, 119, 120, + 121, 122, 123, 124, 125, 126, 3, 4, 5, 6, + 7, 8, 9, 283, 11, 12, 13, 14, 15, 16, + 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, + 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, + 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, + 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, + 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, + 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, + 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, + 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, + 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, + 315, 108, 109, 110, 111, 348, 113, 114, 115, 116, + 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, + 349, 351, 350, 266, 157, 352, 165, 353, 266, 127, + 286, 25, 289, 379, 301, 474, 120, 301, 137, 384, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 413, 414, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 438, 439, 440, -1, -1, -1, 444, + 9, -1, -1, 448, 449, 450, 451, -1, 17, 18, + 19, -1, -1, 22, 23, 24, 25, 26, 27, 28, + 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, + 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, + 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, + 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, + 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, + 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, + 89, 90, 91, 92, 93, 94, 95, 96, 97, -1, + -1, -1, 413, 414, -1, -1, -1, 106, -1, 108, + -1, -1, -1, -1, 113, -1, -1, -1, 117, 118, + 119, 120, 121, -1, 123, -1, 125, 438, 439, 440, + -1, 9, -1, 444, -1, -1, -1, 448, 449, 450, + 451, -1, -1, -1, 22, 23, 24, 25, 26, 27, + 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, + 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, + 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, + 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, + 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, + 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, + -1, -1, -1, -1, -1, -1, 413, 414, 106, -1, + 108, -1, -1, -1, -1, 113, -1, -1, -1, 117, + 118, 119, 120, 121, -1, 123, -1, 125, -1, -1, + -1, 438, 439, 440, -1, -1, -1, 444, -1, -1, + -1, 448, 449, 450, 451, 3, 4, 5, 6, 7, + 8, 9, -1, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, + 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, + 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, + 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, + 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, + 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, + 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, + 98, 99, 100, 101, 102, 103, 104, 105, 106, -1, + 108, 109, 110, 111, -1, 113, 114, 115, 116, 117, + 118, 119, 120, 121, 122, 123, 124, 125, 126, 3, + 4, 5, 6, 7, 8, 9, -1, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, + 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, + 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, + 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, + 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, + 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, + 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, + 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, + 104, 105, 106, -1, 108, 109, 110, 111, -1, 113, + 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, + 124, 125, 126, 3, 4, 5, 6, 7, 8, 9, + -1, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, + 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, + 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, + 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, + 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, + 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, + 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, + 100, 101, 102, 103, 104, 105, 106, -1, 108, 109, + 110, 111, -1, 113, 114, 115, 116, 117, 118, 119, + 120, 121, 122, 123, 124, 125, 126, -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, 413, 414, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 438, 439, 440, -1, -1, -1, 444, 7, 8, 9, + 448, 449, 450, 451, -1, -1, -1, 17, 18, 19, + -1, -1, 22, 23, 24, 25, 26, 27, 28, 29, + 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, + 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, + 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, + 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, + 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, + 90, 91, 92, 93, 94, 95, 96, 97, -1, 413, + 414, -1, -1, -1, -1, -1, 106, -1, 108, -1, + -1, -1, -1, 113, -1, -1, -1, 117, 118, 119, + 120, 121, -1, 123, 438, 125, 440, -1, -1, -1, + 444, -1, -1, -1, 448, 449, 450, 451, -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, 413, 414, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 438, -1, + 440, -1, -1, -1, 444, -1, -1, -1, 448, 449, + 450, 451, 3, 4, 5, 6, 7, 8, 9, -1, + 11, 12, 13, 14, 15, 16, 17, 18, 19, -1, + 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, + 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, + 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, + 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, + 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, + 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, + 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, + 91, 92, 93, 94, 95, 96, 97, -1, -1, 100, + 101, -1, -1, -1, -1, 106, -1, 108, -1, -1, + 111, -1, 113, 114, 115, -1, 117, 118, 119, 120, + 121, -1, 123, 124, 125, 3, 4, 5, 6, 7, + 8, 9, -1, -1, -1, -1, -1, -1, -1, 17, + 18, 19, -1, -1, 22, 23, 24, 25, 26, 27, + 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, + 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, + 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, + 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, + 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, + 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, + -1, -1, -1, -1, -1, -1, -1, -1, 106, -1, + 108, -1, -1, -1, -1, 113, -1, -1, -1, 117, + 118, 119, 120, 121, -1, 123, -1, 125, 3, 4, + 5, 6, 7, 8, 9, -1, -1, -1, -1, -1, + -1, -1, 17, 18, 19, -1, -1, 22, 23, 24, + 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, + 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, + 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, + 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, + 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, + 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, + 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, + 95, 96, 97, -1, -1, -1, -1, -1, -1, -1, + -1, 106, -1, 108, -1, -1, -1, -1, 113, -1, + -1, -1, 117, 118, 119, 120, 121, -1, 123, -1, + 125, -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, 413, 414, -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, 444, -1, -1, -1, 448, 449, 450, + 451, -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, 413, 414, -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, 443, 444, -1, -1, -1, + 448, 449, 450, 451, -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, 413, 414, + -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, 440, -1, -1, -1, 444, + -1, -1, -1, 448, 449, 450, 451, 3, 4, 5, + 6, 7, 8, 9, -1, -1, -1, -1, -1, -1, + -1, 17, 18, 19, -1, -1, 22, 23, 24, 25, + 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, + 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, + 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, + 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, + 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, + 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, + 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, -1, -1, -1, -1, -1, -1, -1, -1, + 106, -1, 108, -1, -1, -1, -1, 113, -1, -1, + -1, 117, 118, 119, 120, 121, -1, 123, -1, 125, + 3, 4, 5, 6, 7, 8, 9, -1, -1, -1, + -1, -1, -1, -1, 17, 18, 19, -1, -1, 22, + 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, + 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, + 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, + 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, + 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, + 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, + 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, + 93, 94, 95, 96, 97, -1, -1, -1, -1, -1, + -1, -1, -1, 106, -1, 108, -1, -1, -1, -1, + 113, -1, -1, -1, 117, 118, 119, 120, 121, -1, + 123, -1, 125, 3, 4, 5, 6, 7, 8, 9, + -1, -1, -1, -1, -1, -1, -1, 17, 18, 19, + -1, -1, 22, 23, 24, 25, 26, 27, 28, 29, + 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, + 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, + 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, + 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, + 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, + 90, 91, 92, 93, 94, 95, 96, 97, -1, -1, + -1, -1, -1, -1, -1, -1, 106, -1, 108, -1, + -1, -1, -1, 113, -1, -1, -1, 117, 118, 119, + 120, 121, -1, 123, -1, 125, -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, 413, 414, -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, 443, 444, -1, + -1, -1, 448, 449, 450, 451, -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, + 413, 414, -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, + 443, 444, -1, -1, -1, 448, 449, 450, 451, -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, 413, 414, -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, 443, 444, -1, -1, -1, 448, 449, + 450, 451, 3, 4, 5, 6, 7, 8, 9, -1, + -1, -1, -1, -1, -1, -1, 17, 18, 19, -1, + -1, 22, 23, 24, 25, 26, 27, 28, 29, 30, + 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, + 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, + 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, + 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, + 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, + 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, + 91, 92, 93, 94, 95, 96, 97, -1, -1, -1, + -1, -1, -1, -1, -1, 106, -1, 108, -1, -1, + -1, -1, 113, -1, -1, -1, 117, 118, 119, 120, + 121, -1, 123, -1, 125, 3, 4, 5, 6, 7, + 8, 9, -1, -1, -1, -1, -1, -1, -1, 17, + 18, 19, -1, -1, 22, 23, 24, 25, 26, 27, + 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, + 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, + 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, + 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, + 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, + 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, + -1, -1, -1, -1, -1, -1, -1, -1, 106, -1, + 108, -1, -1, -1, -1, 113, -1, -1, -1, 117, + 118, 119, 120, 121, -1, 123, -1, 125, 3, 4, + 5, 6, 7, 8, 9, -1, -1, -1, -1, -1, + -1, -1, 17, 18, 19, -1, -1, 22, 23, 24, + 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, + 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, + 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, + 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, + 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, + 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, + 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, + 95, 96, 97, -1, -1, -1, -1, -1, -1, -1, + -1, 106, -1, 108, -1, -1, -1, -1, 113, -1, + -1, -1, 117, 118, 119, 120, 121, -1, 123, -1, + 125, -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, 413, 414, -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, 443, 444, 8, 9, -1, 448, 449, 450, + 451, -1, -1, 17, 18, 19, -1, -1, 22, 23, + 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, + 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, + 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, + 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, + 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, + 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, + 94, 95, 96, 97, -1, 413, 414, -1, -1, -1, + -1, -1, 106, -1, 108, -1, -1, -1, -1, 113, + -1, -1, -1, 117, 118, 119, 120, 121, -1, 123, + -1, 125, -1, -1, -1, -1, 444, -1, -1, -1, + 448, 449, 450, 451, -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, 413, 414, + -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, 444, + -1, -1, -1, 448, 449, 450, 451, 9, -1, 11, + 12, 13, 14, 15, 16, 17, 18, 19, -1, 21, + 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, + 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, + 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, + 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, + 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, + 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, + 92, 93, 94, 95, 96, 97, -1, -1, 100, 101, + -1, -1, -1, -1, 106, -1, 108, -1, -1, 111, + -1, 113, 114, 115, -1, 117, 118, 119, 120, 121, + -1, 123, 124, 125, -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, 9, -1, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 440, 21, 22, 23, + 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, + 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, + 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, + 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, + 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, + 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, + 94, 95, 96, 97, -1, -1, 100, 101, -1, -1, + -1, -1, 106, -1, 108, -1, -1, 111, -1, 113, + 114, 115, -1, 117, 118, 119, 120, 121, -1, 123, + 124, 125, 9, -1, 11, 12, 13, 14, 15, 16, + 17, 18, 19, -1, 21, 22, 23, 24, 25, 26, + 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, + 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, + 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, + 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, + 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, + 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, + 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, + 97, -1, -1, 100, 101, -1, -1, -1, -1, 106, + -1, 108, -1, -1, 111, -1, 113, 114, 115, -1, + 117, 118, 119, 120, 121, -1, 123, 124, 125, -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, 9, 439, 11, 12, + 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, + 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, + 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, + 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, + 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, + 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, + 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, + 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, + 93, 94, 95, 96, 97, -1, -1, 100, 101, -1, + -1, -1, -1, 106, -1, 108, -1, -1, 111, -1, + 113, 114, 115, -1, 117, 118, 119, 120, 121, -1, + 123, 124, 125, -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, 9, -1, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 439, 21, 22, 23, 24, + 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, + 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, + 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, + 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, + 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, + 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, + 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, + 95, 96, 97, -1, -1, 100, 101, -1, -1, -1, + -1, 106, -1, 108, -1, -1, 111, -1, 113, 114, + 115, -1, 117, 118, 119, 120, 121, -1, 123, 124, + 125, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 439 + }; + + /* STOS_[STATE-NUM] -- The (internal number of the) accessing + symbol of state STATE-NUM. */ + const unsigned short int + LolFxParser::yystos_[] = + { + 0, 224, 380, 463, 464, 465, 466, 471, 472, 8, + 196, 245, 473, 0, 464, 9, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, + 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, + 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, + 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, + 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, + 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, + 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, + 95, 96, 97, 100, 101, 106, 108, 111, 113, 114, + 115, 117, 118, 119, 120, 121, 123, 124, 125, 505, + 506, 507, 508, 509, 514, 515, 516, 517, 518, 519, + 523, 524, 525, 526, 527, 528, 529, 554, 555, 556, + 438, 444, 111, 115, 111, 115, 444, 8, 528, 111, + 115, 8, 438, 438, 440, 540, 445, 446, 21, 101, + 111, 112, 115, 511, 512, 522, 440, 446, 8, 518, + 524, 524, 524, 8, 440, 525, 442, 526, 555, 194, + 467, 468, 8, 474, 475, 8, 520, 521, 526, 438, + 16, 523, 525, 530, 531, 3, 4, 5, 6, 7, + 8, 98, 99, 102, 103, 104, 105, 109, 110, 116, + 122, 126, 413, 414, 438, 439, 440, 444, 448, 449, + 450, 451, 476, 477, 478, 480, 481, 482, 483, 484, + 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, + 495, 496, 497, 498, 499, 500, 501, 503, 505, 506, + 525, 535, 536, 537, 538, 541, 542, 543, 546, 548, + 549, 553, 511, 510, 513, 525, 512, 8, 441, 442, + 444, 524, 438, 443, 487, 500, 504, 525, 8, 439, + 467, 441, 445, 446, 441, 445, 446, 440, 530, 525, + 8, 532, 533, 439, 531, 440, 503, 440, 461, 440, + 536, 444, 444, 440, 503, 444, 444, 487, 487, 439, + 541, 503, 413, 414, 442, 447, 445, 445, 446, 125, + 501, 444, 424, 425, 426, 427, 428, 429, 430, 431, + 432, 433, 441, 502, 487, 452, 453, 454, 448, 449, + 419, 420, 415, 416, 455, 456, 417, 418, 457, 458, + 459, 421, 423, 422, 460, 440, 446, 439, 536, 8, + 510, 513, 441, 442, 501, 534, 443, 504, 530, 443, + 438, 8, 475, 4, 521, 439, 532, 442, 440, 446, + 461, 126, 535, 542, 550, 503, 440, 503, 503, 516, + 523, 545, 439, 445, 479, 503, 7, 8, 482, 501, + 501, 487, 487, 487, 489, 489, 490, 490, 491, 491, + 491, 491, 492, 492, 493, 494, 495, 496, 497, 498, + 503, 501, 442, 534, 443, 504, 441, 443, 439, 8, + 172, 177, 180, 196, 227, 245, 440, 469, 470, 6, + 440, 443, 504, 533, 444, 545, 551, 552, 445, 445, + 8, 445, 443, 461, 504, 441, 443, 534, 441, 8, + 440, 441, 442, 441, 441, 441, 441, 442, 441, 439, + 469, 443, 503, 440, 445, 536, 544, 438, 441, 537, + 539, 540, 501, 443, 534, 441, 534, 440, 442, 3, + 4, 8, 175, 237, 4, 8, 8, 8, 8, 4, + 8, 445, 503, 539, 107, 541, 547, 534, 534, 443, + 504, 440, 440, 440, 440, 440, 443, 440, 440, 440, + 440, 443, 440, 440, 536, 439, 440, 443, 441, 441, + 440, 4, 8, 8, 191, 440, 440, 440, 440 + }; + +#if YYDEBUG + /* TOKEN_NUMBER_[YYLEX-NUM] -- Internal symbol number corresponding + to YYLEX-NUM. */ + const unsigned short int + LolFxParser::yytoken_number_[] = + { + 0, 256, 257, 258, 259, 260, 261, 262, 263, 264, + 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, + 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, + 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, + 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, + 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, + 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, + 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, + 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, + 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, + 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, + 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, + 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, + 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, + 415, 416, 417, 418, 419, 420, 421, 422, 423, 424, + 425, 426, 427, 428, 429, 430, 431, 432, 433, 434, + 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, + 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, + 455, 456, 457, 458, 459, 460, 461, 462, 463, 464, + 465, 466, 467, 468, 469, 470, 471, 472, 473, 474, + 475, 476, 477, 478, 479, 480, 481, 482, 483, 484, + 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, + 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, + 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, + 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, + 525, 526, 527, 528, 529, 530, 531, 532, 533, 534, + 535, 536, 537, 538, 539, 540, 541, 542, 543, 544, + 545, 546, 547, 548, 549, 550, 551, 552, 553, 554, + 555, 556, 557, 558, 559, 560, 561, 562, 563, 564, + 565, 566, 567, 568, 569, 570, 571, 572, 573, 574, + 575, 576, 577, 578, 579, 580, 581, 582, 583, 584, + 585, 586, 587, 588, 589, 590, 591, 592, 593, 594, + 595, 596, 597, 598, 599, 600, 601, 602, 603, 604, + 605, 606, 607, 608, 609, 610, 611, 612, 613, 614, + 615, 616, 617, 618, 619, 620, 621, 622, 623, 624, + 625, 626, 627, 628, 629, 630, 631, 632, 633, 634, + 635, 636, 637, 638, 639, 640, 641, 642, 643, 644, + 645, 646, 647, 648, 649, 650, 651, 652, 653, 654, + 655, 656, 657, 658, 659, 660, 661, 662, 663, 664, + 665, 666, 667, 668, 669, 670, 671, 672, 673, 674, + 675, 676, 677, 678, 679, 680, 681, 682, 683, 684, + 685, 686, 687, 688, 689, 690, 691, 692, 123, 125, + 59, 61, 91, 93, 40, 41, 44, 46, 43, 45, + 33, 126, 42, 47, 37, 60, 62, 38, 94, 124, + 63, 58 + }; +#endif + + /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ + const unsigned short int + LolFxParser::yyr1_[] = + { + 0, 462, 463, 464, 464, 465, 465, 466, 467, 467, + 468, 469, 469, 470, 470, 470, 470, 470, 470, 470, + 470, 470, 470, 470, 470, 470, 470, 470, 471, 472, + 473, 473, 474, 474, 475, 475, 476, 477, 477, 477, + 477, 477, 477, 478, 478, 478, 478, 478, 478, 479, + 480, 481, 481, 482, 482, 483, 483, 484, 484, 485, + 486, 486, 486, 487, 487, 487, 487, 488, 488, 488, + 488, 489, 489, 489, 489, 490, 490, 490, 491, 491, + 491, 492, 492, 492, 492, 492, 493, 493, 493, 494, + 494, 495, 495, 496, 496, 497, 497, 498, 498, 499, + 499, 500, 500, 501, 501, 502, 502, 502, 502, 502, + 502, 502, 502, 502, 502, 502, 503, 503, 504, 505, + 505, 505, 505, 505, 505, 505, 505, 506, 507, 507, + 508, 508, 509, 510, 510, 511, 511, 511, 511, 512, + 512, 512, 512, 512, 513, 514, 514, 514, 514, 514, + 514, 514, 515, 515, 515, 515, 515, 515, 515, 515, + 516, 516, 517, 518, 518, 518, 519, 520, 520, 521, + 521, 522, 523, 523, 523, 523, 523, 523, 523, 523, + 524, 524, 524, 524, 524, 524, 524, 524, 524, 524, + 524, 525, 525, 526, 526, 526, 527, 527, 527, 527, + 527, 527, 527, 527, 527, 527, 527, 527, 527, 527, + 527, 527, 527, 527, 527, 527, 527, 527, 527, 527, + 527, 527, 527, 527, 527, 527, 527, 527, 527, 527, + 527, 527, 527, 527, 527, 527, 527, 527, 527, 527, + 527, 527, 527, 527, 527, 527, 527, 527, 527, 527, + 527, 527, 527, 527, 527, 527, 527, 527, 527, 527, + 527, 527, 527, 527, 527, 527, 527, 527, 527, 527, + 527, 527, 527, 527, 527, 527, 527, 527, 527, 527, + 527, 527, 527, 528, 528, 528, 529, 529, 530, 530, + 531, 531, 532, 532, 533, 533, 533, 534, 535, 536, + 536, 537, 537, 537, 537, 537, 537, 537, 538, 538, + 539, 539, 540, 540, 541, 541, 542, 542, 543, 544, + 544, 545, 545, 546, 547, 547, 548, 548, 549, 549, + 549, 550, 550, 551, 551, 552, 552, 553, 553, 553, + 553, 553, 554, 554, 555, 555, 556 + }; + + /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ + const unsigned char + LolFxParser::yyr2_[] = + { + 0, 2, 1, 1, 2, 1, 1, 5, 1, 2, + 5, 1, 2, 1, 4, 4, 4, 4, 4, 7, + 7, 7, 7, 4, 4, 4, 4, 4, 2, 5, + 1, 1, 3, 1, 4, 3, 1, 1, 1, 1, + 1, 1, 3, 1, 4, 1, 3, 2, 2, 1, + 1, 1, 3, 2, 2, 2, 1, 2, 3, 2, + 1, 1, 1, 1, 2, 2, 2, 1, 1, 1, + 1, 1, 3, 3, 3, 1, 3, 3, 1, 3, + 3, 1, 3, 3, 3, 3, 1, 3, 3, 1, + 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, + 3, 1, 5, 1, 3, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 3, 1, 2, + 2, 4, 6, 7, 9, 10, 2, 2, 1, 1, + 2, 3, 3, 2, 5, 3, 2, 3, 2, 0, + 1, 1, 1, 1, 1, 1, 3, 5, 6, 7, + 8, 5, 1, 2, 4, 5, 6, 7, 4, 2, + 1, 2, 1, 1, 1, 1, 4, 1, 3, 1, + 3, 1, 1, 1, 2, 2, 1, 2, 3, 1, + 1, 1, 1, 2, 2, 2, 2, 2, 2, 1, + 1, 1, 2, 1, 3, 4, 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, 5, 4, 1, 2, + 3, 4, 1, 3, 1, 3, 4, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, + 1, 1, 2, 3, 1, 2, 1, 2, 5, 3, + 1, 1, 4, 7, 0, 1, 3, 2, 5, 7, + 6, 1, 1, 1, 0, 2, 3, 2, 2, 2, + 3, 2, 1, 2, 1, 1, 2 + }; + +#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE + /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. + First, the terminals, then, starting at \a yyntokens_, nonterminals. */ + const char* + const LolFxParser::yytname_[] = + { + "T_END", "error", "$undefined", "BOOLCONSTANT", "INTCONSTANT", + "UINTCONSTANT", "FLOATCONSTANT", "FIELDSELECTION", "IDENTIFIER", + "TYPENAME", "GT_SUBROUTINE", "GT_PATCH", "GT_SAMPLE", "GT_FLAT", + "GT_SMOOTH", "GT_LAYOUT", "GT_INVARIANT", "GT_HIGHP", "GT_MEDIUMP", + "GT_LOWP", "GT_PRECISION", "GT_ATTRIBUTE", "GT_VEC2", "GT_VEC3", + "GT_VEC4", "GT_BVEC2", "GT_BVEC3", "GT_BVEC4", "GT_DVEC2", "GT_DVEC3", + "GT_DVEC4", "GT_IVEC2", "GT_IVEC3", "GT_IVEC4", "GT_UVEC2", "GT_UVEC3", + "GT_UVEC4", "GT_MAT2", "GT_MAT2X2", "GT_MAT2X3", "GT_MAT2X4", "GT_MAT3", + "GT_MAT3X2", "GT_MAT3X3", "GT_MAT3X4", "GT_MAT4", "GT_MAT4X2", + "GT_MAT4X3", "GT_MAT4X4", "GT_DMAT2", "GT_DMAT2X2", "GT_DMAT2X3", + "GT_DMAT2X4", "GT_DMAT3", "GT_DMAT3X2", "GT_DMAT3X3", "GT_DMAT3X4", + "GT_DMAT4", "GT_DMAT4X2", "GT_DMAT4X3", "GT_DMAT4X4", + "GT_SAMPLER1DSHADOW", "GT_SAMPLER1DARRAY", "GT_SAMPLER1DARRAYSHADOW", + "GT_SAMPLER2DSHADOW", "GT_SAMPLER2DARRAY", "GT_SAMPLER2DARRAYSHADOW", + "GT_SAMPLER2DRECT", "GT_SAMPLER2DRECTSHADOW", "GT_SAMPLER2DMS", + "GT_SAMPLER2DMSARRAY", "GT_SAMPLERCUBESHADOW", "GT_SAMPLERCUBEARRAY", + "GT_SAMPLERCUBEARRAYSHADOW", "GT_SAMPLERBUFFER", "GT_ISAMPLER1D", + "GT_ISAMPLER1DARRAY", "GT_ISAMPLER2D", "GT_ISAMPLER2DARRAY", + "GT_ISAMPLER2DRECT", "GT_ISAMPLER2DMS", "GT_ISAMPLER2DMSARRAY", + "GT_ISAMPLER3D", "GT_ISAMPLERCUBE", "GT_ISAMPLERCUBEARRAY", + "GT_ISAMPLERBUFFER", "GT_USAMPLER1D", "GT_USAMPLER1DARRAY", + "GT_USAMPLER2D", "GT_USAMPLER2DARRAY", "GT_USAMPLER2DRECT", + "GT_USAMPLER2DMS", "GT_USAMPLER2DMSARRAY", "GT_USAMPLER3D", + "GT_USAMPLERCUBE", "GT_USAMPLERCUBEARRAY", "GT_USAMPLERBUFFER", + "GHT_BOOL", "GHT_BREAK", "GHT_CASE", "GHT_CENTROID", "GHT_CONST", + "GHT_CONTINUE", "GHT_DEFAULT", "GHT_DISCARD", "GHT_DO", "GHT_DOUBLE", + "GHT_ELSE", "GHT_FLOAT", "GHT_FOR", "GHT_IF", "GHT_IN", "GHT_INOUT", + "GHT_INT", "GHT_NOPERSPECTIVE", "GHT_OUT", "GHT_RETURN", "GHT_SAMPLER1D", + "GHT_SAMPLER2D", "GHT_SAMPLER3D", "GHT_SAMPLERCUBE", "GHT_STRUCT", + "GHT_SWITCH", "GHT_UINT", "GHT_UNIFORM", "GHT_VOID", "GHT_WHILE", + "HGT_BOOL", "HGT_BREAK", "HGT_CASE", "HGT_CENTROID", "HGT_CONST", + "HGT_CONTINUE", "HGT_DEFAULT", "HGT_DISCARD", "HGT_DO", "HGT_DOUBLE", + "HGT_ELSE", "HGT_FLOAT", "HGT_FOR", "HGT_IF", "HGT_IN", "HGT_INOUT", + "HGT_INT", "HGT_NOPERSPECTIVE", "HGT_OUT", "HGT_RETURN", "HGT_SAMPLER1D", + "HGT_SAMPLER2D", "HGT_SAMPLER3D", "HGT_SAMPLERCUBE", "HGT_STRUCT", + "HGT_SWITCH", "HGT_UINT", "HGT_UNIFORM", "HGT_VOID", "HGT_WHILE", + "HT_APPENDSTRUCTUREDBUFFER", "HT_ASM", "HT_ASM_FRAGMENT", + "HT_BLENDSTATE", "HT_BUFFER", "HT_BYTEADDRESSBUFFER", "HT_CBUFFER", + "HT_COLUMN_MAJOR", "HT_COMPILE", "HT_COMPILE_FRAGMENT", + "HT_COMPILESHADER", "HT_COMPUTESHADER", "HT_CONSUMESTRUCTUREDBUFFER", + "HT_DEPTHSTENCILSTATE", "HT_DEPTHSTENCILVIEW", "HT_DOMAINSHADER", + "HT_DWORD", "HT_EXTERN", "HT_FALSE", "HT_FXGROUP", "HT_GEOMETRYSHADER", + "HT_GROUPSHARED", "HT_HALF", "HT_HULLSHADER", "HT_INLINE", + "HT_INPUTPATCH", "HT_INTERFACE", "HT_LINE", "HT_LINEADJ", "HT_LINEAR", + "HT_LINESTREAM", "HT_MATRIX", "HT_NAMESPACE", "HT_NOINTERPOLATION", + "HT_NULL", "HT_OUTPUTPATCH", "HT_PACKOFFSET", "HT_PASS", + "HT_PIXELFRAGMENT", "HT_PIXELSHADER", "HT_POINT", "HT_POINTSTREAM", + "HT_PRECISE", "HT_RASTERIZERSTATE", "HT_RENDERTARGETVIEW", "HT_REGISTER", + "HT_ROW_MAJOR", "HT_RWBUFFER", "HT_RWBYTEADDRESSBUFFER", + "HT_RWSTRUCTUREDBUFFER", "HT_RWTEXTURE1D", "HT_RWTEXTURE1DARRAY", + "HT_RWTEXTURE2D", "HT_RWTEXTURE2DARRAY", "HT_RWTEXTURE3D", "HT_SAMPLER", + "HT_SAMPLER_STATE", "HT_SAMPLERSTATE", "HT_SAMPLERCOMPARISONSTATE", + "HT_SHARED", "HT_SNORM", "HT_STATEBLOCK", "HT_STATEBLOCK_STATE", + "HT_STATIC", "HT_STRING", "HT_STRUCTUREDBUFFER", "HT_TBUFFER", + "HT_TECHNIQUE", "HT_TECHNIQUE10", "HT_TECHNIQUE11XZ", "HT_TEXTURE", + "HT_TEXTURE1D", "HT_TEXTURE1DARRAY", "HT_TEXTURE2D", "HT_TEXTURE2DARRAY", + "HT_TEXTURE2DMS", "HT_TEXTURE2DMSARRAY", "HT_TEXTURE3D", + "HT_TEXTURECUBE", "HT_TEXTURECUBEARRAY", "HT_TRUE", "HT_TYPEDEF", + "HT_TRIANGLE", "HT_TRIANGLEADJ", "HT_TRIANGLESTREAM", "HT_UNORM", + "HT_VECTOR", "HT_VERTEXFRAGMENT", "HT_VERTEXSHADER", "HT_VOLATILE", + "HT_BOOL1", "HT_BOOL1x1", "HT_BOOL2x1", "HT_BOOL3x1", "HT_BOOL4x1", + "HT_BOOL2", "HT_BOOL1x2", "HT_BOOL2x2", "HT_BOOL3x2", "HT_BOOL4x2", + "HT_BOOL3", "HT_BOOL1x3", "HT_BOOL2x3", "HT_BOOL3x3", "HT_BOOL4x3", + "HT_BOOL4", "HT_BOOL1x4", "HT_BOOL2x4", "HT_BOOL3x4", "HT_BOOL4x4", + "HT_FLOAT1", "HT_FLOAT1x1", "HT_FLOAT2x1", "HT_FLOAT3x1", "HT_FLOAT4x1", + "HT_FLOAT2", "HT_FLOAT1x2", "HT_FLOAT2x2", "HT_FLOAT3x2", "HT_FLOAT4x2", + "HT_FLOAT3", "HT_FLOAT1x3", "HT_FLOAT2x3", "HT_FLOAT3x3", "HT_FLOAT4x3", + "HT_FLOAT4", "HT_FLOAT1x4", "HT_FLOAT2x4", "HT_FLOAT3x4", "HT_FLOAT4x4", + "HT_DOUBLE1", "HT_DOUBLE1x1", "HT_DOUBLE2x1", "HT_DOUBLE3x1", + "HT_DOUBLE4x1", "HT_DOUBLE2", "HT_DOUBLE1x2", "HT_DOUBLE2x2", + "HT_DOUBLE3x2", "HT_DOUBLE4x2", "HT_DOUBLE3", "HT_DOUBLE1x3", + "HT_DOUBLE2x3", "HT_DOUBLE3x3", "HT_DOUBLE4x3", "HT_DOUBLE4", + "HT_DOUBLE1x4", "HT_DOUBLE2x4", "HT_DOUBLE3x4", "HT_DOUBLE4x4", + "HT_DWORD1", "HT_DWORD1x1", "HT_DWORD2x1", "HT_DWORD3x1", "HT_DWORD4x1", + "HT_DWORD2", "HT_DWORD1x2", "HT_DWORD2x2", "HT_DWORD3x2", "HT_DWORD4x2", + "HT_DWORD3", "HT_DWORD1x3", "HT_DWORD2x3", "HT_DWORD3x3", "HT_DWORD4x3", + "HT_DWORD4", "HT_DWORD1x4", "HT_DWORD2x4", "HT_DWORD3x4", "HT_DWORD4x4", + "HT_INT1", "HT_INT1x1", "HT_INT2x1", "HT_INT3x1", "HT_INT4x1", "HT_INT2", + "HT_INT1x2", "HT_INT2x2", "HT_INT3x2", "HT_INT4x2", "HT_INT3", + "HT_INT1x3", "HT_INT2x3", "HT_INT3x3", "HT_INT4x3", "HT_INT4", + "HT_INT1x4", "HT_INT2x4", "HT_INT3x4", "HT_INT4x4", "HT_UINT1", + "HT_UINT1x1", "HT_UINT2x1", "HT_UINT3x1", "HT_UINT4x1", "HT_UINT2", + "HT_UINT1x2", "HT_UINT2x2", "HT_UINT3x2", "HT_UINT4x2", "HT_UINT3", + "HT_UINT1x3", "HT_UINT2x3", "HT_UINT3x3", "HT_UINT4x3", "HT_UINT4", + "HT_UINT1x4", "HT_UINT2x4", "HT_UINT3x4", "HT_UINT4x4", + "PREPROCESSOR_DEFINE", "PREPROCESSOR_ELIF", "PREPROCESSOR_ELSE", + "PREPROCESSOR_ENDIF", "PREPROCESSOR_ERROR", "PREPROCESSOR_IF", + "PREPROCESSOR_IFDEF", "PREPROCESSOR_IFNDEF", "PREPROCESSOR_INCLUDE", + "PREPROCESSOR_LINE", "PREPROCESSOR_PRAGMA", "PREPROCESSOR_UNDEF", + "PREPROCESSOR_REGION", "PRAGMA_LOLFX", "HT_AUTO", "HT_CATCH", "HT_CHAR", + "HT_CLASS", "HT_CONST_CAST", "HT_DELETE", "HT_DYNAMIC_CAST", "HT_ENUM", + "HT_EXPLICIT", "HT_FRIEND", "HT_GOTO", "HT_LONG", "HT_MUTABLE", "HT_NEW", + "HT_OPERATOR", "HT_PRIVATE", "HT_PROTECTED", "HT_PUBLIC", + "HT_REINTERPRET_CAST", "HT_SHORT", "HT_SIGNED", "HT_SIZEOF", + "HT_STATIC_CAST", "HT_TEMPLATE", "HT_THIS", "HT_THROW", "HT_TRY", + "HT_TYPENAME", "HT_UNION", "HT_UNSIGNED", "HT_USING", "HT_VIRTUAL", + "T_INC", "T_DEC", "T_LE", "T_GE", "T_EQ", "T_NE", "T_LEFT", "T_RIGHT", + "T_AND", "T_OR", "T_XOR", "T_MULEQ", "T_DIVEQ", "T_MODEQ", "T_ADDEQ", + "T_SUBEQ", "T_LEFTEQ", "T_RIGHTEQ", "T_ANDEQ", "T_XOREQ", "T_OREQ", + "FLOAT", "STRING", "NAME", "T_ERROR", "'{'", "'}'", "';'", "'='", "'['", + "']'", "'('", "')'", "','", "'.'", "'+'", "'-'", "'!'", "'~'", "'*'", + "'/'", "'%'", "'<'", "'>'", "'&'", "'^'", "'|'", "'?'", "':'", "$accept", + "lolfx_file", "lolfx_section_list", "lolfx_section", "lolfx_technique", + "pass_list", "pass", "pass_stmt_list", "pass_stmt", "lolfx_shader", + "lolfx_shader_declaration", "lolfx_shader_type", + "lolfx_shader_description_list", "lolfx_shader_description", + "glsl_variable_identifier", "glsl_primary_expression", + "glsl_postfix_expression", "glsl_integer_expression", + "glsl_function_call", "glsl_function_call_or_method", + "glsl_function_call_generic", "glsl_function_call_header_no_parameters", + "glsl_function_call_header_with_parameters", "glsl_function_call_header", + "glsl_function_identifier", "glsl_unary_expression", + "glsl_unary_operator", "glsl_multiplicative_expression", + "glsl_additive_expression", "glsl_shift_expression", + "glsl_relational_expression", "glsl_equality_expression", + "glsl_and_expression", "glsl_exclusive_or_expression", + "glsl_inclusive_or_expression", "glsl_logical_and_expression", + "glsl_logical_xor_expression", "glsl_logical_or_expression", + "glsl_conditional_expression", "glsl_assignment_expression", + "glsl_assignment_operator", "glsl_expression", + "glsl_constant_expression", "glsl_declaration", + "glsl_function_prototype", "glsl_function_declarator", + "glsl_function_header_with_parameters", "glsl_function_header", + "glsl_parameter_declarator", "glsl_parameter_declaration", + "glsl_parameter_qualifier", "glsl_parameter_type_specifier", + "glsl_init_declarator_list", "glsl_single_declaration", + "glsl_fully_specified_type", "glsl_invariant_qualifier", + "glsl_interpolation_qualifier", "glsl_layout_qualifier", + "glsl_layout_qualifier_id_list", "glsl_layout_qualifier_id", + "glsl_parameter_type_qualifier", "glsl_type_qualifier", + "glsl_storage_qualifier", "glsl_type_specifier", + "glsl_type_specifier_no_prec", "glsl_type_specifier_nonarray", + "glsl_precision_qualifier", "glsl_struct_specifier", + "glsl_struct_declaration_list", "glsl_struct_declaration", + "glsl_struct_declarator_list", "glsl_struct_declarator", + "glsl_initializer", "glsl_declaration_statement", "glsl_statement", + "glsl_simple_statement", "glsl_compound_statement", + "glsl_statement_no_new_scope", "glsl_compound_statement_no_new_scope", + "glsl_statement_list", "glsl_expression_statement", + "glsl_selection_statement", "glsl_selection_rest_statement", + "glsl_condition", "glsl_switch_statement", "glsl_switch_statement_list", + "glsl_case_label", "glsl_iteration_statement", "glsl_for_init_statement", + "glsl_conditionopt", "glsl_for_rest_statement", "glsl_jump_statement", + "glsl_translation_unit", "glsl_external_declaration", + "glsl_function_definition", 0 + }; +#endif + +#if YYDEBUG + /* YYRHS -- A `-1'-separated list of the rules' RHS. */ + const LolFxParser::rhs_number_type + LolFxParser::yyrhs_[] = + { + 463, 0, -1, 464, -1, 465, -1, 465, 464, -1, + 466, -1, 471, -1, 224, 8, 438, 467, 439, -1, + 468, -1, 468, 467, -1, 194, 8, 438, 469, 439, + -1, 470, -1, 470, 469, -1, 440, -1, 8, 441, + 8, 440, -1, 8, 441, 4, 440, -1, 8, 441, + 3, 440, -1, 8, 441, 175, 440, -1, 8, 441, + 237, 440, -1, 8, 442, 4, 443, 441, 8, 440, + -1, 8, 442, 4, 443, 441, 4, 440, -1, 227, + 442, 4, 443, 441, 8, 440, -1, 227, 442, 4, + 443, 441, 191, 440, -1, 172, 441, 8, 440, -1, + 177, 441, 8, 440, -1, 180, 441, 8, 440, -1, + 196, 441, 8, 440, -1, 245, 441, 8, 440, -1, + 472, 554, -1, 380, 473, 444, 474, 445, -1, 245, + -1, 196, -1, 475, 446, 475, -1, 475, -1, 8, + 441, 8, 6, -1, 8, 441, 8, -1, 8, -1, + 476, -1, 4, -1, 5, -1, 6, -1, 3, -1, + 444, 503, 445, -1, 477, -1, 478, 442, 479, 443, + -1, 480, -1, 478, 447, 7, -1, 478, 413, -1, + 478, 414, -1, 503, -1, 481, -1, 482, -1, 478, + 447, 482, -1, 484, 445, -1, 483, 445, -1, 485, + 125, -1, 485, -1, 485, 501, -1, 484, 446, 501, + -1, 486, 444, -1, 525, -1, 8, -1, 7, -1, + 478, -1, 413, 487, -1, 414, 487, -1, 488, 487, + -1, 448, -1, 449, -1, 450, -1, 451, -1, 487, + -1, 489, 452, 487, -1, 489, 453, 487, -1, 489, + 454, 487, -1, 489, -1, 490, 448, 489, -1, 490, + 449, 489, -1, 490, -1, 491, 419, 490, -1, 491, + 420, 490, -1, 491, -1, 492, 455, 491, -1, 492, + 456, 491, -1, 492, 415, 491, -1, 492, 416, 491, + -1, 492, -1, 493, 417, 492, -1, 493, 418, 492, + -1, 493, -1, 494, 457, 493, -1, 494, -1, 495, + 458, 494, -1, 495, -1, 496, 459, 495, -1, 496, + -1, 497, 421, 496, -1, 497, -1, 498, 423, 497, + -1, 498, -1, 499, 422, 498, -1, 499, -1, 499, + 460, 503, 461, 501, -1, 500, -1, 487, 502, 501, + -1, 441, -1, 424, -1, 425, -1, 426, -1, 427, + -1, 428, -1, 429, -1, 430, -1, 431, -1, 432, + -1, 433, -1, 501, -1, 503, 446, 501, -1, 500, + -1, 506, 440, -1, 514, 440, -1, 20, 528, 526, + 440, -1, 523, 8, 438, 530, 439, 440, -1, 523, + 8, 438, 530, 439, 8, 440, -1, 523, 8, 438, + 530, 439, 8, 442, 443, 440, -1, 523, 8, 438, + 530, 439, 8, 442, 504, 443, 440, -1, 523, 440, + -1, 507, 445, -1, 509, -1, 508, -1, 509, 511, + -1, 508, 446, 511, -1, 516, 8, 444, -1, 525, + 8, -1, 525, 8, 442, 504, 443, -1, 522, 512, + 510, -1, 512, 510, -1, 522, 512, 513, -1, 512, + 513, -1, -1, 111, -1, 115, -1, 112, -1, 21, + -1, 525, -1, 515, -1, 514, 446, 8, -1, 514, + 446, 8, 442, 443, -1, 514, 446, 8, 442, 504, + 443, -1, 514, 446, 8, 442, 443, 441, 534, -1, + 514, 446, 8, 442, 504, 443, 441, 534, -1, 514, + 446, 8, 441, 534, -1, 516, -1, 516, 8, -1, + 516, 8, 442, 443, -1, 516, 8, 442, 504, 443, + -1, 516, 8, 442, 443, 441, 534, -1, 516, 8, + 442, 504, 443, 441, 534, -1, 516, 8, 441, 534, + -1, 16, 8, -1, 525, -1, 523, 525, -1, 16, + -1, 14, -1, 13, -1, 114, -1, 15, 444, 520, + 445, -1, 521, -1, 520, 446, 521, -1, 8, -1, + 8, 441, 4, -1, 101, -1, 524, -1, 519, -1, + 519, 524, -1, 518, 524, -1, 518, -1, 517, 524, + -1, 517, 518, 524, -1, 517, -1, 101, -1, 111, + -1, 115, -1, 100, 111, -1, 100, 115, -1, 11, + 111, -1, 11, 115, -1, 12, 111, -1, 12, 115, + -1, 124, -1, 21, -1, 526, -1, 528, 526, -1, + 527, -1, 527, 442, 443, -1, 527, 442, 504, 443, + -1, 125, -1, 108, -1, 106, -1, 113, -1, 123, + -1, 97, -1, 22, -1, 23, -1, 24, -1, 28, + -1, 29, -1, 30, -1, 25, -1, 26, -1, 27, + -1, 31, -1, 32, -1, 33, -1, 34, -1, 35, + -1, 36, -1, 37, -1, 41, -1, 45, -1, 38, + -1, 39, -1, 40, -1, 42, -1, 43, -1, 44, + -1, 46, -1, 47, -1, 48, -1, 49, -1, 53, + -1, 57, -1, 50, -1, 51, -1, 52, -1, 54, + -1, 55, -1, 56, -1, 58, -1, 59, -1, 60, + -1, 117, -1, 118, -1, 119, -1, 120, -1, 61, + -1, 64, -1, 71, -1, 62, -1, 65, -1, 63, + -1, 66, -1, 72, -1, 73, -1, 75, -1, 77, + -1, 82, -1, 83, -1, 76, -1, 78, -1, 84, + -1, 86, -1, 88, -1, 93, -1, 94, -1, 87, + -1, 89, -1, 95, -1, 67, -1, 68, -1, 79, + -1, 90, -1, 74, -1, 85, -1, 96, -1, 69, + -1, 80, -1, 91, -1, 70, -1, 81, -1, 92, + -1, 529, -1, 9, -1, 17, -1, 18, -1, 19, + -1, 121, 8, 438, 530, 439, -1, 121, 438, 530, + 439, -1, 531, -1, 530, 531, -1, 525, 532, 440, + -1, 523, 525, 532, 440, -1, 533, -1, 532, 446, + 533, -1, 8, -1, 8, 442, 443, -1, 8, 442, + 504, 443, -1, 501, -1, 505, -1, 538, -1, 537, + -1, 535, -1, 542, -1, 543, -1, 546, -1, 548, + -1, 549, -1, 553, -1, 438, 439, -1, 438, 541, + 439, -1, 540, -1, 537, -1, 438, 439, -1, 438, + 541, 439, -1, 536, -1, 541, 536, -1, 440, -1, + 503, 440, -1, 110, 444, 503, 445, 544, -1, 536, + 107, 536, -1, 536, -1, 503, -1, 516, 8, 441, + 534, -1, 122, 444, 503, 445, 438, 547, 439, -1, + -1, 541, -1, 99, 503, 461, -1, 103, 461, -1, + 126, 444, 545, 445, 539, -1, 105, 536, 126, 444, + 503, 445, 440, -1, 109, 444, 550, 552, 445, 539, + -1, 542, -1, 535, -1, 545, -1, -1, 551, 440, + -1, 551, 440, 503, -1, 102, 440, -1, 98, 440, + -1, 116, 440, -1, 116, 503, 440, -1, 104, 440, + -1, 555, -1, 554, 555, -1, 556, -1, 505, -1, + 506, 540, -1 + }; + + /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in + YYRHS. */ + const unsigned short int + LolFxParser::yyprhs_[] = + { + 0, 0, 3, 5, 7, 10, 12, 14, 20, 22, + 25, 31, 33, 36, 38, 43, 48, 53, 58, 63, + 71, 79, 87, 95, 100, 105, 110, 115, 120, 123, + 129, 131, 133, 137, 139, 144, 148, 150, 152, 154, + 156, 158, 160, 164, 166, 171, 173, 177, 180, 183, + 185, 187, 189, 193, 196, 199, 202, 204, 207, 211, + 214, 216, 218, 220, 222, 225, 228, 231, 233, 235, + 237, 239, 241, 245, 249, 253, 255, 259, 263, 265, + 269, 273, 275, 279, 283, 287, 291, 293, 297, 301, + 303, 307, 309, 313, 315, 319, 321, 325, 327, 331, + 333, 337, 339, 345, 347, 351, 353, 355, 357, 359, + 361, 363, 365, 367, 369, 371, 373, 375, 379, 381, + 384, 387, 392, 399, 407, 417, 428, 431, 434, 436, + 438, 441, 445, 449, 452, 458, 462, 465, 469, 472, + 473, 475, 477, 479, 481, 483, 485, 489, 495, 502, + 510, 519, 525, 527, 530, 535, 541, 548, 556, 561, + 564, 566, 569, 571, 573, 575, 577, 582, 584, 588, + 590, 594, 596, 598, 600, 603, 606, 608, 611, 615, + 617, 619, 621, 623, 626, 629, 632, 635, 638, 641, + 643, 645, 647, 650, 652, 656, 661, 663, 665, 667, + 669, 671, 673, 675, 677, 679, 681, 683, 685, 687, + 689, 691, 693, 695, 697, 699, 701, 703, 705, 707, + 709, 711, 713, 715, 717, 719, 721, 723, 725, 727, + 729, 731, 733, 735, 737, 739, 741, 743, 745, 747, + 749, 751, 753, 755, 757, 759, 761, 763, 765, 767, + 769, 771, 773, 775, 777, 779, 781, 783, 785, 787, + 789, 791, 793, 795, 797, 799, 801, 803, 805, 807, + 809, 811, 813, 815, 817, 819, 821, 823, 825, 827, + 829, 831, 833, 835, 837, 839, 841, 847, 852, 854, + 857, 861, 866, 868, 872, 874, 878, 883, 885, 887, + 889, 891, 893, 895, 897, 899, 901, 903, 905, 908, + 912, 914, 916, 919, 923, 925, 928, 930, 933, 939, + 943, 945, 947, 952, 960, 961, 963, 967, 970, 976, + 984, 991, 993, 995, 997, 998, 1001, 1005, 1008, 1011, + 1014, 1018, 1021, 1023, 1026, 1028, 1030 + }; + + /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */ + const unsigned short int + LolFxParser::yyrline_[] = + { + 0, 257, 711, 715, 716, 720, 721, 729, 737, 738, + 742, 746, 747, 752, 753, 754, 755, 756, 757, 758, + 759, 760, 761, 762, 763, 764, 765, 766, 774, 778, + 782, 783, 787, 788, 792, 793, 801, 805, 806, 807, + 808, 809, 810, 814, 815, 816, 817, 818, 819, 823, + 827, 831, 832, 836, 837, 841, 842, 846, 847, 851, + 855, 856, 857, 861, 862, 863, 864, 868, 869, 870, + 871, 875, 876, 877, 878, 882, 883, 884, 888, 889, + 890, 894, 895, 896, 897, 898, 902, 903, 904, 908, + 909, 913, 914, 918, 919, 923, 924, 928, 929, 933, + 934, 938, 939, 943, 944, 948, 949, 950, 951, 952, + 953, 954, 955, 956, 957, 958, 962, 963, 967, 971, + 972, 973, 974, 975, 976, 977, 978, 982, 986, 987, + 991, 992, 996, 1000, 1001, 1005, 1006, 1007, 1008, 1011, + 1013, 1014, 1015, 1016, 1020, 1024, 1025, 1026, 1027, 1028, + 1029, 1030, 1034, 1035, 1036, 1037, 1038, 1039, 1040, 1041, + 1045, 1046, 1050, 1054, 1055, 1056, 1060, 1064, 1065, 1069, + 1070, 1074, 1078, 1079, 1080, 1081, 1082, 1083, 1084, 1085, + 1089, 1090, 1091, 1092, 1093, 1094, 1095, 1096, 1097, 1098, + 1099, 1103, 1104, 1108, 1109, 1110, 1113, 1114, 1115, 1116, + 1117, 1118, 1119, 1120, 1121, 1122, 1123, 1124, 1125, 1126, + 1127, 1128, 1129, 1130, 1131, 1132, 1133, 1134, 1135, 1136, + 1137, 1138, 1139, 1140, 1141, 1142, 1143, 1144, 1145, 1146, + 1147, 1148, 1149, 1150, 1151, 1152, 1153, 1154, 1155, 1156, + 1157, 1158, 1159, 1160, 1161, 1162, 1163, 1164, 1165, 1166, + 1167, 1168, 1169, 1170, 1171, 1172, 1173, 1174, 1175, 1176, + 1177, 1178, 1179, 1180, 1181, 1182, 1183, 1184, 1185, 1186, + 1187, 1188, 1189, 1190, 1191, 1192, 1193, 1194, 1195, 1196, + 1197, 1198, 1199, 1203, 1204, 1205, 1209, 1210, 1214, 1215, + 1219, 1220, 1224, 1225, 1229, 1230, 1231, 1235, 1239, 1243, + 1244, 1248, 1249, 1250, 1251, 1252, 1253, 1254, 1258, 1259, + 1263, 1264, 1268, 1269, 1273, 1274, 1278, 1279, 1283, 1287, + 1288, 1292, 1293, 1297, 1300, 1302, 1306, 1307, 1311, 1312, + 1313, 1317, 1318, 1322, 1323, 1327, 1328, 1332, 1333, 1334, + 1335, 1336, 1340, 1341, 1345, 1346, 1350 + }; + + // Print the state stack on the debug stream. + void + LolFxParser::yystack_print_ () + { + *yycdebug_ << "Stack now"; + for (state_stack_type::const_iterator i = yystate_stack_.begin (); + i != yystate_stack_.end (); ++i) + *yycdebug_ << ' ' << *i; + *yycdebug_ << std::endl; + } + + // Report on the debug stream that the rule \a yyrule is going to be reduced. + void + LolFxParser::yy_reduce_print_ (int yyrule) + { + unsigned int yylno = yyrline_[yyrule]; + int yynrhs = yyr2_[yyrule]; + /* Print the symbols being reduced, and their result. */ + *yycdebug_ << "Reducing stack by rule " << yyrule - 1 + << " (line " << yylno << "):" << std::endl; + /* The symbols being reduced. */ + for (int yyi = 0; yyi < yynrhs; yyi++) + YY_SYMBOL_PRINT (" $" << yyi + 1 << " =", + yyrhs_[yyprhs_[yyrule] + yyi], + &(yysemantic_stack_[(yynrhs) - (yyi + 1)]), + &(yylocation_stack_[(yynrhs) - (yyi + 1)])); + } +#endif // YYDEBUG + + /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ + LolFxParser::token_number_type + LolFxParser::yytranslate_ (int t) + { + static + const token_number_type + translate_table[] = + { + 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 450, 2, 2, 2, 454, 457, 2, + 444, 445, 452, 448, 446, 449, 447, 453, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 461, 440, + 455, 441, 456, 460, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 442, 2, 443, 458, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 438, 459, 439, 451, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, + 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, + 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, + 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, + 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, + 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, + 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, + 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, + 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, + 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, + 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, + 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, + 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, + 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, + 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, + 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, + 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, + 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, + 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, + 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, + 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, + 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, + 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, + 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, + 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, + 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, + 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, + 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, + 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, + 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, + 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, + 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, + 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, + 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, + 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, + 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, + 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, + 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, + 415, 416, 417, 418, 419, 420, 421, 422, 423, 424, + 425, 426, 427, 428, 429, 430, 431, 432, 433, 434, + 435, 436, 437 + }; + if ((unsigned int) t <= yyuser_token_number_max_) + return translate_table[t]; + else + return yyundef_token_; + } + + const int LolFxParser::yyeof_ = 0; + const int LolFxParser::yylast_ = 4692; + const int LolFxParser::yynnts_ = 95; + const int LolFxParser::yyempty_ = -2; + const int LolFxParser::yyfinal_ = 13; + const int LolFxParser::yyterror_ = 1; + const int LolFxParser::yyerrcode_ = 256; + const int LolFxParser::yyntokens_ = 462; + + const unsigned int LolFxParser::yyuser_token_number_max_ = 692; + const LolFxParser::token_number_type LolFxParser::yyundef_token_ = 2; + + +} // lol + +/* Line 1136 of lalr1.cc */ +#line 2548 "generated/lolfx-parser.cpp" + + +/* Line 1138 of lalr1.cc */ +#line 1353 "gpu/lolfx-parser.y" + + +void lol::LolFxParser::error(const LolFxParser::location_type& l, + const std::string& m) +{ + mc.Error(l, m); +} + + diff --git a/src/generated/lolfx-parser.h b/src/generated/lolfx-parser.h new file mode 100644 index 00000000..53f8c73d --- /dev/null +++ b/src/generated/lolfx-parser.h @@ -0,0 +1,720 @@ +/* A Bison parser, made by GNU Bison 2.5. */ + +/* Skeleton interface for Bison LALR(1) parsers in C++ + + Copyright (C) 2002-2011 Free Software Foundation, Inc. + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . */ + +/* As a special exception, you may create a larger work that contains + part or all of the Bison parser skeleton and distribute that work + under terms of your choice, so long as that work isn't itself a + parser generator using the skeleton or a modified version thereof + as a parser skeleton. Alternatively, if you modify or redistribute + the parser skeleton itself, you may (at your option) remove this + special exception, which will cause the skeleton and the resulting + Bison output files to be licensed under the GNU General Public + License without this special exception. + + This special exception was added by the Free Software Foundation in + version 2.2 of Bison. */ + +/* C++ LALR(1) parser skeleton written by Akim Demaille. */ + +#ifndef PARSER_HEADER_H +# define PARSER_HEADER_H + + + +#include +#include +#include "stack.hh" +#include "location.hh" + +/* Enabling traces. */ +#ifndef YYDEBUG +# define YYDEBUG 1 +#endif + +/* Enabling verbose error messages. */ +#ifdef YYERROR_VERBOSE +# undef YYERROR_VERBOSE +# define YYERROR_VERBOSE 1 +#else +# define YYERROR_VERBOSE 1 +#endif + +/* Enabling the token table. */ +#ifndef YYTOKEN_TABLE +# define YYTOKEN_TABLE 0 +#endif + + +namespace lol { + +/* Line 35 of lalr1.cc */ +#line 68 "generated/lolfx-parser.h" + + /// A Bison parser. + class LolFxParser + { + public: + /// Symbol semantic values. +#ifndef YYSTYPE + union semantic_type + { + +/* Line 35 of lalr1.cc */ +#line 34 "gpu/lolfx-parser.y" + + int ival; + unsigned uval; + float fval; + char *sval; + + + +/* Line 35 of lalr1.cc */ +#line 90 "generated/lolfx-parser.h" + }; +#else + typedef YYSTYPE semantic_type; +#endif + /// Symbol locations. + typedef location location_type; + /// Tokens. + struct token + { + /* Tokens. */ + enum yytokentype { + T_END = 0, + BOOLCONSTANT = 258, + INTCONSTANT = 259, + UINTCONSTANT = 260, + FLOATCONSTANT = 261, + FIELDSELECTION = 262, + IDENTIFIER = 263, + TYPENAME = 264, + GT_SUBROUTINE = 265, + GT_PATCH = 266, + GT_SAMPLE = 267, + GT_FLAT = 268, + GT_SMOOTH = 269, + GT_LAYOUT = 270, + GT_INVARIANT = 271, + GT_HIGHP = 272, + GT_MEDIUMP = 273, + GT_LOWP = 274, + GT_PRECISION = 275, + GT_ATTRIBUTE = 276, + GT_VEC2 = 277, + GT_VEC3 = 278, + GT_VEC4 = 279, + GT_BVEC2 = 280, + GT_BVEC3 = 281, + GT_BVEC4 = 282, + GT_DVEC2 = 283, + GT_DVEC3 = 284, + GT_DVEC4 = 285, + GT_IVEC2 = 286, + GT_IVEC3 = 287, + GT_IVEC4 = 288, + GT_UVEC2 = 289, + GT_UVEC3 = 290, + GT_UVEC4 = 291, + GT_MAT2 = 292, + GT_MAT2X2 = 293, + GT_MAT2X3 = 294, + GT_MAT2X4 = 295, + GT_MAT3 = 296, + GT_MAT3X2 = 297, + GT_MAT3X3 = 298, + GT_MAT3X4 = 299, + GT_MAT4 = 300, + GT_MAT4X2 = 301, + GT_MAT4X3 = 302, + GT_MAT4X4 = 303, + GT_DMAT2 = 304, + GT_DMAT2X2 = 305, + GT_DMAT2X3 = 306, + GT_DMAT2X4 = 307, + GT_DMAT3 = 308, + GT_DMAT3X2 = 309, + GT_DMAT3X3 = 310, + GT_DMAT3X4 = 311, + GT_DMAT4 = 312, + GT_DMAT4X2 = 313, + GT_DMAT4X3 = 314, + GT_DMAT4X4 = 315, + GT_SAMPLER1DSHADOW = 316, + GT_SAMPLER1DARRAY = 317, + GT_SAMPLER1DARRAYSHADOW = 318, + GT_SAMPLER2DSHADOW = 319, + GT_SAMPLER2DARRAY = 320, + GT_SAMPLER2DARRAYSHADOW = 321, + GT_SAMPLER2DRECT = 322, + GT_SAMPLER2DRECTSHADOW = 323, + GT_SAMPLER2DMS = 324, + GT_SAMPLER2DMSARRAY = 325, + GT_SAMPLERCUBESHADOW = 326, + GT_SAMPLERCUBEARRAY = 327, + GT_SAMPLERCUBEARRAYSHADOW = 328, + GT_SAMPLERBUFFER = 329, + GT_ISAMPLER1D = 330, + GT_ISAMPLER1DARRAY = 331, + GT_ISAMPLER2D = 332, + GT_ISAMPLER2DARRAY = 333, + GT_ISAMPLER2DRECT = 334, + GT_ISAMPLER2DMS = 335, + GT_ISAMPLER2DMSARRAY = 336, + GT_ISAMPLER3D = 337, + GT_ISAMPLERCUBE = 338, + GT_ISAMPLERCUBEARRAY = 339, + GT_ISAMPLERBUFFER = 340, + GT_USAMPLER1D = 341, + GT_USAMPLER1DARRAY = 342, + GT_USAMPLER2D = 343, + GT_USAMPLER2DARRAY = 344, + GT_USAMPLER2DRECT = 345, + GT_USAMPLER2DMS = 346, + GT_USAMPLER2DMSARRAY = 347, + GT_USAMPLER3D = 348, + GT_USAMPLERCUBE = 349, + GT_USAMPLERCUBEARRAY = 350, + GT_USAMPLERBUFFER = 351, + GHT_BOOL = 352, + GHT_BREAK = 353, + GHT_CASE = 354, + GHT_CENTROID = 355, + GHT_CONST = 356, + GHT_CONTINUE = 357, + GHT_DEFAULT = 358, + GHT_DISCARD = 359, + GHT_DO = 360, + GHT_DOUBLE = 361, + GHT_ELSE = 362, + GHT_FLOAT = 363, + GHT_FOR = 364, + GHT_IF = 365, + GHT_IN = 366, + GHT_INOUT = 367, + GHT_INT = 368, + GHT_NOPERSPECTIVE = 369, + GHT_OUT = 370, + GHT_RETURN = 371, + GHT_SAMPLER1D = 372, + GHT_SAMPLER2D = 373, + GHT_SAMPLER3D = 374, + GHT_SAMPLERCUBE = 375, + GHT_STRUCT = 376, + GHT_SWITCH = 377, + GHT_UINT = 378, + GHT_UNIFORM = 379, + GHT_VOID = 380, + GHT_WHILE = 381, + HGT_BOOL = 382, + HGT_BREAK = 383, + HGT_CASE = 384, + HGT_CENTROID = 385, + HGT_CONST = 386, + HGT_CONTINUE = 387, + HGT_DEFAULT = 388, + HGT_DISCARD = 389, + HGT_DO = 390, + HGT_DOUBLE = 391, + HGT_ELSE = 392, + HGT_FLOAT = 393, + HGT_FOR = 394, + HGT_IF = 395, + HGT_IN = 396, + HGT_INOUT = 397, + HGT_INT = 398, + HGT_NOPERSPECTIVE = 399, + HGT_OUT = 400, + HGT_RETURN = 401, + HGT_SAMPLER1D = 402, + HGT_SAMPLER2D = 403, + HGT_SAMPLER3D = 404, + HGT_SAMPLERCUBE = 405, + HGT_STRUCT = 406, + HGT_SWITCH = 407, + HGT_UINT = 408, + HGT_UNIFORM = 409, + HGT_VOID = 410, + HGT_WHILE = 411, + HT_APPENDSTRUCTUREDBUFFER = 412, + HT_ASM = 413, + HT_ASM_FRAGMENT = 414, + HT_BLENDSTATE = 415, + HT_BUFFER = 416, + HT_BYTEADDRESSBUFFER = 417, + HT_CBUFFER = 418, + HT_COLUMN_MAJOR = 419, + HT_COMPILE = 420, + HT_COMPILE_FRAGMENT = 421, + HT_COMPILESHADER = 422, + HT_COMPUTESHADER = 423, + HT_CONSUMESTRUCTUREDBUFFER = 424, + HT_DEPTHSTENCILSTATE = 425, + HT_DEPTHSTENCILVIEW = 426, + HT_DOMAINSHADER = 427, + HT_DWORD = 428, + HT_EXTERN = 429, + HT_FALSE = 430, + HT_FXGROUP = 431, + HT_GEOMETRYSHADER = 432, + HT_GROUPSHARED = 433, + HT_HALF = 434, + HT_HULLSHADER = 435, + HT_INLINE = 436, + HT_INPUTPATCH = 437, + HT_INTERFACE = 438, + HT_LINE = 439, + HT_LINEADJ = 440, + HT_LINEAR = 441, + HT_LINESTREAM = 442, + HT_MATRIX = 443, + HT_NAMESPACE = 444, + HT_NOINTERPOLATION = 445, + HT_NULL = 446, + HT_OUTPUTPATCH = 447, + HT_PACKOFFSET = 448, + HT_PASS = 449, + HT_PIXELFRAGMENT = 450, + HT_PIXELSHADER = 451, + HT_POINT = 452, + HT_POINTSTREAM = 453, + HT_PRECISE = 454, + HT_RASTERIZERSTATE = 455, + HT_RENDERTARGETVIEW = 456, + HT_REGISTER = 457, + HT_ROW_MAJOR = 458, + HT_RWBUFFER = 459, + HT_RWBYTEADDRESSBUFFER = 460, + HT_RWSTRUCTUREDBUFFER = 461, + HT_RWTEXTURE1D = 462, + HT_RWTEXTURE1DARRAY = 463, + HT_RWTEXTURE2D = 464, + HT_RWTEXTURE2DARRAY = 465, + HT_RWTEXTURE3D = 466, + HT_SAMPLER = 467, + HT_SAMPLER_STATE = 468, + HT_SAMPLERSTATE = 469, + HT_SAMPLERCOMPARISONSTATE = 470, + HT_SHARED = 471, + HT_SNORM = 472, + HT_STATEBLOCK = 473, + HT_STATEBLOCK_STATE = 474, + HT_STATIC = 475, + HT_STRING = 476, + HT_STRUCTUREDBUFFER = 477, + HT_TBUFFER = 478, + HT_TECHNIQUE = 479, + HT_TECHNIQUE10 = 480, + HT_TECHNIQUE11XZ = 481, + HT_TEXTURE = 482, + HT_TEXTURE1D = 483, + HT_TEXTURE1DARRAY = 484, + HT_TEXTURE2D = 485, + HT_TEXTURE2DARRAY = 486, + HT_TEXTURE2DMS = 487, + HT_TEXTURE2DMSARRAY = 488, + HT_TEXTURE3D = 489, + HT_TEXTURECUBE = 490, + HT_TEXTURECUBEARRAY = 491, + HT_TRUE = 492, + HT_TYPEDEF = 493, + HT_TRIANGLE = 494, + HT_TRIANGLEADJ = 495, + HT_TRIANGLESTREAM = 496, + HT_UNORM = 497, + HT_VECTOR = 498, + HT_VERTEXFRAGMENT = 499, + HT_VERTEXSHADER = 500, + HT_VOLATILE = 501, + HT_BOOL1 = 502, + HT_BOOL1x1 = 503, + HT_BOOL2x1 = 504, + HT_BOOL3x1 = 505, + HT_BOOL4x1 = 506, + HT_BOOL2 = 507, + HT_BOOL1x2 = 508, + HT_BOOL2x2 = 509, + HT_BOOL3x2 = 510, + HT_BOOL4x2 = 511, + HT_BOOL3 = 512, + HT_BOOL1x3 = 513, + HT_BOOL2x3 = 514, + HT_BOOL3x3 = 515, + HT_BOOL4x3 = 516, + HT_BOOL4 = 517, + HT_BOOL1x4 = 518, + HT_BOOL2x4 = 519, + HT_BOOL3x4 = 520, + HT_BOOL4x4 = 521, + HT_FLOAT1 = 522, + HT_FLOAT1x1 = 523, + HT_FLOAT2x1 = 524, + HT_FLOAT3x1 = 525, + HT_FLOAT4x1 = 526, + HT_FLOAT2 = 527, + HT_FLOAT1x2 = 528, + HT_FLOAT2x2 = 529, + HT_FLOAT3x2 = 530, + HT_FLOAT4x2 = 531, + HT_FLOAT3 = 532, + HT_FLOAT1x3 = 533, + HT_FLOAT2x3 = 534, + HT_FLOAT3x3 = 535, + HT_FLOAT4x3 = 536, + HT_FLOAT4 = 537, + HT_FLOAT1x4 = 538, + HT_FLOAT2x4 = 539, + HT_FLOAT3x4 = 540, + HT_FLOAT4x4 = 541, + HT_DOUBLE1 = 542, + HT_DOUBLE1x1 = 543, + HT_DOUBLE2x1 = 544, + HT_DOUBLE3x1 = 545, + HT_DOUBLE4x1 = 546, + HT_DOUBLE2 = 547, + HT_DOUBLE1x2 = 548, + HT_DOUBLE2x2 = 549, + HT_DOUBLE3x2 = 550, + HT_DOUBLE4x2 = 551, + HT_DOUBLE3 = 552, + HT_DOUBLE1x3 = 553, + HT_DOUBLE2x3 = 554, + HT_DOUBLE3x3 = 555, + HT_DOUBLE4x3 = 556, + HT_DOUBLE4 = 557, + HT_DOUBLE1x4 = 558, + HT_DOUBLE2x4 = 559, + HT_DOUBLE3x4 = 560, + HT_DOUBLE4x4 = 561, + HT_DWORD1 = 562, + HT_DWORD1x1 = 563, + HT_DWORD2x1 = 564, + HT_DWORD3x1 = 565, + HT_DWORD4x1 = 566, + HT_DWORD2 = 567, + HT_DWORD1x2 = 568, + HT_DWORD2x2 = 569, + HT_DWORD3x2 = 570, + HT_DWORD4x2 = 571, + HT_DWORD3 = 572, + HT_DWORD1x3 = 573, + HT_DWORD2x3 = 574, + HT_DWORD3x3 = 575, + HT_DWORD4x3 = 576, + HT_DWORD4 = 577, + HT_DWORD1x4 = 578, + HT_DWORD2x4 = 579, + HT_DWORD3x4 = 580, + HT_DWORD4x4 = 581, + HT_INT1 = 582, + HT_INT1x1 = 583, + HT_INT2x1 = 584, + HT_INT3x1 = 585, + HT_INT4x1 = 586, + HT_INT2 = 587, + HT_INT1x2 = 588, + HT_INT2x2 = 589, + HT_INT3x2 = 590, + HT_INT4x2 = 591, + HT_INT3 = 592, + HT_INT1x3 = 593, + HT_INT2x3 = 594, + HT_INT3x3 = 595, + HT_INT4x3 = 596, + HT_INT4 = 597, + HT_INT1x4 = 598, + HT_INT2x4 = 599, + HT_INT3x4 = 600, + HT_INT4x4 = 601, + HT_UINT1 = 602, + HT_UINT1x1 = 603, + HT_UINT2x1 = 604, + HT_UINT3x1 = 605, + HT_UINT4x1 = 606, + HT_UINT2 = 607, + HT_UINT1x2 = 608, + HT_UINT2x2 = 609, + HT_UINT3x2 = 610, + HT_UINT4x2 = 611, + HT_UINT3 = 612, + HT_UINT1x3 = 613, + HT_UINT2x3 = 614, + HT_UINT3x3 = 615, + HT_UINT4x3 = 616, + HT_UINT4 = 617, + HT_UINT1x4 = 618, + HT_UINT2x4 = 619, + HT_UINT3x4 = 620, + HT_UINT4x4 = 621, + PREPROCESSOR_DEFINE = 622, + PREPROCESSOR_ELIF = 623, + PREPROCESSOR_ELSE = 624, + PREPROCESSOR_ENDIF = 625, + PREPROCESSOR_ERROR = 626, + PREPROCESSOR_IF = 627, + PREPROCESSOR_IFDEF = 628, + PREPROCESSOR_IFNDEF = 629, + PREPROCESSOR_INCLUDE = 630, + PREPROCESSOR_LINE = 631, + PREPROCESSOR_PRAGMA = 632, + PREPROCESSOR_UNDEF = 633, + PREPROCESSOR_REGION = 634, + PRAGMA_LOLFX = 635, + HT_AUTO = 636, + HT_CATCH = 637, + HT_CHAR = 638, + HT_CLASS = 639, + HT_CONST_CAST = 640, + HT_DELETE = 641, + HT_DYNAMIC_CAST = 642, + HT_ENUM = 643, + HT_EXPLICIT = 644, + HT_FRIEND = 645, + HT_GOTO = 646, + HT_LONG = 647, + HT_MUTABLE = 648, + HT_NEW = 649, + HT_OPERATOR = 650, + HT_PRIVATE = 651, + HT_PROTECTED = 652, + HT_PUBLIC = 653, + HT_REINTERPRET_CAST = 654, + HT_SHORT = 655, + HT_SIGNED = 656, + HT_SIZEOF = 657, + HT_STATIC_CAST = 658, + HT_TEMPLATE = 659, + HT_THIS = 660, + HT_THROW = 661, + HT_TRY = 662, + HT_TYPENAME = 663, + HT_UNION = 664, + HT_UNSIGNED = 665, + HT_USING = 666, + HT_VIRTUAL = 667, + T_INC = 668, + T_DEC = 669, + T_LE = 670, + T_GE = 671, + T_EQ = 672, + T_NE = 673, + T_LEFT = 674, + T_RIGHT = 675, + T_AND = 676, + T_OR = 677, + T_XOR = 678, + T_MULEQ = 679, + T_DIVEQ = 680, + T_MODEQ = 681, + T_ADDEQ = 682, + T_SUBEQ = 683, + T_LEFTEQ = 684, + T_RIGHTEQ = 685, + T_ANDEQ = 686, + T_XOREQ = 687, + T_OREQ = 688, + FLOAT = 689, + STRING = 690, + NAME = 691, + T_ERROR = 692 + }; + + }; + /// Token type. + typedef token::yytokentype token_type; + + /// Build a parser object. + LolFxParser (class LolFxCompiler& mc_yyarg); + virtual ~LolFxParser (); + + /// Parse. + /// \returns 0 iff parsing succeeded. + virtual int parse (); + +#if YYDEBUG + /// The current debugging stream. + std::ostream& debug_stream () const; + /// Set the current debugging stream. + void set_debug_stream (std::ostream &); + + /// Type for debugging levels. + typedef int debug_level_type; + /// The current debugging level. + debug_level_type debug_level () const; + /// Set the current debugging level. + void set_debug_level (debug_level_type l); +#endif + + private: + /// Report a syntax error. + /// \param loc where the syntax error is found. + /// \param msg a description of the syntax error. + virtual void error (const location_type& loc, const std::string& msg); + + /// Generate an error message. + /// \param state the state where the error occurred. + /// \param tok the lookahead token. + virtual std::string yysyntax_error_ (int yystate, int tok); + +#if YYDEBUG + /// \brief Report a symbol value on the debug stream. + /// \param yytype The token type. + /// \param yyvaluep Its semantic value. + /// \param yylocationp Its location. + virtual void yy_symbol_value_print_ (int yytype, + const semantic_type* yyvaluep, + const location_type* yylocationp); + /// \brief Report a symbol on the debug stream. + /// \param yytype The token type. + /// \param yyvaluep Its semantic value. + /// \param yylocationp Its location. + virtual void yy_symbol_print_ (int yytype, + const semantic_type* yyvaluep, + const location_type* yylocationp); +#endif + + + /// State numbers. + typedef int state_type; + /// State stack type. + typedef stack state_stack_type; + /// Semantic value stack type. + typedef stack semantic_stack_type; + /// location stack type. + typedef stack location_stack_type; + + /// The state stack. + state_stack_type yystate_stack_; + /// The semantic value stack. + semantic_stack_type yysemantic_stack_; + /// The location stack. + location_stack_type yylocation_stack_; + + /// Whether the given \c yypact_ value indicates a defaulted state. + /// \param yyvalue the value to check + static bool yy_pact_value_is_default_ (int yyvalue); + + /// Whether the given \c yytable_ value indicates a syntax error. + /// \param yyvalue the value to check + static bool yy_table_value_is_error_ (int yyvalue); + + /// Internal symbol numbers. + typedef unsigned short int token_number_type; + /* Tables. */ + /// For a state, the index in \a yytable_ of its portion. + static const short int yypact_[]; + static const short int yypact_ninf_; + + /// For a state, default reduction number. + /// Unless\a yytable_ specifies something else to do. + /// Zero means the default is an error. + static const unsigned short int yydefact_[]; + + static const short int yypgoto_[]; + static const short int yydefgoto_[]; + + /// What to do in a state. + /// \a yytable_[yypact_[s]]: what to do in state \a s. + /// - if positive, shift that token. + /// - if negative, reduce the rule which number is the opposite. + /// - if zero, do what YYDEFACT says. + static const short int yytable_[]; + static const short int yytable_ninf_; + + static const short int yycheck_[]; + + /// For a state, its accessing symbol. + static const unsigned short int yystos_[]; + + /// For a rule, its LHS. + static const unsigned short int yyr1_[]; + /// For a rule, its RHS length. + static const unsigned char yyr2_[]; + +#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE + /// For a symbol, its name in clear. + static const char* const yytname_[]; +#endif + + /// Convert the symbol name \a n to a form suitable for a diagnostic. + static std::string yytnamerr_ (const char *n); + +#if YYDEBUG + /// A type to store symbol numbers and -1. + typedef short int rhs_number_type; + /// A `-1'-separated list of the rules' RHS. + static const rhs_number_type yyrhs_[]; + /// For each rule, the index of the first RHS symbol in \a yyrhs_. + static const unsigned short int yyprhs_[]; + /// For each rule, its source line number. + static const unsigned short int yyrline_[]; + /// For each scanner token number, its symbol number. + static const unsigned short int yytoken_number_[]; + /// Report on the debug stream that the rule \a r is going to be reduced. + virtual void yy_reduce_print_ (int r); + /// Print the state stack on the debug stream. + virtual void yystack_print_ (); + + /* Debugging. */ + int yydebug_; + std::ostream* yycdebug_; +#endif + + /// Convert a scanner token number \a t to a symbol number. + token_number_type yytranslate_ (int t); + + /// \brief Reclaim the memory associated to a symbol. + /// \param yymsg Why this token is reclaimed. + /// \param yytype The symbol type. + /// \param yyvaluep Its semantic value. + /// \param yylocationp Its location. + inline void yydestruct_ (const char* yymsg, + int yytype, + semantic_type* yyvaluep, + location_type* yylocationp); + + /// Pop \a n symbols the three stacks. + inline void yypop_ (unsigned int n = 1); + + /* Constants. */ + static const int yyeof_; + /* LAST_ -- Last index in TABLE_. */ + static const int yylast_; + static const int yynnts_; + static const int yyempty_; + static const int yyfinal_; + static const int yyterror_; + static const int yyerrcode_; + static const int yyntokens_; + static const unsigned int yyuser_token_number_max_; + static const token_number_type yyundef_token_; + + /* User arguments. */ + class LolFxCompiler& mc; + }; + +} // lol + +/* Line 35 of lalr1.cc */ +#line 717 "generated/lolfx-parser.h" + + + +#endif /* ! defined PARSER_HEADER_H */ diff --git a/src/generated/lolfx-scanner.cpp b/src/generated/lolfx-scanner.cpp new file mode 100644 index 00000000..0dcb7d47 --- /dev/null +++ b/src/generated/lolfx-scanner.cpp @@ -0,0 +1,5085 @@ +#line 2 "generated/lolfx-scanner.cpp" + +#line 4 "generated/lolfx-scanner.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 + + /* The c++ scanner is a mess. The FlexLexer.h header file relies on the + * following macro. This is required in order to pass the c++-multiple-scanners + * test in the regression suite. We get reports that it breaks inheritance. + * We will address this in a future release of flex, or omit the C++ scanner + * altogether. + */ + #define yyFlexLexer LolFxFlexLexer + +/* First, we deal with platform-specific or compiler-specific issues. */ + +/* begin standard C headers. */ + +/* end standard C headers. */ + +/* flex integer type definitions */ + +#ifndef FLEXINT_H +#define FLEXINT_H + +/* C99 systems have . 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 +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 +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; + +/* 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 /* ! C99 */ + +#endif /* ! FLEXINT_H */ + +/* begin standard C++ headers. */ +#include +#include +#include +#include +#include +/* end standard C++ headers. */ + +#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) + +/* 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 (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 (((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 ) + +#define YY_END_OF_BUFFER_CHAR 0 + +/* 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 32768 +#else +#define YY_BUF_SIZE 16384 +#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 ((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 + +extern int yyleng; + +#define EOB_ACT_CONTINUE_SCAN 0 +#define EOB_ACT_END_OF_FILE 1 +#define EOB_ACT_LAST_MATCH 2 + + #define YY_LESS_LINENO(n) + +/* 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 = (yy_hold_char); \ + YY_RESTORE_YY_MORE_OFFSET \ + (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, (yytext_ptr) ) + +#ifndef YY_TYPEDEF_YY_SIZE_T +#define YY_TYPEDEF_YY_SIZE_T +typedef size_t yy_size_t; +#endif + +#ifndef YY_STRUCT_YY_BUFFER_STATE +#define YY_STRUCT_YY_BUFFER_STATE +struct yy_buffer_state + { + + std::istream* 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. + */ + int 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 ( (yy_buffer_stack) \ + ? (yy_buffer_stack)[(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 (yy_buffer_stack)[(yy_buffer_stack_top)] + +void *LolFxalloc (yy_size_t ); +void *LolFxrealloc (void *,yy_size_t ); +void LolFxfree (void * ); + +#define yy_new_buffer yy_create_buffer + +#define yy_set_interactive(is_interactive) \ + { \ + if ( ! YY_CURRENT_BUFFER ){ \ + yyensure_buffer_stack (); \ + YY_CURRENT_BUFFER_LVALUE = \ + yy_create_buffer( yyin, YY_BUF_SIZE ); \ + } \ + YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \ + } + +#define yy_set_bol(at_bol) \ + { \ + if ( ! YY_CURRENT_BUFFER ){\ + yyensure_buffer_stack (); \ + YY_CURRENT_BUFFER_LVALUE = \ + yy_create_buffer( yyin, YY_BUF_SIZE ); \ + } \ + YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \ + } + +#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol) + +/* Begin user sect3 */ + +typedef unsigned char YY_CHAR; + +#define yytext_ptr yytext + +#include + +/* Done after the current pattern has been matched and before the + * corresponding action - sets up yytext. + */ +#define YY_DO_BEFORE_ACTION \ + (yytext_ptr) = yy_bp; \ + yyleng = (size_t) (yy_cp - yy_bp); \ + (yy_hold_char) = *yy_cp; \ + *yy_cp = '\0'; \ + (yy_c_buf_p) = yy_cp; + +#define YY_NUM_RULES 445 +#define YY_END_OF_BUFFER 446 +/* 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[1633] = + { 0, + 0, 0, 439, 439, 444, 444, 446, 436, 434, 435, + 436, 436, 436, 436, 436, 436, 436, 436, 432, 432, + 436, 436, 436, 433, 433, 433, 433, 433, 433, 433, + 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, + 433, 433, 433, 433, 436, 91, 91, 433, 433, 433, + 433, 91, 433, 433, 433, 433, 433, 433, 92, 92, + 91, 92, 92, 433, 433, 90, 90, 436, 439, 440, + 441, 444, 443, 434, 414, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 422, 417, 427, 420, 409, 423, + 410, 424, 437, 442, 421, 0, 431, 432, 415, 411, + + 413, 412, 416, 433, 433, 433, 433, 433, 433, 433, + 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, + 131, 433, 433, 433, 433, 433, 433, 433, 433, 433, + 433, 433, 433, 433, 433, 433, 136, 137, 433, 433, + 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, + 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, + 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, + 433, 433, 433, 433, 433, 428, 419, 91, 433, 433, + 91, 433, 433, 433, 433, 433, 433, 433, 101, 433, + 433, 433, 433, 433, 91, 433, 106, 107, 433, 433, + + 433, 433, 433, 433, 433, 433, 433, 92, 433, 91, + 433, 433, 433, 92, 433, 433, 433, 433, 433, 433, + 433, 433, 433, 433, 433, 90, 429, 418, 439, 438, + 444, 0, 0, 0, 0, 0, 368, 0, 0, 0, + 0, 0, 430, 425, 426, 433, 154, 433, 433, 433, + 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, + 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, + 433, 433, 433, 433, 433, 433, 135, 433, 433, 433, + 433, 433, 433, 433, 433, 433, 433, 139, 433, 433, + 433, 433, 433, 390, 433, 433, 433, 433, 141, 433, + + 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, + 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, + 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, + 433, 433, 433, 403, 433, 433, 433, 433, 433, 433, + 433, 433, 433, 433, 433, 433, 91, 433, 433, 433, + 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, + 433, 433, 433, 105, 433, 433, 109, 433, 433, 433, + 433, 433, 433, 433, 433, 111, 433, 92, 433, 433, + 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, + 433, 433, 433, 433, 90, 0, 0, 0, 0, 0, + + 0, 0, 0, 0, 0, 0, 0, 0, 433, 433, + 377, 433, 123, 433, 433, 433, 125, 433, 433, 433, + 379, 433, 433, 433, 433, 433, 433, 433, 433, 433, + 433, 433, 433, 433, 133, 384, 433, 433, 433, 433, + 433, 433, 433, 387, 433, 175, 433, 433, 433, 433, + 323, 328, 333, 338, 433, 180, 388, 433, 433, 433, + 433, 433, 187, 433, 433, 433, 190, 433, 433, 433, + 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, + 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, + 433, 433, 433, 433, 433, 433, 433, 401, 433, 433, + + 233, 433, 149, 433, 433, 433, 433, 433, 433, 433, + 433, 151, 433, 433, 91, 433, 93, 433, 433, 95, + 433, 433, 433, 433, 433, 433, 433, 433, 103, 433, + 4, 433, 433, 433, 433, 433, 433, 433, 45, 61, + 65, 69, 433, 433, 433, 92, 433, 433, 433, 433, + 433, 433, 433, 433, 88, 119, 433, 433, 433, 58, + 59, 60, 121, 433, 90, 0, 0, 364, 365, 0, + 0, 0, 0, 0, 372, 0, 0, 0, 433, 433, + 433, 243, 248, 253, 258, 124, 433, 433, 378, 433, + 433, 380, 433, 433, 433, 127, 433, 433, 433, 433, + + 433, 433, 433, 433, 169, 433, 433, 433, 171, 134, + 433, 433, 433, 433, 433, 433, 138, 433, 433, 433, + 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, + 433, 433, 433, 433, 193, 433, 433, 433, 433, 433, + 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, + 433, 396, 433, 433, 213, 433, 433, 433, 433, 433, + 433, 433, 433, 433, 402, 433, 433, 433, 343, 348, + 353, 358, 433, 405, 238, 433, 407, 433, 433, 433, + 433, 152, 433, 94, 49, 50, 51, 433, 97, 433, + 433, 433, 76, 80, 84, 433, 73, 74, 75, 89, + + 104, 43, 108, 433, 433, 52, 53, 54, 433, 433, + 433, 433, 433, 433, 2, 433, 433, 433, 433, 433, + 433, 433, 433, 433, 433, 55, 56, 57, 122, 0, + 0, 366, 367, 369, 0, 0, 0, 374, 0, 433, + 433, 433, 433, 433, 433, 433, 157, 433, 433, 433, + 433, 433, 433, 433, 433, 433, 433, 382, 433, 433, + 433, 132, 303, 308, 313, 318, 433, 433, 170, 263, + 268, 273, 278, 386, 433, 433, 433, 433, 177, 433, + 324, 329, 334, 339, 325, 330, 335, 340, 326, 331, + 336, 341, 327, 332, 337, 342, 433, 433, 182, 433, + + 184, 433, 433, 433, 433, 433, 433, 433, 433, 433, + 433, 433, 433, 433, 394, 433, 433, 433, 433, 142, + 433, 433, 433, 433, 433, 433, 212, 397, 398, 433, + 216, 217, 147, 148, 433, 433, 433, 433, 433, 433, + 433, 433, 433, 433, 433, 433, 433, 239, 433, 433, + 433, 433, 433, 433, 433, 433, 433, 433, 433, 102, + 433, 433, 6, 62, 63, 64, 66, 67, 68, 70, + 71, 72, 433, 433, 433, 112, 3, 5, 117, 433, + 118, 433, 433, 433, 0, 363, 370, 0, 373, 0, + 433, 433, 433, 244, 249, 254, 259, 245, 250, 255, + + 260, 246, 251, 256, 261, 247, 252, 257, 262, 433, + 159, 433, 433, 161, 433, 433, 433, 433, 129, 433, + 130, 433, 283, 288, 293, 298, 433, 433, 433, 433, + 433, 433, 433, 433, 433, 433, 172, 433, 433, 433, + 433, 433, 181, 433, 389, 433, 433, 433, 433, 433, + 433, 433, 433, 433, 195, 392, 433, 433, 433, 433, + 433, 433, 433, 433, 433, 433, 208, 433, 433, 433, + 219, 433, 433, 433, 433, 234, 433, 344, 349, 354, + 359, 345, 350, 355, 360, 346, 351, 356, 361, 347, + 352, 357, 362, 150, 433, 433, 433, 408, 433, 433, + + 433, 433, 99, 100, 77, 78, 79, 81, 82, 83, + 85, 86, 87, 433, 433, 44, 433, 433, 208, 433, + 223, 120, 433, 0, 0, 371, 375, 433, 433, 433, + 433, 126, 433, 433, 433, 433, 433, 433, 128, 433, + 433, 433, 433, 433, 433, 304, 309, 314, 319, 305, + 310, 315, 320, 306, 311, 316, 321, 307, 312, 317, + 322, 433, 385, 264, 269, 274, 279, 265, 270, 275, + 280, 266, 271, 276, 281, 267, 272, 277, 282, 433, + 433, 433, 433, 433, 433, 433, 433, 433, 391, 433, + 433, 433, 433, 433, 433, 433, 198, 433, 433, 433, + + 200, 433, 433, 433, 433, 433, 433, 433, 433, 433, + 433, 433, 433, 433, 400, 433, 433, 433, 433, 235, + 404, 406, 433, 433, 242, 433, 96, 98, 433, 433, + 433, 433, 433, 433, 433, 433, 433, 433, 433, 0, + 375, 433, 433, 433, 433, 433, 433, 433, 433, 433, + 433, 433, 433, 284, 289, 294, 299, 285, 290, 295, + 300, 286, 291, 296, 301, 287, 292, 297, 302, 433, + 433, 433, 433, 433, 179, 433, 185, 433, 433, 433, + 433, 433, 433, 433, 393, 433, 433, 433, 199, 433, + 433, 433, 143, 144, 145, 433, 433, 433, 433, 433, + + 433, 433, 220, 224, 226, 230, 433, 433, 433, 433, + 433, 48, 47, 433, 433, 433, 433, 433, 433, 46, + 113, 114, 115, 433, 433, 433, 433, 433, 433, 433, + 433, 0, 433, 433, 156, 433, 433, 433, 433, 433, + 381, 433, 433, 433, 433, 433, 433, 176, 178, 183, + 433, 433, 433, 189, 433, 433, 433, 433, 433, 433, + 433, 433, 433, 433, 433, 433, 433, 433, 433, 214, + 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, + 433, 14, 15, 16, 433, 433, 433, 433, 433, 433, + 433, 433, 433, 433, 433, 1, 20, 21, 22, 433, + + 433, 0, 433, 433, 433, 433, 433, 433, 433, 433, + 433, 433, 433, 433, 174, 433, 433, 188, 433, 192, + 194, 433, 433, 433, 433, 433, 203, 205, 207, 433, + 146, 433, 433, 433, 399, 433, 221, 433, 433, 433, + 228, 231, 236, 433, 433, 433, 433, 433, 433, 433, + 433, 433, 433, 433, 433, 433, 37, 433, 433, 433, + 116, 433, 433, 433, 433, 433, 433, 376, 433, 155, + 433, 160, 433, 433, 433, 433, 433, 168, 383, 433, + 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, + 433, 210, 433, 433, 433, 433, 433, 433, 433, 433, + + 433, 433, 241, 433, 433, 38, 433, 433, 17, 433, + 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, + 433, 39, 433, 433, 23, 433, 433, 163, 433, 164, + 433, 433, 433, 433, 433, 140, 191, 433, 433, 433, + 433, 433, 433, 433, 433, 209, 433, 433, 222, 433, + 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, + 433, 110, 433, 433, 433, 433, 26, 433, 30, 433, + 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, + 433, 433, 433, 173, 433, 433, 433, 433, 433, 433, + 433, 433, 433, 433, 433, 225, 227, 433, 433, 237, + + 240, 433, 433, 433, 28, 31, 433, 10, 433, 11, + 433, 433, 433, 433, 433, 433, 433, 433, 29, 32, + 433, 433, 433, 433, 433, 433, 433, 186, 196, 433, + 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, + 18, 19, 433, 433, 433, 7, 433, 433, 433, 8, + 433, 433, 24, 25, 433, 433, 433, 433, 162, 433, + 433, 167, 395, 197, 433, 433, 204, 206, 433, 215, + 218, 229, 232, 433, 433, 433, 433, 40, 433, 33, + 433, 433, 433, 433, 158, 433, 166, 433, 433, 433, + 41, 35, 433, 433, 433, 433, 9, 42, 36, 433, + + 433, 433, 202, 433, 433, 433, 433, 433, 433, 433, + 201, 433, 433, 433, 27, 433, 433, 433, 433, 12, + 13, 433, 433, 433, 433, 433, 153, 433, 211, 34, + 165, 0 + } ; + +static yyconst flex_int32_t yy_ec[256] = + { 0, + 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 2, 4, 1, 5, 1, 6, 7, 1, 1, + 1, 8, 9, 1, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 18, 18, 18, 18, 1, 1, 19, + 20, 21, 1, 1, 22, 23, 24, 25, 26, 27, + 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, + 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 1, 1, 1, 48, 49, 1, 50, 51, 52, 53, + + 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, + 74, 75, 1, 76, 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, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1 + } ; + +static yyconst flex_int32_t yy_meta[77] = + { 0, + 1, 1, 2, 1, 1, 1, 1, 3, 1, 1, + 1, 1, 4, 4, 4, 4, 4, 4, 1, 1, + 1, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 1, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 1 + } ; + +static yyconst flex_int16_t yy_base[1639] = + { 0, + 0, 0, 74, 75, 2957, 2956, 2958, 2961, 2955, 2961, + 2936, 77, 2935, 73, 2934, 72, 74, 77, 75, 85, + 68, 2933, 70, 69, 79, 134, 128, 117, 171, 69, + 119, 124, 0, 141, 159, 186, 169, 215, 205, 264, + 249, 184, 238, 75, 96, 275, 313, 212, 362, 185, + 268, 311, 239, 331, 318, 331, 367, 353, 416, 345, + 403, 426, 476, 488, 414, 436, 388, 90, 0, 2961, + 2940, 0, 2961, 2949, 2961, 499, 129, 2896, 59, 110, + 2891, 136, 2885, 2893, 2961, 2961, 2961, 2961, 2961, 2961, + 2961, 2961, 2961, 2961, 2961, 558, 2961, 566, 2926, 2961, + + 2961, 2961, 2925, 0, 160, 181, 222, 244, 247, 284, + 301, 310, 463, 330, 356, 382, 385, 486, 558, 375, + 407, 392, 410, 411, 447, 497, 464, 471, 473, 496, + 509, 503, 517, 525, 535, 545, 0, 557, 552, 553, + 551, 556, 565, 556, 572, 568, 577, 563, 593, 562, + 580, 613, 589, 574, 616, 580, 618, 600, 628, 619, + 612, 631, 624, 613, 639, 650, 658, 628, 633, 667, + 660, 671, 660, 672, 676, 2961, 2961, 670, 2875, 675, + 693, 2889, 673, 687, 718, 721, 689, 2892, 721, 2887, + 696, 707, 709, 707, 734, 2884, 0, 756, 2889, 2884, + + 2863, 731, 726, 2883, 741, 731, 764, 742, 783, 772, + 801, 743, 2871, 812, 2883, 757, 811, 825, 761, 808, + 796, 2879, 836, 828, 772, 818, 2961, 2961, 0, 2961, + 0, 846, 2877, 61, 2878, 2863, 160, 2877, 2865, 847, + 2874, 2859, 891, 2961, 2961, 848, 2876, 846, 850, 854, + 872, 871, 874, 875, 887, 885, 873, 877, 877, 876, + 882, 880, 901, 898, 884, 903, 908, 908, 893, 911, + 908, 901, 903, 911, 898, 919, 0, 917, 911, 920, + 920, 915, 940, 935, 940, 930, 931, 960, 953, 952, + 942, 961, 961, 0, 953, 963, 957, 952, 955, 961, + + 954, 971, 964, 978, 960, 963, 972, 965, 980, 977, + 988, 981, 2875, 982, 985, 1003, 998, 997, 998, 1004, + 1016, 1004, 1003, 1016, 1004, 1020, 1019, 1012, 1009, 1013, + 1019, 1037, 1034, 0, 1035, 1021, 1055, 1027, 1038, 1034, + 1038, 1039, 1043, 1060, 1070, 1060, 1048, 2856, 1062, 1078, + 2870, 1075, 1061, 1065, 1081, 1085, 2852, 1088, 2868, 1088, + 1076, 2850, 1095, 0, 2861, 1076, 1110, 2867, 2854, 2863, + 2850, 2848, 1132, 2854, 1096, 1095, 2859, 784, 1111, 1096, + 1103, 2846, 1111, 2842, 1110, 1111, 1128, 1114, 1129, 2846, + 2855, 1157, 1132, 1125, 1103, 1131, 2848, 2850, 2850, 2845, + + 2838, 2847, 2847, 2838, 2844, 1133, 2843, 2828, 1127, 1140, + 0, 1163, 1186, 1159, 1166, 1172, 0, 1167, 1170, 1165, + 0, 1165, 1172, 1179, 1166, 1180, 1169, 1171, 1184, 1192, + 1185, 1184, 1193, 1189, 0, 0, 1197, 1189, 1203, 1189, + 1196, 1208, 1221, 0, 1211, 0, 1210, 1217, 1212, 1213, + 1215, 1216, 1217, 1218, 1225, 1243, 0, 1236, 1244, 1228, + 1228, 1231, 0, 1249, 1231, 1238, 0, 1244, 1238, 1254, + 1263, 1260, 1257, 1274, 1263, 1263, 1280, 1269, 1275, 1283, + 1275, 1278, 1273, 1286, 1294, 1280, 1296, 1287, 1290, 1299, + 1291, 1303, 1306, 1306, 1300, 1306, 1298, 0, 1297, 1307, + + 0, 1331, 1357, 1323, 1325, 1328, 1336, 1337, 1339, 1350, + 1335, 0, 1337, 1353, 0, 2837, 1366, 1353, 1380, 0, + 1347, 1357, 1359, 1349, 1378, 1393, 1368, 1405, 0, 1376, + 0, 1370, 2829, 1371, 2826, 2827, 1408, 2821, 0, 2817, + 2816, 2815, 2817, 1376, 2829, 0, 1386, 1379, 1398, 2816, + 1408, 2820, 1409, 1392, 0, 1421, 1405, 2818, 1432, 0, + 0, 0, 0, 1416, 0, 1411, 2819, 2961, 2961, 2826, + 2813, 2824, 2824, 2807, 2961, 1416, 2821, 2817, 1426, 1413, + 1413, 1409, 1410, 1411, 1412, 0, 1419, 1438, 0, 1438, + 1429, 0, 1431, 1434, 1427, 2825, 1437, 1437, 1441, 1449, + + 1436, 1438, 1452, 1462, 1492, 1459, 1466, 1462, 0, 1496, + 1473, 1459, 1473, 1479, 1491, 1495, 0, 1485, 1516, 1520, + 1524, 1529, 1496, 1527, 1486, 1483, 1520, 1517, 1531, 1518, + 1518, 1519, 1534, 1535, 1523, 1524, 1524, 1543, 1544, 1530, + 1529, 1545, 1533, 1538, 1552, 1549, 1551, 1536, 1538, 1557, + 1559, 0, 1583, 1582, 0, 1587, 1589, 1586, 1574, 1587, + 1591, 1588, 1597, 1581, 0, 1593, 1596, 1601, 1579, 1580, + 1581, 1582, 1589, 0, 0, 1594, 0, 1591, 1586, 1610, + 1603, 0, 2822, 0, 0, 0, 0, 1598, 2823, 1600, + 1606, 1601, 2798, 2797, 2796, 1638, 0, 0, 0, 0, + + 1655, 0, 0, 2810, 2806, 0, 0, 0, 2797, 1658, + 1661, 1664, 2803, 1625, 0, 1626, 1647, 1657, 2807, 1643, + 2793, 1656, 1647, 1648, 2801, 0, 0, 0, 0, 1666, + 2807, 2961, 2961, 2961, 2805, 2806, 1667, 2961, 2794, 1650, + 1669, 1654, 1682, 1686, 1690, 1710, 0, 1683, 1670, 1690, + 2808, 1695, 1696, 1704, 1703, 1688, 1690, 0, 1691, 1708, + 1694, 1724, 1690, 1697, 1698, 1699, 1721, 1716, 0, 1702, + 1706, 1707, 1708, 0, 1717, 1716, 1735, 1743, 0, 1744, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1745, 1737, 0, 1730, + + 0, 1750, 1755, 1739, 1747, 1749, 1749, 1760, 1749, 1760, + 1749, 1765, 1772, 1758, 0, 1770, 1775, 1763, 1762, 0, + 1776, 1782, 1787, 1786, 1769, 1781, 0, 0, 0, 1788, + 2807, 0, 1780, 0, 1784, 1786, 1784, 1806, 1800, 1807, + 1806, 1827, 1840, 1849, 1855, 1811, 1820, 0, 1840, 1814, + 1825, 2785, 1829, 1834, 1836, 1853, 1866, 1873, 1876, 1882, + 2804, 2799, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 2787, 1842, 1858, 0, 1846, 0, 1852, 2782, + 0, 1874, 1867, 2796, 1900, 2961, 2961, 2795, 1901, 2785, + 1868, 1882, 1889, 0, 0, 0, 0, 0, 0, 0, + + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1875, + 0, 1890, 1883, 1878, 1879, 1898, 1881, 1897, 0, 1898, + 0, 1896, 1881, 1885, 1886, 1887, 1949, 1953, 1957, 1961, + 2798, 1914, 1965, 1970, 1974, 1978, 0, 1950, 1975, 1973, + 1958, 1976, 0, 1975, 0, 1978, 1966, 1978, 1966, 1984, + 1967, 1986, 1987, 1971, 0, 0, 1985, 1965, 1974, 1977, + 1993, 1980, 1978, 1993, 1978, 1981, 2035, 2016, 2029, 2015, + 0, 2013, 2031, 2046, 2032, 0, 2037, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2039, 2026, 2037, 0, 2041, 2777, + + 2043, 2043, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 2782, 2777, 0, 2045, 2779, 2086, 2784, + 2090, 0, 2774, 2075, 2043, 2961, 0, 2049, 2055, 2049, + 2085, 0, 2090, 2084, 2088, 2090, 2080, 2080, 0, 2087, + 2101, 2113, 2117, 2141, 2145, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 2100, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 2085, + 2105, 2119, 2122, 2137, 2142, 2139, 2130, 2143, 0, 2127, + 2143, 2142, 2146, 2149, 2151, 2151, 0, 2139, 2140, 2141, + + 0, 2156, 2140, 2157, 2159, 2160, 2161, 2179, 2147, 2149, + 2166, 2178, 2175, 2176, 0, 2194, 2195, 2197, 2181, 2202, + 0, 0, 2203, 2204, 0, 2786, 0, 0, 2770, 2217, + 2203, 2775, 2209, 2210, 2211, 2767, 2202, 2773, 2225, 2204, + 0, 2203, 2220, 2230, 2217, 2227, 2237, 2221, 2239, 2226, + 2232, 2251, 2253, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 2257, + 2251, 2255, 2243, 2254, 0, 2256, 0, 2258, 2251, 2269, + 2253, 2262, 2271, 2276, 0, 2261, 2275, 2274, 0, 2265, + 2266, 2007, 0, 0, 0, 2278, 2290, 2292, 2274, 2284, + + 2277, 2298, 2821, 2305, 2312, 0, 2308, 2310, 2295, 2309, + 2313, 0, 0, 2781, 2780, 2779, 2761, 2760, 2298, 0, + 126, 2308, 0, 2774, 2326, 2774, 2774, 2773, 2772, 2754, + 2753, 2323, 2328, 2318, 0, 2314, 2320, 2332, 2338, 2336, + 0, 2326, 2339, 2345, 2332, 2351, 2354, 0, 0, 0, + 2361, 2356, 2358, 0, 2364, 2352, 2358, 2353, 2353, 2369, + 2372, 2376, 2378, 2379, 2380, 2369, 2382, 2368, 2388, 2773, + 2371, 2390, 306, 2377, 2378, 2384, 2399, 2396, 2389, 2395, + 2409, 2771, 2392, 0, 2765, 2768, 2409, 2751, 2760, 2749, + 2747, 2760, 2756, 2757, 2417, 0, 2761, 2398, 0, 2755, + + 2758, 2401, 2406, 2408, 2427, 2412, 2432, 2433, 2436, 2440, + 2433, 2429, 2428, 2445, 0, 2431, 2430, 0, 2441, 0, + 0, 2439, 2759, 2440, 2442, 2458, 2462, 2463, 0, 2465, + 0, 2462, 2450, 2453, 0, 2453, 0, 2454, 2463, 2464, + 2483, 2484, 0, 2481, 2488, 2478, 2740, 2739, 2737, 2750, + 2748, 2748, 2475, 2734, 2750, 2732, 2746, 2740, 2739, 2734, + 203, 2708, 2706, 2703, 2714, 2712, 2711, 2961, 2478, 0, + 2480, 0, 2485, 2491, 2487, 2487, 2489, 0, 0, 2510, + 2507, 2512, 2498, 2518, 2517, 2500, 2504, 2524, 2510, 2512, + 2516, 0, 2532, 2518, 2534, 2515, 2541, 2548, 2534, 2535, + + 2554, 2543, 0, 2697, 2696, 2712, 2709, 2706, 2706, 2554, + 2703, 2699, 2298, 2280, 2118, 2056, 2011, 2009, 2017, 2006, + 2005, 2006, 1905, 1902, 1900, 2542, 2555, 0, 2558, 0, + 2543, 2547, 2562, 2554, 2558, 0, 0, 2554, 2574, 2567, + 2576, 2558, 2564, 2566, 2577, 0, 2589, 2587, 0, 2569, + 2571, 2579, 2580, 2592, 2588, 1894, 1891, 1873, 1867, 1868, + 1457, 0, 1269, 1106, 1069, 798, 775, 754, 0, 747, + 725, 719, 715, 695, 692, 689, 657, 2604, 2605, 2599, + 2597, 2615, 2612, 0, 2605, 2615, 2604, 2622, 2607, 2623, + 2629, 2630, 2613, 2614, 2630, 0, 0, 2637, 2639, 0, + + 0, 641, 635, 593, 0, 0, 589, 543, 533, 495, + 505, 472, 452, 466, 461, 439, 432, 433, 0, 0, + 423, 2638, 2641, 2629, 2645, 2632, 2630, 0, 0, 2634, + 2638, 2658, 2659, 2642, 2644, 2656, 2667, 2655, 2650, 2651, + 0, 0, 437, 421, 407, 0, 391, 368, 380, 0, + 353, 358, 0, 0, 362, 355, 2677, 2665, 0, 2680, + 2680, 0, 0, 0, 2680, 2682, 0, 0, 2674, 0, + 0, 0, 0, 323, 322, 321, 320, 0, 307, 289, + 267, 260, 256, 2669, 0, 2689, 0, 2689, 2678, 2679, + 0, 0, 271, 234, 220, 223, 0, 0, 0, 2696, + + 2684, 2688, 0, 2688, 203, 196, 161, 176, 2703, 2704, + 0, 2716, 145, 111, 0, 75, 2715, 2715, 2703, 0, + 0, 60, 2707, 2722, 2723, 41, 0, 2711, 0, 0, + 0, 2961, 2778, 2782, 103, 2786, 2790, 2794 + } ; + +static yyconst flex_int16_t yy_def[1639] = + { 0, + 1632, 1, 1633, 1633, 1634, 1634, 1632, 1632, 1632, 1632, + 1632, 1632, 1632, 1632, 1632, 1632, 1632, 1632, 1632, 1632, + 1632, 1632, 1632, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1632, 1635, 1635, 26, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 40, 1635, 1635, 1635, 1635, 1635, 1632, 1636, 1632, + 1632, 1637, 1632, 1632, 1632, 1632, 1632, 1632, 1632, 1632, + 1632, 1632, 1632, 1632, 1632, 1632, 1632, 1632, 1632, 1632, + 1632, 1632, 1632, 1632, 1632, 1632, 1632, 1632, 1632, 1632, + + 1632, 1632, 1632, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1632, 1632, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1632, 1632, 1636, 1632, + 1637, 1632, 1632, 1632, 1632, 1632, 1632, 1632, 1632, 1632, + 1632, 1632, 1632, 1632, 1632, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1632, 1632, 1632, 1632, 1632, + + 1632, 1632, 1632, 1632, 1632, 1632, 1632, 1632, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1632, 1632, 1632, 1632, 1632, + 1632, 1632, 1632, 1632, 1632, 1632, 1632, 1632, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1632, + 1632, 1632, 1632, 1632, 1632, 1632, 1632, 1632, 1632, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1632, 1632, 1632, 1632, 1632, 1632, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1632, 1632, 1632, 1638, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1632, + 1638, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1632, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + + 1635, 1632, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1632, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, 1635, + 1635, 0, 1632, 1632, 1632, 1632, 1632, 1632 + } ; + +static yyconst flex_int16_t yy_nxt[3038] = + { 0, + 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 8, 18, 19, 20, 20, 20, 20, 20, 21, 22, + 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, + 33, 33, 34, 35, 36, 37, 38, 33, 39, 40, + 41, 42, 43, 44, 33, 33, 33, 45, 8, 46, + 47, 48, 49, 50, 51, 52, 53, 54, 33, 33, + 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, + 65, 66, 67, 67, 67, 68, 70, 70, 76, 86, + 89, 71, 71, 91, 93, 96, 99, 100, 94, 102, + 103, 90, 87, 92, 132, 96, 95, 98, 98, 98, + + 98, 98, 98, 175, 133, 105, 104, 134, 106, 227, + 107, 108, 1630, 77, 109, 176, 97, 110, 398, 234, + 111, 235, 132, 1626, 112, 236, 97, 1622, 399, 78, + 79, 175, 133, 105, 80, 134, 106, 81, 107, 108, + 135, 82, 109, 177, 97, 110, 83, 84, 111, 124, + 137, 125, 112, 119, 97, 113, 114, 120, 138, 115, + 136, 126, 116, 121, 237, 228, 117, 232, 135, 118, + 139, 122, 238, 123, 232, 1288, 140, 124, 137, 125, + 141, 119, 1621, 113, 114, 120, 138, 115, 136, 126, + 116, 121, 127, 1289, 117, 232, 246, 118, 139, 122, + + 142, 123, 240, 128, 140, 147, 129, 143, 141, 130, + 148, 144, 402, 169, 247, 131, 1620, 124, 170, 125, + 127, 145, 403, 171, 246, 1616, 154, 146, 142, 126, + 155, 128, 1615, 147, 129, 143, 149, 130, 148, 144, + 156, 169, 247, 131, 150, 191, 170, 125, 157, 145, + 151, 171, 1418, 152, 154, 146, 153, 126, 155, 1614, + 135, 183, 248, 172, 149, 184, 1613, 173, 156, 249, + 1419, 164, 150, 174, 165, 185, 157, 166, 151, 1608, + 136, 152, 250, 1607, 153, 158, 1606, 167, 135, 127, + 248, 172, 159, 160, 168, 173, 196, 249, 161, 164, + + 128, 174, 165, 129, 162, 166, 130, 163, 136, 251, + 250, 105, 131, 158, 106, 167, 107, 192, 1337, 1338, + 159, 160, 168, 1605, 178, 178, 161, 252, 193, 1599, + 178, 194, 162, 1598, 130, 163, 132, 251, 1597, 105, + 131, 178, 106, 179, 107, 108, 133, 139, 109, 134, + 253, 110, 141, 140, 111, 252, 1596, 137, 112, 1595, + 178, 178, 178, 178, 132, 138, 178, 201, 178, 1594, + 1593, 256, 142, 108, 133, 139, 180, 195, 253, 181, + 203, 202, 111, 182, 204, 197, 112, 119, 143, 147, + 257, 120, 144, 198, 148, 1592, 1591, 121, 199, 256, + + 142, 200, 145, 258, 1583, 122, 259, 123, 146, 208, + 208, 1582, 208, 208, 266, 186, 143, 147, 257, 187, + 144, 1581, 206, 188, 154, 189, 1580, 269, 155, 1579, + 205, 258, 190, 122, 259, 123, 146, 149, 156, 172, + 267, 1578, 266, 173, 270, 150, 157, 1577, 268, 174, + 271, 151, 210, 178, 152, 269, 211, 153, 178, 226, + 226, 226, 226, 1576, 175, 207, 156, 223, 267, 178, + 1575, 173, 270, 150, 157, 212, 268, 224, 271, 151, + 208, 208, 209, 208, 208, 153, 1574, 213, 272, 1556, + 208, 208, 225, 208, 214, 215, 275, 216, 164, 1555, + + 76, 165, 254, 255, 166, 1554, 276, 226, 226, 226, + 226, 277, 1553, 1552, 167, 1551, 272, 169, 260, 261, + 262, 168, 170, 1550, 275, 278, 164, 171, 1549, 217, + 254, 255, 166, 273, 276, 77, 279, 274, 280, 277, + 208, 208, 218, 208, 208, 219, 260, 261, 262, 168, + 220, 78, 79, 278, 1548, 221, 80, 281, 222, 81, + 282, 273, 1547, 82, 279, 274, 280, 283, 83, 84, + 243, 243, 243, 243, 243, 243, 96, 284, 98, 98, + 98, 98, 98, 98, 263, 281, 289, 290, 282, 285, + 264, 291, 286, 287, 265, 283, 292, 288, 293, 294, + + 297, 295, 298, 299, 1546, 284, 302, 97, 296, 303, + 1545, 307, 263, 308, 289, 290, 300, 285, 264, 291, + 286, 287, 265, 313, 292, 288, 293, 294, 297, 295, + 298, 299, 301, 317, 302, 97, 296, 303, 304, 307, + 314, 308, 305, 309, 300, 310, 320, 322, 306, 318, + 311, 313, 323, 325, 326, 1544, 312, 315, 316, 1543, + 301, 317, 327, 319, 335, 321, 304, 336, 314, 324, + 305, 309, 328, 310, 320, 322, 306, 318, 311, 330, + 323, 325, 326, 329, 312, 315, 316, 332, 331, 340, + 327, 319, 335, 321, 341, 336, 337, 324, 343, 333, + + 328, 344, 338, 334, 345, 346, 339, 330, 1542, 342, + 250, 329, 254, 255, 1541, 332, 331, 340, 251, 347, + 347, 257, 341, 1521, 337, 347, 343, 333, 266, 344, + 338, 334, 345, 346, 339, 271, 347, 342, 349, 275, + 352, 255, 347, 347, 276, 277, 350, 263, 347, 353, + 260, 261, 262, 264, 267, 1520, 356, 265, 362, 347, + 1519, 1518, 268, 360, 1517, 290, 291, 361, 1516, 282, + 295, 299, 363, 364, 1515, 355, 317, 296, 260, 261, + 354, 264, 267, 347, 347, 265, 325, 300, 285, 347, + 358, 286, 287, 290, 373, 336, 288, 282, 295, 376, + + 347, 346, 372, 301, 381, 375, 378, 378, 304, 378, + 378, 308, 305, 1514, 385, 300, 285, 1513, 306, 366, + 287, 347, 347, 388, 367, 340, 368, 347, 309, 394, + 310, 301, 377, 323, 327, 311, 379, 337, 347, 308, + 305, 312, 1512, 338, 328, 390, 306, 339, 546, 546, + 324, 546, 546, 340, 332, 329, 309, 344, 310, 341, + 345, 323, 327, 311, 1511, 389, 333, 396, 396, 380, + 334, 338, 328, 409, 342, 339, 378, 378, 383, 378, + 378, 411, 332, 386, 412, 393, 413, 392, 345, 395, + 395, 395, 395, 414, 387, 396, 406, 415, 334, 416, + + 417, 409, 342, 243, 243, 243, 243, 243, 243, 411, + 418, 419, 412, 420, 413, 421, 422, 423, 424, 425, + 426, 414, 427, 428, 429, 415, 430, 416, 417, 431, + 432, 433, 434, 435, 436, 437, 438, 439, 418, 419, + 440, 420, 441, 421, 422, 423, 424, 425, 426, 442, + 427, 428, 429, 443, 430, 444, 445, 431, 432, 433, + 434, 435, 436, 437, 438, 439, 446, 447, 440, 448, + 441, 449, 450, 451, 452, 453, 454, 442, 456, 457, + 458, 443, 459, 444, 445, 455, 460, 461, 462, 463, + 464, 465, 466, 467, 446, 447, 468, 448, 469, 449, + + 450, 470, 471, 472, 473, 474, 456, 457, 458, 475, + 459, 476, 477, 455, 460, 461, 462, 463, 464, 465, + 466, 467, 478, 480, 468, 482, 469, 481, 483, 470, + 471, 472, 473, 474, 484, 485, 486, 475, 487, 476, + 477, 488, 489, 490, 493, 491, 494, 495, 496, 497, + 478, 480, 498, 482, 499, 481, 483, 492, 500, 501, + 502, 503, 484, 485, 486, 506, 487, 507, 508, 488, + 489, 490, 493, 491, 494, 495, 496, 497, 509, 510, + 498, 504, 499, 511, 512, 492, 500, 501, 502, 503, + 505, 513, 514, 506, 413, 507, 508, 515, 515, 414, + + 417, 420, 427, 515, 425, 426, 509, 510, 430, 504, + 432, 511, 512, 435, 515, 439, 440, 449, 505, 513, + 514, 462, 517, 451, 452, 453, 454, 518, 520, 521, + 524, 465, 522, 523, 470, 455, 525, 478, 527, 484, + 491, 529, 1510, 530, 532, 534, 540, 541, 542, 544, + 493, 497, 492, 501, 503, 504, 512, 514, 566, 465, + 566, 579, 547, 455, 505, 548, 580, 549, 491, 1509, + 458, 560, 561, 562, 565, 565, 565, 565, 553, 554, + 551, 555, 556, 557, 563, 564, 566, 581, 576, 579, + 586, 587, 505, 588, 580, 589, 590, 509, 458, 582, + + 583, 584, 585, 591, 592, 593, 596, 597, 594, 598, + 599, 600, 601, 602, 603, 581, 604, 605, 586, 587, + 595, 588, 606, 589, 590, 509, 607, 608, 609, 610, + 611, 591, 592, 593, 596, 597, 594, 598, 599, 600, + 601, 602, 603, 612, 604, 605, 613, 614, 595, 615, + 606, 616, 617, 618, 607, 608, 609, 610, 611, 619, + 620, 621, 622, 623, 624, 626, 627, 628, 629, 630, + 631, 612, 632, 633, 613, 614, 634, 615, 635, 616, + 617, 618, 625, 636, 637, 638, 639, 619, 620, 621, + 622, 623, 624, 626, 627, 628, 629, 630, 631, 640, + + 632, 633, 641, 642, 634, 643, 635, 644, 645, 646, + 625, 636, 637, 638, 639, 647, 648, 649, 650, 651, + 652, 653, 654, 655, 656, 658, 659, 640, 657, 660, + 641, 642, 661, 643, 662, 644, 645, 646, 663, 664, + 665, 666, 1508, 647, 648, 649, 650, 651, 652, 653, + 654, 655, 656, 658, 659, 667, 657, 660, 673, 674, + 661, 675, 662, 676, 677, 668, 663, 664, 665, 666, + 669, 670, 671, 672, 678, 679, 680, 681, 682, 582, + 583, 584, 585, 667, 586, 591, 673, 674, 598, 675, + 599, 676, 677, 668, 685, 686, 687, 596, 597, 602, + + 604, 609, 678, 679, 680, 681, 682, 693, 694, 695, + 610, 617, 684, 688, 630, 636, 690, 644, 691, 697, + 698, 699, 706, 707, 708, 689, 597, 692, 696, 700, + 650, 659, 660, 664, 669, 670, 671, 672, 701, 703, + 673, 682, 714, 716, 730, 717, 726, 727, 728, 730, + 740, 741, 742, 743, 744, 745, 746, 747, 718, 720, + 722, 723, 748, 749, 750, 751, 752, 753, 724, 729, + 755, 756, 730, 757, 758, 759, 760, 737, 740, 741, + 742, 743, 744, 745, 746, 747, 761, 762, 767, 768, + 748, 749, 750, 751, 752, 753, 769, 774, 755, 756, + + 775, 757, 758, 759, 760, 763, 764, 765, 766, 770, + 771, 772, 773, 776, 761, 762, 767, 768, 777, 778, + 779, 780, 797, 1507, 769, 774, 800, 801, 775, 781, + 782, 783, 784, 785, 786, 787, 788, 789, 790, 791, + 792, 776, 793, 794, 795, 796, 777, 778, 779, 780, + 797, 798, 802, 803, 800, 801, 804, 805, 806, 807, + 808, 809, 811, 812, 813, 799, 814, 815, 816, 817, + 818, 819, 820, 821, 810, 822, 823, 824, 825, 798, + 802, 803, 826, 827, 804, 805, 806, 807, 808, 809, + 811, 812, 813, 799, 814, 815, 816, 817, 818, 819, + + 820, 821, 810, 822, 823, 824, 825, 828, 829, 830, + 826, 827, 831, 832, 833, 834, 835, 836, 837, 838, + 839, 840, 841, 842, 843, 844, 845, 846, 847, 848, + 849, 850, 851, 750, 756, 828, 829, 830, 757, 760, + 831, 832, 833, 834, 835, 836, 837, 838, 839, 840, + 841, 842, 843, 844, 845, 846, 847, 848, 849, 850, + 851, 853, 854, 762, 805, 812, 855, 856, 770, 771, + 772, 773, 864, 865, 866, 867, 868, 869, 870, 871, + 872, 820, 826, 833, 834, 838, 846, 885, 885, 891, + 892, 860, 874, 875, 893, 894, 895, 896, 897, 898, + + 899, 900, 901, 902, 903, 904, 905, 910, 911, 876, + 877, 879, 881, 882, 883, 885, 889, 891, 892, 912, + 914, 915, 893, 906, 907, 908, 909, 916, 917, 918, + 919, 920, 921, 922, 927, 910, 911, 923, 924, 925, + 926, 928, 929, 930, 931, 932, 933, 912, 914, 915, + 934, 935, 936, 937, 938, 916, 917, 918, 919, 920, + 921, 922, 927, 939, 940, 941, 942, 943, 944, 928, + 929, 930, 931, 932, 933, 945, 946, 947, 934, 935, + 936, 937, 938, 948, 949, 950, 951, 952, 953, 954, + 955, 939, 940, 941, 942, 943, 944, 956, 957, 958, + + 959, 960, 961, 945, 946, 947, 962, 963, 964, 965, + 966, 948, 949, 950, 951, 952, 953, 954, 955, 967, + 968, 970, 971, 972, 973, 956, 957, 958, 959, 960, + 961, 974, 975, 976, 962, 963, 964, 965, 966, 977, + 978, 979, 980, 981, 994, 995, 998, 967, 968, 970, + 971, 972, 973, 982, 983, 984, 985, 999, 912, 974, + 975, 976, 986, 987, 988, 989, 996, 977, 990, 991, + 992, 993, 994, 995, 998, 918, 919, 921, 948, 997, + 1005, 1006, 1007, 955, 967, 999, 1001, 1008, 1009, 1010, + 1011, 1012, 1013, 970, 996, 923, 924, 925, 926, 974, + + 994, 1024, 1024, 1002, 1003, 1004, 1017, 997, 1028, 1029, + 1030, 955, 1019, 1031, 1032, 1018, 1033, 1034, 1036, 1037, + 1038, 970, 1039, 1040, 1041, 1042, 1035, 1021, 1022, 1043, + 1044, 1045, 1025, 1025, 1506, 1505, 1028, 1029, 1030, 1504, + 1503, 1031, 1032, 1502, 1033, 1034, 1036, 1037, 1038, 1477, + 1039, 1040, 1041, 1042, 1063, 1476, 1475, 1043, 1044, 1045, + 1025, 1025, 1046, 1047, 1048, 1049, 1050, 1051, 1052, 1053, + 1054, 1055, 1056, 1057, 1058, 1059, 1060, 1061, 1064, 1065, + 1066, 1067, 1063, 1068, 1069, 1070, 1071, 1072, 1073, 1074, + 1075, 1076, 1077, 1078, 1079, 1080, 1081, 1082, 1083, 1084, + + 1085, 1086, 1087, 1088, 1089, 1090, 1091, 1092, 1093, 1094, + 1095, 1096, 1097, 1098, 1099, 1100, 1101, 1102, 1103, 1104, + 1263, 1264, 1265, 1080, 1081, 1082, 1083, 1084, 1085, 1086, + 1087, 1088, 1089, 1090, 1091, 1092, 1093, 1094, 1095, 1096, + 1097, 1098, 1099, 1100, 1101, 1102, 1103, 1104, 1105, 1106, + 1107, 1111, 1112, 1113, 1114, 1474, 1115, 1120, 1108, 1116, + 1117, 1118, 1121, 1122, 1123, 1124, 1125, 1032, 1039, 1119, + 1088, 1473, 1472, 1471, 1109, 1470, 1024, 1469, 1140, 1111, + 1112, 1113, 1114, 1110, 1115, 1120, 1108, 1142, 1143, 1144, + 1121, 1122, 1123, 1124, 1125, 1127, 1128, 1119, 1131, 1133, + + 1134, 1135, 1109, 1116, 1117, 1118, 1140, 1025, 1468, 1108, + 1145, 1146, 1147, 1119, 1148, 1142, 1143, 1144, 1149, 1150, + 1151, 1152, 1153, 1170, 1171, 1109, 1154, 1155, 1156, 1157, + 1158, 1159, 1160, 1161, 1110, 1025, 1136, 1137, 1145, 1146, + 1147, 1119, 1148, 1172, 1173, 1174, 1149, 1150, 1151, 1152, + 1153, 1170, 1171, 1109, 1162, 1163, 1164, 1165, 1166, 1167, + 1168, 1169, 1175, 1176, 1177, 1178, 1179, 1180, 1181, 1182, + 1183, 1172, 1173, 1174, 1184, 1185, 1186, 1187, 1188, 1189, + 1190, 1191, 1192, 1193, 1194, 1195, 1467, 1198, 1199, 1200, + 1175, 1176, 1177, 1178, 1179, 1180, 1181, 1182, 1183, 1201, + + 1202, 1203, 1184, 1185, 1186, 1187, 1188, 1189, 1190, 1191, + 1192, 1193, 1194, 1195, 1196, 1198, 1199, 1200, 1204, 1205, + 1197, 1206, 1207, 1208, 1210, 1211, 1179, 1201, 1202, 1203, + 1214, 1215, 1216, 1193, 1194, 1195, 1232, 1196, 1227, 1228, + 1229, 1209, 1196, 1197, 1233, 1234, 1204, 1205, 1197, 1206, + 1207, 1208, 1210, 1211, 1219, 1235, 1236, 1237, 1238, 1239, + 1240, 1221, 1222, 1223, 1232, 1196, 1241, 1217, 1218, 1209, + 1242, 1225, 1233, 1234, 1243, 1230, 1231, 1244, 1245, 1246, + 1247, 1248, 1249, 1235, 1236, 1237, 1238, 1239, 1240, 1250, + 1251, 1252, 1253, 1254, 1241, 1255, 1256, 1257, 1242, 1258, + + 1259, 1260, 1243, 1261, 1262, 1244, 1245, 1246, 1247, 1248, + 1249, 1266, 1267, 1268, 1269, 1270, 1271, 1250, 1251, 1252, + 1253, 1254, 1272, 1255, 1256, 1257, 1274, 1258, 1259, 1260, + 1277, 1261, 1262, 1275, 1278, 1279, 1280, 1281, 1252, 1266, + 1267, 1268, 1269, 1270, 1271, 1276, 1466, 1465, 1267, 1302, + 1272, 1303, 1304, 1305, 1274, 1306, 1307, 1290, 1277, 1308, + 1309, 1275, 1278, 1279, 1280, 1281, 1287, 1310, 1311, 1291, + 1312, 1313, 1314, 1276, 1292, 1293, 1295, 1302, 1315, 1303, + 1304, 1305, 1316, 1306, 1307, 1317, 1318, 1308, 1309, 1319, + 1320, 1321, 1322, 1323, 1324, 1310, 1311, 1325, 1312, 1313, + + 1314, 1326, 1327, 1328, 1329, 1330, 1315, 1331, 1332, 1333, + 1316, 1335, 1336, 1317, 1318, 1339, 1340, 1319, 1320, 1321, + 1322, 1323, 1324, 1341, 1342, 1325, 1343, 1344, 1345, 1326, + 1327, 1328, 1329, 1330, 1346, 1331, 1332, 1333, 1317, 1335, + 1336, 1348, 1331, 1339, 1340, 1368, 1369, 1363, 1370, 1371, + 1372, 1341, 1342, 1349, 1343, 1344, 1345, 1373, 1350, 1364, + 1374, 1375, 1346, 1376, 1365, 1377, 1353, 1378, 1379, 1380, + 1361, 1381, 1382, 1368, 1369, 1383, 1370, 1371, 1372, 1384, + 1386, 1387, 1388, 1389, 1390, 1373, 1391, 1392, 1374, 1375, + 1393, 1376, 1394, 1377, 1395, 1378, 1379, 1380, 1396, 1381, + + 1382, 1397, 1398, 1383, 1399, 1400, 1401, 1384, 1386, 1387, + 1388, 1389, 1390, 1402, 1391, 1392, 1403, 1382, 1393, 1426, + 1394, 1427, 1395, 1428, 1429, 1430, 1396, 1431, 1432, 1397, + 1398, 1433, 1399, 1400, 1401, 1434, 1435, 1436, 1437, 1438, + 1439, 1402, 1440, 1441, 1403, 1410, 1442, 1426, 1443, 1427, + 1444, 1428, 1429, 1430, 1445, 1431, 1432, 1446, 1447, 1433, + 1448, 1449, 1450, 1434, 1435, 1436, 1437, 1438, 1439, 1451, + 1440, 1441, 1452, 1453, 1442, 1454, 1443, 1455, 1444, 1436, + 1478, 1479, 1445, 1480, 1481, 1446, 1447, 1482, 1448, 1449, + 1450, 1483, 1484, 1485, 1486, 1487, 1488, 1451, 1489, 1490, + + 1452, 1453, 1491, 1454, 1492, 1455, 1493, 1462, 1478, 1479, + 1494, 1480, 1481, 1495, 1496, 1482, 1497, 1498, 1499, 1483, + 1484, 1485, 1486, 1487, 1488, 1500, 1489, 1490, 1501, 1522, + 1491, 1523, 1492, 1524, 1493, 1525, 1526, 1527, 1494, 1528, + 1529, 1495, 1496, 1530, 1497, 1498, 1499, 1531, 1532, 1533, + 1534, 1535, 1536, 1500, 1537, 1538, 1501, 1522, 1539, 1523, + 1540, 1524, 1557, 1525, 1526, 1527, 1558, 1528, 1529, 1559, + 1560, 1530, 1561, 1562, 1563, 1531, 1532, 1533, 1534, 1535, + 1536, 1564, 1537, 1538, 1565, 1566, 1539, 1567, 1540, 1568, + 1557, 1569, 1570, 1571, 1558, 1572, 1573, 1559, 1560, 1584, + + 1561, 1562, 1563, 1585, 1586, 1587, 1588, 1589, 1590, 1564, + 1600, 1601, 1565, 1566, 1602, 1567, 1603, 1568, 1604, 1569, + 1570, 1571, 1609, 1572, 1573, 1610, 1611, 1584, 1612, 1617, + 1618, 1585, 1586, 1587, 1588, 1589, 1590, 1619, 1600, 1601, + 1623, 1624, 1602, 1625, 1603, 1627, 1604, 1628, 1629, 1631, + 1609, 1464, 1463, 1610, 1611, 1461, 1612, 1617, 1618, 1460, + 1459, 1458, 1457, 1456, 1425, 1619, 1424, 1423, 1623, 1624, + 1422, 1625, 1421, 1627, 1420, 1628, 1629, 1631, 69, 69, + 69, 69, 72, 72, 72, 72, 229, 1417, 1416, 229, + 231, 1415, 231, 231, 1141, 1414, 1141, 1141, 1413, 1412, + + 1411, 1409, 1408, 1407, 1406, 1405, 1404, 1385, 1367, 1366, + 1362, 1360, 1359, 1358, 1357, 1356, 1355, 1354, 1352, 1351, + 1347, 1334, 1301, 1300, 1299, 1298, 1297, 1296, 1294, 1286, + 1285, 1284, 1283, 1282, 1273, 1226, 1224, 1220, 1213, 1212, + 1139, 1138, 1132, 1130, 1129, 1126, 1062, 1027, 1026, 1023, + 1020, 1016, 1015, 1014, 1000, 969, 913, 890, 888, 887, + 886, 884, 880, 878, 873, 863, 862, 861, 859, 858, + 857, 754, 852, 754, 739, 738, 736, 735, 734, 733, + 732, 731, 725, 721, 719, 715, 713, 712, 711, 710, + 709, 705, 704, 702, 683, 578, 577, 575, 574, 573, + + 572, 571, 570, 569, 568, 567, 559, 558, 552, 550, + 545, 543, 539, 538, 537, 536, 535, 533, 531, 528, + 526, 519, 516, 479, 410, 408, 407, 405, 404, 401, + 400, 397, 391, 384, 382, 374, 371, 370, 369, 365, + 359, 357, 351, 348, 245, 244, 242, 241, 239, 233, + 74, 230, 101, 88, 85, 75, 74, 1632, 73, 73, + 7, 1632, 1632, 1632, 1632, 1632, 1632, 1632, 1632, 1632, + 1632, 1632, 1632, 1632, 1632, 1632, 1632, 1632, 1632, 1632, + 1632, 1632, 1632, 1632, 1632, 1632, 1632, 1632, 1632, 1632, + 1632, 1632, 1632, 1632, 1632, 1632, 1632, 1632, 1632, 1632, + + 1632, 1632, 1632, 1632, 1632, 1632, 1632, 1632, 1632, 1632, + 1632, 1632, 1632, 1632, 1632, 1632, 1632, 1632, 1632, 1632, + 1632, 1632, 1632, 1632, 1632, 1632, 1632, 1632, 1632, 1632, + 1632, 1632, 1632, 1632, 1632, 1632, 1632 + } ; + +static yyconst flex_int16_t yy_chk[3038] = + { 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, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 3, 4, 12, 14, + 16, 3, 4, 17, 18, 19, 21, 21, 18, 23, + 23, 16, 14, 17, 30, 20, 18, 20, 20, 20, + + 20, 20, 20, 44, 30, 24, 1635, 30, 24, 68, + 24, 25, 1626, 12, 25, 45, 19, 25, 234, 79, + 25, 79, 30, 1622, 25, 79, 20, 1616, 234, 12, + 12, 44, 30, 24, 12, 30, 24, 12, 24, 25, + 31, 12, 25, 45, 19, 25, 12, 12, 25, 28, + 32, 28, 25, 27, 20, 26, 26, 27, 32, 26, + 31, 28, 26, 27, 80, 68, 26, 77, 31, 26, + 34, 27, 80, 27, 82, 1221, 34, 28, 32, 28, + 35, 27, 1614, 26, 26, 27, 32, 26, 31, 28, + 26, 27, 29, 1221, 26, 77, 105, 26, 34, 27, + + 35, 27, 82, 29, 34, 37, 29, 36, 35, 29, + 37, 36, 237, 42, 106, 29, 1613, 50, 42, 50, + 29, 36, 237, 42, 105, 1608, 39, 36, 35, 50, + 39, 29, 1607, 37, 29, 36, 38, 29, 37, 36, + 39, 42, 106, 29, 38, 50, 42, 50, 39, 36, + 38, 42, 1361, 38, 39, 36, 38, 50, 39, 1606, + 53, 48, 107, 43, 38, 48, 1605, 43, 39, 108, + 1361, 41, 38, 43, 41, 48, 39, 41, 38, 1596, + 53, 38, 109, 1595, 38, 40, 1594, 41, 53, 51, + 107, 43, 40, 40, 41, 43, 53, 108, 40, 41, + + 51, 43, 41, 51, 40, 41, 51, 40, 53, 110, + 109, 46, 51, 40, 46, 41, 46, 51, 1273, 1273, + 40, 40, 41, 1593, 46, 46, 40, 111, 51, 1583, + 46, 51, 40, 1582, 51, 40, 52, 110, 1581, 46, + 51, 46, 46, 46, 46, 47, 52, 55, 47, 52, + 112, 47, 56, 55, 47, 111, 1580, 54, 47, 1579, + 52, 52, 47, 47, 52, 54, 52, 55, 47, 1577, + 1576, 114, 56, 47, 52, 55, 47, 52, 112, 47, + 56, 55, 47, 47, 56, 54, 47, 49, 57, 58, + 115, 49, 57, 54, 58, 1575, 1574, 49, 54, 114, + + 56, 54, 57, 116, 1556, 49, 117, 49, 57, 60, + 60, 1555, 60, 60, 120, 49, 57, 58, 115, 49, + 57, 1552, 58, 49, 61, 49, 1551, 122, 61, 1549, + 57, 116, 49, 49, 117, 49, 57, 59, 61, 65, + 121, 1548, 120, 65, 123, 59, 61, 1547, 121, 65, + 124, 59, 61, 61, 59, 122, 61, 59, 61, 67, + 67, 67, 67, 1545, 66, 59, 61, 65, 121, 61, + 1544, 65, 123, 59, 61, 62, 121, 65, 124, 59, + 59, 59, 59, 59, 59, 59, 1543, 62, 125, 1521, + 62, 62, 66, 62, 62, 62, 127, 62, 63, 1518, + + 76, 63, 113, 113, 63, 1517, 128, 66, 66, 66, + 66, 129, 1516, 1515, 63, 1514, 125, 64, 118, 118, + 118, 63, 64, 1513, 127, 130, 63, 64, 1512, 63, + 113, 113, 63, 126, 128, 76, 131, 126, 132, 129, + 63, 63, 63, 63, 63, 64, 118, 118, 118, 63, + 64, 76, 76, 130, 1511, 64, 76, 133, 64, 76, + 134, 126, 1510, 76, 131, 126, 132, 135, 76, 76, + 96, 96, 96, 96, 96, 96, 98, 136, 98, 98, + 98, 98, 98, 98, 119, 133, 139, 140, 134, 138, + 119, 141, 138, 138, 119, 135, 142, 138, 143, 144, + + 146, 145, 147, 148, 1509, 136, 150, 98, 145, 151, + 1508, 153, 119, 154, 139, 140, 149, 138, 119, 141, + 138, 138, 119, 156, 142, 138, 143, 144, 146, 145, + 147, 148, 149, 158, 150, 98, 145, 151, 152, 153, + 157, 154, 152, 155, 149, 155, 160, 161, 152, 159, + 155, 156, 162, 163, 164, 1507, 155, 157, 157, 1504, + 149, 158, 165, 159, 168, 160, 152, 169, 157, 162, + 152, 155, 165, 155, 160, 161, 152, 159, 155, 166, + 162, 163, 164, 165, 155, 157, 157, 167, 166, 171, + 165, 159, 168, 160, 172, 169, 170, 162, 173, 167, + + 165, 174, 170, 167, 174, 175, 170, 166, 1503, 172, + 180, 165, 183, 183, 1502, 167, 166, 171, 181, 178, + 178, 184, 172, 1477, 170, 178, 173, 167, 187, 174, + 170, 167, 174, 175, 170, 191, 178, 172, 180, 192, + 183, 183, 181, 181, 193, 194, 181, 186, 181, 184, + 185, 185, 185, 186, 189, 1476, 187, 186, 193, 181, + 1475, 1474, 189, 191, 1473, 202, 203, 192, 1472, 195, + 205, 206, 193, 194, 1471, 186, 212, 205, 185, 185, + 185, 186, 189, 195, 195, 186, 216, 207, 198, 195, + 189, 198, 198, 202, 203, 219, 198, 195, 205, 206, + + 195, 225, 202, 207, 212, 205, 208, 208, 209, 208, + 208, 210, 209, 1470, 216, 207, 198, 1468, 209, 198, + 198, 210, 210, 219, 198, 221, 198, 210, 211, 225, + 211, 207, 207, 214, 217, 211, 209, 220, 210, 210, + 209, 211, 1467, 220, 217, 221, 209, 220, 378, 378, + 214, 378, 378, 221, 218, 217, 211, 224, 211, 223, + 224, 214, 217, 211, 1466, 220, 218, 232, 240, 211, + 218, 220, 217, 246, 223, 220, 214, 214, 214, 214, + 214, 248, 218, 217, 249, 224, 250, 223, 224, 226, + 226, 226, 226, 251, 218, 232, 240, 252, 218, 253, + + 254, 246, 223, 243, 243, 243, 243, 243, 243, 248, + 255, 256, 249, 257, 250, 258, 259, 260, 261, 262, + 262, 251, 263, 264, 265, 252, 266, 253, 254, 267, + 268, 269, 270, 271, 272, 273, 274, 275, 255, 256, + 276, 257, 278, 258, 259, 260, 261, 262, 262, 279, + 263, 264, 265, 280, 266, 281, 282, 267, 268, 269, + 270, 271, 272, 273, 274, 275, 283, 284, 276, 285, + 278, 286, 287, 288, 288, 288, 288, 279, 289, 290, + 291, 280, 292, 281, 282, 288, 293, 295, 296, 297, + 298, 299, 300, 301, 283, 284, 302, 285, 303, 286, + + 287, 304, 305, 306, 307, 308, 289, 290, 291, 309, + 292, 310, 311, 288, 293, 295, 296, 297, 298, 299, + 300, 301, 312, 314, 302, 315, 303, 314, 316, 304, + 305, 306, 307, 308, 317, 318, 319, 309, 320, 310, + 311, 321, 322, 323, 325, 324, 326, 327, 328, 329, + 312, 314, 330, 315, 331, 314, 316, 324, 332, 333, + 335, 336, 317, 318, 319, 338, 320, 339, 340, 321, + 322, 323, 325, 324, 326, 327, 328, 329, 341, 342, + 330, 337, 331, 343, 344, 324, 332, 333, 335, 336, + 337, 345, 346, 338, 349, 339, 340, 347, 347, 350, + + 352, 353, 355, 347, 354, 354, 341, 342, 356, 337, + 358, 343, 344, 360, 347, 361, 363, 366, 337, 345, + 346, 375, 349, 367, 367, 367, 367, 350, 352, 353, + 355, 376, 354, 354, 379, 367, 356, 380, 358, 381, + 383, 360, 1465, 361, 363, 366, 373, 373, 373, 375, + 385, 386, 383, 387, 388, 389, 393, 394, 396, 376, + 406, 409, 379, 367, 389, 380, 410, 381, 383, 1464, + 373, 392, 392, 392, 395, 395, 395, 395, 385, 386, + 383, 387, 388, 389, 393, 394, 396, 412, 406, 409, + 414, 415, 389, 416, 410, 418, 419, 392, 373, 413, + + 413, 413, 413, 420, 422, 423, 425, 425, 424, 426, + 427, 428, 429, 430, 431, 412, 432, 433, 414, 415, + 424, 416, 434, 418, 419, 392, 437, 438, 439, 440, + 441, 420, 422, 423, 425, 425, 424, 426, 427, 428, + 429, 430, 431, 442, 432, 433, 443, 445, 424, 447, + 434, 448, 449, 450, 437, 438, 439, 440, 441, 451, + 452, 453, 454, 455, 456, 458, 459, 460, 461, 462, + 464, 442, 465, 466, 443, 445, 468, 447, 469, 448, + 449, 450, 456, 470, 471, 472, 473, 451, 452, 453, + 454, 455, 456, 458, 459, 460, 461, 462, 464, 474, + + 465, 466, 475, 476, 468, 477, 469, 478, 479, 480, + 456, 470, 471, 472, 473, 481, 482, 483, 484, 485, + 486, 487, 488, 489, 490, 491, 492, 474, 490, 493, + 475, 476, 494, 477, 495, 478, 479, 480, 496, 497, + 499, 500, 1463, 481, 482, 483, 484, 485, 486, 487, + 488, 489, 490, 491, 492, 502, 490, 493, 504, 505, + 494, 506, 495, 507, 508, 502, 496, 497, 499, 500, + 503, 503, 503, 503, 509, 510, 511, 513, 514, 517, + 517, 517, 517, 502, 518, 521, 504, 505, 523, 506, + 524, 507, 508, 502, 519, 519, 519, 522, 522, 525, + + 527, 530, 509, 510, 511, 513, 514, 526, 526, 526, + 532, 534, 518, 521, 544, 547, 523, 548, 524, 528, + 528, 528, 537, 537, 537, 522, 522, 525, 527, 530, + 549, 551, 553, 554, 556, 556, 556, 556, 532, 534, + 557, 564, 544, 547, 566, 548, 559, 559, 559, 576, + 579, 580, 581, 582, 583, 584, 585, 587, 549, 551, + 553, 554, 588, 590, 591, 593, 594, 595, 557, 564, + 597, 598, 566, 599, 600, 601, 602, 576, 579, 580, + 581, 582, 583, 584, 585, 587, 603, 604, 606, 607, + 588, 590, 591, 593, 594, 595, 608, 611, 597, 598, + + 612, 599, 600, 601, 602, 605, 605, 605, 605, 610, + 610, 610, 610, 613, 603, 604, 606, 607, 614, 615, + 616, 618, 623, 1461, 608, 611, 625, 626, 612, 619, + 619, 619, 619, 620, 620, 620, 620, 621, 621, 621, + 621, 613, 622, 622, 622, 622, 614, 615, 616, 618, + 623, 624, 627, 628, 625, 626, 629, 630, 631, 632, + 633, 634, 635, 636, 637, 624, 638, 639, 640, 641, + 642, 643, 644, 645, 634, 646, 647, 648, 649, 624, + 627, 628, 650, 651, 629, 630, 631, 632, 633, 634, + 635, 636, 637, 624, 638, 639, 640, 641, 642, 643, + + 644, 645, 634, 646, 647, 648, 649, 653, 654, 656, + 650, 651, 657, 658, 659, 660, 661, 662, 663, 664, + 666, 667, 668, 669, 670, 671, 672, 673, 676, 678, + 679, 680, 681, 688, 690, 653, 654, 656, 691, 692, + 657, 658, 659, 660, 661, 662, 663, 664, 666, 667, + 668, 669, 670, 671, 672, 673, 676, 678, 679, 680, + 681, 688, 690, 696, 714, 716, 691, 692, 701, 701, + 701, 701, 710, 710, 710, 711, 711, 711, 712, 712, + 712, 717, 718, 720, 722, 723, 724, 730, 737, 740, + 741, 696, 714, 716, 742, 743, 743, 743, 743, 744, + + 744, 744, 744, 745, 745, 745, 745, 748, 749, 717, + 718, 720, 722, 723, 724, 730, 737, 740, 741, 750, + 752, 753, 742, 746, 746, 746, 746, 754, 755, 756, + 757, 759, 760, 761, 763, 748, 749, 762, 762, 762, + 762, 764, 765, 766, 767, 768, 770, 750, 752, 753, + 771, 772, 773, 775, 776, 754, 755, 756, 757, 759, + 760, 761, 763, 777, 778, 780, 797, 798, 800, 764, + 765, 766, 767, 768, 770, 802, 803, 804, 771, 772, + 773, 775, 776, 805, 806, 807, 808, 809, 810, 811, + 812, 777, 778, 780, 797, 798, 800, 813, 814, 816, + + 817, 818, 819, 802, 803, 804, 821, 822, 823, 824, + 825, 805, 806, 807, 808, 809, 810, 811, 812, 826, + 830, 833, 835, 836, 837, 813, 814, 816, 817, 818, + 819, 838, 839, 840, 821, 822, 823, 824, 825, 841, + 842, 842, 842, 842, 846, 847, 850, 826, 830, 833, + 835, 836, 837, 843, 843, 843, 843, 851, 853, 838, + 839, 840, 844, 844, 844, 844, 849, 841, 845, 845, + 845, 845, 846, 847, 850, 854, 855, 856, 874, 849, + 857, 857, 857, 875, 877, 851, 853, 858, 858, 858, + 859, 859, 859, 879, 849, 860, 860, 860, 860, 882, + + 883, 885, 889, 854, 855, 856, 874, 849, 891, 892, + 893, 875, 877, 910, 912, 875, 913, 914, 915, 916, + 917, 879, 918, 920, 922, 923, 914, 882, 883, 924, + 925, 926, 885, 889, 1460, 1459, 891, 892, 893, 1458, + 1457, 910, 912, 1456, 913, 914, 915, 916, 917, 1425, + 918, 920, 922, 923, 932, 1424, 1423, 924, 925, 926, + 885, 889, 927, 927, 927, 927, 928, 928, 928, 928, + 929, 929, 929, 929, 930, 930, 930, 930, 933, 933, + 933, 933, 932, 934, 934, 934, 934, 935, 935, 935, + 935, 936, 936, 936, 936, 938, 939, 940, 941, 942, + + 944, 946, 947, 948, 949, 950, 951, 952, 953, 954, + 957, 958, 959, 960, 961, 962, 963, 964, 965, 966, + 1192, 1192, 1192, 938, 939, 940, 941, 942, 944, 946, + 947, 948, 949, 950, 951, 952, 953, 954, 957, 958, + 959, 960, 961, 962, 963, 964, 965, 966, 967, 967, + 967, 968, 969, 970, 972, 1422, 973, 975, 967, 974, + 974, 974, 977, 995, 996, 997, 999, 1001, 1002, 974, + 1017, 1421, 1420, 1419, 967, 1418, 1024, 1417, 1025, 968, + 969, 970, 972, 967, 973, 975, 967, 1028, 1029, 1030, + 977, 995, 996, 997, 999, 1001, 1002, 974, 1017, 1019, + + 1019, 1019, 967, 1021, 1021, 1021, 1025, 1024, 1416, 1019, + 1031, 1033, 1034, 1021, 1035, 1028, 1029, 1030, 1036, 1037, + 1038, 1040, 1041, 1062, 1080, 1019, 1042, 1042, 1042, 1042, + 1043, 1043, 1043, 1043, 1019, 1024, 1019, 1019, 1031, 1033, + 1034, 1021, 1035, 1081, 1082, 1083, 1036, 1037, 1038, 1040, + 1041, 1062, 1080, 1019, 1044, 1044, 1044, 1044, 1045, 1045, + 1045, 1045, 1084, 1085, 1086, 1087, 1088, 1090, 1091, 1092, + 1093, 1081, 1082, 1083, 1094, 1095, 1096, 1098, 1099, 1100, + 1102, 1103, 1104, 1105, 1106, 1107, 1415, 1109, 1110, 1111, + 1084, 1085, 1086, 1087, 1088, 1090, 1091, 1092, 1093, 1112, + + 1113, 1114, 1094, 1095, 1096, 1098, 1099, 1100, 1102, 1103, + 1104, 1105, 1106, 1107, 1108, 1109, 1110, 1111, 1116, 1117, + 1108, 1118, 1119, 1120, 1123, 1124, 1131, 1112, 1113, 1114, + 1130, 1130, 1130, 1133, 1134, 1135, 1140, 1137, 1139, 1139, + 1139, 1120, 1108, 1137, 1142, 1143, 1116, 1117, 1108, 1118, + 1119, 1120, 1123, 1124, 1131, 1144, 1145, 1146, 1147, 1148, + 1149, 1133, 1134, 1135, 1140, 1137, 1150, 1130, 1130, 1120, + 1151, 1137, 1142, 1143, 1152, 1139, 1139, 1153, 1170, 1171, + 1172, 1173, 1174, 1144, 1145, 1146, 1147, 1148, 1149, 1176, + 1178, 1179, 1180, 1181, 1150, 1182, 1183, 1184, 1151, 1186, + + 1187, 1188, 1152, 1190, 1191, 1153, 1170, 1171, 1172, 1173, + 1174, 1196, 1197, 1198, 1199, 1200, 1201, 1176, 1178, 1179, + 1180, 1181, 1202, 1182, 1183, 1184, 1204, 1186, 1187, 1188, + 1207, 1190, 1191, 1205, 1208, 1209, 1210, 1211, 1219, 1196, + 1197, 1198, 1199, 1200, 1201, 1205, 1414, 1413, 1225, 1232, + 1202, 1233, 1234, 1236, 1204, 1237, 1238, 1222, 1207, 1239, + 1240, 1205, 1208, 1209, 1210, 1211, 1219, 1242, 1243, 1222, + 1244, 1245, 1246, 1205, 1222, 1222, 1225, 1232, 1247, 1233, + 1234, 1236, 1251, 1237, 1238, 1252, 1253, 1239, 1240, 1255, + 1256, 1257, 1258, 1259, 1260, 1242, 1243, 1261, 1244, 1245, + + 1246, 1262, 1263, 1264, 1265, 1266, 1247, 1267, 1268, 1269, + 1251, 1271, 1272, 1252, 1253, 1274, 1275, 1255, 1256, 1257, + 1258, 1259, 1260, 1276, 1277, 1261, 1278, 1279, 1280, 1262, + 1263, 1264, 1265, 1266, 1281, 1267, 1268, 1269, 1287, 1271, + 1272, 1283, 1295, 1274, 1275, 1302, 1303, 1298, 1304, 1305, + 1306, 1276, 1277, 1283, 1278, 1279, 1280, 1307, 1283, 1298, + 1308, 1309, 1281, 1310, 1298, 1311, 1287, 1312, 1313, 1314, + 1295, 1316, 1317, 1302, 1303, 1319, 1304, 1305, 1306, 1322, + 1324, 1325, 1326, 1327, 1328, 1307, 1330, 1332, 1308, 1309, + 1333, 1310, 1334, 1311, 1336, 1312, 1313, 1314, 1338, 1316, + + 1317, 1339, 1340, 1319, 1341, 1342, 1344, 1322, 1324, 1325, + 1326, 1327, 1328, 1345, 1330, 1332, 1346, 1353, 1333, 1369, + 1334, 1371, 1336, 1373, 1374, 1375, 1338, 1376, 1377, 1339, + 1340, 1377, 1341, 1342, 1344, 1380, 1381, 1382, 1383, 1384, + 1385, 1345, 1386, 1387, 1346, 1353, 1388, 1369, 1389, 1371, + 1390, 1373, 1374, 1375, 1391, 1376, 1377, 1393, 1394, 1377, + 1395, 1396, 1397, 1380, 1381, 1382, 1383, 1384, 1385, 1398, + 1386, 1387, 1399, 1400, 1388, 1401, 1389, 1402, 1390, 1410, + 1426, 1427, 1391, 1429, 1431, 1393, 1394, 1432, 1395, 1396, + 1397, 1433, 1434, 1435, 1438, 1439, 1440, 1398, 1441, 1442, + + 1399, 1400, 1443, 1401, 1444, 1402, 1445, 1410, 1426, 1427, + 1447, 1429, 1431, 1448, 1450, 1432, 1451, 1452, 1453, 1433, + 1434, 1435, 1438, 1439, 1440, 1454, 1441, 1442, 1455, 1478, + 1443, 1479, 1444, 1480, 1445, 1481, 1482, 1483, 1447, 1485, + 1486, 1448, 1450, 1487, 1451, 1452, 1453, 1488, 1489, 1490, + 1491, 1492, 1493, 1454, 1494, 1495, 1455, 1478, 1498, 1479, + 1499, 1480, 1522, 1481, 1482, 1483, 1523, 1485, 1486, 1524, + 1525, 1487, 1526, 1527, 1530, 1488, 1489, 1490, 1491, 1492, + 1493, 1531, 1494, 1495, 1532, 1533, 1498, 1534, 1499, 1535, + 1522, 1536, 1537, 1538, 1523, 1539, 1540, 1524, 1525, 1557, + + 1526, 1527, 1530, 1558, 1560, 1561, 1565, 1566, 1569, 1531, + 1584, 1586, 1532, 1533, 1588, 1534, 1589, 1535, 1590, 1536, + 1537, 1538, 1600, 1539, 1540, 1601, 1602, 1557, 1604, 1609, + 1610, 1558, 1560, 1561, 1565, 1566, 1569, 1612, 1584, 1586, + 1617, 1618, 1588, 1619, 1589, 1623, 1590, 1624, 1625, 1628, + 1600, 1412, 1411, 1601, 1602, 1409, 1604, 1609, 1610, 1408, + 1407, 1406, 1405, 1404, 1367, 1612, 1366, 1365, 1617, 1618, + 1364, 1619, 1363, 1623, 1362, 1624, 1625, 1628, 1633, 1633, + 1633, 1633, 1634, 1634, 1634, 1634, 1636, 1360, 1359, 1636, + 1637, 1358, 1637, 1637, 1638, 1357, 1638, 1638, 1356, 1355, + + 1354, 1352, 1351, 1350, 1349, 1348, 1347, 1323, 1301, 1300, + 1297, 1294, 1293, 1292, 1291, 1290, 1289, 1288, 1286, 1285, + 1282, 1270, 1231, 1230, 1229, 1228, 1227, 1226, 1224, 1218, + 1217, 1216, 1215, 1214, 1203, 1138, 1136, 1132, 1129, 1126, + 1023, 1020, 1018, 1015, 1014, 1000, 931, 890, 888, 884, + 880, 873, 862, 861, 852, 831, 751, 739, 736, 735, + 731, 725, 721, 719, 713, 709, 705, 704, 695, 694, + 693, 689, 683, 596, 578, 577, 574, 573, 572, 571, + 570, 567, 558, 552, 550, 545, 543, 542, 541, 540, + 538, 536, 535, 533, 516, 408, 407, 405, 404, 403, + + 402, 401, 400, 399, 398, 397, 391, 390, 384, 382, + 377, 374, 372, 371, 370, 369, 368, 365, 362, 359, + 357, 351, 348, 313, 247, 242, 241, 239, 238, 236, + 235, 233, 222, 215, 213, 204, 201, 200, 199, 196, + 190, 188, 182, 179, 103, 99, 84, 83, 81, 78, + 74, 71, 22, 15, 13, 11, 9, 7, 6, 5, + 1632, 1632, 1632, 1632, 1632, 1632, 1632, 1632, 1632, 1632, + 1632, 1632, 1632, 1632, 1632, 1632, 1632, 1632, 1632, 1632, + 1632, 1632, 1632, 1632, 1632, 1632, 1632, 1632, 1632, 1632, + 1632, 1632, 1632, 1632, 1632, 1632, 1632, 1632, 1632, 1632, + + 1632, 1632, 1632, 1632, 1632, 1632, 1632, 1632, 1632, 1632, + 1632, 1632, 1632, 1632, 1632, 1632, 1632, 1632, 1632, 1632, + 1632, 1632, 1632, 1632, 1632, 1632, 1632, 1632, 1632, 1632, + 1632, 1632, 1632, 1632, 1632, 1632, 1632 + } ; + +/* 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 +#line 1 "gpu/lolfx-scanner.l" +#line 2 "gpu/lolfx-scanner.l" +// +// Lol Engine +// +// Copyright: (c) 2010-2012 Sam Hocevar +// This program is free software; you can redistribute it and/or +// modify it under the terms of the Do What The Fuck You Want To +// Public License, Version 2, as published by Sam Hocevar. See +// http://sam.zoy.org/projects/COPYING.WTFPL for more details. +// + +#if defined HAVE_CONFIG_H +# include "config.h" +#endif + +#include +using std::exit; +using std::malloc; +using std::realloc; +using std::free; +#include + +#include "core.h" +#include "gpu/lolfx-compiler.h" + +typedef lol::LolFxParser::token token; +typedef lol::LolFxParser::token_type token_type; + +#ifndef YY_DECL +# define YY_DECL lol::LolFxParser::token_type \ + lol::LolFxScanner::lex(lol::LolFxParser::semantic_type* yylval, \ + lol::LolFxParser::location_type* yylloc) +#endif + +#define yyterminate() return token::T_END +#define YY_NO_UNISTD_H +#define YY_USER_ACTION yylloc->columns(yyleng); + + +#line 1662 "generated/lolfx-scanner.cpp" + +#define INITIAL 0 +#define C_COMMENT 1 +#define CPP_COMMENT 2 + +#ifndef YY_NO_UNISTD_H +/* Special case for "unistd.h", since it is non-ANSI. We include it way + * down here because we want the user's section 1 to have been scanned first. + * The user has a chance to override it with an option. + */ +#include +#endif + +#ifndef YY_EXTRA_TYPE +#define YY_EXTRA_TYPE void * +#endif + +#ifndef yytext_ptr +static void yy_flex_strncpy (char *,yyconst char *,int ); +#endif + +#ifdef YY_NEED_STRLEN +static int yy_flex_strlen (yyconst char * ); +#endif + +#ifndef YY_NO_INPUT + +#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 16384 +#else +#define YY_READ_BUF_SIZE 8192 +#endif /* __ia64__ */ +#endif + +/* Copy whatever the last rule matched to the standard output. */ +#ifndef ECHO +#define ECHO LexerOutput( yytext, yyleng ) +#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 ( (result = LexerInput( (char *) buf, max_size )) < 0 ) \ + YY_FATAL_ERROR( "input in flex scanner failed" ); + +#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) LexerError( 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 1 +#define YY_DECL int yyFlexLexer::yylex() +#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; + +#line 46 "gpu/lolfx-scanner.l" + + + + /* reset location at the beginning of yylex() */ + yylloc->step(); + + int language_guess = INITIAL; + + + /* + * GLSL keywords + */ + +#line 1783 "generated/lolfx-scanner.cpp" + + if ( !(yy_init) ) + { + (yy_init) = 1; + +#ifdef YY_USER_INIT + YY_USER_INIT; +#endif + + if ( ! (yy_start) ) + (yy_start) = 1; /* first start state */ + + if ( ! yyin ) + yyin = & std::cin; + + if ( ! yyout ) + yyout = & std::cout; + + if ( ! YY_CURRENT_BUFFER ) { + yyensure_buffer_stack (); + YY_CURRENT_BUFFER_LVALUE = + yy_create_buffer( yyin, YY_BUF_SIZE ); + } + + yy_load_buffer_state( ); + } + + while ( 1 ) /* loops until end-of-file is reached */ + { + yy_cp = (yy_c_buf_p); + + /* Support of yytext. */ + *yy_cp = (yy_hold_char); + + /* yy_bp points to the position in yy_ch_buf of the start of + * the current run. + */ + yy_bp = yy_cp; + + yy_current_state = (yy_start); +yy_match: + do + { + register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)]; + if ( yy_accept[yy_current_state] ) + { + (yy_last_accepting_state) = yy_current_state; + (yy_last_accepting_cpos) = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 1633 ) + 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 != 1632 ); + yy_cp = (yy_last_accepting_cpos); + yy_current_state = (yy_last_accepting_state); + +yy_find_action: + yy_act = yy_accept[yy_current_state]; + + YY_DO_BEFORE_ACTION; + +do_action: /* This label is used only to access EOF actions. */ + + switch ( yy_act ) + { /* beginning of action switch */ + case 0: /* must back up */ + /* undo the effects of YY_DO_BEFORE_ACTION */ + *yy_cp = (yy_hold_char); + yy_cp = (yy_last_accepting_cpos); + yy_current_state = (yy_last_accepting_state); + goto yy_find_action; + +case 1: +YY_RULE_SETUP +#line 59 "gpu/lolfx-scanner.l" +{ return token::GT_SUBROUTINE; } + YY_BREAK +case 2: +YY_RULE_SETUP +#line 60 "gpu/lolfx-scanner.l" +{ return token::GT_PATCH; } + YY_BREAK +case 3: +YY_RULE_SETUP +#line 61 "gpu/lolfx-scanner.l" +{ return token::GT_SAMPLE; } + YY_BREAK +case 4: +YY_RULE_SETUP +#line 62 "gpu/lolfx-scanner.l" +{ return token::GT_FLAT; } + YY_BREAK +case 5: +YY_RULE_SETUP +#line 63 "gpu/lolfx-scanner.l" +{ return token::GT_SMOOTH; } + YY_BREAK +case 6: +YY_RULE_SETUP +#line 64 "gpu/lolfx-scanner.l" +{ return token::GT_LAYOUT; } + YY_BREAK +case 7: +YY_RULE_SETUP +#line 65 "gpu/lolfx-scanner.l" +{ return token::GT_SAMPLER1DSHADOW; } + YY_BREAK +case 8: +YY_RULE_SETUP +#line 66 "gpu/lolfx-scanner.l" +{ return token::GT_SAMPLER2DSHADOW; } + YY_BREAK +case 9: +YY_RULE_SETUP +#line 67 "gpu/lolfx-scanner.l" +{ return token::GT_SAMPLERCUBESHADOW; } + YY_BREAK +case 10: +YY_RULE_SETUP +#line 68 "gpu/lolfx-scanner.l" +{ return token::GT_SAMPLER1DARRAY; } + YY_BREAK +case 11: +YY_RULE_SETUP +#line 69 "gpu/lolfx-scanner.l" +{ return token::GT_SAMPLER2DARRAY; } + YY_BREAK +case 12: +YY_RULE_SETUP +#line 70 "gpu/lolfx-scanner.l" +{ return token::GT_SAMPLER1DARRAYSHADOW; } + YY_BREAK +case 13: +YY_RULE_SETUP +#line 71 "gpu/lolfx-scanner.l" +{ return token::GT_SAMPLER2DARRAYSHADOW; } + YY_BREAK +case 14: +YY_RULE_SETUP +#line 72 "gpu/lolfx-scanner.l" +{ return token::GT_ISAMPLER1D; } + YY_BREAK +case 15: +YY_RULE_SETUP +#line 73 "gpu/lolfx-scanner.l" +{ return token::GT_ISAMPLER2D; } + YY_BREAK +case 16: +YY_RULE_SETUP +#line 74 "gpu/lolfx-scanner.l" +{ return token::GT_ISAMPLER3D; } + YY_BREAK +case 17: +YY_RULE_SETUP +#line 75 "gpu/lolfx-scanner.l" +{ return token::GT_ISAMPLERCUBE; } + YY_BREAK +case 18: +YY_RULE_SETUP +#line 76 "gpu/lolfx-scanner.l" +{ return token::GT_ISAMPLER1DARRAY; } + YY_BREAK +case 19: +YY_RULE_SETUP +#line 77 "gpu/lolfx-scanner.l" +{ return token::GT_ISAMPLER2DARRAY; } + YY_BREAK +case 20: +YY_RULE_SETUP +#line 78 "gpu/lolfx-scanner.l" +{ return token::GT_USAMPLER1D; } + YY_BREAK +case 21: +YY_RULE_SETUP +#line 79 "gpu/lolfx-scanner.l" +{ return token::GT_USAMPLER2D; } + YY_BREAK +case 22: +YY_RULE_SETUP +#line 80 "gpu/lolfx-scanner.l" +{ return token::GT_USAMPLER3D; } + YY_BREAK +case 23: +YY_RULE_SETUP +#line 81 "gpu/lolfx-scanner.l" +{ return token::GT_USAMPLERCUBE; } + YY_BREAK +case 24: +YY_RULE_SETUP +#line 82 "gpu/lolfx-scanner.l" +{ return token::GT_USAMPLER1DARRAY; } + YY_BREAK +case 25: +YY_RULE_SETUP +#line 83 "gpu/lolfx-scanner.l" +{ return token::GT_USAMPLER2DARRAY; } + YY_BREAK +case 26: +YY_RULE_SETUP +#line 84 "gpu/lolfx-scanner.l" +{ return token::GT_SAMPLER2DRECT; } + YY_BREAK +case 27: +YY_RULE_SETUP +#line 85 "gpu/lolfx-scanner.l" +{ return token::GT_SAMPLER2DRECTSHADOW; } + YY_BREAK +case 28: +YY_RULE_SETUP +#line 86 "gpu/lolfx-scanner.l" +{ return token::GT_ISAMPLER2DRECT; } + YY_BREAK +case 29: +YY_RULE_SETUP +#line 87 "gpu/lolfx-scanner.l" +{ return token::GT_USAMPLER2DRECT; } + YY_BREAK +case 30: +YY_RULE_SETUP +#line 88 "gpu/lolfx-scanner.l" +{ return token::GT_SAMPLERBUFFER; } + YY_BREAK +case 31: +YY_RULE_SETUP +#line 89 "gpu/lolfx-scanner.l" +{ return token::GT_ISAMPLERBUFFER; } + YY_BREAK +case 32: +YY_RULE_SETUP +#line 90 "gpu/lolfx-scanner.l" +{ return token::GT_USAMPLERBUFFER; } + YY_BREAK +case 33: +YY_RULE_SETUP +#line 91 "gpu/lolfx-scanner.l" +{ return token::GT_SAMPLERCUBEARRAY; } + YY_BREAK +case 34: +YY_RULE_SETUP +#line 92 "gpu/lolfx-scanner.l" +{ return token::GT_SAMPLERCUBEARRAYSHADOW; } + YY_BREAK +case 35: +YY_RULE_SETUP +#line 93 "gpu/lolfx-scanner.l" +{ return token::GT_ISAMPLERCUBEARRAY; } + YY_BREAK +case 36: +YY_RULE_SETUP +#line 94 "gpu/lolfx-scanner.l" +{ return token::GT_USAMPLERCUBEARRAY; } + YY_BREAK +case 37: +YY_RULE_SETUP +#line 95 "gpu/lolfx-scanner.l" +{ return token::GT_SAMPLER2DMS; } + YY_BREAK +case 38: +YY_RULE_SETUP +#line 96 "gpu/lolfx-scanner.l" +{ return token::GT_ISAMPLER2DMS; } + YY_BREAK +case 39: +YY_RULE_SETUP +#line 97 "gpu/lolfx-scanner.l" +{ return token::GT_USAMPLER2DMS; } + YY_BREAK +case 40: +YY_RULE_SETUP +#line 98 "gpu/lolfx-scanner.l" +{ return token::GT_SAMPLER2DMSARRAY; } + YY_BREAK +case 41: +YY_RULE_SETUP +#line 99 "gpu/lolfx-scanner.l" +{ return token::GT_ISAMPLER2DMSARRAY; } + YY_BREAK +case 42: +YY_RULE_SETUP +#line 100 "gpu/lolfx-scanner.l" +{ return token::GT_USAMPLER2DMSARRAY; } + YY_BREAK +case 43: +YY_RULE_SETUP +#line 102 "gpu/lolfx-scanner.l" +{ return token::GT_HIGHP; } + YY_BREAK +case 44: +YY_RULE_SETUP +#line 103 "gpu/lolfx-scanner.l" +{ return token::GT_MEDIUMP; } + YY_BREAK +case 45: +YY_RULE_SETUP +#line 104 "gpu/lolfx-scanner.l" +{ return token::GT_LOWP; } + YY_BREAK +case 46: +YY_RULE_SETUP +#line 105 "gpu/lolfx-scanner.l" +{ return token::GT_PRECISION; } + YY_BREAK +case 47: +YY_RULE_SETUP +#line 106 "gpu/lolfx-scanner.l" +{ return token::GT_INVARIANT; } + YY_BREAK +/* + * Deprecated GLSL keywords + */ +case 48: +YY_RULE_SETUP +#line 112 "gpu/lolfx-scanner.l" +{ return token::GT_ATTRIBUTE; } + YY_BREAK +/* + * GLSL vector types + */ +case 49: +YY_RULE_SETUP +#line 118 "gpu/lolfx-scanner.l" +{ return token::GT_BVEC2; } + YY_BREAK +case 50: +YY_RULE_SETUP +#line 119 "gpu/lolfx-scanner.l" +{ return token::GT_BVEC3; } + YY_BREAK +case 51: +YY_RULE_SETUP +#line 120 "gpu/lolfx-scanner.l" +{ return token::GT_BVEC4; } + YY_BREAK +case 52: +YY_RULE_SETUP +#line 122 "gpu/lolfx-scanner.l" +{ return token::GT_IVEC2; } + YY_BREAK +case 53: +YY_RULE_SETUP +#line 123 "gpu/lolfx-scanner.l" +{ return token::GT_IVEC3; } + YY_BREAK +case 54: +YY_RULE_SETUP +#line 124 "gpu/lolfx-scanner.l" +{ return token::GT_IVEC4; } + YY_BREAK +case 55: +YY_RULE_SETUP +#line 126 "gpu/lolfx-scanner.l" +{ return token::GT_UVEC2; } + YY_BREAK +case 56: +YY_RULE_SETUP +#line 127 "gpu/lolfx-scanner.l" +{ return token::GT_UVEC3; } + YY_BREAK +case 57: +YY_RULE_SETUP +#line 128 "gpu/lolfx-scanner.l" +{ return token::GT_UVEC4; } + YY_BREAK +case 58: +YY_RULE_SETUP +#line 130 "gpu/lolfx-scanner.l" +{ return token::GT_VEC2; } + YY_BREAK +case 59: +YY_RULE_SETUP +#line 131 "gpu/lolfx-scanner.l" +{ return token::GT_VEC3; } + YY_BREAK +case 60: +YY_RULE_SETUP +#line 132 "gpu/lolfx-scanner.l" +{ return token::GT_VEC4; } + YY_BREAK +case 61: +YY_RULE_SETUP +#line 133 "gpu/lolfx-scanner.l" +{ return token::GT_MAT2; } + YY_BREAK +case 62: +YY_RULE_SETUP +#line 134 "gpu/lolfx-scanner.l" +{ return token::GT_MAT2X2; } + YY_BREAK +case 63: +YY_RULE_SETUP +#line 135 "gpu/lolfx-scanner.l" +{ return token::GT_MAT2X3; } + YY_BREAK +case 64: +YY_RULE_SETUP +#line 136 "gpu/lolfx-scanner.l" +{ return token::GT_MAT2X4; } + YY_BREAK +case 65: +YY_RULE_SETUP +#line 137 "gpu/lolfx-scanner.l" +{ return token::GT_MAT3; } + YY_BREAK +case 66: +YY_RULE_SETUP +#line 138 "gpu/lolfx-scanner.l" +{ return token::GT_MAT3X2; } + YY_BREAK +case 67: +YY_RULE_SETUP +#line 139 "gpu/lolfx-scanner.l" +{ return token::GT_MAT3X3; } + YY_BREAK +case 68: +YY_RULE_SETUP +#line 140 "gpu/lolfx-scanner.l" +{ return token::GT_MAT3X4; } + YY_BREAK +case 69: +YY_RULE_SETUP +#line 141 "gpu/lolfx-scanner.l" +{ return token::GT_MAT4; } + YY_BREAK +case 70: +YY_RULE_SETUP +#line 142 "gpu/lolfx-scanner.l" +{ return token::GT_MAT4X2; } + YY_BREAK +case 71: +YY_RULE_SETUP +#line 143 "gpu/lolfx-scanner.l" +{ return token::GT_MAT4X3; } + YY_BREAK +case 72: +YY_RULE_SETUP +#line 144 "gpu/lolfx-scanner.l" +{ return token::GT_MAT4X4; } + YY_BREAK +case 73: +YY_RULE_SETUP +#line 146 "gpu/lolfx-scanner.l" +{ return token::GT_DVEC2; } + YY_BREAK +case 74: +YY_RULE_SETUP +#line 147 "gpu/lolfx-scanner.l" +{ return token::GT_DVEC3; } + YY_BREAK +case 75: +YY_RULE_SETUP +#line 148 "gpu/lolfx-scanner.l" +{ return token::GT_DVEC4; } + YY_BREAK +case 76: +YY_RULE_SETUP +#line 149 "gpu/lolfx-scanner.l" +{ return token::GT_DMAT2; } + YY_BREAK +case 77: +YY_RULE_SETUP +#line 150 "gpu/lolfx-scanner.l" +{ return token::GT_DMAT2X2; } + YY_BREAK +case 78: +YY_RULE_SETUP +#line 151 "gpu/lolfx-scanner.l" +{ return token::GT_DMAT2X3; } + YY_BREAK +case 79: +YY_RULE_SETUP +#line 152 "gpu/lolfx-scanner.l" +{ return token::GT_DMAT2X4; } + YY_BREAK +case 80: +YY_RULE_SETUP +#line 153 "gpu/lolfx-scanner.l" +{ return token::GT_DMAT3; } + YY_BREAK +case 81: +YY_RULE_SETUP +#line 154 "gpu/lolfx-scanner.l" +{ return token::GT_DMAT3X2; } + YY_BREAK +case 82: +YY_RULE_SETUP +#line 155 "gpu/lolfx-scanner.l" +{ return token::GT_DMAT3X3; } + YY_BREAK +case 83: +YY_RULE_SETUP +#line 156 "gpu/lolfx-scanner.l" +{ return token::GT_DMAT3X4; } + YY_BREAK +case 84: +YY_RULE_SETUP +#line 157 "gpu/lolfx-scanner.l" +{ return token::GT_DMAT4; } + YY_BREAK +case 85: +YY_RULE_SETUP +#line 158 "gpu/lolfx-scanner.l" +{ return token::GT_DMAT4X2; } + YY_BREAK +case 86: +YY_RULE_SETUP +#line 159 "gpu/lolfx-scanner.l" +{ return token::GT_DMAT4X3; } + YY_BREAK +case 87: +YY_RULE_SETUP +#line 160 "gpu/lolfx-scanner.l" +{ return token::GT_DMAT4X4; } + YY_BREAK +/* + * GLSL constant values + */ +case 88: +YY_RULE_SETUP +#line 166 "gpu/lolfx-scanner.l" +{ yylval->ival = 1; return token::BOOLCONSTANT; } + YY_BREAK +case 89: +YY_RULE_SETUP +#line 167 "gpu/lolfx-scanner.l" +{ yylval->ival = 0; return token::BOOLCONSTANT; } + YY_BREAK +case 90: +YY_RULE_SETUP +#line 169 "gpu/lolfx-scanner.l" +{ return token::FIELDSELECTION; } + YY_BREAK +case 91: +YY_RULE_SETUP +#line 170 "gpu/lolfx-scanner.l" +{ return token::FIELDSELECTION; } + YY_BREAK +case 92: +YY_RULE_SETUP +#line 171 "gpu/lolfx-scanner.l" +{ return token::FIELDSELECTION; } + YY_BREAK +/* + * GLSL keywords that are also valid or reserved in HLSL + * and HLSL keywords that are also valid or reserved in GLSL. + */ +case 93: +YY_RULE_SETUP +#line 178 "gpu/lolfx-scanner.l" +{ return token::GHT_BOOL; } + YY_BREAK +case 94: +YY_RULE_SETUP +#line 179 "gpu/lolfx-scanner.l" +{ return token::GHT_BREAK; } + YY_BREAK +case 95: +YY_RULE_SETUP +#line 180 "gpu/lolfx-scanner.l" +{ return token::GHT_CASE; } + YY_BREAK +case 96: +YY_RULE_SETUP +#line 181 "gpu/lolfx-scanner.l" +{ return token::GHT_CENTROID; } + YY_BREAK +case 97: +YY_RULE_SETUP +#line 182 "gpu/lolfx-scanner.l" +{ return token::GHT_CONST; } + YY_BREAK +case 98: +YY_RULE_SETUP +#line 183 "gpu/lolfx-scanner.l" +{ return token::GHT_CONTINUE; } + YY_BREAK +case 99: +YY_RULE_SETUP +#line 184 "gpu/lolfx-scanner.l" +{ return token::GHT_DEFAULT; } + YY_BREAK +case 100: +YY_RULE_SETUP +#line 185 "gpu/lolfx-scanner.l" +{ return token::GHT_DISCARD; } + YY_BREAK +case 101: +YY_RULE_SETUP +#line 186 "gpu/lolfx-scanner.l" +{ return token::GHT_DO; } + YY_BREAK +case 102: +YY_RULE_SETUP +#line 187 "gpu/lolfx-scanner.l" +{ return token::GHT_DOUBLE; } + YY_BREAK +case 103: +YY_RULE_SETUP +#line 188 "gpu/lolfx-scanner.l" +{ return token::GHT_ELSE; } + YY_BREAK +case 104: +YY_RULE_SETUP +#line 189 "gpu/lolfx-scanner.l" +{ return token::GHT_FLOAT; } + YY_BREAK +case 105: +YY_RULE_SETUP +#line 190 "gpu/lolfx-scanner.l" +{ return token::GHT_FOR; } + YY_BREAK +case 106: +YY_RULE_SETUP +#line 191 "gpu/lolfx-scanner.l" +{ return token::GHT_IF; } + YY_BREAK +case 107: +YY_RULE_SETUP +#line 192 "gpu/lolfx-scanner.l" +{ return token::GHT_IN; } + YY_BREAK +case 108: +YY_RULE_SETUP +#line 193 "gpu/lolfx-scanner.l" +{ return token::GHT_INOUT; } + YY_BREAK +case 109: +YY_RULE_SETUP +#line 194 "gpu/lolfx-scanner.l" +{ return token::GHT_INT; } + YY_BREAK +case 110: +YY_RULE_SETUP +#line 195 "gpu/lolfx-scanner.l" +{ return token::GHT_NOPERSPECTIVE; } + YY_BREAK +case 111: +YY_RULE_SETUP +#line 196 "gpu/lolfx-scanner.l" +{ return token::GHT_OUT; } + YY_BREAK +case 112: +YY_RULE_SETUP +#line 197 "gpu/lolfx-scanner.l" +{ return token::GHT_RETURN; } + YY_BREAK +case 113: +YY_RULE_SETUP +#line 198 "gpu/lolfx-scanner.l" +{ return token::GHT_SAMPLER1D; } + YY_BREAK +case 114: +YY_RULE_SETUP +#line 199 "gpu/lolfx-scanner.l" +{ return token::GHT_SAMPLER2D; } + YY_BREAK +case 115: +YY_RULE_SETUP +#line 200 "gpu/lolfx-scanner.l" +{ return token::GHT_SAMPLER3D; } + YY_BREAK +case 116: +YY_RULE_SETUP +#line 201 "gpu/lolfx-scanner.l" +{ return token::GHT_SAMPLERCUBE; } + YY_BREAK +case 117: +YY_RULE_SETUP +#line 202 "gpu/lolfx-scanner.l" +{ return token::GHT_STRUCT; } + YY_BREAK +case 118: +YY_RULE_SETUP +#line 203 "gpu/lolfx-scanner.l" +{ return token::GHT_SWITCH; } + YY_BREAK +case 119: +YY_RULE_SETUP +#line 204 "gpu/lolfx-scanner.l" +{ return token::GHT_UINT; } + YY_BREAK +case 120: +YY_RULE_SETUP +#line 205 "gpu/lolfx-scanner.l" +{ return token::GHT_UNIFORM; } + YY_BREAK +case 121: +YY_RULE_SETUP +#line 206 "gpu/lolfx-scanner.l" +{ return token::GHT_VOID; } + YY_BREAK +case 122: +YY_RULE_SETUP +#line 207 "gpu/lolfx-scanner.l" +{ return token::GHT_WHILE; } + YY_BREAK +case 123: +YY_RULE_SETUP +#line 209 "gpu/lolfx-scanner.l" +{ return token::HGT_BOOL; } + YY_BREAK +case 124: +YY_RULE_SETUP +#line 210 "gpu/lolfx-scanner.l" +{ return token::HGT_BREAK; } + YY_BREAK +case 125: +YY_RULE_SETUP +#line 211 "gpu/lolfx-scanner.l" +{ return token::HGT_CASE; } + YY_BREAK +case 126: +YY_RULE_SETUP +#line 212 "gpu/lolfx-scanner.l" +{ return token::HGT_CENTROID; } + YY_BREAK +case 127: +YY_RULE_SETUP +#line 213 "gpu/lolfx-scanner.l" +{ return token::HGT_CONST; } + YY_BREAK +case 128: +YY_RULE_SETUP +#line 214 "gpu/lolfx-scanner.l" +{ return token::HGT_CONTINUE; } + YY_BREAK +case 129: +YY_RULE_SETUP +#line 215 "gpu/lolfx-scanner.l" +{ return token::HGT_DEFAULT; } + YY_BREAK +case 130: +YY_RULE_SETUP +#line 216 "gpu/lolfx-scanner.l" +{ return token::HGT_DISCARD; } + YY_BREAK +case 131: +YY_RULE_SETUP +#line 217 "gpu/lolfx-scanner.l" +{ return token::HGT_DO; } + YY_BREAK +case 132: +YY_RULE_SETUP +#line 218 "gpu/lolfx-scanner.l" +{ return token::HGT_DOUBLE; } + YY_BREAK +case 133: +YY_RULE_SETUP +#line 219 "gpu/lolfx-scanner.l" +{ return token::HGT_ELSE; } + YY_BREAK +case 134: +YY_RULE_SETUP +#line 220 "gpu/lolfx-scanner.l" +{ return token::HGT_FLOAT; } + YY_BREAK +case 135: +YY_RULE_SETUP +#line 221 "gpu/lolfx-scanner.l" +{ return token::HGT_FOR; } + YY_BREAK +case 136: +YY_RULE_SETUP +#line 222 "gpu/lolfx-scanner.l" +{ return token::HGT_IF; } + YY_BREAK +case 137: +YY_RULE_SETUP +#line 223 "gpu/lolfx-scanner.l" +{ return token::HGT_IN; } + YY_BREAK +case 138: +YY_RULE_SETUP +#line 224 "gpu/lolfx-scanner.l" +{ return token::HGT_INOUT; } + YY_BREAK +case 139: +YY_RULE_SETUP +#line 225 "gpu/lolfx-scanner.l" +{ return token::HGT_INT; } + YY_BREAK +case 140: +YY_RULE_SETUP +#line 226 "gpu/lolfx-scanner.l" +{ return token::HGT_NOPERSPECTIVE; } + YY_BREAK +case 141: +YY_RULE_SETUP +#line 227 "gpu/lolfx-scanner.l" +{ return token::HGT_OUT; } + YY_BREAK +case 142: +YY_RULE_SETUP +#line 228 "gpu/lolfx-scanner.l" +{ return token::HGT_RETURN; } + YY_BREAK +case 143: +YY_RULE_SETUP +#line 229 "gpu/lolfx-scanner.l" +{ return token::HGT_SAMPLER1D; } + YY_BREAK +case 144: +YY_RULE_SETUP +#line 230 "gpu/lolfx-scanner.l" +{ return token::HGT_SAMPLER2D; } + YY_BREAK +case 145: +YY_RULE_SETUP +#line 231 "gpu/lolfx-scanner.l" +{ return token::HGT_SAMPLER3D; } + YY_BREAK +case 146: +YY_RULE_SETUP +#line 232 "gpu/lolfx-scanner.l" +{ return token::HGT_SAMPLERCUBE; } + YY_BREAK +case 147: +YY_RULE_SETUP +#line 233 "gpu/lolfx-scanner.l" +{ return token::HGT_STRUCT; } + YY_BREAK +case 148: +YY_RULE_SETUP +#line 234 "gpu/lolfx-scanner.l" +{ return token::HGT_SWITCH; } + YY_BREAK +case 149: +YY_RULE_SETUP +#line 235 "gpu/lolfx-scanner.l" +{ return token::HGT_UINT; } + YY_BREAK +case 150: +YY_RULE_SETUP +#line 236 "gpu/lolfx-scanner.l" +{ return token::HGT_UNIFORM; } + YY_BREAK +case 151: +YY_RULE_SETUP +#line 237 "gpu/lolfx-scanner.l" +{ return token::HGT_VOID; } + YY_BREAK +case 152: +YY_RULE_SETUP +#line 238 "gpu/lolfx-scanner.l" +{ return token::HGT_WHILE; } + YY_BREAK +/* + * HLSL keywords + * Gathered from http://msdn.microsoft.com/en-us/library/windows/desktop/bb509568%28v=vs.85%29.aspx + */ +case 153: +YY_RULE_SETUP +#line 245 "gpu/lolfx-scanner.l" +{ return token::HT_APPENDSTRUCTUREDBUFFER; } + YY_BREAK +case 154: +YY_RULE_SETUP +#line 246 "gpu/lolfx-scanner.l" +{ return token::HT_ASM; } + YY_BREAK +case 155: +YY_RULE_SETUP +#line 247 "gpu/lolfx-scanner.l" +{ return token::HT_ASM_FRAGMENT; } + YY_BREAK +case 156: +YY_RULE_SETUP +#line 248 "gpu/lolfx-scanner.l" +{ return token::HT_BLENDSTATE; } + YY_BREAK +case 157: +YY_RULE_SETUP +#line 249 "gpu/lolfx-scanner.l" +{ return token::HT_BUFFER; } + YY_BREAK +case 158: +YY_RULE_SETUP +#line 250 "gpu/lolfx-scanner.l" +{ return token::HT_BYTEADDRESSBUFFER; } + YY_BREAK +case 159: +YY_RULE_SETUP +#line 251 "gpu/lolfx-scanner.l" +{ return token::HT_CBUFFER; } + YY_BREAK +case 160: +YY_RULE_SETUP +#line 252 "gpu/lolfx-scanner.l" +{ return token::HT_COLUMN_MAJOR; } + YY_BREAK +case 161: +YY_RULE_SETUP +#line 253 "gpu/lolfx-scanner.l" +{ return token::HT_COMPILE; } + YY_BREAK +case 162: +YY_RULE_SETUP +#line 254 "gpu/lolfx-scanner.l" +{ return token::HT_COMPILE_FRAGMENT; } + YY_BREAK +case 163: +YY_RULE_SETUP +#line 255 "gpu/lolfx-scanner.l" +{ return token::HT_COMPILESHADER; } + YY_BREAK +case 164: +YY_RULE_SETUP +#line 256 "gpu/lolfx-scanner.l" +{ return token::HT_COMPUTESHADER; } + YY_BREAK +case 165: +YY_RULE_SETUP +#line 257 "gpu/lolfx-scanner.l" +{ return token::HT_CONSUMESTRUCTUREDBUFFER; } + YY_BREAK +case 166: +YY_RULE_SETUP +#line 258 "gpu/lolfx-scanner.l" +{ return token::HT_DEPTHSTENCILSTATE; } + YY_BREAK +case 167: +YY_RULE_SETUP +#line 259 "gpu/lolfx-scanner.l" +{ return token::HT_DEPTHSTENCILVIEW; } + YY_BREAK +case 168: +YY_RULE_SETUP +#line 260 "gpu/lolfx-scanner.l" +{ return token::HT_DOMAINSHADER; } + YY_BREAK +case 169: +YY_RULE_SETUP +#line 261 "gpu/lolfx-scanner.l" +{ return token::HT_DWORD; } + YY_BREAK +case 170: +YY_RULE_SETUP +#line 262 "gpu/lolfx-scanner.l" +{ return token::HT_EXTERN; } + YY_BREAK +case 171: +YY_RULE_SETUP +#line 263 "gpu/lolfx-scanner.l" +{ return token::HT_FALSE; } + YY_BREAK +case 172: +YY_RULE_SETUP +#line 264 "gpu/lolfx-scanner.l" +{ return token::HT_FXGROUP; } + YY_BREAK +case 173: +YY_RULE_SETUP +#line 265 "gpu/lolfx-scanner.l" +{ return token::HT_GEOMETRYSHADER; } + YY_BREAK +case 174: +YY_RULE_SETUP +#line 266 "gpu/lolfx-scanner.l" +{ return token::HT_GROUPSHARED; } + YY_BREAK +case 175: +YY_RULE_SETUP +#line 267 "gpu/lolfx-scanner.l" +{ return token::HT_HALF; } + YY_BREAK +case 176: +YY_RULE_SETUP +#line 268 "gpu/lolfx-scanner.l" +{ return token::HT_HULLSHADER; } + YY_BREAK +case 177: +YY_RULE_SETUP +#line 269 "gpu/lolfx-scanner.l" +{ return token::HT_INLINE; } + YY_BREAK +case 178: +YY_RULE_SETUP +#line 270 "gpu/lolfx-scanner.l" +{ return token::HT_INPUTPATCH; } + YY_BREAK +case 179: +YY_RULE_SETUP +#line 271 "gpu/lolfx-scanner.l" +{ return token::HT_INTERFACE; } + YY_BREAK +case 180: +YY_RULE_SETUP +#line 272 "gpu/lolfx-scanner.l" +{ return token::HT_LINE; } + YY_BREAK +case 181: +YY_RULE_SETUP +#line 273 "gpu/lolfx-scanner.l" +{ return token::HT_LINEADJ; } + YY_BREAK +case 182: +YY_RULE_SETUP +#line 274 "gpu/lolfx-scanner.l" +{ return token::HT_LINEAR; } + YY_BREAK +case 183: +YY_RULE_SETUP +#line 275 "gpu/lolfx-scanner.l" +{ return token::HT_LINESTREAM; } + YY_BREAK +case 184: +YY_RULE_SETUP +#line 276 "gpu/lolfx-scanner.l" +{ return token::HT_MATRIX; } + YY_BREAK +case 185: +YY_RULE_SETUP +#line 277 "gpu/lolfx-scanner.l" +{ return token::HT_NAMESPACE; } + YY_BREAK +case 186: +YY_RULE_SETUP +#line 278 "gpu/lolfx-scanner.l" +{ return token::HT_NOINTERPOLATION; } + YY_BREAK +case 187: +YY_RULE_SETUP +#line 279 "gpu/lolfx-scanner.l" +{ return token::HT_NULL; } + YY_BREAK +case 188: +YY_RULE_SETUP +#line 280 "gpu/lolfx-scanner.l" +{ return token::HT_OUTPUTPATCH; } + YY_BREAK +case 189: +YY_RULE_SETUP +#line 281 "gpu/lolfx-scanner.l" +{ return token::HT_PACKOFFSET; } + YY_BREAK +case 190: +YY_RULE_SETUP +#line 282 "gpu/lolfx-scanner.l" +{ return token::HT_PASS; } + YY_BREAK +case 191: +YY_RULE_SETUP +#line 283 "gpu/lolfx-scanner.l" +{ return token::HT_PIXELFRAGMENT; } + YY_BREAK +case 192: +YY_RULE_SETUP +#line 284 "gpu/lolfx-scanner.l" +{ return token::HT_PIXELSHADER; } + YY_BREAK +case 193: +YY_RULE_SETUP +#line 285 "gpu/lolfx-scanner.l" +{ return token::HT_POINT; } + YY_BREAK +case 194: +YY_RULE_SETUP +#line 286 "gpu/lolfx-scanner.l" +{ return token::HT_POINTSTREAM; } + YY_BREAK +case 195: +YY_RULE_SETUP +#line 287 "gpu/lolfx-scanner.l" +{ return token::HT_PRECISE; } + YY_BREAK +case 196: +YY_RULE_SETUP +#line 288 "gpu/lolfx-scanner.l" +{ return token::HT_RASTERIZERSTATE; } + YY_BREAK +case 197: +YY_RULE_SETUP +#line 289 "gpu/lolfx-scanner.l" +{ return token::HT_RENDERTARGETVIEW; } + YY_BREAK +case 198: +YY_RULE_SETUP +#line 290 "gpu/lolfx-scanner.l" +{ return token::HT_REGISTER; } + YY_BREAK +case 199: +YY_RULE_SETUP +#line 291 "gpu/lolfx-scanner.l" +{ return token::HT_ROW_MAJOR; } + YY_BREAK +case 200: +YY_RULE_SETUP +#line 292 "gpu/lolfx-scanner.l" +{ return token::HT_RWBUFFER; } + YY_BREAK +case 201: +YY_RULE_SETUP +#line 293 "gpu/lolfx-scanner.l" +{ return token::HT_RWBYTEADDRESSBUFFER; } + YY_BREAK +case 202: +YY_RULE_SETUP +#line 294 "gpu/lolfx-scanner.l" +{ return token::HT_RWSTRUCTUREDBUFFER; } + YY_BREAK +case 203: +YY_RULE_SETUP +#line 295 "gpu/lolfx-scanner.l" +{ return token::HT_RWTEXTURE1D; } + YY_BREAK +case 204: +YY_RULE_SETUP +#line 296 "gpu/lolfx-scanner.l" +{ return token::HT_RWTEXTURE1DARRAY; } + YY_BREAK +case 205: +YY_RULE_SETUP +#line 297 "gpu/lolfx-scanner.l" +{ return token::HT_RWTEXTURE2D; } + YY_BREAK +case 206: +YY_RULE_SETUP +#line 298 "gpu/lolfx-scanner.l" +{ return token::HT_RWTEXTURE2DARRAY; } + YY_BREAK +case 207: +YY_RULE_SETUP +#line 299 "gpu/lolfx-scanner.l" +{ return token::HT_RWTEXTURE3D; } + YY_BREAK +case 208: +YY_RULE_SETUP +#line 300 "gpu/lolfx-scanner.l" +{ return token::HT_SAMPLER; } + YY_BREAK +case 209: +YY_RULE_SETUP +#line 301 "gpu/lolfx-scanner.l" +{ return token::HT_SAMPLER_STATE; } + YY_BREAK +case 210: +YY_RULE_SETUP +#line 302 "gpu/lolfx-scanner.l" +{ return token::HT_SAMPLERSTATE; } + YY_BREAK +case 211: +YY_RULE_SETUP +#line 303 "gpu/lolfx-scanner.l" +{ return token::HT_SAMPLERCOMPARISONSTATE; } + YY_BREAK +case 212: +YY_RULE_SETUP +#line 304 "gpu/lolfx-scanner.l" +{ return token::HT_SHARED; } + YY_BREAK +case 213: +YY_RULE_SETUP +#line 305 "gpu/lolfx-scanner.l" +{ return token::HT_SNORM; } + YY_BREAK +case 214: +YY_RULE_SETUP +#line 306 "gpu/lolfx-scanner.l" +{ return token::HT_STATEBLOCK; } + YY_BREAK +case 215: +YY_RULE_SETUP +#line 307 "gpu/lolfx-scanner.l" +{ return token::HT_STATEBLOCK_STATE; } + YY_BREAK +case 216: +YY_RULE_SETUP +#line 308 "gpu/lolfx-scanner.l" +{ return token::HT_STATIC; } + YY_BREAK +case 217: +YY_RULE_SETUP +#line 309 "gpu/lolfx-scanner.l" +{ return token::HT_STRING; } + YY_BREAK +case 218: +YY_RULE_SETUP +#line 310 "gpu/lolfx-scanner.l" +{ return token::HT_STRUCTUREDBUFFER; } + YY_BREAK +case 219: +YY_RULE_SETUP +#line 311 "gpu/lolfx-scanner.l" +{ return token::HT_TBUFFER; } + YY_BREAK +case 220: +YY_RULE_SETUP +#line 312 "gpu/lolfx-scanner.l" +{ return token::HT_TECHNIQUE; } + YY_BREAK +case 221: +YY_RULE_SETUP +#line 313 "gpu/lolfx-scanner.l" +{ return token::HT_TECHNIQUE10; } + YY_BREAK +case 222: +YY_RULE_SETUP +#line 314 "gpu/lolfx-scanner.l" +{ return token::HT_TECHNIQUE11XZ; } + YY_BREAK +case 223: +YY_RULE_SETUP +#line 315 "gpu/lolfx-scanner.l" +{ return token::HT_TEXTURE; } + YY_BREAK +case 224: +YY_RULE_SETUP +#line 316 "gpu/lolfx-scanner.l" +{ return token::HT_TEXTURE1D; } + YY_BREAK +case 225: +YY_RULE_SETUP +#line 317 "gpu/lolfx-scanner.l" +{ return token::HT_TEXTURE1DARRAY; } + YY_BREAK +case 226: +YY_RULE_SETUP +#line 318 "gpu/lolfx-scanner.l" +{ return token::HT_TEXTURE2D; } + YY_BREAK +case 227: +YY_RULE_SETUP +#line 319 "gpu/lolfx-scanner.l" +{ return token::HT_TEXTURE2DARRAY; } + YY_BREAK +case 228: +YY_RULE_SETUP +#line 320 "gpu/lolfx-scanner.l" +{ return token::HT_TEXTURE2DMS; } + YY_BREAK +case 229: +YY_RULE_SETUP +#line 321 "gpu/lolfx-scanner.l" +{ return token::HT_TEXTURE2DMSARRAY; } + YY_BREAK +case 230: +YY_RULE_SETUP +#line 322 "gpu/lolfx-scanner.l" +{ return token::HT_TEXTURE3D; } + YY_BREAK +case 231: +YY_RULE_SETUP +#line 323 "gpu/lolfx-scanner.l" +{ return token::HT_TEXTURECUBE; } + YY_BREAK +case 232: +YY_RULE_SETUP +#line 324 "gpu/lolfx-scanner.l" +{ return token::HT_TEXTURECUBEARRAY; } + YY_BREAK +case 233: +YY_RULE_SETUP +#line 325 "gpu/lolfx-scanner.l" +{ return token::HT_TRUE; } + YY_BREAK +case 234: +YY_RULE_SETUP +#line 326 "gpu/lolfx-scanner.l" +{ return token::HT_TYPEDEF; } + YY_BREAK +case 235: +YY_RULE_SETUP +#line 327 "gpu/lolfx-scanner.l" +{ return token::HT_TRIANGLE; } + YY_BREAK +case 236: +YY_RULE_SETUP +#line 328 "gpu/lolfx-scanner.l" +{ return token::HT_TRIANGLEADJ; } + YY_BREAK +case 237: +YY_RULE_SETUP +#line 329 "gpu/lolfx-scanner.l" +{ return token::HT_TRIANGLESTREAM; } + YY_BREAK +case 238: +YY_RULE_SETUP +#line 330 "gpu/lolfx-scanner.l" +{ return token::HT_UNORM; } + YY_BREAK +case 239: +YY_RULE_SETUP +#line 331 "gpu/lolfx-scanner.l" +{ return token::HT_VECTOR; } + YY_BREAK +case 240: +YY_RULE_SETUP +#line 332 "gpu/lolfx-scanner.l" +{ return token::HT_VERTEXFRAGMENT; } + YY_BREAK +case 241: +YY_RULE_SETUP +#line 333 "gpu/lolfx-scanner.l" +{ return token::HT_VERTEXSHADER; } + YY_BREAK +case 242: +YY_RULE_SETUP +#line 334 "gpu/lolfx-scanner.l" +{ return token::HT_VOLATILE; } + YY_BREAK +/* + * HLSL vector types + * TODO: this can probably be factored somehow + */ +case 243: +YY_RULE_SETUP +#line 341 "gpu/lolfx-scanner.l" +{ return token::HT_BOOL1; } + YY_BREAK +case 244: +YY_RULE_SETUP +#line 342 "gpu/lolfx-scanner.l" +{ return token::HT_BOOL1x1; } + YY_BREAK +case 245: +YY_RULE_SETUP +#line 343 "gpu/lolfx-scanner.l" +{ return token::HT_BOOL2x1; } + YY_BREAK +case 246: +YY_RULE_SETUP +#line 344 "gpu/lolfx-scanner.l" +{ return token::HT_BOOL3x1; } + YY_BREAK +case 247: +YY_RULE_SETUP +#line 345 "gpu/lolfx-scanner.l" +{ return token::HT_BOOL4x1; } + YY_BREAK +case 248: +YY_RULE_SETUP +#line 346 "gpu/lolfx-scanner.l" +{ return token::HT_BOOL2; } + YY_BREAK +case 249: +YY_RULE_SETUP +#line 347 "gpu/lolfx-scanner.l" +{ return token::HT_BOOL1x2; } + YY_BREAK +case 250: +YY_RULE_SETUP +#line 348 "gpu/lolfx-scanner.l" +{ return token::HT_BOOL2x2; } + YY_BREAK +case 251: +YY_RULE_SETUP +#line 349 "gpu/lolfx-scanner.l" +{ return token::HT_BOOL3x2; } + YY_BREAK +case 252: +YY_RULE_SETUP +#line 350 "gpu/lolfx-scanner.l" +{ return token::HT_BOOL4x2; } + YY_BREAK +case 253: +YY_RULE_SETUP +#line 351 "gpu/lolfx-scanner.l" +{ return token::HT_BOOL3; } + YY_BREAK +case 254: +YY_RULE_SETUP +#line 352 "gpu/lolfx-scanner.l" +{ return token::HT_BOOL1x3; } + YY_BREAK +case 255: +YY_RULE_SETUP +#line 353 "gpu/lolfx-scanner.l" +{ return token::HT_BOOL2x3; } + YY_BREAK +case 256: +YY_RULE_SETUP +#line 354 "gpu/lolfx-scanner.l" +{ return token::HT_BOOL3x3; } + YY_BREAK +case 257: +YY_RULE_SETUP +#line 355 "gpu/lolfx-scanner.l" +{ return token::HT_BOOL4x3; } + YY_BREAK +case 258: +YY_RULE_SETUP +#line 356 "gpu/lolfx-scanner.l" +{ return token::HT_BOOL4; } + YY_BREAK +case 259: +YY_RULE_SETUP +#line 357 "gpu/lolfx-scanner.l" +{ return token::HT_BOOL1x4; } + YY_BREAK +case 260: +YY_RULE_SETUP +#line 358 "gpu/lolfx-scanner.l" +{ return token::HT_BOOL2x4; } + YY_BREAK +case 261: +YY_RULE_SETUP +#line 359 "gpu/lolfx-scanner.l" +{ return token::HT_BOOL3x4; } + YY_BREAK +case 262: +YY_RULE_SETUP +#line 360 "gpu/lolfx-scanner.l" +{ return token::HT_BOOL4x4; } + YY_BREAK +case 263: +YY_RULE_SETUP +#line 362 "gpu/lolfx-scanner.l" +{ return token::HT_FLOAT1; } + YY_BREAK +case 264: +YY_RULE_SETUP +#line 363 "gpu/lolfx-scanner.l" +{ return token::HT_FLOAT1x1; } + YY_BREAK +case 265: +YY_RULE_SETUP +#line 364 "gpu/lolfx-scanner.l" +{ return token::HT_FLOAT2x1; } + YY_BREAK +case 266: +YY_RULE_SETUP +#line 365 "gpu/lolfx-scanner.l" +{ return token::HT_FLOAT3x1; } + YY_BREAK +case 267: +YY_RULE_SETUP +#line 366 "gpu/lolfx-scanner.l" +{ return token::HT_FLOAT4x1; } + YY_BREAK +case 268: +YY_RULE_SETUP +#line 367 "gpu/lolfx-scanner.l" +{ return token::HT_FLOAT2; } + YY_BREAK +case 269: +YY_RULE_SETUP +#line 368 "gpu/lolfx-scanner.l" +{ return token::HT_FLOAT1x2; } + YY_BREAK +case 270: +YY_RULE_SETUP +#line 369 "gpu/lolfx-scanner.l" +{ return token::HT_FLOAT2x2; } + YY_BREAK +case 271: +YY_RULE_SETUP +#line 370 "gpu/lolfx-scanner.l" +{ return token::HT_FLOAT3x2; } + YY_BREAK +case 272: +YY_RULE_SETUP +#line 371 "gpu/lolfx-scanner.l" +{ return token::HT_FLOAT4x2; } + YY_BREAK +case 273: +YY_RULE_SETUP +#line 372 "gpu/lolfx-scanner.l" +{ return token::HT_FLOAT3; } + YY_BREAK +case 274: +YY_RULE_SETUP +#line 373 "gpu/lolfx-scanner.l" +{ return token::HT_FLOAT1x3; } + YY_BREAK +case 275: +YY_RULE_SETUP +#line 374 "gpu/lolfx-scanner.l" +{ return token::HT_FLOAT2x3; } + YY_BREAK +case 276: +YY_RULE_SETUP +#line 375 "gpu/lolfx-scanner.l" +{ return token::HT_FLOAT3x3; } + YY_BREAK +case 277: +YY_RULE_SETUP +#line 376 "gpu/lolfx-scanner.l" +{ return token::HT_FLOAT4x3; } + YY_BREAK +case 278: +YY_RULE_SETUP +#line 377 "gpu/lolfx-scanner.l" +{ return token::HT_FLOAT4; } + YY_BREAK +case 279: +YY_RULE_SETUP +#line 378 "gpu/lolfx-scanner.l" +{ return token::HT_FLOAT1x4; } + YY_BREAK +case 280: +YY_RULE_SETUP +#line 379 "gpu/lolfx-scanner.l" +{ return token::HT_FLOAT2x4; } + YY_BREAK +case 281: +YY_RULE_SETUP +#line 380 "gpu/lolfx-scanner.l" +{ return token::HT_FLOAT3x4; } + YY_BREAK +case 282: +YY_RULE_SETUP +#line 381 "gpu/lolfx-scanner.l" +{ return token::HT_FLOAT4x4; } + YY_BREAK +case 283: +YY_RULE_SETUP +#line 383 "gpu/lolfx-scanner.l" +{ return token::HT_DOUBLE1; } + YY_BREAK +case 284: +YY_RULE_SETUP +#line 384 "gpu/lolfx-scanner.l" +{ return token::HT_DOUBLE1x1; } + YY_BREAK +case 285: +YY_RULE_SETUP +#line 385 "gpu/lolfx-scanner.l" +{ return token::HT_DOUBLE2x1; } + YY_BREAK +case 286: +YY_RULE_SETUP +#line 386 "gpu/lolfx-scanner.l" +{ return token::HT_DOUBLE3x1; } + YY_BREAK +case 287: +YY_RULE_SETUP +#line 387 "gpu/lolfx-scanner.l" +{ return token::HT_DOUBLE4x1; } + YY_BREAK +case 288: +YY_RULE_SETUP +#line 388 "gpu/lolfx-scanner.l" +{ return token::HT_DOUBLE2; } + YY_BREAK +case 289: +YY_RULE_SETUP +#line 389 "gpu/lolfx-scanner.l" +{ return token::HT_DOUBLE1x2; } + YY_BREAK +case 290: +YY_RULE_SETUP +#line 390 "gpu/lolfx-scanner.l" +{ return token::HT_DOUBLE2x2; } + YY_BREAK +case 291: +YY_RULE_SETUP +#line 391 "gpu/lolfx-scanner.l" +{ return token::HT_DOUBLE3x2; } + YY_BREAK +case 292: +YY_RULE_SETUP +#line 392 "gpu/lolfx-scanner.l" +{ return token::HT_DOUBLE4x2; } + YY_BREAK +case 293: +YY_RULE_SETUP +#line 393 "gpu/lolfx-scanner.l" +{ return token::HT_DOUBLE3; } + YY_BREAK +case 294: +YY_RULE_SETUP +#line 394 "gpu/lolfx-scanner.l" +{ return token::HT_DOUBLE1x3; } + YY_BREAK +case 295: +YY_RULE_SETUP +#line 395 "gpu/lolfx-scanner.l" +{ return token::HT_DOUBLE2x3; } + YY_BREAK +case 296: +YY_RULE_SETUP +#line 396 "gpu/lolfx-scanner.l" +{ return token::HT_DOUBLE3x3; } + YY_BREAK +case 297: +YY_RULE_SETUP +#line 397 "gpu/lolfx-scanner.l" +{ return token::HT_DOUBLE4x3; } + YY_BREAK +case 298: +YY_RULE_SETUP +#line 398 "gpu/lolfx-scanner.l" +{ return token::HT_DOUBLE4; } + YY_BREAK +case 299: +YY_RULE_SETUP +#line 399 "gpu/lolfx-scanner.l" +{ return token::HT_DOUBLE1x4; } + YY_BREAK +case 300: +YY_RULE_SETUP +#line 400 "gpu/lolfx-scanner.l" +{ return token::HT_DOUBLE2x4; } + YY_BREAK +case 301: +YY_RULE_SETUP +#line 401 "gpu/lolfx-scanner.l" +{ return token::HT_DOUBLE3x4; } + YY_BREAK +case 302: +YY_RULE_SETUP +#line 402 "gpu/lolfx-scanner.l" +{ return token::HT_DOUBLE4x4; } + YY_BREAK +case 303: +YY_RULE_SETUP +#line 404 "gpu/lolfx-scanner.l" +{ return token::HT_DWORD1; } + YY_BREAK +case 304: +YY_RULE_SETUP +#line 405 "gpu/lolfx-scanner.l" +{ return token::HT_DWORD1x1; } + YY_BREAK +case 305: +YY_RULE_SETUP +#line 406 "gpu/lolfx-scanner.l" +{ return token::HT_DWORD2x1; } + YY_BREAK +case 306: +YY_RULE_SETUP +#line 407 "gpu/lolfx-scanner.l" +{ return token::HT_DWORD3x1; } + YY_BREAK +case 307: +YY_RULE_SETUP +#line 408 "gpu/lolfx-scanner.l" +{ return token::HT_DWORD4x1; } + YY_BREAK +case 308: +YY_RULE_SETUP +#line 409 "gpu/lolfx-scanner.l" +{ return token::HT_DWORD2; } + YY_BREAK +case 309: +YY_RULE_SETUP +#line 410 "gpu/lolfx-scanner.l" +{ return token::HT_DWORD1x2; } + YY_BREAK +case 310: +YY_RULE_SETUP +#line 411 "gpu/lolfx-scanner.l" +{ return token::HT_DWORD2x2; } + YY_BREAK +case 311: +YY_RULE_SETUP +#line 412 "gpu/lolfx-scanner.l" +{ return token::HT_DWORD3x2; } + YY_BREAK +case 312: +YY_RULE_SETUP +#line 413 "gpu/lolfx-scanner.l" +{ return token::HT_DWORD4x2; } + YY_BREAK +case 313: +YY_RULE_SETUP +#line 414 "gpu/lolfx-scanner.l" +{ return token::HT_DWORD3; } + YY_BREAK +case 314: +YY_RULE_SETUP +#line 415 "gpu/lolfx-scanner.l" +{ return token::HT_DWORD1x3; } + YY_BREAK +case 315: +YY_RULE_SETUP +#line 416 "gpu/lolfx-scanner.l" +{ return token::HT_DWORD2x3; } + YY_BREAK +case 316: +YY_RULE_SETUP +#line 417 "gpu/lolfx-scanner.l" +{ return token::HT_DWORD3x3; } + YY_BREAK +case 317: +YY_RULE_SETUP +#line 418 "gpu/lolfx-scanner.l" +{ return token::HT_DWORD4x3; } + YY_BREAK +case 318: +YY_RULE_SETUP +#line 419 "gpu/lolfx-scanner.l" +{ return token::HT_DWORD4; } + YY_BREAK +case 319: +YY_RULE_SETUP +#line 420 "gpu/lolfx-scanner.l" +{ return token::HT_DWORD1x4; } + YY_BREAK +case 320: +YY_RULE_SETUP +#line 421 "gpu/lolfx-scanner.l" +{ return token::HT_DWORD2x4; } + YY_BREAK +case 321: +YY_RULE_SETUP +#line 422 "gpu/lolfx-scanner.l" +{ return token::HT_DWORD3x4; } + YY_BREAK +case 322: +YY_RULE_SETUP +#line 423 "gpu/lolfx-scanner.l" +{ return token::HT_DWORD4x4; } + YY_BREAK +case 323: +YY_RULE_SETUP +#line 425 "gpu/lolfx-scanner.l" +{ return token::HT_INT1; } + YY_BREAK +case 324: +YY_RULE_SETUP +#line 426 "gpu/lolfx-scanner.l" +{ return token::HT_INT1x1; } + YY_BREAK +case 325: +YY_RULE_SETUP +#line 427 "gpu/lolfx-scanner.l" +{ return token::HT_INT2x1; } + YY_BREAK +case 326: +YY_RULE_SETUP +#line 428 "gpu/lolfx-scanner.l" +{ return token::HT_INT3x1; } + YY_BREAK +case 327: +YY_RULE_SETUP +#line 429 "gpu/lolfx-scanner.l" +{ return token::HT_INT4x1; } + YY_BREAK +case 328: +YY_RULE_SETUP +#line 430 "gpu/lolfx-scanner.l" +{ return token::HT_INT2; } + YY_BREAK +case 329: +YY_RULE_SETUP +#line 431 "gpu/lolfx-scanner.l" +{ return token::HT_INT1x2; } + YY_BREAK +case 330: +YY_RULE_SETUP +#line 432 "gpu/lolfx-scanner.l" +{ return token::HT_INT2x2; } + YY_BREAK +case 331: +YY_RULE_SETUP +#line 433 "gpu/lolfx-scanner.l" +{ return token::HT_INT3x2; } + YY_BREAK +case 332: +YY_RULE_SETUP +#line 434 "gpu/lolfx-scanner.l" +{ return token::HT_INT4x2; } + YY_BREAK +case 333: +YY_RULE_SETUP +#line 435 "gpu/lolfx-scanner.l" +{ return token::HT_INT3; } + YY_BREAK +case 334: +YY_RULE_SETUP +#line 436 "gpu/lolfx-scanner.l" +{ return token::HT_INT1x3; } + YY_BREAK +case 335: +YY_RULE_SETUP +#line 437 "gpu/lolfx-scanner.l" +{ return token::HT_INT2x3; } + YY_BREAK +case 336: +YY_RULE_SETUP +#line 438 "gpu/lolfx-scanner.l" +{ return token::HT_INT3x3; } + YY_BREAK +case 337: +YY_RULE_SETUP +#line 439 "gpu/lolfx-scanner.l" +{ return token::HT_INT4x3; } + YY_BREAK +case 338: +YY_RULE_SETUP +#line 440 "gpu/lolfx-scanner.l" +{ return token::HT_INT4; } + YY_BREAK +case 339: +YY_RULE_SETUP +#line 441 "gpu/lolfx-scanner.l" +{ return token::HT_INT1x4; } + YY_BREAK +case 340: +YY_RULE_SETUP +#line 442 "gpu/lolfx-scanner.l" +{ return token::HT_INT2x4; } + YY_BREAK +case 341: +YY_RULE_SETUP +#line 443 "gpu/lolfx-scanner.l" +{ return token::HT_INT3x4; } + YY_BREAK +case 342: +YY_RULE_SETUP +#line 444 "gpu/lolfx-scanner.l" +{ return token::HT_INT4x4; } + YY_BREAK +case 343: +YY_RULE_SETUP +#line 446 "gpu/lolfx-scanner.l" +{ return token::HT_UINT1; } + YY_BREAK +case 344: +YY_RULE_SETUP +#line 447 "gpu/lolfx-scanner.l" +{ return token::HT_UINT1x1; } + YY_BREAK +case 345: +YY_RULE_SETUP +#line 448 "gpu/lolfx-scanner.l" +{ return token::HT_UINT2x1; } + YY_BREAK +case 346: +YY_RULE_SETUP +#line 449 "gpu/lolfx-scanner.l" +{ return token::HT_UINT3x1; } + YY_BREAK +case 347: +YY_RULE_SETUP +#line 450 "gpu/lolfx-scanner.l" +{ return token::HT_UINT4x1; } + YY_BREAK +case 348: +YY_RULE_SETUP +#line 451 "gpu/lolfx-scanner.l" +{ return token::HT_UINT2; } + YY_BREAK +case 349: +YY_RULE_SETUP +#line 452 "gpu/lolfx-scanner.l" +{ return token::HT_UINT1x2; } + YY_BREAK +case 350: +YY_RULE_SETUP +#line 453 "gpu/lolfx-scanner.l" +{ return token::HT_UINT2x2; } + YY_BREAK +case 351: +YY_RULE_SETUP +#line 454 "gpu/lolfx-scanner.l" +{ return token::HT_UINT3x2; } + YY_BREAK +case 352: +YY_RULE_SETUP +#line 455 "gpu/lolfx-scanner.l" +{ return token::HT_UINT4x2; } + YY_BREAK +case 353: +YY_RULE_SETUP +#line 456 "gpu/lolfx-scanner.l" +{ return token::HT_UINT3; } + YY_BREAK +case 354: +YY_RULE_SETUP +#line 457 "gpu/lolfx-scanner.l" +{ return token::HT_UINT1x3; } + YY_BREAK +case 355: +YY_RULE_SETUP +#line 458 "gpu/lolfx-scanner.l" +{ return token::HT_UINT2x3; } + YY_BREAK +case 356: +YY_RULE_SETUP +#line 459 "gpu/lolfx-scanner.l" +{ return token::HT_UINT3x3; } + YY_BREAK +case 357: +YY_RULE_SETUP +#line 460 "gpu/lolfx-scanner.l" +{ return token::HT_UINT4x3; } + YY_BREAK +case 358: +YY_RULE_SETUP +#line 461 "gpu/lolfx-scanner.l" +{ return token::HT_UINT4; } + YY_BREAK +case 359: +YY_RULE_SETUP +#line 462 "gpu/lolfx-scanner.l" +{ return token::HT_UINT1x4; } + YY_BREAK +case 360: +YY_RULE_SETUP +#line 463 "gpu/lolfx-scanner.l" +{ return token::HT_UINT2x4; } + YY_BREAK +case 361: +YY_RULE_SETUP +#line 464 "gpu/lolfx-scanner.l" +{ return token::HT_UINT3x4; } + YY_BREAK +case 362: +YY_RULE_SETUP +#line 465 "gpu/lolfx-scanner.l" +{ return token::HT_UINT4x4; } + YY_BREAK +/* + * HLSL preprocessor directives + * Gathered from http://msdn.microsoft.com/en-us/library/windows/desktop/bb943993%28v=vs.85%29.aspx + */ +case 363: +YY_RULE_SETUP +#line 472 "gpu/lolfx-scanner.l" +{ return token::PREPROCESSOR_DEFINE; } + YY_BREAK +case 364: +YY_RULE_SETUP +#line 473 "gpu/lolfx-scanner.l" +{ return token::PREPROCESSOR_ELIF; } + YY_BREAK +case 365: +YY_RULE_SETUP +#line 474 "gpu/lolfx-scanner.l" +{ return token::PREPROCESSOR_ELSE; } + YY_BREAK +case 366: +YY_RULE_SETUP +#line 475 "gpu/lolfx-scanner.l" +{ return token::PREPROCESSOR_ENDIF; } + YY_BREAK +case 367: +YY_RULE_SETUP +#line 476 "gpu/lolfx-scanner.l" +{ return token::PREPROCESSOR_ERROR; } + YY_BREAK +case 368: +YY_RULE_SETUP +#line 477 "gpu/lolfx-scanner.l" +{ return token::PREPROCESSOR_IF; } + YY_BREAK +case 369: +YY_RULE_SETUP +#line 478 "gpu/lolfx-scanner.l" +{ return token::PREPROCESSOR_IFDEF; } + YY_BREAK +case 370: +YY_RULE_SETUP +#line 479 "gpu/lolfx-scanner.l" +{ return token::PREPROCESSOR_IFNDEF; } + YY_BREAK +case 371: +YY_RULE_SETUP +#line 480 "gpu/lolfx-scanner.l" +{ return token::PREPROCESSOR_INCLUDE; } + YY_BREAK +case 372: +YY_RULE_SETUP +#line 481 "gpu/lolfx-scanner.l" +{ return token::PREPROCESSOR_LINE; } + YY_BREAK +case 373: +YY_RULE_SETUP +#line 482 "gpu/lolfx-scanner.l" +{ return token::PREPROCESSOR_PRAGMA; } + YY_BREAK +case 374: +YY_RULE_SETUP +#line 483 "gpu/lolfx-scanner.l" +{ return token::PREPROCESSOR_UNDEF; } + YY_BREAK +/* + * GLSL preprocessor directives + */ +case 375: +YY_RULE_SETUP +#line 489 "gpu/lolfx-scanner.l" +{ /* ignore for now */ } + YY_BREAK +/* + * LolFx preprocessor directives + */ +case 376: +YY_RULE_SETUP +#line 495 "gpu/lolfx-scanner.l" +{ return token::PRAGMA_LOLFX; } + YY_BREAK +/* + * HLSL reserved keywords + * Gathered from http://msdn.microsoft.com/en-us/library/windows/desktop/bb509569%28v=vs.85%29.aspx + */ +case 377: +YY_RULE_SETUP +#line 502 "gpu/lolfx-scanner.l" +{ return token::HT_AUTO; } + YY_BREAK +case 378: +YY_RULE_SETUP +#line 503 "gpu/lolfx-scanner.l" +{ return token::HT_CATCH; } + YY_BREAK +case 379: +YY_RULE_SETUP +#line 504 "gpu/lolfx-scanner.l" +{ return token::HT_CHAR; } + YY_BREAK +case 380: +YY_RULE_SETUP +#line 505 "gpu/lolfx-scanner.l" +{ return token::HT_CLASS; } + YY_BREAK +case 381: +YY_RULE_SETUP +#line 506 "gpu/lolfx-scanner.l" +{ return token::HT_CONST_CAST; } + YY_BREAK +case 382: +YY_RULE_SETUP +#line 507 "gpu/lolfx-scanner.l" +{ return token::HT_DELETE; } + YY_BREAK +case 383: +YY_RULE_SETUP +#line 508 "gpu/lolfx-scanner.l" +{ return token::HT_DYNAMIC_CAST; } + YY_BREAK +case 384: +YY_RULE_SETUP +#line 509 "gpu/lolfx-scanner.l" +{ return token::HT_ENUM; } + YY_BREAK +case 385: +YY_RULE_SETUP +#line 510 "gpu/lolfx-scanner.l" +{ return token::HT_EXPLICIT; } + YY_BREAK +case 386: +YY_RULE_SETUP +#line 511 "gpu/lolfx-scanner.l" +{ return token::HT_FRIEND; } + YY_BREAK +case 387: +YY_RULE_SETUP +#line 512 "gpu/lolfx-scanner.l" +{ return token::HT_GOTO; } + YY_BREAK +case 388: +YY_RULE_SETUP +#line 513 "gpu/lolfx-scanner.l" +{ return token::HT_LONG; } + YY_BREAK +case 389: +YY_RULE_SETUP +#line 514 "gpu/lolfx-scanner.l" +{ return token::HT_MUTABLE; } + YY_BREAK +case 390: +YY_RULE_SETUP +#line 515 "gpu/lolfx-scanner.l" +{ return token::HT_NEW; } + YY_BREAK +case 391: +YY_RULE_SETUP +#line 516 "gpu/lolfx-scanner.l" +{ return token::HT_OPERATOR; } + YY_BREAK +case 392: +YY_RULE_SETUP +#line 517 "gpu/lolfx-scanner.l" +{ return token::HT_PRIVATE; } + YY_BREAK +case 393: +YY_RULE_SETUP +#line 518 "gpu/lolfx-scanner.l" +{ return token::HT_PROTECTED; } + YY_BREAK +case 394: +YY_RULE_SETUP +#line 519 "gpu/lolfx-scanner.l" +{ return token::HT_PUBLIC; } + YY_BREAK +case 395: +YY_RULE_SETUP +#line 520 "gpu/lolfx-scanner.l" +{ return token::HT_REINTERPRET_CAST; } + YY_BREAK +case 396: +YY_RULE_SETUP +#line 521 "gpu/lolfx-scanner.l" +{ return token::HT_SHORT; } + YY_BREAK +case 397: +YY_RULE_SETUP +#line 522 "gpu/lolfx-scanner.l" +{ return token::HT_SIGNED; } + YY_BREAK +case 398: +YY_RULE_SETUP +#line 523 "gpu/lolfx-scanner.l" +{ return token::HT_SIZEOF; } + YY_BREAK +case 399: +YY_RULE_SETUP +#line 524 "gpu/lolfx-scanner.l" +{ return token::HT_STATIC_CAST; } + YY_BREAK +case 400: +YY_RULE_SETUP +#line 525 "gpu/lolfx-scanner.l" +{ return token::HT_TEMPLATE; } + YY_BREAK +case 401: +YY_RULE_SETUP +#line 526 "gpu/lolfx-scanner.l" +{ return token::HT_THIS; } + YY_BREAK +case 402: +YY_RULE_SETUP +#line 527 "gpu/lolfx-scanner.l" +{ return token::HT_THROW; } + YY_BREAK +case 403: +YY_RULE_SETUP +#line 528 "gpu/lolfx-scanner.l" +{ return token::HT_TRY; } + YY_BREAK +case 404: +YY_RULE_SETUP +#line 529 "gpu/lolfx-scanner.l" +{ return token::HT_TYPENAME; } + YY_BREAK +case 405: +YY_RULE_SETUP +#line 530 "gpu/lolfx-scanner.l" +{ return token::HT_UNION; } + YY_BREAK +case 406: +YY_RULE_SETUP +#line 531 "gpu/lolfx-scanner.l" +{ return token::HT_UNSIGNED; } + YY_BREAK +case 407: +YY_RULE_SETUP +#line 532 "gpu/lolfx-scanner.l" +{ return token::HT_USING; } + YY_BREAK +case 408: +YY_RULE_SETUP +#line 533 "gpu/lolfx-scanner.l" +{ return token::HT_VIRTUAL; } + YY_BREAK +/* + * Various tokens + */ +case 409: +YY_RULE_SETUP +#line 539 "gpu/lolfx-scanner.l" +{ return token::T_INC; } + YY_BREAK +case 410: +YY_RULE_SETUP +#line 540 "gpu/lolfx-scanner.l" +{ return token::T_DEC; } + YY_BREAK +case 411: +YY_RULE_SETUP +#line 541 "gpu/lolfx-scanner.l" +{ return token::T_LE; } + YY_BREAK +case 412: +YY_RULE_SETUP +#line 542 "gpu/lolfx-scanner.l" +{ return token::T_GE; } + YY_BREAK +case 413: +YY_RULE_SETUP +#line 543 "gpu/lolfx-scanner.l" +{ return token::T_EQ; } + YY_BREAK +case 414: +YY_RULE_SETUP +#line 544 "gpu/lolfx-scanner.l" +{ return token::T_NE; } + YY_BREAK +case 415: +YY_RULE_SETUP +#line 545 "gpu/lolfx-scanner.l" +{ return token::T_LEFT; } + YY_BREAK +case 416: +YY_RULE_SETUP +#line 546 "gpu/lolfx-scanner.l" +{ return token::T_RIGHT; } + YY_BREAK +case 417: +YY_RULE_SETUP +#line 547 "gpu/lolfx-scanner.l" +{ return token::T_AND; } + YY_BREAK +case 418: +YY_RULE_SETUP +#line 548 "gpu/lolfx-scanner.l" +{ return token::T_OR; } + YY_BREAK +case 419: +YY_RULE_SETUP +#line 549 "gpu/lolfx-scanner.l" +{ return token::T_XOR; } + YY_BREAK +case 420: +YY_RULE_SETUP +#line 551 "gpu/lolfx-scanner.l" +{ return token::T_MULEQ; } + YY_BREAK +case 421: +YY_RULE_SETUP +#line 552 "gpu/lolfx-scanner.l" +{ return token::T_DIVEQ; } + YY_BREAK +case 422: +YY_RULE_SETUP +#line 553 "gpu/lolfx-scanner.l" +{ return token::T_MODEQ; } + YY_BREAK +case 423: +YY_RULE_SETUP +#line 554 "gpu/lolfx-scanner.l" +{ return token::T_ADDEQ; } + YY_BREAK +case 424: +YY_RULE_SETUP +#line 555 "gpu/lolfx-scanner.l" +{ return token::T_SUBEQ; } + YY_BREAK +case 425: +YY_RULE_SETUP +#line 556 "gpu/lolfx-scanner.l" +{ return token::T_LEFTEQ; } + YY_BREAK +case 426: +YY_RULE_SETUP +#line 557 "gpu/lolfx-scanner.l" +{ return token::T_RIGHTEQ; } + YY_BREAK +case 427: +YY_RULE_SETUP +#line 558 "gpu/lolfx-scanner.l" +{ return token::T_ANDEQ; } + YY_BREAK +case 428: +YY_RULE_SETUP +#line 559 "gpu/lolfx-scanner.l" +{ return token::T_XOREQ; } + YY_BREAK +case 429: +YY_RULE_SETUP +#line 560 "gpu/lolfx-scanner.l" +{ return token::T_OREQ; } + YY_BREAK +case 430: +YY_RULE_SETUP +#line 562 "gpu/lolfx-scanner.l" +{ + yylval->fval = std::atof(yytext); + return token::FLOATCONSTANT; +} + YY_BREAK +case 431: +YY_RULE_SETUP +#line 566 "gpu/lolfx-scanner.l" +{ + yylval->uval = std::atoi(yytext); + return token::UINTCONSTANT; +} + YY_BREAK +case 432: +YY_RULE_SETUP +#line 570 "gpu/lolfx-scanner.l" +{ + yylval->ival = std::atoi(yytext); + return token::INTCONSTANT; +} + YY_BREAK +case 433: +YY_RULE_SETUP +#line 575 "gpu/lolfx-scanner.l" +{ + /* Copy token for now */ + yylval->sval = strdup(yytext); + return token::IDENTIFIER; +} + YY_BREAK +case 434: +YY_RULE_SETUP +#line 581 "gpu/lolfx-scanner.l" +{ /* ignore whitespace */ } + YY_BREAK +case 435: +/* rule 435 can match eol */ +YY_RULE_SETUP +#line 582 "gpu/lolfx-scanner.l" +{ ++yylineno; } + YY_BREAK +case 436: +YY_RULE_SETUP +#line 583 "gpu/lolfx-scanner.l" +{ return token::T_ERROR; } + YY_BREAK +/* + * Ignore C comments + */ +case 437: +YY_RULE_SETUP +#line 589 "gpu/lolfx-scanner.l" +{ BEGIN(C_COMMENT); } + YY_BREAK +case 438: +YY_RULE_SETUP +#line 590 "gpu/lolfx-scanner.l" +{ BEGIN(INITIAL); } + YY_BREAK +case 439: +YY_RULE_SETUP +#line 591 "gpu/lolfx-scanner.l" +{ } + YY_BREAK +case 440: +/* rule 440 can match eol */ +YY_RULE_SETUP +#line 592 "gpu/lolfx-scanner.l" +{ ++yylineno; } + YY_BREAK +case 441: +YY_RULE_SETUP +#line 593 "gpu/lolfx-scanner.l" +{ } + YY_BREAK +/* + * Ignore C++ comments + */ +case 442: +YY_RULE_SETUP +#line 599 "gpu/lolfx-scanner.l" +{ BEGIN(CPP_COMMENT); } + YY_BREAK +case 443: +/* rule 443 can match eol */ +YY_RULE_SETUP +#line 600 "gpu/lolfx-scanner.l" +{ ++yylineno; BEGIN(INITIAL); } + YY_BREAK +case 444: +YY_RULE_SETUP +#line 601 "gpu/lolfx-scanner.l" +{ } + YY_BREAK +case 445: +YY_RULE_SETUP +#line 603 "gpu/lolfx-scanner.l" +ECHO; + YY_BREAK +#line 4147 "generated/lolfx-scanner.cpp" +case YY_STATE_EOF(INITIAL): +case YY_STATE_EOF(C_COMMENT): +case YY_STATE_EOF(CPP_COMMENT): + yyterminate(); + + case YY_END_OF_BUFFER: + { + /* Amount of text matched not including the EOB char. */ + int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1; + + /* Undo the effects of YY_DO_BEFORE_ACTION. */ + *yy_cp = (yy_hold_char); + YY_RESTORE_YY_MORE_OFFSET + + if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) + { + /* We're scanning a new file or input source. It's + * possible that this happened because the user + * just pointed yyin at a new source and called + * yylex(). If so, then we have to assure + * consistency between YY_CURRENT_BUFFER and our + * globals. Here is the right place to do so, because + * this is the first action (other than possibly a + * back-up) that will match for the new input source. + */ + (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; + YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; + YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; + } + + /* Note that here we test for yy_c_buf_p "<=" to the position + * of the first EOB in the buffer, since yy_c_buf_p will + * already have been incremented past the NUL character + * (since all states make transitions on EOB to the + * end-of-buffer state). Contrast this with the test + * in input(). + */ + if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] ) + { /* This was really a NUL. */ + yy_state_type yy_next_state; + + (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text; + + yy_current_state = yy_get_previous_state( ); + + /* Okay, we're now positioned to make the NUL + * transition. We couldn't have + * yy_get_previous_state() go ahead and do it + * for us because it doesn't know how to deal + * with the possibility of jamming (and we don't + * want to build jamming into it because then it + * will run more slowly). + */ + + yy_next_state = yy_try_NUL_trans( yy_current_state ); + + yy_bp = (yytext_ptr) + YY_MORE_ADJ; + + if ( yy_next_state ) + { + /* Consume the NUL. */ + yy_cp = ++(yy_c_buf_p); + yy_current_state = yy_next_state; + goto yy_match; + } + + else + { + yy_cp = (yy_last_accepting_cpos); + yy_current_state = (yy_last_accepting_state); + goto yy_find_action; + } + } + + else switch ( yy_get_next_buffer( ) ) + { + case EOB_ACT_END_OF_FILE: + { + (yy_did_buffer_switch_on_eof) = 0; + + if ( yywrap( ) ) + { + /* Note: because we've taken care in + * yy_get_next_buffer() to have set up + * yytext, we can now set up + * yy_c_buf_p so that if some total + * hoser (like flex itself) wants to + * call the scanner after we return the + * YY_NULL, it'll still work - another + * YY_NULL will get returned. + */ + (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ; + + yy_act = YY_STATE_EOF(YY_START); + goto do_action; + } + + else + { + if ( ! (yy_did_buffer_switch_on_eof) ) + YY_NEW_FILE; + } + break; + } + + case EOB_ACT_CONTINUE_SCAN: + (yy_c_buf_p) = + (yytext_ptr) + yy_amount_of_matched_text; + + yy_current_state = yy_get_previous_state( ); + + yy_cp = (yy_c_buf_p); + yy_bp = (yytext_ptr) + YY_MORE_ADJ; + goto yy_match; + + case EOB_ACT_LAST_MATCH: + (yy_c_buf_p) = + &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)]; + + yy_current_state = yy_get_previous_state( ); + + yy_cp = (yy_c_buf_p); + yy_bp = (yytext_ptr) + YY_MORE_ADJ; + goto yy_find_action; + } + break; + } + + default: + YY_FATAL_ERROR( + "fatal flex scanner internal error--no action found" ); + } /* end of action switch */ + } /* end of scanning one token */ +} /* end of yylex */ + +/* The contents of this function are C++ specific, so the () macro is not used. + */ +yyFlexLexer::yyFlexLexer( std::istream* arg_yyin, std::ostream* arg_yyout ) +{ + yyin = arg_yyin; + yyout = arg_yyout; + yy_c_buf_p = 0; + yy_init = 0; + yy_start = 0; + yy_flex_debug = 0; + yylineno = 1; // this will only get updated if %option yylineno + + yy_did_buffer_switch_on_eof = 0; + + yy_looking_for_trail_begin = 0; + yy_more_flag = 0; + yy_more_len = 0; + yy_more_offset = yy_prev_more_offset = 0; + + yy_start_stack_ptr = yy_start_stack_depth = 0; + yy_start_stack = NULL; + + yy_buffer_stack = 0; + yy_buffer_stack_top = 0; + yy_buffer_stack_max = 0; + + yy_state_buf = 0; + +} + +/* The contents of this function are C++ specific, so the () macro is not used. + */ +yyFlexLexer::~yyFlexLexer() +{ + delete [] yy_state_buf; + LolFxfree(yy_start_stack ); + yy_delete_buffer( YY_CURRENT_BUFFER ); + LolFxfree(yy_buffer_stack ); +} + +/* The contents of this function are C++ specific, so the () macro is not used. + */ +void yyFlexLexer::switch_streams( std::istream* new_in, std::ostream* new_out ) +{ + if ( new_in ) + { + yy_delete_buffer( YY_CURRENT_BUFFER ); + yy_switch_to_buffer( yy_create_buffer( new_in, YY_BUF_SIZE ) ); + } + + if ( new_out ) + yyout = new_out; +} + +#ifdef YY_INTERACTIVE +int yyFlexLexer::LexerInput( char* buf, int /* max_size */ ) +#else +int yyFlexLexer::LexerInput( char* buf, int max_size ) +#endif +{ + if ( yyin->eof() || yyin->fail() ) + return 0; + +#ifdef YY_INTERACTIVE + yyin->get( buf[0] ); + + if ( yyin->eof() ) + return 0; + + if ( yyin->bad() ) + return -1; + + return 1; + +#else + (void) yyin->read( buf, max_size ); + + if ( yyin->bad() ) + return -1; + else + return yyin->gcount(); +#endif +} + +void yyFlexLexer::LexerOutput( const char* buf, int size ) +{ + (void) yyout->write( buf, size ); +} + +/* 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 + */ +int yyFlexLexer::yy_get_next_buffer() +{ + register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; + register char *source = (yytext_ptr); + register int number_to_move, i; + int ret_val; + + if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] ) + YY_FATAL_ERROR( + "fatal flex scanner internal error--end of buffer missed" ); + + if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 ) + { /* Don't try to fill the buffer, so this is an EOF. */ + if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 ) + { + /* We matched a single character, the EOB, so + * treat this as a final EOF. + */ + return EOB_ACT_END_OF_FILE; + } + + else + { + /* We matched some text prior to the EOB, first + * process it. + */ + return EOB_ACT_LAST_MATCH; + } + } + + /* Try to read more data. */ + + /* First move last chars to start of buffer. */ + number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1; + + for ( i = 0; i < number_to_move; ++i ) + *(dest++) = *(source++); + + if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING ) + /* don't do the read, it's not guaranteed to return an EOF, + * just force an EOF + */ + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0; + + else + { + int num_to_read = + YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; + + while ( num_to_read <= 0 ) + { /* Not enough room in the buffer - grow it. */ + + /* just a shorter name for the current buffer */ + YY_BUFFER_STATE b = YY_CURRENT_BUFFER; + + int yy_c_buf_p_offset = + (int) ((yy_c_buf_p) - b->yy_ch_buf); + + if ( b->yy_is_our_buffer ) + { + int new_size = b->yy_buf_size * 2; + + if ( new_size <= 0 ) + b->yy_buf_size += b->yy_buf_size / 8; + else + b->yy_buf_size *= 2; + + b->yy_ch_buf = (char *) + /* Include room in for 2 EOB chars. */ + LolFxrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 ); + } + else + /* Can't grow it, we don't own it. */ + b->yy_ch_buf = 0; + + if ( ! b->yy_ch_buf ) + YY_FATAL_ERROR( + "fatal error - scanner input buffer overflow" ); + + (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset]; + + num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - + number_to_move - 1; + + } + + if ( num_to_read > YY_READ_BUF_SIZE ) + num_to_read = YY_READ_BUF_SIZE; + + /* Read in more data. */ + YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]), + (yy_n_chars), (size_t) num_to_read ); + + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); + } + + if ( (yy_n_chars) == 0 ) + { + if ( number_to_move == YY_MORE_ADJ ) + { + ret_val = EOB_ACT_END_OF_FILE; + yyrestart( yyin ); + } + + else + { + ret_val = EOB_ACT_LAST_MATCH; + YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = + YY_BUFFER_EOF_PENDING; + } + } + + else + ret_val = EOB_ACT_CONTINUE_SCAN; + + if ((yy_size_t) ((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 = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1); + YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) LolFxrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size ); + if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" ); + } + + (yy_n_chars) += number_to_move; + YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR; + YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR; + + (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; + + return ret_val; +} + +/* yy_get_previous_state - get the state just before the EOB char was reached */ + + yy_state_type yyFlexLexer::yy_get_previous_state() +{ + register yy_state_type yy_current_state; + register char *yy_cp; + + yy_current_state = (yy_start); + + for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp ) + { + register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); + if ( yy_accept[yy_current_state] ) + { + (yy_last_accepting_state) = yy_current_state; + (yy_last_accepting_cpos) = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 1633 ) + 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 ); + */ + yy_state_type yyFlexLexer::yy_try_NUL_trans( yy_state_type yy_current_state ) +{ + register int yy_is_jam; + register char *yy_cp = (yy_c_buf_p); + + register YY_CHAR yy_c = 1; + if ( yy_accept[yy_current_state] ) + { + (yy_last_accepting_state) = yy_current_state; + (yy_last_accepting_cpos) = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 1633 ) + 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 == 1632); + + return yy_is_jam ? 0 : yy_current_state; +} + + void yyFlexLexer::yyunput( int c, register char* yy_bp) +{ + register char *yy_cp; + + yy_cp = (yy_c_buf_p); + + /* undo effects of setting up yytext */ + *yy_cp = (yy_hold_char); + + if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 ) + { /* need to shift things up to make room */ + /* +2 for EOB chars. */ + register int number_to_move = (yy_n_chars) + 2; + register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[ + YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2]; + register char *source = + &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]; + + while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) + *--dest = *--source; + + yy_cp += (int) (dest - source); + yy_bp += (int) (dest - source); + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = + (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size; + + if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 ) + YY_FATAL_ERROR( "flex scanner push-back overflow" ); + } + + *--yy_cp = (char) c; + + (yytext_ptr) = yy_bp; + (yy_hold_char) = *yy_cp; + (yy_c_buf_p) = yy_cp; +} + + int yyFlexLexer::yyinput() +{ + int c; + + *(yy_c_buf_p) = (yy_hold_char); + + if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR ) + { + /* yy_c_buf_p now points to the character we want to return. + * If this occurs *before* the EOB characters, then it's a + * valid NUL; if not, then we've hit the end of the buffer. + */ + if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] ) + /* This was really a NUL. */ + *(yy_c_buf_p) = '\0'; + + else + { /* need more input */ + int offset = (yy_c_buf_p) - (yytext_ptr); + ++(yy_c_buf_p); + + switch ( yy_get_next_buffer( ) ) + { + 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 ); + + /*FALLTHROUGH*/ + + case EOB_ACT_END_OF_FILE: + { + if ( yywrap( ) ) + return EOF; + + if ( ! (yy_did_buffer_switch_on_eof) ) + YY_NEW_FILE; +#ifdef __cplusplus + return yyinput(); +#else + return input(); +#endif + } + + case EOB_ACT_CONTINUE_SCAN: + (yy_c_buf_p) = (yytext_ptr) + offset; + break; + } + } + } + + c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */ + *(yy_c_buf_p) = '\0'; /* preserve yytext */ + (yy_hold_char) = *++(yy_c_buf_p); + + return c; +} + +/** Immediately switch to a different input stream. + * @param input_file A readable stream. + * + * @note This function does not reset the start condition to @c INITIAL . + */ + void yyFlexLexer::yyrestart( std::istream* input_file ) +{ + + if ( ! YY_CURRENT_BUFFER ){ + yyensure_buffer_stack (); + YY_CURRENT_BUFFER_LVALUE = + yy_create_buffer( yyin, YY_BUF_SIZE ); + } + + yy_init_buffer( YY_CURRENT_BUFFER, input_file ); + yy_load_buffer_state( ); +} + +/** Switch to a different input buffer. + * @param new_buffer The new input buffer. + * + */ + void yyFlexLexer::yy_switch_to_buffer( YY_BUFFER_STATE new_buffer ) +{ + + /* TODO. We should be able to replace this entire function body + * with + * yypop_buffer_state(); + * yypush_buffer_state(new_buffer); + */ + yyensure_buffer_stack (); + if ( YY_CURRENT_BUFFER == new_buffer ) + return; + + if ( YY_CURRENT_BUFFER ) + { + /* Flush out information for old buffer. */ + *(yy_c_buf_p) = (yy_hold_char); + YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p); + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); + } + + YY_CURRENT_BUFFER_LVALUE = new_buffer; + yy_load_buffer_state( ); + + /* 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. + */ + (yy_did_buffer_switch_on_eof) = 1; +} + + void yyFlexLexer::yy_load_buffer_state() +{ + (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; + (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; + yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; + (yy_hold_char) = *(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. + * + * @return the allocated buffer state. + */ + YY_BUFFER_STATE yyFlexLexer::yy_create_buffer( std::istream* file, int size ) +{ + YY_BUFFER_STATE b; + + b = (YY_BUFFER_STATE) LolFxalloc(sizeof( struct yy_buffer_state ) ); + 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 *) LolFxalloc(b->yy_buf_size + 2 ); + 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 ); + + return b; +} + +/** Destroy the buffer. + * @param b a buffer created with yy_create_buffer() + * + */ + void yyFlexLexer::yy_delete_buffer( YY_BUFFER_STATE b ) +{ + + 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 ) + LolFxfree((void *) b->yy_ch_buf ); + + LolFxfree((void *) b ); +} + +extern "C" int isatty (int ); + +/* 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. + */ + void yyFlexLexer::yy_init_buffer( YY_BUFFER_STATE b, std::istream* file ) + +{ + int oerrno = errno; + + yy_flush_buffer( b ); + + 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. + * + */ + void yyFlexLexer::yy_flush_buffer( YY_BUFFER_STATE b ) +{ + 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( ); +} + +/** 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. + * + */ +void yyFlexLexer::yypush_buffer_state (YY_BUFFER_STATE new_buffer) +{ + if (new_buffer == NULL) + return; + + yyensure_buffer_stack(); + + /* This block is copied from yy_switch_to_buffer. */ + if ( YY_CURRENT_BUFFER ) + { + /* Flush out information for old buffer. */ + *(yy_c_buf_p) = (yy_hold_char); + YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p); + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); + } + + /* Only push if top exists. Otherwise, replace top. */ + if (YY_CURRENT_BUFFER) + (yy_buffer_stack_top)++; + YY_CURRENT_BUFFER_LVALUE = new_buffer; + + /* copied from yy_switch_to_buffer. */ + yy_load_buffer_state( ); + (yy_did_buffer_switch_on_eof) = 1; +} + +/** Removes and deletes the top of the stack, if present. + * The next element becomes the new top. + * + */ +void yyFlexLexer::yypop_buffer_state (void) +{ + if (!YY_CURRENT_BUFFER) + return; + + yy_delete_buffer(YY_CURRENT_BUFFER ); + YY_CURRENT_BUFFER_LVALUE = NULL; + if ((yy_buffer_stack_top) > 0) + --(yy_buffer_stack_top); + + if (YY_CURRENT_BUFFER) { + yy_load_buffer_state( ); + (yy_did_buffer_switch_on_eof) = 1; + } +} + +/* Allocates the stack if it does not exist. + * Guarantees space for at least one push. + */ +void yyFlexLexer::yyensure_buffer_stack(void) +{ + int num_to_alloc; + + if (!(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; + (yy_buffer_stack) = (struct yy_buffer_state**)LolFxalloc + (num_to_alloc * sizeof(struct yy_buffer_state*) + ); + if ( ! (yy_buffer_stack) ) + YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); + + memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*)); + + (yy_buffer_stack_max) = num_to_alloc; + (yy_buffer_stack_top) = 0; + return; + } + + if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){ + + /* Increase the buffer to prepare for a possible push. */ + int grow_size = 8 /* arbitrary grow size */; + + num_to_alloc = (yy_buffer_stack_max) + grow_size; + (yy_buffer_stack) = (struct yy_buffer_state**)LolFxrealloc + ((yy_buffer_stack), + num_to_alloc * sizeof(struct yy_buffer_state*) + ); + if ( ! (yy_buffer_stack) ) + YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); + + /* zero only the new slots.*/ + memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*)); + (yy_buffer_stack_max) = num_to_alloc; + } +} + + void yyFlexLexer::yy_push_state( int new_state ) +{ + if ( (yy_start_stack_ptr) >= (yy_start_stack_depth) ) + { + yy_size_t new_size; + + (yy_start_stack_depth) += YY_START_STACK_INCR; + new_size = (yy_start_stack_depth) * sizeof( int ); + + if ( ! (yy_start_stack) ) + (yy_start_stack) = (int *) LolFxalloc(new_size ); + + else + (yy_start_stack) = (int *) LolFxrealloc((void *) (yy_start_stack),new_size ); + + if ( ! (yy_start_stack) ) + YY_FATAL_ERROR( "out of memory expanding start-condition stack" ); + } + + (yy_start_stack)[(yy_start_stack_ptr)++] = YY_START; + + BEGIN(new_state); +} + + void yyFlexLexer::yy_pop_state() +{ + if ( --(yy_start_stack_ptr) < 0 ) + YY_FATAL_ERROR( "start-condition stack underflow" ); + + BEGIN((yy_start_stack)[(yy_start_stack_ptr)]); +} + + int yyFlexLexer::yy_top_state() +{ + return (yy_start_stack)[(yy_start_stack_ptr) - 1]; +} + +#ifndef YY_EXIT_FAILURE +#define YY_EXIT_FAILURE 2 +#endif + +void yyFlexLexer::LexerError( yyconst char msg[] ) +{ + std::cerr << msg << std::endl; + 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] = (yy_hold_char); \ + (yy_c_buf_p) = yytext + yyless_macro_arg; \ + (yy_hold_char) = *(yy_c_buf_p); \ + *(yy_c_buf_p) = '\0'; \ + yyleng = yyless_macro_arg; \ + } \ + while ( 0 ) + +/* Accessor methods (get/set functions) to struct members. */ + +/* + * Internal utility routines. + */ + +#ifndef yytext_ptr +static void yy_flex_strncpy (char* s1, yyconst char * s2, int n ) +{ + 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 ) +{ + register int n; + for ( n = 0; s[n]; ++n ) + ; + + return n; +} +#endif + +void *LolFxalloc (yy_size_t size ) +{ + return (void *) malloc( size ); +} + +void *LolFxrealloc (void * ptr, yy_size_t size ) +{ + /* 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 LolFxfree (void * ptr ) +{ + free( (char *) ptr ); /* see LolFxrealloc() for (char *) cast */ +} + +#define YYTABLES_NAME "yytables" + +#line 603 "gpu/lolfx-scanner.l" + + + +lol::LolFxScanner::LolFxScanner(char const *command) + : LolFxFlexLexer(0, 0), + m_input(command) +{ +} + +lol::LolFxScanner::~LolFxScanner() +{ +} + +int lol::LolFxScanner::LexerInput(char* buf, int max_size) +{ + buf[0] = m_input[0]; + if (buf[0]) + ++m_input; + return buf[0] ? 1 : 0; +} + +#ifdef yylex +#undef yylex +#endif +int LolFxFlexLexer::yylex() +{ + std::cerr << "in LolFxFlexLexer::yylex() !" << std::endl; + return 0; +} + +int LolFxFlexLexer::yywrap() +{ + return 1; +} + + diff --git a/src/gpu/lolfx-compiler.cpp b/src/gpu/lolfx-compiler.cpp new file mode 100644 index 00000000..86d73836 --- /dev/null +++ b/src/gpu/lolfx-compiler.cpp @@ -0,0 +1,50 @@ +// +// Lol Engine +// +// Copyright: (c) 2010-2012 Sam Hocevar +// This program is free software; you can redistribute it and/or +// modify it under the terms of the Do What The Fuck You Want To +// Public License, Version 2, as published by Sam Hocevar. See +// http://sam.zoy.org/projects/COPYING.WTFPL for more details. +// + +#if defined HAVE_CONFIG_H +# include "config.h" +#endif + +#include + +#include "core.h" +#include "gpu/lolfx-compiler.h" + +namespace lol +{ + +LolFxCompiler::LolFxCompiler(LolFx &lolfx) + : m_lolfx(lolfx) +{ +} + +bool LolFxCompiler::ParseString(char const *command) +{ + LolFxScanner scanner(command); + m_lexer = &scanner; + LolFxParser parser(*this); + if (parser.parse() != 0) + return false; + return true; +} + +void LolFxCompiler::Error(const class location& l, const std::string& m) +{ + Log::Error("Syntax error line %d column %d: %s", + l.begin.line, l.begin.column, m.c_str()); +} + +void LolFxCompiler::Error(const std::string& m) +{ + Log::Error("Syntax error: %s", m.c_str()); +} + +} /* namespace lol */ + diff --git a/src/gpu/lolfx-compiler.h b/src/gpu/lolfx-compiler.h new file mode 100644 index 00000000..8ee62192 --- /dev/null +++ b/src/gpu/lolfx-compiler.h @@ -0,0 +1,59 @@ +// +// Lol Engine +// +// Copyright: (c) 2010-2012 Sam Hocevar +// This program is free software; you can redistribute it and/or +// modify it under the terms of the Do What The Fuck You Want To +// Public License, Version 2, as published by Sam Hocevar. See +// http://sam.zoy.org/projects/COPYING.WTFPL for more details. +// + +#ifndef __LOLFX_COMPILER_H__ +#define __LOLFX_COMPILER_H__ + +#include + +#ifndef __FLEX_LEXER_H +# define yyFlexLexer LolFxFlexLexer +# include "FlexLexer.h" +# undef yyFlexLexer +#endif + +#include "generated/lolfx-parser.h" + +class LolFx; + +namespace lol +{ + +class LolFxScanner : public LolFxFlexLexer +{ +public: + LolFxScanner(char const *command); + virtual ~LolFxScanner(); + virtual int LexerInput(char* buf, int max_size); + virtual LolFxParser::token_type lex(LolFxParser::semantic_type* yylval, + LolFxParser::location_type* yylloc); + +private: + char const *m_input; +}; + +class LolFxCompiler +{ +public: + LolFxCompiler(class LolFx &lolfx); + + bool ParseString(char const *command); + + void Error(const class location& l, const std::string& m); + void Error(const std::string& m); + + class LolFxScanner *m_lexer; + class LolFx &m_lolfx; +}; + +} /* namespace lol */ + +#endif /* __LOLFX_COMPILER_H__ */ + diff --git a/test/sandbox/lex/lolfx.y b/src/gpu/lolfx-parser.y similarity index 94% rename from test/sandbox/lex/lolfx.y rename to src/gpu/lolfx-parser.y index 14dbc9ff..68c62bb9 100644 --- a/test/sandbox/lex/lolfx.y +++ b/src/gpu/lolfx-parser.y @@ -1,15 +1,34 @@ %{ -#include -#include +// +// Lol Engine +// +// Copyright: (c) 2010-2012 Sam Hocevar +// This program is free software; you can redistribute it and/or +// modify it under the terms of the Do What The Fuck You Want To +// Public License, Version 2, as published by Sam Hocevar. See +// http://sam.zoy.org/projects/COPYING.WTFPL for more details. +// -extern "C" int yylex(); -extern "C" int yyparse(); -extern "C" FILE *yyin; -extern "C" int yylineno; +#if defined HAVE_CONFIG_H +# include "config.h" +#endif + +#include "core.h" + +#include -void yyerror(const char *s); %} +%require "2.3" +%debug +%defines +%skeleton "lalr1.cc" +%name-prefix="lol" +%define parser_class_name "LolFxParser" +%locations +%parse-param { class LolFxCompiler& mc } +%error-verbose + /* The classic Bison union trick */ %union { @@ -19,7 +38,7 @@ void yyerror(const char *s); char *sval; } -%type lolfx_shader_name +/* %type lolfx_shader_name */ /* * GLSL and HLSL generic tokens @@ -180,6 +199,8 @@ void yyerror(const char *s); %token PREPROCESSOR_LINE PREPROCESSOR_PRAGMA PREPROCESSOR_UNDEF %token PREPROCESSOR_REGION +%token PRAGMA_LOLFX + /* * HLSL reserved keywords */ @@ -206,12 +227,26 @@ void yyerror(const char *s); %token FLOAT %token STRING NAME + /* + * Special tokens + */ + +%token T_END 0 +%token T_ERROR + /* * Our entry point */ %start lolfx_file +%{ +#include "gpu/lolfx-compiler.h" + +#undef yylex +#define yylex mc.m_lexer->lex +%} + %% /* @@ -691,7 +726,7 @@ lolfx_section: */ lolfx_technique: - HT_TECHNIQUE IDENTIFIER '{' pass_list '}' { std::cout << "New tech" << std::endl; } + HT_TECHNIQUE IDENTIFIER '{' pass_list '}' { std::cout << "New tech " << $2 << std::endl; } ; /* @@ -704,7 +739,7 @@ pass_list: ; pass: - HT_PASS IDENTIFIER '{' pass_stmt_list '}' { std::cout << "New pass" << std::endl; } + HT_PASS IDENTIFIER '{' pass_stmt_list '}' { std::cout << "New pass " << $2 << std::endl; } ; pass_stmt_list: @@ -736,17 +771,26 @@ pass_stmt: */ lolfx_shader: - lolfx_shader_region glsl_translation_unit - | lolfx_shader_region + lolfx_shader_declaration glsl_translation_unit + ; + +lolfx_shader_declaration: + PRAGMA_LOLFX lolfx_shader_type '(' lolfx_shader_description_list ')' { std::cout << "new shader" << std::endl; } + ; + +lolfx_shader_type: + HT_VERTEXSHADER + | HT_PIXELSHADER ; -lolfx_shader_region: - PREPROCESSOR_REGION lolfx_shader_name { std::cout << "new shader " << $2 << std::endl; } +lolfx_shader_description_list: + lolfx_shader_description ',' lolfx_shader_description + | lolfx_shader_description ; -lolfx_shader_name: - IDENTIFIER { $$ = $1; } - | lolfx_shader_name '.' IDENTIFIER { $$ = $3; } /* FIXME: concatenate */ +lolfx_shader_description: + IDENTIFIER '=' IDENTIFIER FLOATCONSTANT + | IDENTIFIER '=' IDENTIFIER ; /* @@ -1308,21 +1352,9 @@ glsl_function_definition: %% -main() -{ - yyin = stdin;//fopen("test.lolfx", "r"); - do - { - yyparse(); - } - while (!feof(yyin)); - - fclose(yyin); -} - -void yyerror(const char *s) +void lol::LolFxParser::error(const LolFxParser::location_type& l, + const std::string& m) { - std::cout << "Parse error line " << yylineno << ": " << s << std::endl; - exit(-1); + mc.Error(l, m); } diff --git a/src/gpu/lolfx-scanner.l b/src/gpu/lolfx-scanner.l new file mode 100644 index 00000000..cf4841a5 --- /dev/null +++ b/src/gpu/lolfx-scanner.l @@ -0,0 +1,636 @@ +%{ +// +// Lol Engine +// +// Copyright: (c) 2010-2012 Sam Hocevar +// This program is free software; you can redistribute it and/or +// modify it under the terms of the Do What The Fuck You Want To +// Public License, Version 2, as published by Sam Hocevar. See +// http://sam.zoy.org/projects/COPYING.WTFPL for more details. +// + +#if defined HAVE_CONFIG_H +# include "config.h" +#endif + +#include +using std::exit; +using std::malloc; +using std::realloc; +using std::free; +#include + +#include "core.h" +#include "gpu/lolfx-compiler.h" + +typedef lol::LolFxParser::token token; +typedef lol::LolFxParser::token_type token_type; + +#ifndef YY_DECL +# define YY_DECL lol::LolFxParser::token_type \ + lol::LolFxScanner::lex(lol::LolFxParser::semantic_type* yylval, \ + lol::LolFxParser::location_type* yylloc) +#endif + +#define yyterminate() return token::T_END +#define YY_NO_UNISTD_H +#define YY_USER_ACTION yylloc->columns(yyleng); +%} + +%option c++ prefix="LolFx" +%option batch yywrap nounput stack + +%x C_COMMENT +%x CPP_COMMENT + +%% + +%{ + /* reset location at the beginning of yylex() */ + yylloc->step(); + + int language_guess = INITIAL; +%} + + /* + * GLSL keywords + */ + +"subroutine" { return token::GT_SUBROUTINE; } +"patch" { return token::GT_PATCH; } +"sample" { return token::GT_SAMPLE; } +"flat" { return token::GT_FLAT; } +"smooth" { return token::GT_SMOOTH; } +"layout" { return token::GT_LAYOUT; } +"sampler1dshadow" { return token::GT_SAMPLER1DSHADOW; } +"sampler2dshadow" { return token::GT_SAMPLER2DSHADOW; } +"samplercubeshadow" { return token::GT_SAMPLERCUBESHADOW; } +"sampler1darray" { return token::GT_SAMPLER1DARRAY; } +"sampler2darray" { return token::GT_SAMPLER2DARRAY; } +"sampler1darrayshadow" { return token::GT_SAMPLER1DARRAYSHADOW; } +"sampler2darrayshadow" { return token::GT_SAMPLER2DARRAYSHADOW; } +"isampler1d" { return token::GT_ISAMPLER1D; } +"isampler2d" { return token::GT_ISAMPLER2D; } +"isampler3d" { return token::GT_ISAMPLER3D; } +"isamplercube" { return token::GT_ISAMPLERCUBE; } +"isampler1darray" { return token::GT_ISAMPLER1DARRAY; } +"isampler2darray" { return token::GT_ISAMPLER2DARRAY; } +"usampler1d" { return token::GT_USAMPLER1D; } +"usampler2d" { return token::GT_USAMPLER2D; } +"usampler3d" { return token::GT_USAMPLER3D; } +"usamplercube" { return token::GT_USAMPLERCUBE; } +"usampler1darray" { return token::GT_USAMPLER1DARRAY; } +"usampler2darray" { return token::GT_USAMPLER2DARRAY; } +"sampler2drect" { return token::GT_SAMPLER2DRECT; } +"sampler2drectshadow" { return token::GT_SAMPLER2DRECTSHADOW; } +"isampler2drect" { return token::GT_ISAMPLER2DRECT; } +"usampler2drect" { return token::GT_USAMPLER2DRECT; } +"samplerbuffer" { return token::GT_SAMPLERBUFFER; } +"isamplerbuffer" { return token::GT_ISAMPLERBUFFER; } +"usamplerbuffer" { return token::GT_USAMPLERBUFFER; } +"samplercubearray" { return token::GT_SAMPLERCUBEARRAY; } +"samplercubearrayshadow" { return token::GT_SAMPLERCUBEARRAYSHADOW; } +"isamplercubearray" { return token::GT_ISAMPLERCUBEARRAY; } +"usamplercubearray" { return token::GT_USAMPLERCUBEARRAY; } +"sampler2dms" { return token::GT_SAMPLER2DMS; } +"isampler2dms" { return token::GT_ISAMPLER2DMS; } +"usampler2dms" { return token::GT_USAMPLER2DMS; } +"sampler2dmsarray" { return token::GT_SAMPLER2DMSARRAY; } +"isampler2dmsarray" { return token::GT_ISAMPLER2DMSARRAY; } +"usampler2dmsarray" { return token::GT_USAMPLER2DMSARRAY; } + +"highp" { return token::GT_HIGHP; } +"mediump" { return token::GT_MEDIUMP; } +"lowp" { return token::GT_LOWP; } +"precision" { return token::GT_PRECISION; } +"invariant" { return token::GT_INVARIANT; } + + /* + * Deprecated GLSL keywords + */ + +"attribute" { return token::GT_ATTRIBUTE; } + + /* + * GLSL vector types + */ + +"bvec2" { return token::GT_BVEC2; } +"bvec3" { return token::GT_BVEC3; } +"bvec4" { return token::GT_BVEC4; } + +"ivec2" { return token::GT_IVEC2; } +"ivec3" { return token::GT_IVEC3; } +"ivec4" { return token::GT_IVEC4; } + +"uvec2" { return token::GT_UVEC2; } +"uvec3" { return token::GT_UVEC3; } +"uvec4" { return token::GT_UVEC4; } + +"vec2" { return token::GT_VEC2; } +"vec3" { return token::GT_VEC3; } +"vec4" { return token::GT_VEC4; } +"mat2" { return token::GT_MAT2; } +"mat2x2" { return token::GT_MAT2X2; } +"mat2x3" { return token::GT_MAT2X3; } +"mat2x4" { return token::GT_MAT2X4; } +"mat3" { return token::GT_MAT3; } +"mat3x2" { return token::GT_MAT3X2; } +"mat3x3" { return token::GT_MAT3X3; } +"mat3x4" { return token::GT_MAT3X4; } +"mat4" { return token::GT_MAT4; } +"mat4x2" { return token::GT_MAT4X2; } +"mat4x3" { return token::GT_MAT4X3; } +"mat4x4" { return token::GT_MAT4X4; } + +"dvec2" { return token::GT_DVEC2; } +"dvec3" { return token::GT_DVEC3; } +"dvec4" { return token::GT_DVEC4; } +"dmat2" { return token::GT_DMAT2; } +"dmat2x2" { return token::GT_DMAT2X2; } +"dmat2x3" { return token::GT_DMAT2X3; } +"dmat2x4" { return token::GT_DMAT2X4; } +"dmat3" { return token::GT_DMAT3; } +"dmat3x2" { return token::GT_DMAT3X2; } +"dmat3x3" { return token::GT_DMAT3X3; } +"dmat3x4" { return token::GT_DMAT3X4; } +"dmat4" { return token::GT_DMAT4; } +"dmat4x2" { return token::GT_DMAT4X2; } +"dmat4x3" { return token::GT_DMAT4X3; } +"dmat4x4" { return token::GT_DMAT4X4; } + + /* + * GLSL constant values + */ + +"true" { yylval->ival = 1; return token::BOOLCONSTANT; } +"false" { yylval->ival = 0; return token::BOOLCONSTANT; } + +[xyzw]{1,4} { return token::FIELDSELECTION; } +[rgba]{1,4} { return token::FIELDSELECTION; } +[stpq]{1,4} { return token::FIELDSELECTION; } + + /* + * GLSL keywords that are also valid or reserved in HLSL + * and HLSL keywords that are also valid or reserved in GLSL. + */ + +"bool" { return token::GHT_BOOL; } +"break" { return token::GHT_BREAK; } +"case" { return token::GHT_CASE; } +"centroid" { return token::GHT_CENTROID; } +"const" { return token::GHT_CONST; } +"continue" { return token::GHT_CONTINUE; } +"default" { return token::GHT_DEFAULT; } +"discard" { return token::GHT_DISCARD; } +"do" { return token::GHT_DO; } +"double" { return token::GHT_DOUBLE; } +"else" { return token::GHT_ELSE; } +"float" { return token::GHT_FLOAT; } +"for" { return token::GHT_FOR; } +"if" { return token::GHT_IF; } +"in" { return token::GHT_IN; } +"inout" { return token::GHT_INOUT; } +"int" { return token::GHT_INT; } +"noperspective" { return token::GHT_NOPERSPECTIVE; } +"out" { return token::GHT_OUT; } +"return" { return token::GHT_RETURN; } +"sampler1d" { return token::GHT_SAMPLER1D; } +"sampler2d" { return token::GHT_SAMPLER2D; } +"sampler3d" { return token::GHT_SAMPLER3D; } +"samplercube" { return token::GHT_SAMPLERCUBE; } +"struct" { return token::GHT_STRUCT; } +"switch" { return token::GHT_SWITCH; } +"uint" { return token::GHT_UINT; } +"uniform" { return token::GHT_UNIFORM; } +"void" { return token::GHT_VOID; } +"while" { return token::GHT_WHILE; } + +(?i:bool) { return token::HGT_BOOL; } +(?i:break) { return token::HGT_BREAK; } +(?i:case) { return token::HGT_CASE; } +(?i:centroid) { return token::HGT_CENTROID; } +(?i:const) { return token::HGT_CONST; } +(?i:continue) { return token::HGT_CONTINUE; } +(?i:default) { return token::HGT_DEFAULT; } +(?i:discard) { return token::HGT_DISCARD; } +(?i:do) { return token::HGT_DO; } +(?i:double) { return token::HGT_DOUBLE; } +(?i:else) { return token::HGT_ELSE; } +(?i:float) { return token::HGT_FLOAT; } +(?i:for) { return token::HGT_FOR; } +(?i:if) { return token::HGT_IF; } +(?i:in) { return token::HGT_IN; } +(?i:inout) { return token::HGT_INOUT; } +(?i:int) { return token::HGT_INT; } +(?i:noperspective) { return token::HGT_NOPERSPECTIVE; } +(?i:out) { return token::HGT_OUT; } +(?i:return) { return token::HGT_RETURN; } +(?i:sampler1d) { return token::HGT_SAMPLER1D; } +(?i:sampler2d) { return token::HGT_SAMPLER2D; } +(?i:sampler3d) { return token::HGT_SAMPLER3D; } +(?i:samplercube) { return token::HGT_SAMPLERCUBE; } +(?i:struct) { return token::HGT_STRUCT; } +(?i:switch) { return token::HGT_SWITCH; } +(?i:uint) { return token::HGT_UINT; } +(?i:uniform) { return token::HGT_UNIFORM; } +(?i:void) { return token::HGT_VOID; } +(?i:while) { return token::HGT_WHILE; } + + /* + * HLSL keywords + * Gathered from http://msdn.microsoft.com/en-us/library/windows/desktop/bb509568%28v=vs.85%29.aspx + */ + +(?i:appendstructuredbuffer) { return token::HT_APPENDSTRUCTUREDBUFFER; } +(?i:asm) { return token::HT_ASM; } +(?i:asm_fragment) { return token::HT_ASM_FRAGMENT; } +(?i:blendstate) { return token::HT_BLENDSTATE; } +(?i:buffer) { return token::HT_BUFFER; } +(?i:byteaddressbuffer) { return token::HT_BYTEADDRESSBUFFER; } +(?i:cbuffer) { return token::HT_CBUFFER; } +(?i:column_major) { return token::HT_COLUMN_MAJOR; } +(?i:compile) { return token::HT_COMPILE; } +(?i:compile_fragment) { return token::HT_COMPILE_FRAGMENT; } +(?i:compileshader) { return token::HT_COMPILESHADER; } +(?i:computeshader) { return token::HT_COMPUTESHADER; } +(?i:consumestructuredbuffer) { return token::HT_CONSUMESTRUCTUREDBUFFER; } +(?i:depthstencilstate) { return token::HT_DEPTHSTENCILSTATE; } +(?i:depthstencilview) { return token::HT_DEPTHSTENCILVIEW; } +(?i:domainshader) { return token::HT_DOMAINSHADER; } +(?i:dword) { return token::HT_DWORD; } +(?i:extern) { return token::HT_EXTERN; } +(?i:false) { return token::HT_FALSE; } +(?i:fxgroup) { return token::HT_FXGROUP; } +(?i:geometryshader) { return token::HT_GEOMETRYSHADER; } +(?i:groupshared) { return token::HT_GROUPSHARED; } +(?i:half) { return token::HT_HALF; } +(?i:hullshader) { return token::HT_HULLSHADER; } +(?i:inline) { return token::HT_INLINE; } +(?i:inputpatch) { return token::HT_INPUTPATCH; } +(?i:interface) { return token::HT_INTERFACE; } +(?i:line) { return token::HT_LINE; } +(?i:lineadj) { return token::HT_LINEADJ; } +(?i:linear) { return token::HT_LINEAR; } +(?i:linestream) { return token::HT_LINESTREAM; } +(?i:matrix) { return token::HT_MATRIX; } +(?i:namespace) { return token::HT_NAMESPACE; } +(?i:nointerpolation) { return token::HT_NOINTERPOLATION; } +(?i:null) { return token::HT_NULL; } +(?i:outputpatch) { return token::HT_OUTPUTPATCH; } +(?i:packoffset) { return token::HT_PACKOFFSET; } +(?i:pass) { return token::HT_PASS; } +(?i:pixelfragment) { return token::HT_PIXELFRAGMENT; } +(?i:pixelshader) { return token::HT_PIXELSHADER; } +(?i:point) { return token::HT_POINT; } +(?i:pointstream) { return token::HT_POINTSTREAM; } +(?i:precise) { return token::HT_PRECISE; } +(?i:rasterizerstate) { return token::HT_RASTERIZERSTATE; } +(?i:rendertargetview) { return token::HT_RENDERTARGETVIEW; } +(?i:register) { return token::HT_REGISTER; } +(?i:row_major) { return token::HT_ROW_MAJOR; } +(?i:rwbuffer) { return token::HT_RWBUFFER; } +(?i:rwbyteaddressbuffer) { return token::HT_RWBYTEADDRESSBUFFER; } +(?i:rwstructuredbuffer) { return token::HT_RWSTRUCTUREDBUFFER; } +(?i:rwtexture1d) { return token::HT_RWTEXTURE1D; } +(?i:rwtexture1darray) { return token::HT_RWTEXTURE1DARRAY; } +(?i:rwtexture2d) { return token::HT_RWTEXTURE2D; } +(?i:rwtexture2darray) { return token::HT_RWTEXTURE2DARRAY; } +(?i:rwtexture3d) { return token::HT_RWTEXTURE3D; } +(?i:sampler) { return token::HT_SAMPLER; } +(?i:sampler_state) { return token::HT_SAMPLER_STATE; } +(?i:samplerstate) { return token::HT_SAMPLERSTATE; } +(?i:samplercomparisonstate) { return token::HT_SAMPLERCOMPARISONSTATE; } +(?i:shared) { return token::HT_SHARED; } +(?i:snorm) { return token::HT_SNORM; } +(?i:stateblock) { return token::HT_STATEBLOCK; } +(?i:stateblock_state) { return token::HT_STATEBLOCK_STATE; } +(?i:static) { return token::HT_STATIC; } +(?i:string) { return token::HT_STRING; } +(?i:structuredbuffer) { return token::HT_STRUCTUREDBUFFER; } +(?i:tbuffer) { return token::HT_TBUFFER; } +(?i:technique) { return token::HT_TECHNIQUE; } +(?i:technique10) { return token::HT_TECHNIQUE10; } +(?i:technique11xz) { return token::HT_TECHNIQUE11XZ; } +"texture" { return token::HT_TEXTURE; } +(?i:texture1d) { return token::HT_TEXTURE1D; } +(?i:texture1darray) { return token::HT_TEXTURE1DARRAY; } +(?i:texture2d) { return token::HT_TEXTURE2D; } +(?i:texture2darray) { return token::HT_TEXTURE2DARRAY; } +(?i:texture2dms) { return token::HT_TEXTURE2DMS; } +(?i:texture2dmsarray) { return token::HT_TEXTURE2DMSARRAY; } +(?i:texture3d) { return token::HT_TEXTURE3D; } +(?i:texturecube) { return token::HT_TEXTURECUBE; } +(?i:texturecubearray) { return token::HT_TEXTURECUBEARRAY; } +(?i:true) { return token::HT_TRUE; } +(?i:typedef) { return token::HT_TYPEDEF; } +(?i:triangle) { return token::HT_TRIANGLE; } +(?i:triangleadj) { return token::HT_TRIANGLEADJ; } +(?i:trianglestream) { return token::HT_TRIANGLESTREAM; } +(?i:unorm) { return token::HT_UNORM; } +(?i:vector) { return token::HT_VECTOR; } +(?i:vertexfragment) { return token::HT_VERTEXFRAGMENT; } +(?i:vertexshader) { return token::HT_VERTEXSHADER; } +(?i:volatile) { return token::HT_VOLATILE; } + + /* + * HLSL vector types + * TODO: this can probably be factored somehow + */ + +(?i:bool1) { return token::HT_BOOL1; } +(?i:bool1x1) { return token::HT_BOOL1x1; } +(?i:bool2x1) { return token::HT_BOOL2x1; } +(?i:bool3x1) { return token::HT_BOOL3x1; } +(?i:bool4x1) { return token::HT_BOOL4x1; } +(?i:bool2) { return token::HT_BOOL2; } +(?i:bool1x2) { return token::HT_BOOL1x2; } +(?i:bool2x2) { return token::HT_BOOL2x2; } +(?i:bool3x2) { return token::HT_BOOL3x2; } +(?i:bool4x2) { return token::HT_BOOL4x2; } +(?i:bool3) { return token::HT_BOOL3; } +(?i:bool1x3) { return token::HT_BOOL1x3; } +(?i:bool2x3) { return token::HT_BOOL2x3; } +(?i:bool3x3) { return token::HT_BOOL3x3; } +(?i:bool4x3) { return token::HT_BOOL4x3; } +(?i:bool4) { return token::HT_BOOL4; } +(?i:bool1x4) { return token::HT_BOOL1x4; } +(?i:bool2x4) { return token::HT_BOOL2x4; } +(?i:bool3x4) { return token::HT_BOOL3x4; } +(?i:bool4x4) { return token::HT_BOOL4x4; } + +(?i:float1) { return token::HT_FLOAT1; } +(?i:float1x1) { return token::HT_FLOAT1x1; } +(?i:float2x1) { return token::HT_FLOAT2x1; } +(?i:float3x1) { return token::HT_FLOAT3x1; } +(?i:float4x1) { return token::HT_FLOAT4x1; } +(?i:float2) { return token::HT_FLOAT2; } +(?i:float1x2) { return token::HT_FLOAT1x2; } +(?i:float2x2) { return token::HT_FLOAT2x2; } +(?i:float3x2) { return token::HT_FLOAT3x2; } +(?i:float4x2) { return token::HT_FLOAT4x2; } +(?i:float3) { return token::HT_FLOAT3; } +(?i:float1x3) { return token::HT_FLOAT1x3; } +(?i:float2x3) { return token::HT_FLOAT2x3; } +(?i:float3x3) { return token::HT_FLOAT3x3; } +(?i:float4x3) { return token::HT_FLOAT4x3; } +(?i:float4) { return token::HT_FLOAT4; } +(?i:float1x4) { return token::HT_FLOAT1x4; } +(?i:float2x4) { return token::HT_FLOAT2x4; } +(?i:float3x4) { return token::HT_FLOAT3x4; } +(?i:float4x4) { return token::HT_FLOAT4x4; } + +(?i:double1) { return token::HT_DOUBLE1; } +(?i:double1x1) { return token::HT_DOUBLE1x1; } +(?i:double2x1) { return token::HT_DOUBLE2x1; } +(?i:double3x1) { return token::HT_DOUBLE3x1; } +(?i:double4x1) { return token::HT_DOUBLE4x1; } +(?i:double2) { return token::HT_DOUBLE2; } +(?i:double1x2) { return token::HT_DOUBLE1x2; } +(?i:double2x2) { return token::HT_DOUBLE2x2; } +(?i:double3x2) { return token::HT_DOUBLE3x2; } +(?i:double4x2) { return token::HT_DOUBLE4x2; } +(?i:double3) { return token::HT_DOUBLE3; } +(?i:double1x3) { return token::HT_DOUBLE1x3; } +(?i:double2x3) { return token::HT_DOUBLE2x3; } +(?i:double3x3) { return token::HT_DOUBLE3x3; } +(?i:double4x3) { return token::HT_DOUBLE4x3; } +(?i:double4) { return token::HT_DOUBLE4; } +(?i:double1x4) { return token::HT_DOUBLE1x4; } +(?i:double2x4) { return token::HT_DOUBLE2x4; } +(?i:double3x4) { return token::HT_DOUBLE3x4; } +(?i:double4x4) { return token::HT_DOUBLE4x4; } + +(?i:dword1) { return token::HT_DWORD1; } +(?i:dword1x1) { return token::HT_DWORD1x1; } +(?i:dword2x1) { return token::HT_DWORD2x1; } +(?i:dword3x1) { return token::HT_DWORD3x1; } +(?i:dword4x1) { return token::HT_DWORD4x1; } +(?i:dword2) { return token::HT_DWORD2; } +(?i:dword1x2) { return token::HT_DWORD1x2; } +(?i:dword2x2) { return token::HT_DWORD2x2; } +(?i:dword3x2) { return token::HT_DWORD3x2; } +(?i:dword4x2) { return token::HT_DWORD4x2; } +(?i:dword3) { return token::HT_DWORD3; } +(?i:dword1x3) { return token::HT_DWORD1x3; } +(?i:dword2x3) { return token::HT_DWORD2x3; } +(?i:dword3x3) { return token::HT_DWORD3x3; } +(?i:dword4x3) { return token::HT_DWORD4x3; } +(?i:dword4) { return token::HT_DWORD4; } +(?i:dword1x4) { return token::HT_DWORD1x4; } +(?i:dword2x4) { return token::HT_DWORD2x4; } +(?i:dword3x4) { return token::HT_DWORD3x4; } +(?i:dword4x4) { return token::HT_DWORD4x4; } + +(?i:int1) { return token::HT_INT1; } +(?i:int1x1) { return token::HT_INT1x1; } +(?i:int2x1) { return token::HT_INT2x1; } +(?i:int3x1) { return token::HT_INT3x1; } +(?i:int4x1) { return token::HT_INT4x1; } +(?i:int2) { return token::HT_INT2; } +(?i:int1x2) { return token::HT_INT1x2; } +(?i:int2x2) { return token::HT_INT2x2; } +(?i:int3x2) { return token::HT_INT3x2; } +(?i:int4x2) { return token::HT_INT4x2; } +(?i:int3) { return token::HT_INT3; } +(?i:int1x3) { return token::HT_INT1x3; } +(?i:int2x3) { return token::HT_INT2x3; } +(?i:int3x3) { return token::HT_INT3x3; } +(?i:int4x3) { return token::HT_INT4x3; } +(?i:int4) { return token::HT_INT4; } +(?i:int1x4) { return token::HT_INT1x4; } +(?i:int2x4) { return token::HT_INT2x4; } +(?i:int3x4) { return token::HT_INT3x4; } +(?i:int4x4) { return token::HT_INT4x4; } + +(?i:uint1) { return token::HT_UINT1; } +(?i:uint1x1) { return token::HT_UINT1x1; } +(?i:uint2x1) { return token::HT_UINT2x1; } +(?i:uint3x1) { return token::HT_UINT3x1; } +(?i:uint4x1) { return token::HT_UINT4x1; } +(?i:uint2) { return token::HT_UINT2; } +(?i:uint1x2) { return token::HT_UINT1x2; } +(?i:uint2x2) { return token::HT_UINT2x2; } +(?i:uint3x2) { return token::HT_UINT3x2; } +(?i:uint4x2) { return token::HT_UINT4x2; } +(?i:uint3) { return token::HT_UINT3; } +(?i:uint1x3) { return token::HT_UINT1x3; } +(?i:uint2x3) { return token::HT_UINT2x3; } +(?i:uint3x3) { return token::HT_UINT3x3; } +(?i:uint4x3) { return token::HT_UINT4x3; } +(?i:uint4) { return token::HT_UINT4; } +(?i:uint1x4) { return token::HT_UINT1x4; } +(?i:uint2x4) { return token::HT_UINT2x4; } +(?i:uint3x4) { return token::HT_UINT3x4; } +(?i:uint4x4) { return token::HT_UINT4x4; } + + /* + * HLSL preprocessor directives + * Gathered from http://msdn.microsoft.com/en-us/library/windows/desktop/bb943993%28v=vs.85%29.aspx + */ + +"#"[ \t]*"define" { return token::PREPROCESSOR_DEFINE; } +"#"[ \t]*"elif" { return token::PREPROCESSOR_ELIF; } +"#"[ \t]*"else" { return token::PREPROCESSOR_ELSE; } +"#"[ \t]*"endif" { return token::PREPROCESSOR_ENDIF; } +"#"[ \t]*"error" { return token::PREPROCESSOR_ERROR; } +"#"[ \t]*"if" { return token::PREPROCESSOR_IF; } +"#"[ \t]*"ifdef" { return token::PREPROCESSOR_IFDEF; } +"#"[ \t]*"ifndef" { return token::PREPROCESSOR_IFNDEF; } +"#"[ \t]*"include" { return token::PREPROCESSOR_INCLUDE; } +"#"[ \t]*"line" { return token::PREPROCESSOR_LINE; } +"#"[ \t]*"pragma" { return token::PREPROCESSOR_PRAGMA; } +"#"[ \t]*"undef" { return token::PREPROCESSOR_UNDEF; } + + /* + * GLSL preprocessor directives + */ + +"#"[ \t]*"version".* { /* ignore for now */ } + + /* + * LolFx preprocessor directives + */ + +"#"[ \t]*(?i:pragma)[ \t]*(?i:lolfx) { return token::PRAGMA_LOLFX; } + + /* + * HLSL reserved keywords + * Gathered from http://msdn.microsoft.com/en-us/library/windows/desktop/bb509569%28v=vs.85%29.aspx + */ + +(?i:auto) { return token::HT_AUTO; } +(?i:catch) { return token::HT_CATCH; } +(?i:char) { return token::HT_CHAR; } +(?i:class) { return token::HT_CLASS; } +(?i:const_cast) { return token::HT_CONST_CAST; } +(?i:delete) { return token::HT_DELETE; } +(?i:dynamic_cast) { return token::HT_DYNAMIC_CAST; } +(?i:enum) { return token::HT_ENUM; } +(?i:explicit) { return token::HT_EXPLICIT; } +(?i:friend) { return token::HT_FRIEND; } +(?i:goto) { return token::HT_GOTO; } +(?i:long) { return token::HT_LONG; } +(?i:mutable) { return token::HT_MUTABLE; } +(?i:new) { return token::HT_NEW; } +(?i:operator) { return token::HT_OPERATOR; } +(?i:private) { return token::HT_PRIVATE; } +(?i:protected) { return token::HT_PROTECTED; } +(?i:public) { return token::HT_PUBLIC; } +(?i:reinterpret_cast) { return token::HT_REINTERPRET_CAST; } +(?i:short) { return token::HT_SHORT; } +(?i:signed) { return token::HT_SIGNED; } +(?i:sizeof) { return token::HT_SIZEOF; } +(?i:static_cast) { return token::HT_STATIC_CAST; } +(?i:template) { return token::HT_TEMPLATE; } +(?i:this) { return token::HT_THIS; } +(?i:throw) { return token::HT_THROW; } +(?i:try) { return token::HT_TRY; } +(?i:typename) { return token::HT_TYPENAME; } +(?i:union) { return token::HT_UNION; } +(?i:unsigned) { return token::HT_UNSIGNED; } +(?i:using) { return token::HT_USING; } +(?i:virtual) { return token::HT_VIRTUAL; } + + /* + * Various tokens + */ + +"++" { return token::T_INC; } +"--" { return token::T_DEC; } +"<=" { return token::T_LE; } +">=" { return token::T_GE; } +"==" { return token::T_EQ; } +"!=" { return token::T_NE; } +"<<" { return token::T_LEFT; } +">>" { return token::T_RIGHT; } +"&&" { return token::T_AND; } +"||" { return token::T_OR; } +"^^" { return token::T_XOR; } + +"*=" { return token::T_MULEQ; } +"/=" { return token::T_DIVEQ; } +"%=" { return token::T_MODEQ; } +"+=" { return token::T_ADDEQ; } +"-=" { return token::T_SUBEQ; } +"<<=" { return token::T_LEFTEQ; } +">>=" { return token::T_RIGHTEQ; } +"&=" { return token::T_ANDEQ; } +"^=" { return token::T_XOREQ; } +"|=" { return token::T_OREQ; } + +(0|[1-9][0-9]*)\.[0-9]+ { + yylval->fval = std::atof(yytext); + return token::FLOATCONSTANT; +} +(0|[1-9][0-9]*)[uU] { + yylval->uval = std::atoi(yytext); + return token::UINTCONSTANT; +} +(0|[1-9][0-9]*) { + yylval->ival = std::atoi(yytext); + return token::INTCONSTANT; +} + +[a-zA-Z][a-zA-Z0-9_]* { + /* Copy token for now */ + yylval->sval = strdup(yytext); + return token::IDENTIFIER; +} + +[ \t]+ { /* ignore whitespace */ } +[\n] { ++yylineno; } +. { return token::T_ERROR; } + + /* + * Ignore C comments + */ + +"/*" { BEGIN(C_COMMENT); } +"*/" { BEGIN(INITIAL); } +[^*\n]* { } +\n { ++yylineno; } +. { } + + /* + * Ignore C++ comments + */ + +"//" { BEGIN(CPP_COMMENT); } +\n { ++yylineno; BEGIN(INITIAL); } +.* { } + +%% + +lol::LolFxScanner::LolFxScanner(char const *command) + : LolFxFlexLexer(0, 0), + m_input(command) +{ +} + +lol::LolFxScanner::~LolFxScanner() +{ +} + +int lol::LolFxScanner::LexerInput(char* buf, int max_size) +{ + buf[0] = m_input[0]; + if (buf[0]) + ++m_input; + return buf[0] ? 1 : 0; +} + +#ifdef yylex +#undef yylex +#endif +int LolFxFlexLexer::yylex() +{ + std::cerr << "in LolFxFlexLexer::yylex() !" << std::endl; + return 0; +} + +int LolFxFlexLexer::yywrap() +{ + return 1; +} + diff --git a/src/gpu/testmaterial.lolfx b/src/gpu/testmaterial.lolfx index b96a5c9d..86792a79 100644 --- a/src/gpu/testmaterial.lolfx +++ b/src/gpu/testmaterial.lolfx @@ -32,69 +32,68 @@ technique Foo alphaop[1] = disable; // Ye old way - vertexshader = ... - geometryshader = ... - pixelshader = ... + vertexshader = blah; + geometryshader = blah; + pixelshader = blah; // Ogre crap // The D3D11 way, but we must make it work with GLSL too - SetBlendState(AdditiveBlending, float4(0.0f, 0.0f, 0.0f, 0.0f), 0xFFFFFFFF); - SetDepthStencilState(DisableDepth, 0); - SetRasterizerState() - - SetVertexShader - SetDomainShader - SetHullShader - SetGeometryShader - SetPixelShader - SetComputeShader /* WTF? */ - - SetRenderTargets(RTV0, DSV); - SetRenderTargets(RTV0, RTV1, DSV); - ... - SetRenderTargets(RTV0, RTV1, RTV2, RTV3, RTV4, RTV5, RTV6, RTV7, DSV); + //SetBlendState(AdditiveBlending, float4(0.0f, 0.0f, 0.0f, 0.0f), 0xFFFFFFFF); + //SetDepthStencilState(DisableDepth, 0); + //SetRasterizerState() + + //SetVertexShader + //SetDomainShader + //SetHullShader + //SetGeometryShader + //SetPixelShader + //SetComputeShader /* WTF? */ + + //SetRenderTargets(RTV0, DSV); + //SetRenderTargets(RTV0, RTV1, DSV); + //... + //SetRenderTargets(RTV0, RTV1, RTV2, RTV3, RTV4, RTV5, RTV6, RTV7, DSV); } pass p1 { // Autres vertex/pixel shaders avec éventuellement des // dépendances sur le résultat des passes précédentes - vertexshader = ... + vertexshader = something_else; } } /* Defines GLSL shader "Prout" */ -#section GLSL.Prout +#pragma lolfx vertexshader(lang=GLSL 1.20, name=prout) #version 120 /* Valid with my GLSL compiler */ -#pragma lolfx semantic(in_Vertex, POSITION) -#pragma lolfx semantic(in_Normal, NORMAL) -#pragma lolfx semantic(in_Color, COLOR) +//#pragma lolfx semantic(in_Vertex, POSITION) +//#pragma lolfx semantic(in_Normal, NORMAL) +//#pragma lolfx semantic(in_Color, COLOR) attribute vec3 in_Vertex; attribute vec3 in_Normal; attribute vec4 in_Color; void main(void) { - ... + /* ... */ } /* Defines GLSL shader "Zob" */ - -#section GLSL.Zob +#pragma lolfx vertexshader(lang=GLSL 1.20, name=zob) void main(void) { - shit fuck fuck shit; + shit(); fuck(); fuck(); shit(); } -/* Defines HLSL shader "Prout" */ +/* Defines HLSL vertex shader "Prout" */ -#section HLSL.Prout +#pragma lolfx vertexshader(lang=HLSL, name=prout) void main(void) { diff --git a/src/lolcore.vcxproj b/src/lolcore.vcxproj index b99e4137..76d3fab6 100644 --- a/src/lolcore.vcxproj +++ b/src/lolcore.vcxproj @@ -249,8 +249,11 @@ + + + @@ -561,10 +564,12 @@ + + @@ -621,6 +626,8 @@ + + diff --git a/src/lolcore.vcxproj.filters b/src/lolcore.vcxproj.filters index acb72d8c..5ddb33ea 100644 --- a/src/lolcore.vcxproj.filters +++ b/src/lolcore.vcxproj.filters @@ -241,6 +241,12 @@ src\generated + + src\generated + + + src\generated + src\platform\ps3 @@ -1583,4 +1589,4 @@ src\easymesh - \ No newline at end of file + diff --git a/test/sandbox/lex/.gitignore b/test/sandbox/lex/.gitignore deleted file mode 100644 index 7b525ac4..00000000 --- a/test/sandbox/lex/.gitignore +++ /dev/null @@ -1,4 +0,0 @@ -lex.yy.c -lolfx.tab.c -lolfx.tab.h -parser diff --git a/test/sandbox/lex/Makefile b/test/sandbox/lex/Makefile deleted file mode 100644 index 45db8e8c..00000000 --- a/test/sandbox/lex/Makefile +++ /dev/null @@ -1,12 +0,0 @@ - -parser: lex.yy.c lolfx.tab.c - $(CXX) $^ -o $@ -lfl - -lolfx.tab.c: lolfx.y - bison -d $^ - -lex.yy.c: lolfx.l - flex -d $^ - -clean: - rm -f lex.yy.c lolfx.tab.c lolfx.tab.h parser diff --git a/test/sandbox/lex/lolfx.l b/test/sandbox/lex/lolfx.l deleted file mode 100644 index 89752a9b..00000000 --- a/test/sandbox/lex/lolfx.l +++ /dev/null @@ -1,561 +0,0 @@ -%{ -#include -#define YY_DECL extern "C" int yylex() -#include "lolfx.tab.h" -%} - -%x GLSL -%x HLSL -%x C_COMMENT -%x CPP_COMMENT - -%% - -%{ -int comment_caller = INITIAL; -%} - - /* - * GLSL keywords - */ - -"subroutine" { return GT_SUBROUTINE; } -"patch" { return GT_PATCH; } -"sample" { return GT_SAMPLE; } -"flat" { return GT_FLAT; } -"smooth" { return GT_SMOOTH; } -"layout" { return GT_LAYOUT; } -"sampler1dshadow" { return GT_SAMPLER1DSHADOW; } -"sampler2dshadow" { return GT_SAMPLER2DSHADOW; } -"samplercubeshadow" { return GT_SAMPLERCUBESHADOW; } -"sampler1darray" { return GT_SAMPLER1DARRAY; } -"sampler2darray" { return GT_SAMPLER2DARRAY; } -"sampler1darrayshadow" { return GT_SAMPLER1DARRAYSHADOW; } -"sampler2darrayshadow" { return GT_SAMPLER2DARRAYSHADOW; } -"isampler1d" { return GT_ISAMPLER1D; } -"isampler2d" { return GT_ISAMPLER2D; } -"isampler3d" { return GT_ISAMPLER3D; } -"isamplercube" { return GT_ISAMPLERCUBE; } -"isampler1darray" { return GT_ISAMPLER1DARRAY; } -"isampler2darray" { return GT_ISAMPLER2DARRAY; } -"usampler1d" { return GT_USAMPLER1D; } -"usampler2d" { return GT_USAMPLER2D; } -"usampler3d" { return GT_USAMPLER3D; } -"usamplercube" { return GT_USAMPLERCUBE; } -"usampler1darray" { return GT_USAMPLER1DARRAY; } -"usampler2darray" { return GT_USAMPLER2DARRAY; } -"sampler2drect" { return GT_SAMPLER2DRECT; } -"sampler2drectshadow" { return GT_SAMPLER2DRECTSHADOW; } -"isampler2drect" { return GT_ISAMPLER2DRECT; } -"usampler2drect" { return GT_USAMPLER2DRECT; } -"samplerbuffer" { return GT_SAMPLERBUFFER; } -"isamplerbuffer" { return GT_ISAMPLERBUFFER; } -"usamplerbuffer" { return GT_USAMPLERBUFFER; } -"samplercubearray" { return GT_SAMPLERCUBEARRAY; } -"samplercubearrayshadow" { return GT_SAMPLERCUBEARRAYSHADOW; } -"isamplercubearray" { return GT_ISAMPLERCUBEARRAY; } -"usamplercubearray" { return GT_USAMPLERCUBEARRAY; } -"sampler2dms" { return GT_SAMPLER2DMS; } -"isampler2dms" { return GT_ISAMPLER2DMS; } -"usampler2dms" { return GT_USAMPLER2DMS; } -"sampler2dmsarray" { return GT_SAMPLER2DMSARRAY; } -"isampler2dmsarray" { return GT_ISAMPLER2DMSARRAY; } -"usampler2dmsarray" { return GT_USAMPLER2DMSARRAY; } - -"highp" { return GT_HIGHP; } -"mediump" { return GT_MEDIUMP; } -"lowp" { return GT_LOWP; } -"precision" { return GT_PRECISION; } -"invariant" { return GT_INVARIANT; } - - /* - * Deprecated GLSL keywords - */ - -"attribute" { return GT_ATTRIBUTE; } - - /* - * GLSL vector types - */ - -"bvec2" { return GT_BVEC2; } -"bvec3" { return GT_BVEC3; } -"bvec4" { return GT_BVEC4; } - -"ivec2" { return GT_IVEC2; } -"ivec3" { return GT_IVEC3; } -"ivec4" { return GT_IVEC4; } - -"uvec2" { return GT_UVEC2; } -"uvec3" { return GT_UVEC3; } -"uvec4" { return GT_UVEC4; } - -"vec2" { return GT_VEC2; } -"vec3" { return GT_VEC3; } -"vec4" { return GT_VEC4; } -"mat2" { return GT_MAT2; } -"mat2x2" { return GT_MAT2X2; } -"mat2x3" { return GT_MAT2X3; } -"mat2x4" { return GT_MAT2X4; } -"mat3" { return GT_MAT3; } -"mat3x2" { return GT_MAT3X2; } -"mat3x3" { return GT_MAT3X3; } -"mat3x4" { return GT_MAT3X4; } -"mat4" { return GT_MAT4; } -"mat4x2" { return GT_MAT4X2; } -"mat4x3" { return GT_MAT4X3; } -"mat4x4" { return GT_MAT4X4; } - -"dvec2" { return GT_DVEC2; } -"dvec3" { return GT_DVEC3; } -"dvec4" { return GT_DVEC4; } -"dmat2" { return GT_DMAT2; } -"dmat2x2" { return GT_DMAT2X2; } -"dmat2x3" { return GT_DMAT2X3; } -"dmat2x4" { return GT_DMAT2X4; } -"dmat3" { return GT_DMAT3; } -"dmat3x2" { return GT_DMAT3X2; } -"dmat3x3" { return GT_DMAT3X3; } -"dmat3x4" { return GT_DMAT3X4; } -"dmat4" { return GT_DMAT4; } -"dmat4x2" { return GT_DMAT4X2; } -"dmat4x3" { return GT_DMAT4X3; } -"dmat4x4" { return GT_DMAT4X4; } - - /* - * GLSL constant values - */ - -"true" { yylval.ival = 1; return BOOLCONSTANT; } -"false" { yylval.ival = 0; return BOOLCONSTANT; } - -[xyzw]{1,4} { return FIELDSELECTION; } -[rgba]{1,4} { return FIELDSELECTION; } -[stpq]{1,4} { return FIELDSELECTION; } - - /* - * GLSL keywords that are also valid or reserved in HLSL - * and HLSL keywords that are also valid or reserved in GLSL. - */ - -"bool" { return GHT_BOOL; } -"break" { return GHT_BREAK; } -"case" { return GHT_CASE; } -"centroid" { return GHT_CENTROID; } -"const" { return GHT_CONST; } -"continue" { return GHT_CONTINUE; } -"default" { return GHT_DEFAULT; } -"discard" { return GHT_DISCARD; } -"do" { return GHT_DO; } -"double" { return GHT_DOUBLE; } -"else" { return GHT_ELSE; } -"float" { return GHT_FLOAT; } -"for" { return GHT_FOR; } -"if" { return GHT_IF; } -"in" { return GHT_IN; } -"inout" { return GHT_INOUT; } -"int" { return GHT_INT; } -"noperspective" { return GHT_NOPERSPECTIVE; } -"out" { return GHT_OUT; } -"return" { return GHT_RETURN; } -"sampler1d" { return GHT_SAMPLER1D; } -"sampler2d" { return GHT_SAMPLER2D; } -"sampler3d" { return GHT_SAMPLER3D; } -"samplercube" { return GHT_SAMPLERCUBE; } -"struct" { return GHT_STRUCT; } -"switch" { return GHT_SWITCH; } -"uint" { return GHT_UINT; } -"uniform" { return GHT_UNIFORM; } -"void" { return GHT_VOID; } -"while" { return GHT_WHILE; } - -(?i:bool) { return HGT_BOOL; } -(?i:break) { return HGT_BREAK; } -(?i:case) { return HGT_CASE; } -(?i:centroid) { return HGT_CENTROID; } -(?i:const) { return HGT_CONST; } -(?i:continue) { return HGT_CONTINUE; } -(?i:default) { return HGT_DEFAULT; } -(?i:discard) { return HGT_DISCARD; } -(?i:do) { return HGT_DO; } -(?i:double) { return HGT_DOUBLE; } -(?i:else) { return HGT_ELSE; } -(?i:float) { return HGT_FLOAT; } -(?i:for) { return HGT_FOR; } -(?i:if) { return HGT_IF; } -(?i:in) { return HGT_IN; } -(?i:inout) { return HGT_INOUT; } -(?i:int) { return HGT_INT; } -(?i:noperspective) { return HGT_NOPERSPECTIVE; } -(?i:out) { return HGT_OUT; } -(?i:return) { return HGT_RETURN; } -(?i:sampler1d) { return HGT_SAMPLER1D; } -(?i:sampler2d) { return HGT_SAMPLER2D; } -(?i:sampler3d) { return HGT_SAMPLER3D; } -(?i:samplercube) { return HGT_SAMPLERCUBE; } -(?i:struct) { return HGT_STRUCT; } -(?i:switch) { return HGT_SWITCH; } -(?i:uint) { return HGT_UINT; } -(?i:uniform) { return HGT_UNIFORM; } -(?i:void) { return HGT_VOID; } -(?i:while) { return HGT_WHILE; } - - /* - * HLSL keywords - * Gathered from http://msdn.microsoft.com/en-us/library/windows/desktop/bb509568%28v=vs.85%29.aspx - */ - -(?i:appendstructuredbuffer) { return HT_APPENDSTRUCTUREDBUFFER; } -(?i:asm) { return HT_ASM; } -(?i:asm_fragment) { return HT_ASM_FRAGMENT; } -(?i:blendstate) { return HT_BLENDSTATE; } -(?i:buffer) { return HT_BUFFER; } -(?i:byteaddressbuffer) { return HT_BYTEADDRESSBUFFER; } -(?i:cbuffer) { return HT_CBUFFER; } -(?i:column_major) { return HT_COLUMN_MAJOR; } -(?i:compile) { return HT_COMPILE; } -(?i:compile_fragment) { return HT_COMPILE_FRAGMENT; } -(?i:compileshader) { return HT_COMPILESHADER; } -(?i:computeshader) { return HT_COMPUTESHADER; } -(?i:consumestructuredbuffer) { return HT_CONSUMESTRUCTUREDBUFFER; } -(?i:depthstencilstate) { return HT_DEPTHSTENCILSTATE; } -(?i:depthstencilview) { return HT_DEPTHSTENCILVIEW; } -(?i:domainshader) { return HT_DOMAINSHADER; } -(?i:dword) { return HT_DWORD; } -(?i:extern) { return HT_EXTERN; } -(?i:false) { return HT_FALSE; } -(?i:fxgroup) { return HT_FXGROUP; } -(?i:geometryshader) { return HT_GEOMETRYSHADER; } -(?i:groupshared) { return HT_GROUPSHARED; } -(?i:half) { return HT_HALF; } -(?i:hullshader) { return HT_HULLSHADER; } -(?i:inline) { return HT_INLINE; } -(?i:inputpatch) { return HT_INPUTPATCH; } -(?i:interface) { return HT_INTERFACE; } -(?i:line) { return HT_LINE; } -(?i:lineadj) { return HT_LINEADJ; } -(?i:linear) { return HT_LINEAR; } -(?i:linestream) { return HT_LINESTREAM; } -(?i:matrix) { return HT_MATRIX; } -(?i:namespace) { return HT_NAMESPACE; } -(?i:nointerpolation) { return HT_NOINTERPOLATION; } -(?i:null) { return HT_NULL; } -(?i:outputpatch) { return HT_OUTPUTPATCH; } -(?i:packoffset) { return HT_PACKOFFSET; } -(?i:pass) { return HT_PASS; } -(?i:pixelfragment) { return HT_PIXELFRAGMENT; } -(?i:pixelshader) { return HT_PIXELSHADER; } -(?i:point) { return HT_POINT; } -(?i:pointstream) { return HT_POINTSTREAM; } -(?i:precise) { return HT_PRECISE; } -(?i:rasterizerstate) { return HT_RASTERIZERSTATE; } -(?i:rendertargetview) { return HT_RENDERTARGETVIEW; } -(?i:register) { return HT_REGISTER; } -(?i:row_major) { return HT_ROW_MAJOR; } -(?i:rwbuffer) { return HT_RWBUFFER; } -(?i:rwbyteaddressbuffer) { return HT_RWBYTEADDRESSBUFFER; } -(?i:rwstructuredbuffer) { return HT_RWSTRUCTUREDBUFFER; } -(?i:rwtexture1d) { return HT_RWTEXTURE1D; } -(?i:rwtexture1darray) { return HT_RWTEXTURE1DARRAY; } -(?i:rwtexture2d) { return HT_RWTEXTURE2D; } -(?i:rwtexture2darray) { return HT_RWTEXTURE2DARRAY; } -(?i:rwtexture3d) { return HT_RWTEXTURE3D; } -(?i:sampler) { return HT_SAMPLER; } -(?i:sampler_state) { return HT_SAMPLER_STATE; } -(?i:samplerstate) { return HT_SAMPLERSTATE; } -(?i:samplercomparisonstate) { return HT_SAMPLERCOMPARISONSTATE; } -(?i:shared) { return HT_SHARED; } -(?i:snorm) { return HT_SNORM; } -(?i:stateblock) { return HT_STATEBLOCK; } -(?i:stateblock_state) { return HT_STATEBLOCK_STATE; } -(?i:static) { return HT_STATIC; } -(?i:string) { return HT_STRING; } -(?i:structuredbuffer) { return HT_STRUCTUREDBUFFER; } -(?i:tbuffer) { return HT_TBUFFER; } -(?i:technique) { return HT_TECHNIQUE; } -(?i:technique10) { return HT_TECHNIQUE10; } -(?i:technique11xz) { return HT_TECHNIQUE11XZ; } -"texture" { return HT_TEXTURE; } -(?i:texture1d) { return HT_TEXTURE1D; } -(?i:texture1darray) { return HT_TEXTURE1DARRAY; } -(?i:texture2d) { return HT_TEXTURE2D; } -(?i:texture2darray) { return HT_TEXTURE2DARRAY; } -(?i:texture2dms) { return HT_TEXTURE2DMS; } -(?i:texture2dmsarray) { return HT_TEXTURE2DMSARRAY; } -(?i:texture3d) { return HT_TEXTURE3D; } -(?i:texturecube) { return HT_TEXTURECUBE; } -(?i:texturecubearray) { return HT_TEXTURECUBEARRAY; } -(?i:true) { return HT_TRUE; } -(?i:typedef) { return HT_TYPEDEF; } -(?i:triangle) { return HT_TRIANGLE; } -(?i:triangleadj) { return HT_TRIANGLEADJ; } -(?i:trianglestream) { return HT_TRIANGLESTREAM; } -(?i:unorm) { return HT_UNORM; } -(?i:vector) { return HT_VECTOR; } -(?i:vertexfragment) { return HT_VERTEXFRAGMENT; } -(?i:vertexshader) { return HT_VERTEXSHADER; } -(?i:volatile) { return HT_VOLATILE; } - - /* - * HLSL vector types - * TODO: this can probably be factored somehow - */ - -(?i:bool1) { return HT_BOOL1; } -(?i:bool1x1) { return HT_BOOL1x1; } -(?i:bool2x1) { return HT_BOOL2x1; } -(?i:bool3x1) { return HT_BOOL3x1; } -(?i:bool4x1) { return HT_BOOL4x1; } -(?i:bool2) { return HT_BOOL2; } -(?i:bool1x2) { return HT_BOOL1x2; } -(?i:bool2x2) { return HT_BOOL2x2; } -(?i:bool3x2) { return HT_BOOL3x2; } -(?i:bool4x2) { return HT_BOOL4x2; } -(?i:bool3) { return HT_BOOL3; } -(?i:bool1x3) { return HT_BOOL1x3; } -(?i:bool2x3) { return HT_BOOL2x3; } -(?i:bool3x3) { return HT_BOOL3x3; } -(?i:bool4x3) { return HT_BOOL4x3; } -(?i:bool4) { return HT_BOOL4; } -(?i:bool1x4) { return HT_BOOL1x4; } -(?i:bool2x4) { return HT_BOOL2x4; } -(?i:bool3x4) { return HT_BOOL3x4; } -(?i:bool4x4) { return HT_BOOL4x4; } - -(?i:float1) { return HT_FLOAT1; } -(?i:float1x1) { return HT_FLOAT1x1; } -(?i:float2x1) { return HT_FLOAT2x1; } -(?i:float3x1) { return HT_FLOAT3x1; } -(?i:float4x1) { return HT_FLOAT4x1; } -(?i:float2) { return HT_FLOAT2; } -(?i:float1x2) { return HT_FLOAT1x2; } -(?i:float2x2) { return HT_FLOAT2x2; } -(?i:float3x2) { return HT_FLOAT3x2; } -(?i:float4x2) { return HT_FLOAT4x2; } -(?i:float3) { return HT_FLOAT3; } -(?i:float1x3) { return HT_FLOAT1x3; } -(?i:float2x3) { return HT_FLOAT2x3; } -(?i:float3x3) { return HT_FLOAT3x3; } -(?i:float4x3) { return HT_FLOAT4x3; } -(?i:float4) { return HT_FLOAT4; } -(?i:float1x4) { return HT_FLOAT1x4; } -(?i:float2x4) { return HT_FLOAT2x4; } -(?i:float3x4) { return HT_FLOAT3x4; } -(?i:float4x4) { return HT_FLOAT4x4; } - -(?i:double1) { return HT_DOUBLE1; } -(?i:double1x1) { return HT_DOUBLE1x1; } -(?i:double2x1) { return HT_DOUBLE2x1; } -(?i:double3x1) { return HT_DOUBLE3x1; } -(?i:double4x1) { return HT_DOUBLE4x1; } -(?i:double2) { return HT_DOUBLE2; } -(?i:double1x2) { return HT_DOUBLE1x2; } -(?i:double2x2) { return HT_DOUBLE2x2; } -(?i:double3x2) { return HT_DOUBLE3x2; } -(?i:double4x2) { return HT_DOUBLE4x2; } -(?i:double3) { return HT_DOUBLE3; } -(?i:double1x3) { return HT_DOUBLE1x3; } -(?i:double2x3) { return HT_DOUBLE2x3; } -(?i:double3x3) { return HT_DOUBLE3x3; } -(?i:double4x3) { return HT_DOUBLE4x3; } -(?i:double4) { return HT_DOUBLE4; } -(?i:double1x4) { return HT_DOUBLE1x4; } -(?i:double2x4) { return HT_DOUBLE2x4; } -(?i:double3x4) { return HT_DOUBLE3x4; } -(?i:double4x4) { return HT_DOUBLE4x4; } - -(?i:dword1) { return HT_DWORD1; } -(?i:dword1x1) { return HT_DWORD1x1; } -(?i:dword2x1) { return HT_DWORD2x1; } -(?i:dword3x1) { return HT_DWORD3x1; } -(?i:dword4x1) { return HT_DWORD4x1; } -(?i:dword2) { return HT_DWORD2; } -(?i:dword1x2) { return HT_DWORD1x2; } -(?i:dword2x2) { return HT_DWORD2x2; } -(?i:dword3x2) { return HT_DWORD3x2; } -(?i:dword4x2) { return HT_DWORD4x2; } -(?i:dword3) { return HT_DWORD3; } -(?i:dword1x3) { return HT_DWORD1x3; } -(?i:dword2x3) { return HT_DWORD2x3; } -(?i:dword3x3) { return HT_DWORD3x3; } -(?i:dword4x3) { return HT_DWORD4x3; } -(?i:dword4) { return HT_DWORD4; } -(?i:dword1x4) { return HT_DWORD1x4; } -(?i:dword2x4) { return HT_DWORD2x4; } -(?i:dword3x4) { return HT_DWORD3x4; } -(?i:dword4x4) { return HT_DWORD4x4; } - -(?i:int1) { return HT_INT1; } -(?i:int1x1) { return HT_INT1x1; } -(?i:int2x1) { return HT_INT2x1; } -(?i:int3x1) { return HT_INT3x1; } -(?i:int4x1) { return HT_INT4x1; } -(?i:int2) { return HT_INT2; } -(?i:int1x2) { return HT_INT1x2; } -(?i:int2x2) { return HT_INT2x2; } -(?i:int3x2) { return HT_INT3x2; } -(?i:int4x2) { return HT_INT4x2; } -(?i:int3) { return HT_INT3; } -(?i:int1x3) { return HT_INT1x3; } -(?i:int2x3) { return HT_INT2x3; } -(?i:int3x3) { return HT_INT3x3; } -(?i:int4x3) { return HT_INT4x3; } -(?i:int4) { return HT_INT4; } -(?i:int1x4) { return HT_INT1x4; } -(?i:int2x4) { return HT_INT2x4; } -(?i:int3x4) { return HT_INT3x4; } -(?i:int4x4) { return HT_INT4x4; } - -(?i:uint1) { return HT_UINT1; } -(?i:uint1x1) { return HT_UINT1x1; } -(?i:uint2x1) { return HT_UINT2x1; } -(?i:uint3x1) { return HT_UINT3x1; } -(?i:uint4x1) { return HT_UINT4x1; } -(?i:uint2) { return HT_UINT2; } -(?i:uint1x2) { return HT_UINT1x2; } -(?i:uint2x2) { return HT_UINT2x2; } -(?i:uint3x2) { return HT_UINT3x2; } -(?i:uint4x2) { return HT_UINT4x2; } -(?i:uint3) { return HT_UINT3; } -(?i:uint1x3) { return HT_UINT1x3; } -(?i:uint2x3) { return HT_UINT2x3; } -(?i:uint3x3) { return HT_UINT3x3; } -(?i:uint4x3) { return HT_UINT4x3; } -(?i:uint4) { return HT_UINT4; } -(?i:uint1x4) { return HT_UINT1x4; } -(?i:uint2x4) { return HT_UINT2x4; } -(?i:uint3x4) { return HT_UINT3x4; } -(?i:uint4x4) { return HT_UINT4x4; } - - /* - * HLSL preprocessor directives - * Gathered from http://msdn.microsoft.com/en-us/library/windows/desktop/bb943993%28v=vs.85%29.aspx - */ - -"#"[ \t]*"define" { return PREPROCESSOR_DEFINE; } -"#"[ \t]*"elif" { return PREPROCESSOR_ELIF; } -"#"[ \t]*"else" { return PREPROCESSOR_ELSE; } -"#"[ \t]*"endif" { return PREPROCESSOR_ENDIF; } -"#"[ \t]*"error" { return PREPROCESSOR_ERROR; } -"#"[ \t]*"if" { return PREPROCESSOR_IF; } -"#"[ \t]*"ifdef" { return PREPROCESSOR_IFDEF; } -"#"[ \t]*"ifndef" { return PREPROCESSOR_IFNDEF; } -"#"[ \t]*"include" { return PREPROCESSOR_INCLUDE; } -"#"[ \t]*"line" { return PREPROCESSOR_LINE; } -"#"[ \t]*"pragma" { return PREPROCESSOR_PRAGMA; } -"#"[ \t]*"undef" { return PREPROCESSOR_UNDEF; } - - /* - * GLSL preprocessor directives - */ - -"#"[ \t]*"version".* { /* ignore for now */ } - - /* - * LolFx preprocessor directives - */ - -"#"[ \t]*"region GLSL" { BEGIN(GLSL); } -"#"[ \t]*"region HLSL" { BEGIN(HLSL); } -"#"[ \t]*"pragma"[ \t]*"lolfx".* { /* ignore for now */ } - - /* - * HLSL reserved keywords - * Gathered from http://msdn.microsoft.com/en-us/library/windows/desktop/bb509569%28v=vs.85%29.aspx - */ - -(?i:auto) { return HT_AUTO; } -(?i:catch) { return HT_CATCH; } -(?i:char) { return HT_CHAR; } -(?i:class) { return HT_CLASS; } -(?i:const_cast) { return HT_CONST_CAST; } -(?i:delete) { return HT_DELETE; } -(?i:dynamic_cast) { return HT_DYNAMIC_CAST; } -(?i:enum) { return HT_ENUM; } -(?i:explicit) { return HT_EXPLICIT; } -(?i:friend) { return HT_FRIEND; } -(?i:goto) { return HT_GOTO; } -(?i:long) { return HT_LONG; } -(?i:mutable) { return HT_MUTABLE; } -(?i:new) { return HT_NEW; } -(?i:operator) { return HT_OPERATOR; } -(?i:private) { return HT_PRIVATE; } -(?i:protected) { return HT_PROTECTED; } -(?i:public) { return HT_PUBLIC; } -(?i:reinterpret_cast) { return HT_REINTERPRET_CAST; } -(?i:short) { return HT_SHORT; } -(?i:signed) { return HT_SIGNED; } -(?i:sizeof) { return HT_SIZEOF; } -(?i:static_cast) { return HT_STATIC_CAST; } -(?i:template) { return HT_TEMPLATE; } -(?i:this) { return HT_THIS; } -(?i:throw) { return HT_THROW; } -(?i:try) { return HT_TRY; } -(?i:typename) { return HT_TYPENAME; } -(?i:union) { return HT_UNION; } -(?i:unsigned) { return HT_UNSIGNED; } -(?i:using) { return HT_USING; } -(?i:virtual) { return HT_VIRTUAL; } - - /* - * Various tokens - */ - -"++" { return T_INC; } -"--" { return T_DEC; } -"<=" { return T_LE; } -">=" { return T_GE; } -"==" { return T_EQ; } -"!=" { return T_NE; } -"<<" { return T_LEFT; } -">>" { return T_RIGHT; } -"&&" { return T_AND; } -"||" { return T_OR; } -"^^" { return T_XOR; } - -"*=" { return T_MULEQ; } -"/=" { return T_DIVEQ; } -"%=" { return T_MODEQ; } -"+=" { return T_ADDEQ; } -"-=" { return T_SUBEQ; } -"<<=" { return T_LEFTEQ; } -">>=" { return T_RIGHTEQ; } -"&=" { return T_ANDEQ; } -"^=" { return T_XOREQ; } -"|=" { return T_OREQ; } - -(0|[1-9][0-9]*)\.[0-9]+ { yylval.fval = atof(yytext); return FLOATCONSTANT; } -(0|[1-9][0-9]*)[uU] { yylval.uval = atoi(yytext); return UINTCONSTANT; } -(0|[1-9][0-9]*) { yylval.ival = atoi(yytext); return INTCONSTANT; } - -[a-zA-Z][a-zA-Z0-9_]* { - /* Copy token for now */ - yylval.sval = strdup(yytext); - return IDENTIFIER; -} -[ \t\n]+ { /* ignore whitespace */ } -. { return *yytext; } - - /* - * Ignore C comments - */ - -"/*" { comment_caller = GLSL; BEGIN(C_COMMENT); } -"/*" { comment_caller = HLSL; BEGIN(C_COMMENT); } -"/*" { comment_caller = INITIAL; BEGIN(C_COMMENT); } -"*/" { BEGIN(comment_caller); } -[^*]* { } -. { } - - /* - * Ignore C++ comments - */ - -"//" { comment_caller = GLSL; BEGIN(CPP_COMMENT); } -"//" { comment_caller = HLSL; BEGIN(CPP_COMMENT); } -"//" { comment_caller = INITIAL; BEGIN(CPP_COMMENT); } -\n { BEGIN(comment_caller); } -.* { } - -%% - diff --git a/test/sandbox/lex/test.lolfx b/test/sandbox/lex/test.lolfx deleted file mode 100644 index 9ef471c8..00000000 --- a/test/sandbox/lex/test.lolfx +++ /dev/null @@ -1,103 +0,0 @@ -/* - * LolFx Test Material - */ - -// Can have lots of different techniques in a single lolfx file, -// especially if they share common shader code. -technique Foo -{ - // Multiple passes, with alpha on/off, with various blending methods, - // with depth test disabled... - pass p0 - { - texture[0] = null; - texture[1] = null; - texture[2] = null; - - cullmode = none; // ccw - lighting = false; - zenable = true; // false - alphablendenable = true; // false - srcblend = src_alpha; // one - destblend = inv_src_alpha; - - colorop[0] = select_arg1; - colorarg1[0] = diffuse; - - alphaop[0] = select_arg1; - alphaarg1[0] = diffuse; - - colorop[1] = disable; - - alphaop[1] = disable; - - // Ye old way - vertexshader = blah; - geometryshader = blah; - pixelshader = blah; - - // Ogre crap - - // The D3D11 way, but we must make it work with GLSL too - //SetBlendState(AdditiveBlending, float4(0.0f, 0.0f, 0.0f, 0.0f), 0xFFFFFFFF); - //SetDepthStencilState(DisableDepth, 0); - //SetRasterizerState() - - //SetVertexShader - //SetDomainShader - //SetHullShader - //SetGeometryShader - //SetPixelShader - //SetComputeShader /* WTF? */ - - //SetRenderTargets(RTV0, DSV); - //SetRenderTargets(RTV0, RTV1, DSV); - //... - //SetRenderTargets(RTV0, RTV1, RTV2, RTV3, RTV4, RTV5, RTV6, RTV7, DSV); - } - - pass p1 - { - // Autres vertex/pixel shaders avec éventuellement des - // dépendances sur le résultat des passes précédentes - vertexshader = something_else; - } -} - -/* Defines GLSL shader "Prout" */ - -#region GLSL.Prout - -#version 120 - -/* Valid with my GLSL compiler */ -#pragma lolfx semantic(in_Vertex, POSITION) -#pragma lolfx semantic(in_Normal, NORMAL) -#pragma lolfx semantic(in_Color, COLOR) -attribute vec3 in_Vertex; -attribute vec3 in_Normal; -attribute vec4 in_Color; - -void main(void) -{ - /* ... */ -} - -/* Defines GLSL shader "Zob" */ - -#region GLSL.Zob - -void main(void) -{ - shit(); fuck(); fuck(); shit(); -} - -/* Defines HLSL shader "Prout" */ - -#region HLSL.Prout - -void main(void) -{ - /* Blah */ -} -