/* A Bison parser, made by GNU Bison 2.3. */ /* Skeleton implementation for Bison LALR(1) parsers in C++ Copyright (C) 2002, 2003, 2004, 2005, 2006 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 2, 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, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ /* 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 SPARQLNSlex #include "SPARQLParser.hh" /* User implementation prologue. */ #line 4228 "SPARQLParser.yy" #include "SPARQLScanner.hh" #line 4452 "SPARQLParser.yy" #include #include "SPARQLScanner.hh" /* this "connects" the bison parser in the driver to the flex scanner class * object. it defines the yylex() function call to pull the next token from the * current lexer object of the driver context. */ #undef yylex #define yylex driver.lexer->lex /* Line 317 of lalr1.cc. */ #line 58 "SPARQLParser.cc" #ifndef YY_ # if 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 /* Suppress unused-variable warnings by "using" E. */ #define YYUSE(e) ((void) (e)) /* A pseudo ostream that takes yydebug_ into account. */ # define YYCDEBUG \ for (bool yydebugcond_ = yydebug_; yydebugcond_; yydebugcond_ = false) \ (*yycdebug_) /* Enable debugging if requested. */ #if YYDEBUG # 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 YY_SYMBOL_PRINT(Title, Type, Value, Location) # define YY_REDUCE_PRINT(Rule) # define YY_STACK_PRINT() #endif /* !YYDEBUG */ #define YYACCEPT goto yyacceptlab #define YYABORT goto yyabortlab #define YYERROR goto yyerrorlab namespace SPARQLNS { #if YYERROR_VERBOSE /* 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 SPARQLParser::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; } #endif /// Build a parser object. SPARQLParser::SPARQLParser (class Driver& driver_yyarg) : yydebug_ (false), yycdebug_ (&std::cerr), driver (driver_yyarg) { } SPARQLParser::~SPARQLParser () { } #if YYDEBUG /*--------------------------------. | Print this symbol on YYOUTPUT. | `--------------------------------*/ inline void SPARQLParser::yy_symbol_value_print_ (int yytype, const semantic_type* yyvaluep, const location_type* yylocationp) { YYUSE (yylocationp); YYUSE (yyvaluep); switch (yytype) { default: break; } } void SPARQLParser::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 /* ! YYDEBUG */ void SPARQLParser::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 SPARQLParser::yypop_ (unsigned int n) { yystate_stack_.pop (n); yysemantic_stack_.pop (n); yylocation_stack_.pop (n); } std::ostream& SPARQLParser::debug_stream () const { return *yycdebug_; } void SPARQLParser::set_debug_stream (std::ostream& o) { yycdebug_ = &o; } SPARQLParser::debug_level_type SPARQLParser::debug_level () const { return yydebug_; } void SPARQLParser::set_debug_level (debug_level_type l) { yydebug_ = l; } int SPARQLParser::parse () { /// Look-ahead and look-ahead 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 look-ahead. semantic_type yylval; /// Location of the look-ahead. location_type yylloc; /// The locations where the error started and ended. location yyerror_range[2]; /// $$. semantic_type yyval; /// @$. location_type yyloc; int yyresult; YYCDEBUG << "Starting parse" << std::endl; /* User initialization code. */ #line 31 "SPARQLParser.yy" { // initialize the initial location object yylloc.begin.filename = yylloc.end.filename = &driver.streamname; } /* Line 547 of yacc.c. */ #line 295 "SPARQLParser.cc" /* 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; goto yybackup; /* Backup. */ yybackup: /* Try to take a decision without look-ahead. */ yyn = yypact_[yystate]; if (yyn == yypact_ninf_) goto yydefault; /* Read a look-ahead 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 (yyn == 0 || yyn == yytable_ninf_) goto yyerrlab; yyn = -yyn; goto yyreduce; } /* Accept? */ if (yyn == yyfinal_) goto yyacceptlab; /* Shift the look-ahead token. */ YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); /* Discard the token being shifted unless it is eof. */ if (yychar != yyeof_) 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 2: #line 4467 "SPARQLParser.yy" { StupidGlobal = new Query((yysemantic_stack_[(2) - (1)].p_Prologue), (yysemantic_stack_[(2) - (2)].p__O_QSelectQuery_E_Or_QConstructQuery_E_Or_QDescribeQuery_E_Or_QAskQuery_E_C)); ;} break; case 3: #line 4473 "SPARQLParser.yy" { (yyval.p__O_QSelectQuery_E_Or_QConstructQuery_E_Or_QDescribeQuery_E_Or_QAskQuery_E_C) = new _O_QSelectQuery_E_Or_QConstructQuery_E_Or_QDescribeQuery_E_Or_QAskQuery_E_C_rule0((yysemantic_stack_[(1) - (1)].p_SelectQuery)); ;} break; case 4: #line 4477 "SPARQLParser.yy" { (yyval.p__O_QSelectQuery_E_Or_QConstructQuery_E_Or_QDescribeQuery_E_Or_QAskQuery_E_C) = new _O_QSelectQuery_E_Or_QConstructQuery_E_Or_QDescribeQuery_E_Or_QAskQuery_E_C_rule1((yysemantic_stack_[(1) - (1)].p_ConstructQuery)); ;} break; case 5: #line 4481 "SPARQLParser.yy" { (yyval.p__O_QSelectQuery_E_Or_QConstructQuery_E_Or_QDescribeQuery_E_Or_QAskQuery_E_C) = new _O_QSelectQuery_E_Or_QConstructQuery_E_Or_QDescribeQuery_E_Or_QAskQuery_E_C_rule2((yysemantic_stack_[(1) - (1)].p_DescribeQuery)); ;} break; case 6: #line 4485 "SPARQLParser.yy" { (yyval.p__O_QSelectQuery_E_Or_QConstructQuery_E_Or_QDescribeQuery_E_Or_QAskQuery_E_C) = new _O_QSelectQuery_E_Or_QConstructQuery_E_Or_QDescribeQuery_E_Or_QAskQuery_E_C_rule3((yysemantic_stack_[(1) - (1)].p_AskQuery)); ;} break; case 7: #line 4491 "SPARQLParser.yy" { (yyval.p_Prologue) = new Prologue((yysemantic_stack_[(2) - (1)].p__QBaseDecl_E_Opt), (yysemantic_stack_[(2) - (2)].p__QPrefixDecl_E_Star)); ;} break; case 8: #line 4497 "SPARQLParser.yy" { (yyval.p__QBaseDecl_E_Opt) = new _QBaseDecl_E_Opt_rule0(); ;} break; case 9: #line 4501 "SPARQLParser.yy" { (yyval.p__QBaseDecl_E_Opt) = new _QBaseDecl_E_Opt_rule1((yysemantic_stack_[(1) - (1)].p_BaseDecl)); ;} break; case 10: #line 4507 "SPARQLParser.yy" { (yyval.p__QPrefixDecl_E_Star) = new _QPrefixDecl_E_Star_rule0(); ;} break; case 11: #line 4511 "SPARQLParser.yy" { (yyval.p__QPrefixDecl_E_Star) = new _QPrefixDecl_E_Star_rule1((yysemantic_stack_[(2) - (1)].p__QPrefixDecl_E_Star), (yysemantic_stack_[(2) - (2)].p_PrefixDecl)); ;} break; case 12: #line 4517 "SPARQLParser.yy" { (yyval.p_BaseDecl) = new BaseDecl((yysemantic_stack_[(2) - (1)].p_IT_BASE), (yysemantic_stack_[(2) - (2)].p_IRI_REF)); ;} break; case 13: #line 4523 "SPARQLParser.yy" { (yyval.p_PrefixDecl) = new PrefixDecl((yysemantic_stack_[(3) - (1)].p_IT_PREFIX), (yysemantic_stack_[(3) - (2)].p_PNAME_NS), (yysemantic_stack_[(3) - (3)].p_IRI_REF)); ;} break; case 14: #line 4529 "SPARQLParser.yy" { (yyval.p_SelectQuery) = new SelectQuery((yysemantic_stack_[(6) - (1)].p_IT_SELECT), (yysemantic_stack_[(6) - (2)].p__Q_O_QIT_DISTINCT_E_Or_QIT_REDUCED_E_C_E_Opt), (yysemantic_stack_[(6) - (3)].p__O_QVar_E_Plus_Or_QGT_TIMES_E_C), (yysemantic_stack_[(6) - (4)].p__QDatasetClause_E_Star), (yysemantic_stack_[(6) - (5)].p_WhereClause), (yysemantic_stack_[(6) - (6)].p_SolutionModifier)); ;} break; case 15: #line 4535 "SPARQLParser.yy" { (yyval.p__O_QIT_DISTINCT_E_Or_QIT_REDUCED_E_C) = new _O_QIT_DISTINCT_E_Or_QIT_REDUCED_E_C_rule0((yysemantic_stack_[(1) - (1)].p_IT_DISTINCT)); ;} break; case 16: #line 4539 "SPARQLParser.yy" { (yyval.p__O_QIT_DISTINCT_E_Or_QIT_REDUCED_E_C) = new _O_QIT_DISTINCT_E_Or_QIT_REDUCED_E_C_rule1((yysemantic_stack_[(1) - (1)].p_IT_REDUCED)); ;} break; case 17: #line 4545 "SPARQLParser.yy" { (yyval.p__Q_O_QIT_DISTINCT_E_Or_QIT_REDUCED_E_C_E_Opt) = new _Q_O_QIT_DISTINCT_E_Or_QIT_REDUCED_E_C_E_Opt_rule0(); ;} break; case 18: #line 4549 "SPARQLParser.yy" { (yyval.p__Q_O_QIT_DISTINCT_E_Or_QIT_REDUCED_E_C_E_Opt) = new _Q_O_QIT_DISTINCT_E_Or_QIT_REDUCED_E_C_E_Opt_rule1((yysemantic_stack_[(1) - (1)].p__O_QIT_DISTINCT_E_Or_QIT_REDUCED_E_C)); ;} break; case 19: #line 4555 "SPARQLParser.yy" { (yyval.p__QVar_E_Plus) = new _QVar_E_Plus_rule0((yysemantic_stack_[(1) - (1)].p_Var)); ;} break; case 20: #line 4559 "SPARQLParser.yy" { (yyval.p__QVar_E_Plus) = new _QVar_E_Plus_rule1((yysemantic_stack_[(2) - (1)].p__QVar_E_Plus), (yysemantic_stack_[(2) - (2)].p_Var)); ;} break; case 21: #line 4565 "SPARQLParser.yy" { (yyval.p__O_QVar_E_Plus_Or_QGT_TIMES_E_C) = new _O_QVar_E_Plus_Or_QGT_TIMES_E_C_rule0((yysemantic_stack_[(1) - (1)].p__QVar_E_Plus)); ;} break; case 22: #line 4569 "SPARQLParser.yy" { (yyval.p__O_QVar_E_Plus_Or_QGT_TIMES_E_C) = new _O_QVar_E_Plus_Or_QGT_TIMES_E_C_rule1((yysemantic_stack_[(1) - (1)].p_GT_TIMES)); ;} break; case 23: #line 4575 "SPARQLParser.yy" { (yyval.p__QDatasetClause_E_Star) = new _QDatasetClause_E_Star_rule0(); ;} break; case 24: #line 4579 "SPARQLParser.yy" { (yyval.p__QDatasetClause_E_Star) = new _QDatasetClause_E_Star_rule1((yysemantic_stack_[(2) - (1)].p__QDatasetClause_E_Star), (yysemantic_stack_[(2) - (2)].p_DatasetClause)); ;} break; case 25: #line 4585 "SPARQLParser.yy" { (yyval.p_ConstructQuery) = new ConstructQuery((yysemantic_stack_[(5) - (1)].p_IT_CONSTRUCT), (yysemantic_stack_[(5) - (2)].p_ConstructTemplate), (yysemantic_stack_[(5) - (3)].p__QDatasetClause_E_Star), (yysemantic_stack_[(5) - (4)].p_WhereClause), (yysemantic_stack_[(5) - (5)].p_SolutionModifier)); ;} break; case 26: #line 4591 "SPARQLParser.yy" { (yyval.p_DescribeQuery) = new DescribeQuery((yysemantic_stack_[(5) - (1)].p_IT_DESCRIBE), (yysemantic_stack_[(5) - (2)].p__O_QVarOrIRIref_E_Plus_Or_QGT_TIMES_E_C), (yysemantic_stack_[(5) - (3)].p__QDatasetClause_E_Star), (yysemantic_stack_[(5) - (4)].p__QWhereClause_E_Opt), (yysemantic_stack_[(5) - (5)].p_SolutionModifier)); ;} break; case 27: #line 4597 "SPARQLParser.yy" { (yyval.p__QVarOrIRIref_E_Plus) = new _QVarOrIRIref_E_Plus_rule0((yysemantic_stack_[(1) - (1)].p_VarOrIRIref)); ;} break; case 28: #line 4601 "SPARQLParser.yy" { (yyval.p__QVarOrIRIref_E_Plus) = new _QVarOrIRIref_E_Plus_rule1((yysemantic_stack_[(2) - (1)].p__QVarOrIRIref_E_Plus), (yysemantic_stack_[(2) - (2)].p_VarOrIRIref)); ;} break; case 29: #line 4607 "SPARQLParser.yy" { (yyval.p__O_QVarOrIRIref_E_Plus_Or_QGT_TIMES_E_C) = new _O_QVarOrIRIref_E_Plus_Or_QGT_TIMES_E_C_rule0((yysemantic_stack_[(1) - (1)].p__QVarOrIRIref_E_Plus)); ;} break; case 30: #line 4611 "SPARQLParser.yy" { (yyval.p__O_QVarOrIRIref_E_Plus_Or_QGT_TIMES_E_C) = new _O_QVarOrIRIref_E_Plus_Or_QGT_TIMES_E_C_rule1((yysemantic_stack_[(1) - (1)].p_GT_TIMES)); ;} break; case 31: #line 4617 "SPARQLParser.yy" { (yyval.p__QWhereClause_E_Opt) = new _QWhereClause_E_Opt_rule0(); ;} break; case 32: #line 4621 "SPARQLParser.yy" { (yyval.p__QWhereClause_E_Opt) = new _QWhereClause_E_Opt_rule1((yysemantic_stack_[(1) - (1)].p_WhereClause)); ;} break; case 33: #line 4627 "SPARQLParser.yy" { (yyval.p_AskQuery) = new AskQuery((yysemantic_stack_[(3) - (1)].p_IT_ASK), (yysemantic_stack_[(3) - (2)].p__QDatasetClause_E_Star), (yysemantic_stack_[(3) - (3)].p_WhereClause)); ;} break; case 34: #line 4633 "SPARQLParser.yy" { (yyval.p_DatasetClause) = new DatasetClause((yysemantic_stack_[(2) - (1)].p_IT_FROM), (yysemantic_stack_[(2) - (2)].p__O_QDefaultGraphClause_E_Or_QNamedGraphClause_E_C)); ;} break; case 35: #line 4639 "SPARQLParser.yy" { (yyval.p__O_QDefaultGraphClause_E_Or_QNamedGraphClause_E_C) = new _O_QDefaultGraphClause_E_Or_QNamedGraphClause_E_C_rule0((yysemantic_stack_[(1) - (1)].p_DefaultGraphClause)); ;} break; case 36: #line 4643 "SPARQLParser.yy" { (yyval.p__O_QDefaultGraphClause_E_Or_QNamedGraphClause_E_C) = new _O_QDefaultGraphClause_E_Or_QNamedGraphClause_E_C_rule1((yysemantic_stack_[(1) - (1)].p_NamedGraphClause)); ;} break; case 37: #line 4649 "SPARQLParser.yy" { (yyval.p_DefaultGraphClause) = new DefaultGraphClause((yysemantic_stack_[(1) - (1)].p_SourceSelector)); ;} break; case 38: #line 4655 "SPARQLParser.yy" { (yyval.p_NamedGraphClause) = new NamedGraphClause((yysemantic_stack_[(2) - (1)].p_IT_NAMED), (yysemantic_stack_[(2) - (2)].p_SourceSelector)); ;} break; case 39: #line 4661 "SPARQLParser.yy" { (yyval.p_SourceSelector) = new SourceSelector((yysemantic_stack_[(1) - (1)].p_IRIref)); ;} break; case 40: #line 4667 "SPARQLParser.yy" { (yyval.p_WhereClause) = new WhereClause((yysemantic_stack_[(2) - (1)].p__QIT_WHERE_E_Opt), (yysemantic_stack_[(2) - (2)].p_GroupGraphPattern)); ;} break; case 41: #line 4673 "SPARQLParser.yy" { (yyval.p__QIT_WHERE_E_Opt) = new _QIT_WHERE_E_Opt_rule0(); ;} break; case 42: #line 4677 "SPARQLParser.yy" { (yyval.p__QIT_WHERE_E_Opt) = new _QIT_WHERE_E_Opt_rule1((yysemantic_stack_[(1) - (1)].p_IT_WHERE)); ;} break; case 43: #line 4683 "SPARQLParser.yy" { (yyval.p_SolutionModifier) = new SolutionModifier((yysemantic_stack_[(2) - (1)].p__QOrderClause_E_Opt), (yysemantic_stack_[(2) - (2)].p__QLimitOffsetClauses_E_Opt)); ;} break; case 44: #line 4689 "SPARQLParser.yy" { (yyval.p__QOrderClause_E_Opt) = new _QOrderClause_E_Opt_rule0(); ;} break; case 45: #line 4693 "SPARQLParser.yy" { (yyval.p__QOrderClause_E_Opt) = new _QOrderClause_E_Opt_rule1((yysemantic_stack_[(1) - (1)].p_OrderClause)); ;} break; case 46: #line 4699 "SPARQLParser.yy" { (yyval.p__QLimitOffsetClauses_E_Opt) = new _QLimitOffsetClauses_E_Opt_rule0(); ;} break; case 47: #line 4703 "SPARQLParser.yy" { (yyval.p__QLimitOffsetClauses_E_Opt) = new _QLimitOffsetClauses_E_Opt_rule1((yysemantic_stack_[(1) - (1)].p_LimitOffsetClauses)); ;} break; case 48: #line 4709 "SPARQLParser.yy" { (yyval.p_LimitOffsetClauses) = new LimitOffsetClauses((yysemantic_stack_[(1) - (1)].p__O_QLimitClause_E_S_QOffsetClause_E_Opt_Or_QOffsetClause_E_S_QLimitClause_E_Opt_C)); ;} break; case 49: #line 4715 "SPARQLParser.yy" { (yyval.p__QOffsetClause_E_Opt) = new _QOffsetClause_E_Opt_rule0(); ;} break; case 50: #line 4719 "SPARQLParser.yy" { (yyval.p__QOffsetClause_E_Opt) = new _QOffsetClause_E_Opt_rule1((yysemantic_stack_[(1) - (1)].p_OffsetClause)); ;} break; case 51: #line 4725 "SPARQLParser.yy" { (yyval.p__QLimitClause_E_Opt) = new _QLimitClause_E_Opt_rule0(); ;} break; case 52: #line 4729 "SPARQLParser.yy" { (yyval.p__QLimitClause_E_Opt) = new _QLimitClause_E_Opt_rule1((yysemantic_stack_[(1) - (1)].p_LimitClause)); ;} break; case 53: #line 4735 "SPARQLParser.yy" { (yyval.p__O_QLimitClause_E_S_QOffsetClause_E_Opt_Or_QOffsetClause_E_S_QLimitClause_E_Opt_C) = new _O_QLimitClause_E_S_QOffsetClause_E_Opt_Or_QOffsetClause_E_S_QLimitClause_E_Opt_C_rule0((yysemantic_stack_[(2) - (1)].p_LimitClause), (yysemantic_stack_[(2) - (2)].p__QOffsetClause_E_Opt)); ;} break; case 54: #line 4739 "SPARQLParser.yy" { (yyval.p__O_QLimitClause_E_S_QOffsetClause_E_Opt_Or_QOffsetClause_E_S_QLimitClause_E_Opt_C) = new _O_QLimitClause_E_S_QOffsetClause_E_Opt_Or_QOffsetClause_E_S_QLimitClause_E_Opt_C_rule1((yysemantic_stack_[(2) - (1)].p_OffsetClause), (yysemantic_stack_[(2) - (2)].p__QLimitClause_E_Opt)); ;} break; case 55: #line 4745 "SPARQLParser.yy" { (yyval.p_OrderClause) = new OrderClause((yysemantic_stack_[(3) - (1)].p_IT_ORDER), (yysemantic_stack_[(3) - (2)].p_IT_BY), (yysemantic_stack_[(3) - (3)].p__QOrderCondition_E_Plus)); ;} break; case 56: #line 4751 "SPARQLParser.yy" { (yyval.p__QOrderCondition_E_Plus) = new _QOrderCondition_E_Plus_rule0((yysemantic_stack_[(1) - (1)].p_OrderCondition)); ;} break; case 57: #line 4755 "SPARQLParser.yy" { (yyval.p__QOrderCondition_E_Plus) = new _QOrderCondition_E_Plus_rule1((yysemantic_stack_[(2) - (1)].p__QOrderCondition_E_Plus), (yysemantic_stack_[(2) - (2)].p_OrderCondition)); ;} break; case 58: #line 4761 "SPARQLParser.yy" { (yyval.p_OrderCondition) = new OrderCondition_rule0((yysemantic_stack_[(1) - (1)].p__O_QIT_ASC_E_Or_QIT_DESC_E_S_QBrackettedExpression_E_C)); ;} break; case 59: #line 4765 "SPARQLParser.yy" { (yyval.p_OrderCondition) = new OrderCondition_rule1((yysemantic_stack_[(1) - (1)].p__O_QConstraint_E_Or_QVar_E_C)); ;} break; case 60: #line 4771 "SPARQLParser.yy" { (yyval.p__O_QIT_ASC_E_Or_QIT_DESC_E_C) = new _O_QIT_ASC_E_Or_QIT_DESC_E_C_rule0((yysemantic_stack_[(1) - (1)].p_IT_ASC)); ;} break; case 61: #line 4775 "SPARQLParser.yy" { (yyval.p__O_QIT_ASC_E_Or_QIT_DESC_E_C) = new _O_QIT_ASC_E_Or_QIT_DESC_E_C_rule1((yysemantic_stack_[(1) - (1)].p_IT_DESC)); ;} break; case 62: #line 4781 "SPARQLParser.yy" { (yyval.p__O_QIT_ASC_E_Or_QIT_DESC_E_S_QBrackettedExpression_E_C) = new _O_QIT_ASC_E_Or_QIT_DESC_E_S_QBrackettedExpression_E_C((yysemantic_stack_[(2) - (1)].p__O_QIT_ASC_E_Or_QIT_DESC_E_C), (yysemantic_stack_[(2) - (2)].p_BrackettedExpression)); ;} break; case 63: #line 4787 "SPARQLParser.yy" { (yyval.p__O_QConstraint_E_Or_QVar_E_C) = new _O_QConstraint_E_Or_QVar_E_C_rule0((yysemantic_stack_[(1) - (1)].p_Constraint)); ;} break; case 64: #line 4791 "SPARQLParser.yy" { (yyval.p__O_QConstraint_E_Or_QVar_E_C) = new _O_QConstraint_E_Or_QVar_E_C_rule1((yysemantic_stack_[(1) - (1)].p_Var)); ;} break; case 65: #line 4797 "SPARQLParser.yy" { (yyval.p_LimitClause) = new LimitClause((yysemantic_stack_[(2) - (1)].p_IT_LIMIT), (yysemantic_stack_[(2) - (2)].p_INTEGER)); ;} break; case 66: #line 4803 "SPARQLParser.yy" { (yyval.p_OffsetClause) = new OffsetClause((yysemantic_stack_[(2) - (1)].p_IT_OFFSET), (yysemantic_stack_[(2) - (2)].p_INTEGER)); ;} break; case 67: #line 4809 "SPARQLParser.yy" { (yyval.p_GroupGraphPattern) = new GroupGraphPattern((yysemantic_stack_[(4) - (1)].p_GT_LCURLEY), (yysemantic_stack_[(4) - (2)].p__QTriplesBlock_E_Opt), (yysemantic_stack_[(4) - (3)].p__Q_O_QGraphPatternNotTriples_E_Or_QFilter_E_S_QGT_DOT_E_Opt_S_QTriplesBlock_E_Opt_C_E_Star), (yysemantic_stack_[(4) - (4)].p_GT_RCURLEY)); ;} break; case 68: #line 4815 "SPARQLParser.yy" { (yyval.p__QTriplesBlock_E_Opt) = new _QTriplesBlock_E_Opt_rule0(); ;} break; case 69: #line 4819 "SPARQLParser.yy" { (yyval.p__QTriplesBlock_E_Opt) = new _QTriplesBlock_E_Opt_rule1((yysemantic_stack_[(1) - (1)].p_TriplesBlock)); ;} break; case 70: #line 4825 "SPARQLParser.yy" { (yyval.p__O_QGraphPatternNotTriples_E_Or_QFilter_E_C) = new _O_QGraphPatternNotTriples_E_Or_QFilter_E_C_rule0((yysemantic_stack_[(1) - (1)].p_GraphPatternNotTriples)); ;} break; case 71: #line 4829 "SPARQLParser.yy" { (yyval.p__O_QGraphPatternNotTriples_E_Or_QFilter_E_C) = new _O_QGraphPatternNotTriples_E_Or_QFilter_E_C_rule1((yysemantic_stack_[(1) - (1)].p_Filter)); ;} break; case 72: #line 4835 "SPARQLParser.yy" { (yyval.p__QGT_DOT_E_Opt) = new _QGT_DOT_E_Opt_rule0(); ;} break; case 73: #line 4839 "SPARQLParser.yy" { (yyval.p__QGT_DOT_E_Opt) = new _QGT_DOT_E_Opt_rule1((yysemantic_stack_[(1) - (1)].p_GT_DOT)); ;} break; case 74: #line 4845 "SPARQLParser.yy" { (yyval.p__O_QGraphPatternNotTriples_E_Or_QFilter_E_S_QGT_DOT_E_Opt_S_QTriplesBlock_E_Opt_C) = new _O_QGraphPatternNotTriples_E_Or_QFilter_E_S_QGT_DOT_E_Opt_S_QTriplesBlock_E_Opt_C((yysemantic_stack_[(3) - (1)].p__O_QGraphPatternNotTriples_E_Or_QFilter_E_C), (yysemantic_stack_[(3) - (2)].p__QGT_DOT_E_Opt), (yysemantic_stack_[(3) - (3)].p__QTriplesBlock_E_Opt)); ;} break; case 75: #line 4851 "SPARQLParser.yy" { (yyval.p__Q_O_QGraphPatternNotTriples_E_Or_QFilter_E_S_QGT_DOT_E_Opt_S_QTriplesBlock_E_Opt_C_E_Star) = new _Q_O_QGraphPatternNotTriples_E_Or_QFilter_E_S_QGT_DOT_E_Opt_S_QTriplesBlock_E_Opt_C_E_Star_rule0(); ;} break; case 76: #line 4855 "SPARQLParser.yy" { (yyval.p__Q_O_QGraphPatternNotTriples_E_Or_QFilter_E_S_QGT_DOT_E_Opt_S_QTriplesBlock_E_Opt_C_E_Star) = new _Q_O_QGraphPatternNotTriples_E_Or_QFilter_E_S_QGT_DOT_E_Opt_S_QTriplesBlock_E_Opt_C_E_Star_rule1((yysemantic_stack_[(2) - (1)].p__Q_O_QGraphPatternNotTriples_E_Or_QFilter_E_S_QGT_DOT_E_Opt_S_QTriplesBlock_E_Opt_C_E_Star), (yysemantic_stack_[(2) - (2)].p__O_QGraphPatternNotTriples_E_Or_QFilter_E_S_QGT_DOT_E_Opt_S_QTriplesBlock_E_Opt_C)); ;} break; case 77: #line 4861 "SPARQLParser.yy" { (yyval.p_TriplesBlock) = new TriplesBlock((yysemantic_stack_[(2) - (1)].p_TriplesSameSubject), (yysemantic_stack_[(2) - (2)].p__Q_O_QGT_DOT_E_S_QTriplesBlock_E_Opt_C_E_Opt)); ;} break; case 78: #line 4867 "SPARQLParser.yy" { (yyval.p__O_QGT_DOT_E_S_QTriplesBlock_E_Opt_C) = new _O_QGT_DOT_E_S_QTriplesBlock_E_Opt_C((yysemantic_stack_[(2) - (1)].p_GT_DOT), (yysemantic_stack_[(2) - (2)].p__QTriplesBlock_E_Opt)); ;} break; case 79: #line 4873 "SPARQLParser.yy" { (yyval.p__Q_O_QGT_DOT_E_S_QTriplesBlock_E_Opt_C_E_Opt) = new _Q_O_QGT_DOT_E_S_QTriplesBlock_E_Opt_C_E_Opt_rule0(); ;} break; case 80: #line 4877 "SPARQLParser.yy" { (yyval.p__Q_O_QGT_DOT_E_S_QTriplesBlock_E_Opt_C_E_Opt) = new _Q_O_QGT_DOT_E_S_QTriplesBlock_E_Opt_C_E_Opt_rule1((yysemantic_stack_[(1) - (1)].p__O_QGT_DOT_E_S_QTriplesBlock_E_Opt_C)); ;} break; case 81: #line 4883 "SPARQLParser.yy" { (yyval.p_GraphPatternNotTriples) = new GraphPatternNotTriples_rule0((yysemantic_stack_[(1) - (1)].p_OptionalGraphPattern)); ;} break; case 82: #line 4887 "SPARQLParser.yy" { (yyval.p_GraphPatternNotTriples) = new GraphPatternNotTriples_rule1((yysemantic_stack_[(1) - (1)].p_GroupOrUnionGraphPattern)); ;} break; case 83: #line 4891 "SPARQLParser.yy" { (yyval.p_GraphPatternNotTriples) = new GraphPatternNotTriples_rule2((yysemantic_stack_[(1) - (1)].p_GraphGraphPattern)); ;} break; case 84: #line 4897 "SPARQLParser.yy" { (yyval.p_OptionalGraphPattern) = new OptionalGraphPattern((yysemantic_stack_[(2) - (1)].p_IT_OPTIONAL), (yysemantic_stack_[(2) - (2)].p_GroupGraphPattern)); ;} break; case 85: #line 4903 "SPARQLParser.yy" { (yyval.p_GraphGraphPattern) = new GraphGraphPattern((yysemantic_stack_[(3) - (1)].p_IT_GRAPH), (yysemantic_stack_[(3) - (2)].p_VarOrIRIref), (yysemantic_stack_[(3) - (3)].p_GroupGraphPattern)); ;} break; case 86: #line 4909 "SPARQLParser.yy" { (yyval.p_GroupOrUnionGraphPattern) = new GroupOrUnionGraphPattern((yysemantic_stack_[(2) - (1)].p_GroupGraphPattern), (yysemantic_stack_[(2) - (2)].p__Q_O_QIT_UNION_E_S_QGroupGraphPattern_E_C_E_Star)); ;} break; case 87: #line 4915 "SPARQLParser.yy" { (yyval.p__O_QIT_UNION_E_S_QGroupGraphPattern_E_C) = new _O_QIT_UNION_E_S_QGroupGraphPattern_E_C((yysemantic_stack_[(2) - (1)].p_IT_UNION), (yysemantic_stack_[(2) - (2)].p_GroupGraphPattern)); ;} break; case 88: #line 4921 "SPARQLParser.yy" { (yyval.p__Q_O_QIT_UNION_E_S_QGroupGraphPattern_E_C_E_Star) = new _Q_O_QIT_UNION_E_S_QGroupGraphPattern_E_C_E_Star_rule0(); ;} break; case 89: #line 4925 "SPARQLParser.yy" { (yyval.p__Q_O_QIT_UNION_E_S_QGroupGraphPattern_E_C_E_Star) = new _Q_O_QIT_UNION_E_S_QGroupGraphPattern_E_C_E_Star_rule1((yysemantic_stack_[(2) - (1)].p__Q_O_QIT_UNION_E_S_QGroupGraphPattern_E_C_E_Star), (yysemantic_stack_[(2) - (2)].p__O_QIT_UNION_E_S_QGroupGraphPattern_E_C)); ;} break; case 90: #line 4931 "SPARQLParser.yy" { (yyval.p_Filter) = new Filter((yysemantic_stack_[(2) - (1)].p_IT_FILTER), (yysemantic_stack_[(2) - (2)].p_Constraint)); ;} break; case 91: #line 4937 "SPARQLParser.yy" { (yyval.p_Constraint) = new Constraint_rule0((yysemantic_stack_[(1) - (1)].p_BrackettedExpression)); ;} break; case 92: #line 4941 "SPARQLParser.yy" { (yyval.p_Constraint) = new Constraint_rule1((yysemantic_stack_[(1) - (1)].p_BuiltInCall)); ;} break; case 93: #line 4945 "SPARQLParser.yy" { (yyval.p_Constraint) = new Constraint_rule2((yysemantic_stack_[(1) - (1)].p_FunctionCall)); ;} break; case 94: #line 4951 "SPARQLParser.yy" { (yyval.p_FunctionCall) = new FunctionCall((yysemantic_stack_[(2) - (1)].p_IRIref), (yysemantic_stack_[(2) - (2)].p_ArgList)); ;} break; case 95: #line 4957 "SPARQLParser.yy" { (yyval.p_ArgList) = new ArgList((yysemantic_stack_[(1) - (1)].p__O_QNIL_E_Or_QGT_LPAREN_E_S_QExpression_E_S_QGT_COMMA_E_S_QExpression_E_Star_S_QGT_RPAREN_E_C)); ;} break; case 96: #line 4963 "SPARQLParser.yy" { (yyval.p__O_QGT_COMMA_E_S_QExpression_E_C) = new _O_QGT_COMMA_E_S_QExpression_E_C((yysemantic_stack_[(2) - (1)].p_GT_COMMA), (yysemantic_stack_[(2) - (2)].p_Expression)); ;} break; case 97: #line 4969 "SPARQLParser.yy" { (yyval.p__Q_O_QGT_COMMA_E_S_QExpression_E_C_E_Star) = new _Q_O_QGT_COMMA_E_S_QExpression_E_C_E_Star_rule0(); ;} break; case 98: #line 4973 "SPARQLParser.yy" { (yyval.p__Q_O_QGT_COMMA_E_S_QExpression_E_C_E_Star) = new _Q_O_QGT_COMMA_E_S_QExpression_E_C_E_Star_rule1((yysemantic_stack_[(2) - (1)].p__Q_O_QGT_COMMA_E_S_QExpression_E_C_E_Star), (yysemantic_stack_[(2) - (2)].p__O_QGT_COMMA_E_S_QExpression_E_C)); ;} break; case 99: #line 4979 "SPARQLParser.yy" { (yyval.p__O_QNIL_E_Or_QGT_LPAREN_E_S_QExpression_E_S_QGT_COMMA_E_S_QExpression_E_Star_S_QGT_RPAREN_E_C) = new _O_QNIL_E_Or_QGT_LPAREN_E_S_QExpression_E_S_QGT_COMMA_E_S_QExpression_E_Star_S_QGT_RPAREN_E_C_rule0((yysemantic_stack_[(1) - (1)].p_NIL)); ;} break; case 100: #line 4983 "SPARQLParser.yy" { (yyval.p__O_QNIL_E_Or_QGT_LPAREN_E_S_QExpression_E_S_QGT_COMMA_E_S_QExpression_E_Star_S_QGT_RPAREN_E_C) = new _O_QNIL_E_Or_QGT_LPAREN_E_S_QExpression_E_S_QGT_COMMA_E_S_QExpression_E_Star_S_QGT_RPAREN_E_C_rule1((yysemantic_stack_[(4) - (1)].p_GT_LPAREN), (yysemantic_stack_[(4) - (2)].p_Expression), (yysemantic_stack_[(4) - (3)].p__Q_O_QGT_COMMA_E_S_QExpression_E_C_E_Star), (yysemantic_stack_[(4) - (4)].p_GT_RPAREN)); ;} break; case 101: #line 4989 "SPARQLParser.yy" { (yyval.p_ConstructTemplate) = new ConstructTemplate((yysemantic_stack_[(3) - (1)].p_GT_LCURLEY), (yysemantic_stack_[(3) - (2)].p__QConstructTriples_E_Opt), (yysemantic_stack_[(3) - (3)].p_GT_RCURLEY)); ;} break; case 102: #line 4995 "SPARQLParser.yy" { (yyval.p__QConstructTriples_E_Opt) = new _QConstructTriples_E_Opt_rule0(); ;} break; case 103: #line 4999 "SPARQLParser.yy" { (yyval.p__QConstructTriples_E_Opt) = new _QConstructTriples_E_Opt_rule1((yysemantic_stack_[(1) - (1)].p_ConstructTriples)); ;} break; case 104: #line 5005 "SPARQLParser.yy" { (yyval.p_ConstructTriples) = new ConstructTriples((yysemantic_stack_[(2) - (1)].p_TriplesSameSubject), (yysemantic_stack_[(2) - (2)].p__Q_O_QGT_DOT_E_S_QConstructTriples_E_Opt_C_E_Opt)); ;} break; case 105: #line 5011 "SPARQLParser.yy" { (yyval.p__O_QGT_DOT_E_S_QConstructTriples_E_Opt_C) = new _O_QGT_DOT_E_S_QConstructTriples_E_Opt_C((yysemantic_stack_[(2) - (1)].p_GT_DOT), (yysemantic_stack_[(2) - (2)].p__QConstructTriples_E_Opt)); ;} break; case 106: #line 5017 "SPARQLParser.yy" { (yyval.p__Q_O_QGT_DOT_E_S_QConstructTriples_E_Opt_C_E_Opt) = new _Q_O_QGT_DOT_E_S_QConstructTriples_E_Opt_C_E_Opt_rule0(); ;} break; case 107: #line 5021 "SPARQLParser.yy" { (yyval.p__Q_O_QGT_DOT_E_S_QConstructTriples_E_Opt_C_E_Opt) = new _Q_O_QGT_DOT_E_S_QConstructTriples_E_Opt_C_E_Opt_rule1((yysemantic_stack_[(1) - (1)].p__O_QGT_DOT_E_S_QConstructTriples_E_Opt_C)); ;} break; case 108: #line 5027 "SPARQLParser.yy" { (yyval.p_TriplesSameSubject) = new TriplesSameSubject_rule0((yysemantic_stack_[(2) - (1)].p_VarOrTerm), (yysemantic_stack_[(2) - (2)].p_PropertyListNotEmpty)); ;} break; case 109: #line 5031 "SPARQLParser.yy" { (yyval.p_TriplesSameSubject) = new TriplesSameSubject_rule1((yysemantic_stack_[(2) - (1)].p_TriplesNode), (yysemantic_stack_[(2) - (2)].p_PropertyList)); ;} break; case 110: #line 5037 "SPARQLParser.yy" { (yyval.p_PropertyListNotEmpty) = new PropertyListNotEmpty((yysemantic_stack_[(3) - (1)].p_Verb), (yysemantic_stack_[(3) - (2)].p_ObjectList), (yysemantic_stack_[(3) - (3)].p__Q_O_QGT_SEMI_E_S_QVerb_E_S_QObjectList_E_Opt_C_E_Star)); ;} break; case 111: #line 5043 "SPARQLParser.yy" { (yyval.p__O_QVerb_E_S_QObjectList_E_C) = new _O_QVerb_E_S_QObjectList_E_C((yysemantic_stack_[(2) - (1)].p_Verb), (yysemantic_stack_[(2) - (2)].p_ObjectList)); ;} break; case 112: #line 5049 "SPARQLParser.yy" { (yyval.p__Q_O_QVerb_E_S_QObjectList_E_C_E_Opt) = new _Q_O_QVerb_E_S_QObjectList_E_C_E_Opt_rule0(); ;} break; case 113: #line 5053 "SPARQLParser.yy" { (yyval.p__Q_O_QVerb_E_S_QObjectList_E_C_E_Opt) = new _Q_O_QVerb_E_S_QObjectList_E_C_E_Opt_rule1((yysemantic_stack_[(1) - (1)].p__O_QVerb_E_S_QObjectList_E_C)); ;} break; case 114: #line 5059 "SPARQLParser.yy" { (yyval.p__O_QGT_SEMI_E_S_QVerb_E_S_QObjectList_E_Opt_C) = new _O_QGT_SEMI_E_S_QVerb_E_S_QObjectList_E_Opt_C((yysemantic_stack_[(2) - (1)].p_GT_SEMI), (yysemantic_stack_[(2) - (2)].p__Q_O_QVerb_E_S_QObjectList_E_C_E_Opt)); ;} break; case 115: #line 5065 "SPARQLParser.yy" { (yyval.p__Q_O_QGT_SEMI_E_S_QVerb_E_S_QObjectList_E_Opt_C_E_Star) = new _Q_O_QGT_SEMI_E_S_QVerb_E_S_QObjectList_E_Opt_C_E_Star_rule0(); ;} break; case 116: #line 5069 "SPARQLParser.yy" { (yyval.p__Q_O_QGT_SEMI_E_S_QVerb_E_S_QObjectList_E_Opt_C_E_Star) = new _Q_O_QGT_SEMI_E_S_QVerb_E_S_QObjectList_E_Opt_C_E_Star_rule1((yysemantic_stack_[(2) - (1)].p__Q_O_QGT_SEMI_E_S_QVerb_E_S_QObjectList_E_Opt_C_E_Star), (yysemantic_stack_[(2) - (2)].p__O_QGT_SEMI_E_S_QVerb_E_S_QObjectList_E_Opt_C)); ;} break; case 117: #line 5075 "SPARQLParser.yy" { (yyval.p_PropertyList) = new PropertyList((yysemantic_stack_[(1) - (1)].p__QPropertyListNotEmpty_E_Opt)); ;} break; case 118: #line 5081 "SPARQLParser.yy" { (yyval.p__QPropertyListNotEmpty_E_Opt) = new _QPropertyListNotEmpty_E_Opt_rule0(); ;} break; case 119: #line 5085 "SPARQLParser.yy" { (yyval.p__QPropertyListNotEmpty_E_Opt) = new _QPropertyListNotEmpty_E_Opt_rule1((yysemantic_stack_[(1) - (1)].p_PropertyListNotEmpty)); ;} break; case 120: #line 5091 "SPARQLParser.yy" { (yyval.p_ObjectList) = new ObjectList((yysemantic_stack_[(2) - (1)].p_Object), (yysemantic_stack_[(2) - (2)].p__Q_O_QGT_COMMA_E_S_QObject_E_C_E_Star)); ;} break; case 121: #line 5097 "SPARQLParser.yy" { (yyval.p__O_QGT_COMMA_E_S_QObject_E_C) = new _O_QGT_COMMA_E_S_QObject_E_C((yysemantic_stack_[(2) - (1)].p_GT_COMMA), (yysemantic_stack_[(2) - (2)].p_Object)); ;} break; case 122: #line 5103 "SPARQLParser.yy" { (yyval.p__Q_O_QGT_COMMA_E_S_QObject_E_C_E_Star) = new _Q_O_QGT_COMMA_E_S_QObject_E_C_E_Star_rule0(); ;} break; case 123: #line 5107 "SPARQLParser.yy" { (yyval.p__Q_O_QGT_COMMA_E_S_QObject_E_C_E_Star) = new _Q_O_QGT_COMMA_E_S_QObject_E_C_E_Star_rule1((yysemantic_stack_[(2) - (1)].p__Q_O_QGT_COMMA_E_S_QObject_E_C_E_Star), (yysemantic_stack_[(2) - (2)].p__O_QGT_COMMA_E_S_QObject_E_C)); ;} break; case 124: #line 5113 "SPARQLParser.yy" { (yyval.p_Object) = new Object((yysemantic_stack_[(1) - (1)].p_GraphNode)); ;} break; case 125: #line 5119 "SPARQLParser.yy" { (yyval.p_Verb) = new Verb_rule0((yysemantic_stack_[(1) - (1)].p_VarOrIRIref)); ;} break; case 126: #line 5123 "SPARQLParser.yy" { (yyval.p_Verb) = new Verb_rule1((yysemantic_stack_[(1) - (1)].p_IT_a)); ;} break; case 127: #line 5129 "SPARQLParser.yy" { (yyval.p_TriplesNode) = new TriplesNode_rule0((yysemantic_stack_[(1) - (1)].p_Collection)); ;} break; case 128: #line 5133 "SPARQLParser.yy" { (yyval.p_TriplesNode) = new TriplesNode_rule1((yysemantic_stack_[(1) - (1)].p_BlankNodePropertyList)); ;} break; case 129: #line 5139 "SPARQLParser.yy" { (yyval.p_BlankNodePropertyList) = new BlankNodePropertyList((yysemantic_stack_[(3) - (1)].p_GT_LBRACKET), (yysemantic_stack_[(3) - (2)].p_PropertyListNotEmpty), (yysemantic_stack_[(3) - (3)].p_GT_RBRACKET)); ;} break; case 130: #line 5145 "SPARQLParser.yy" { (yyval.p_Collection) = new Collection((yysemantic_stack_[(3) - (1)].p_GT_LPAREN), (yysemantic_stack_[(3) - (2)].p__QGraphNode_E_Plus), (yysemantic_stack_[(3) - (3)].p_GT_RPAREN)); ;} break; case 131: #line 5151 "SPARQLParser.yy" { (yyval.p__QGraphNode_E_Plus) = new _QGraphNode_E_Plus_rule0((yysemantic_stack_[(1) - (1)].p_GraphNode)); ;} break; case 132: #line 5155 "SPARQLParser.yy" { (yyval.p__QGraphNode_E_Plus) = new _QGraphNode_E_Plus_rule1((yysemantic_stack_[(2) - (1)].p__QGraphNode_E_Plus), (yysemantic_stack_[(2) - (2)].p_GraphNode)); ;} break; case 133: #line 5161 "SPARQLParser.yy" { (yyval.p_GraphNode) = new GraphNode_rule0((yysemantic_stack_[(1) - (1)].p_VarOrTerm)); ;} break; case 134: #line 5165 "SPARQLParser.yy" { (yyval.p_GraphNode) = new GraphNode_rule1((yysemantic_stack_[(1) - (1)].p_TriplesNode)); ;} break; case 135: #line 5171 "SPARQLParser.yy" { (yyval.p_VarOrTerm) = new VarOrTerm_rule0((yysemantic_stack_[(1) - (1)].p_Var)); ;} break; case 136: #line 5175 "SPARQLParser.yy" { (yyval.p_VarOrTerm) = new VarOrTerm_rule1((yysemantic_stack_[(1) - (1)].p_GraphTerm)); ;} break; case 137: #line 5181 "SPARQLParser.yy" { (yyval.p_VarOrIRIref) = new VarOrIRIref_rule0((yysemantic_stack_[(1) - (1)].p_Var)); ;} break; case 138: #line 5185 "SPARQLParser.yy" { (yyval.p_VarOrIRIref) = new VarOrIRIref_rule1((yysemantic_stack_[(1) - (1)].p_IRIref)); ;} break; case 139: #line 5191 "SPARQLParser.yy" { (yyval.p_Var) = new Var_rule0((yysemantic_stack_[(1) - (1)].p_VAR1)); ;} break; case 140: #line 5195 "SPARQLParser.yy" { (yyval.p_Var) = new Var_rule1((yysemantic_stack_[(1) - (1)].p_VAR2)); ;} break; case 141: #line 5201 "SPARQLParser.yy" { (yyval.p_GraphTerm) = new GraphTerm_rule0((yysemantic_stack_[(1) - (1)].p_IRIref)); ;} break; case 142: #line 5205 "SPARQLParser.yy" { (yyval.p_GraphTerm) = new GraphTerm_rule1((yysemantic_stack_[(1) - (1)].p_RDFLiteral)); ;} break; case 143: #line 5209 "SPARQLParser.yy" { (yyval.p_GraphTerm) = new GraphTerm_rule2((yysemantic_stack_[(1) - (1)].p_NumericLiteral)); ;} break; case 144: #line 5213 "SPARQLParser.yy" { (yyval.p_GraphTerm) = new GraphTerm_rule3((yysemantic_stack_[(1) - (1)].p_BooleanLiteral)); ;} break; case 145: #line 5217 "SPARQLParser.yy" { (yyval.p_GraphTerm) = new GraphTerm_rule4((yysemantic_stack_[(1) - (1)].p_BlankNode)); ;} break; case 146: #line 5221 "SPARQLParser.yy" { (yyval.p_GraphTerm) = new GraphTerm_rule5((yysemantic_stack_[(1) - (1)].p_NIL)); ;} break; case 147: #line 5227 "SPARQLParser.yy" { (yyval.p_Expression) = new Expression((yysemantic_stack_[(1) - (1)].p_ConditionalOrExpression)); ;} break; case 148: #line 5233 "SPARQLParser.yy" { (yyval.p_ConditionalOrExpression) = new ConditionalOrExpression((yysemantic_stack_[(2) - (1)].p_ConditionalAndExpression), (yysemantic_stack_[(2) - (2)].p__Q_O_QGT_OR_E_S_QConditionalAndExpression_E_C_E_Star)); ;} break; case 149: #line 5239 "SPARQLParser.yy" { (yyval.p__O_QGT_OR_E_S_QConditionalAndExpression_E_C) = new _O_QGT_OR_E_S_QConditionalAndExpression_E_C((yysemantic_stack_[(2) - (1)].p_GT_OR), (yysemantic_stack_[(2) - (2)].p_ConditionalAndExpression)); ;} break; case 150: #line 5245 "SPARQLParser.yy" { (yyval.p__Q_O_QGT_OR_E_S_QConditionalAndExpression_E_C_E_Star) = new _Q_O_QGT_OR_E_S_QConditionalAndExpression_E_C_E_Star_rule0(); ;} break; case 151: #line 5249 "SPARQLParser.yy" { (yyval.p__Q_O_QGT_OR_E_S_QConditionalAndExpression_E_C_E_Star) = new _Q_O_QGT_OR_E_S_QConditionalAndExpression_E_C_E_Star_rule1((yysemantic_stack_[(2) - (1)].p__Q_O_QGT_OR_E_S_QConditionalAndExpression_E_C_E_Star), (yysemantic_stack_[(2) - (2)].p__O_QGT_OR_E_S_QConditionalAndExpression_E_C)); ;} break; case 152: #line 5255 "SPARQLParser.yy" { (yyval.p_ConditionalAndExpression) = new ConditionalAndExpression((yysemantic_stack_[(2) - (1)].p_ValueLogical), (yysemantic_stack_[(2) - (2)].p__Q_O_QGT_AND_E_S_QValueLogical_E_C_E_Star)); ;} break; case 153: #line 5261 "SPARQLParser.yy" { (yyval.p__O_QGT_AND_E_S_QValueLogical_E_C) = new _O_QGT_AND_E_S_QValueLogical_E_C((yysemantic_stack_[(2) - (1)].p_GT_AND), (yysemantic_stack_[(2) - (2)].p_ValueLogical)); ;} break; case 154: #line 5267 "SPARQLParser.yy" { (yyval.p__Q_O_QGT_AND_E_S_QValueLogical_E_C_E_Star) = new _Q_O_QGT_AND_E_S_QValueLogical_E_C_E_Star_rule0(); ;} break; case 155: #line 5271 "SPARQLParser.yy" { (yyval.p__Q_O_QGT_AND_E_S_QValueLogical_E_C_E_Star) = new _Q_O_QGT_AND_E_S_QValueLogical_E_C_E_Star_rule1((yysemantic_stack_[(2) - (1)].p__Q_O_QGT_AND_E_S_QValueLogical_E_C_E_Star), (yysemantic_stack_[(2) - (2)].p__O_QGT_AND_E_S_QValueLogical_E_C)); ;} break; case 156: #line 5277 "SPARQLParser.yy" { (yyval.p_ValueLogical) = new ValueLogical((yysemantic_stack_[(1) - (1)].p_RelationalExpression)); ;} break; case 157: #line 5283 "SPARQLParser.yy" { (yyval.p_RelationalExpression) = new RelationalExpression((yysemantic_stack_[(2) - (1)].p_NumericExpression), (yysemantic_stack_[(2) - (2)].p__Q_O_QGT_EQUAL_E_S_QNumericExpression_E_Or_QGT_NEQUAL_E_S_QNumericExpression_E_Or_QGT_LT_E_S_QNumericExpression_E_Or_QGT_GT_E_S_QNumericExpression_E_Or_QGT_LE_E_S_QNumericExpression_E_Or_QGT_GE_E_S_QNumericExpression_E_C_E_Opt)); ;} break; case 158: #line 5289 "SPARQLParser.yy" { (yyval.p__O_QGT_EQUAL_E_S_QNumericExpression_E_Or_QGT_NEQUAL_E_S_QNumericExpression_E_Or_QGT_LT_E_S_QNumericExpression_E_Or_QGT_GT_E_S_QNumericExpression_E_Or_QGT_LE_E_S_QNumericExpression_E_Or_QGT_GE_E_S_QNumericExpression_E_C) = new _O_QGT_EQUAL_E_S_QNumericExpression_E_Or_QGT_NEQUAL_E_S_QNumericExpression_E_Or_QGT_LT_E_S_QNumericExpression_E_Or_QGT_GT_E_S_QNumericExpression_E_Or_QGT_LE_E_S_QNumericExpression_E_Or_QGT_GE_E_S_QNumericExpression_E_C_rule0((yysemantic_stack_[(2) - (1)].p_GT_EQUAL), (yysemantic_stack_[(2) - (2)].p_NumericExpression)); ;} break; case 159: #line 5293 "SPARQLParser.yy" { (yyval.p__O_QGT_EQUAL_E_S_QNumericExpression_E_Or_QGT_NEQUAL_E_S_QNumericExpression_E_Or_QGT_LT_E_S_QNumericExpression_E_Or_QGT_GT_E_S_QNumericExpression_E_Or_QGT_LE_E_S_QNumericExpression_E_Or_QGT_GE_E_S_QNumericExpression_E_C) = new _O_QGT_EQUAL_E_S_QNumericExpression_E_Or_QGT_NEQUAL_E_S_QNumericExpression_E_Or_QGT_LT_E_S_QNumericExpression_E_Or_QGT_GT_E_S_QNumericExpression_E_Or_QGT_LE_E_S_QNumericExpression_E_Or_QGT_GE_E_S_QNumericExpression_E_C_rule1((yysemantic_stack_[(2) - (1)].p_GT_NEQUAL), (yysemantic_stack_[(2) - (2)].p_NumericExpression)); ;} break; case 160: #line 5297 "SPARQLParser.yy" { (yyval.p__O_QGT_EQUAL_E_S_QNumericExpression_E_Or_QGT_NEQUAL_E_S_QNumericExpression_E_Or_QGT_LT_E_S_QNumericExpression_E_Or_QGT_GT_E_S_QNumericExpression_E_Or_QGT_LE_E_S_QNumericExpression_E_Or_QGT_GE_E_S_QNumericExpression_E_C) = new _O_QGT_EQUAL_E_S_QNumericExpression_E_Or_QGT_NEQUAL_E_S_QNumericExpression_E_Or_QGT_LT_E_S_QNumericExpression_E_Or_QGT_GT_E_S_QNumericExpression_E_Or_QGT_LE_E_S_QNumericExpression_E_Or_QGT_GE_E_S_QNumericExpression_E_C_rule2((yysemantic_stack_[(2) - (1)].p_GT_LT), (yysemantic_stack_[(2) - (2)].p_NumericExpression)); ;} break; case 161: #line 5301 "SPARQLParser.yy" { (yyval.p__O_QGT_EQUAL_E_S_QNumericExpression_E_Or_QGT_NEQUAL_E_S_QNumericExpression_E_Or_QGT_LT_E_S_QNumericExpression_E_Or_QGT_GT_E_S_QNumericExpression_E_Or_QGT_LE_E_S_QNumericExpression_E_Or_QGT_GE_E_S_QNumericExpression_E_C) = new _O_QGT_EQUAL_E_S_QNumericExpression_E_Or_QGT_NEQUAL_E_S_QNumericExpression_E_Or_QGT_LT_E_S_QNumericExpression_E_Or_QGT_GT_E_S_QNumericExpression_E_Or_QGT_LE_E_S_QNumericExpression_E_Or_QGT_GE_E_S_QNumericExpression_E_C_rule3((yysemantic_stack_[(2) - (1)].p_GT_GT), (yysemantic_stack_[(2) - (2)].p_NumericExpression)); ;} break; case 162: #line 5305 "SPARQLParser.yy" { (yyval.p__O_QGT_EQUAL_E_S_QNumericExpression_E_Or_QGT_NEQUAL_E_S_QNumericExpression_E_Or_QGT_LT_E_S_QNumericExpression_E_Or_QGT_GT_E_S_QNumericExpression_E_Or_QGT_LE_E_S_QNumericExpression_E_Or_QGT_GE_E_S_QNumericExpression_E_C) = new _O_QGT_EQUAL_E_S_QNumericExpression_E_Or_QGT_NEQUAL_E_S_QNumericExpression_E_Or_QGT_LT_E_S_QNumericExpression_E_Or_QGT_GT_E_S_QNumericExpression_E_Or_QGT_LE_E_S_QNumericExpression_E_Or_QGT_GE_E_S_QNumericExpression_E_C_rule4((yysemantic_stack_[(2) - (1)].p_GT_LE), (yysemantic_stack_[(2) - (2)].p_NumericExpression)); ;} break; case 163: #line 5309 "SPARQLParser.yy" { (yyval.p__O_QGT_EQUAL_E_S_QNumericExpression_E_Or_QGT_NEQUAL_E_S_QNumericExpression_E_Or_QGT_LT_E_S_QNumericExpression_E_Or_QGT_GT_E_S_QNumericExpression_E_Or_QGT_LE_E_S_QNumericExpression_E_Or_QGT_GE_E_S_QNumericExpression_E_C) = new _O_QGT_EQUAL_E_S_QNumericExpression_E_Or_QGT_NEQUAL_E_S_QNumericExpression_E_Or_QGT_LT_E_S_QNumericExpression_E_Or_QGT_GT_E_S_QNumericExpression_E_Or_QGT_LE_E_S_QNumericExpression_E_Or_QGT_GE_E_S_QNumericExpression_E_C_rule5((yysemantic_stack_[(2) - (1)].p_GT_GE), (yysemantic_stack_[(2) - (2)].p_NumericExpression)); ;} break; case 164: #line 5315 "SPARQLParser.yy" { (yyval.p__Q_O_QGT_EQUAL_E_S_QNumericExpression_E_Or_QGT_NEQUAL_E_S_QNumericExpression_E_Or_QGT_LT_E_S_QNumericExpression_E_Or_QGT_GT_E_S_QNumericExpression_E_Or_QGT_LE_E_S_QNumericExpression_E_Or_QGT_GE_E_S_QNumericExpression_E_C_E_Opt) = new _Q_O_QGT_EQUAL_E_S_QNumericExpression_E_Or_QGT_NEQUAL_E_S_QNumericExpression_E_Or_QGT_LT_E_S_QNumericExpression_E_Or_QGT_GT_E_S_QNumericExpression_E_Or_QGT_LE_E_S_QNumericExpression_E_Or_QGT_GE_E_S_QNumericExpression_E_C_E_Opt_rule0(); ;} break; case 165: #line 5319 "SPARQLParser.yy" { (yyval.p__Q_O_QGT_EQUAL_E_S_QNumericExpression_E_Or_QGT_NEQUAL_E_S_QNumericExpression_E_Or_QGT_LT_E_S_QNumericExpression_E_Or_QGT_GT_E_S_QNumericExpression_E_Or_QGT_LE_E_S_QNumericExpression_E_Or_QGT_GE_E_S_QNumericExpression_E_C_E_Opt) = new _Q_O_QGT_EQUAL_E_S_QNumericExpression_E_Or_QGT_NEQUAL_E_S_QNumericExpression_E_Or_QGT_LT_E_S_QNumericExpression_E_Or_QGT_GT_E_S_QNumericExpression_E_Or_QGT_LE_E_S_QNumericExpression_E_Or_QGT_GE_E_S_QNumericExpression_E_C_E_Opt_rule1((yysemantic_stack_[(1) - (1)].p__O_QGT_EQUAL_E_S_QNumericExpression_E_Or_QGT_NEQUAL_E_S_QNumericExpression_E_Or_QGT_LT_E_S_QNumericExpression_E_Or_QGT_GT_E_S_QNumericExpression_E_Or_QGT_LE_E_S_QNumericExpression_E_Or_QGT_GE_E_S_QNumericExpression_E_C)); ;} break; case 166: #line 5325 "SPARQLParser.yy" { (yyval.p_NumericExpression) = new NumericExpression((yysemantic_stack_[(1) - (1)].p_AdditiveExpression)); ;} break; case 167: #line 5331 "SPARQLParser.yy" { (yyval.p_AdditiveExpression) = new AdditiveExpression((yysemantic_stack_[(2) - (1)].p_MultiplicativeExpression), (yysemantic_stack_[(2) - (2)].p__Q_O_QGT_PLUS_E_S_QMultiplicativeExpression_E_Or_QGT_MINUS_E_S_QMultiplicativeExpression_E_Or_QNumericLiteralPositive_E_Or_QNumericLiteralNegative_E_C_E_Star)); ;} break; case 168: #line 5337 "SPARQLParser.yy" { (yyval.p__O_QGT_PLUS_E_S_QMultiplicativeExpression_E_Or_QGT_MINUS_E_S_QMultiplicativeExpression_E_Or_QNumericLiteralPositive_E_Or_QNumericLiteralNegative_E_C) = new _O_QGT_PLUS_E_S_QMultiplicativeExpression_E_Or_QGT_MINUS_E_S_QMultiplicativeExpression_E_Or_QNumericLiteralPositive_E_Or_QNumericLiteralNegative_E_C_rule0((yysemantic_stack_[(2) - (1)].p_GT_PLUS), (yysemantic_stack_[(2) - (2)].p_MultiplicativeExpression)); ;} break; case 169: #line 5341 "SPARQLParser.yy" { (yyval.p__O_QGT_PLUS_E_S_QMultiplicativeExpression_E_Or_QGT_MINUS_E_S_QMultiplicativeExpression_E_Or_QNumericLiteralPositive_E_Or_QNumericLiteralNegative_E_C) = new _O_QGT_PLUS_E_S_QMultiplicativeExpression_E_Or_QGT_MINUS_E_S_QMultiplicativeExpression_E_Or_QNumericLiteralPositive_E_Or_QNumericLiteralNegative_E_C_rule1((yysemantic_stack_[(2) - (1)].p_GT_MINUS), (yysemantic_stack_[(2) - (2)].p_MultiplicativeExpression)); ;} break; case 170: #line 5345 "SPARQLParser.yy" { (yyval.p__O_QGT_PLUS_E_S_QMultiplicativeExpression_E_Or_QGT_MINUS_E_S_QMultiplicativeExpression_E_Or_QNumericLiteralPositive_E_Or_QNumericLiteralNegative_E_C) = new _O_QGT_PLUS_E_S_QMultiplicativeExpression_E_Or_QGT_MINUS_E_S_QMultiplicativeExpression_E_Or_QNumericLiteralPositive_E_Or_QNumericLiteralNegative_E_C_rule2((yysemantic_stack_[(1) - (1)].p_NumericLiteralPositive)); ;} break; case 171: #line 5349 "SPARQLParser.yy" { (yyval.p__O_QGT_PLUS_E_S_QMultiplicativeExpression_E_Or_QGT_MINUS_E_S_QMultiplicativeExpression_E_Or_QNumericLiteralPositive_E_Or_QNumericLiteralNegative_E_C) = new _O_QGT_PLUS_E_S_QMultiplicativeExpression_E_Or_QGT_MINUS_E_S_QMultiplicativeExpression_E_Or_QNumericLiteralPositive_E_Or_QNumericLiteralNegative_E_C_rule3((yysemantic_stack_[(1) - (1)].p_NumericLiteralNegative)); ;} break; case 172: #line 5355 "SPARQLParser.yy" { (yyval.p__Q_O_QGT_PLUS_E_S_QMultiplicativeExpression_E_Or_QGT_MINUS_E_S_QMultiplicativeExpression_E_Or_QNumericLiteralPositive_E_Or_QNumericLiteralNegative_E_C_E_Star) = new _Q_O_QGT_PLUS_E_S_QMultiplicativeExpression_E_Or_QGT_MINUS_E_S_QMultiplicativeExpression_E_Or_QNumericLiteralPositive_E_Or_QNumericLiteralNegative_E_C_E_Star_rule0(); ;} break; case 173: #line 5359 "SPARQLParser.yy" { (yyval.p__Q_O_QGT_PLUS_E_S_QMultiplicativeExpression_E_Or_QGT_MINUS_E_S_QMultiplicativeExpression_E_Or_QNumericLiteralPositive_E_Or_QNumericLiteralNegative_E_C_E_Star) = new _Q_O_QGT_PLUS_E_S_QMultiplicativeExpression_E_Or_QGT_MINUS_E_S_QMultiplicativeExpression_E_Or_QNumericLiteralPositive_E_Or_QNumericLiteralNegative_E_C_E_Star_rule1((yysemantic_stack_[(2) - (1)].p__Q_O_QGT_PLUS_E_S_QMultiplicativeExpression_E_Or_QGT_MINUS_E_S_QMultiplicativeExpression_E_Or_QNumericLiteralPositive_E_Or_QNumericLiteralNegative_E_C_E_Star), (yysemantic_stack_[(2) - (2)].p__O_QGT_PLUS_E_S_QMultiplicativeExpression_E_Or_QGT_MINUS_E_S_QMultiplicativeExpression_E_Or_QNumericLiteralPositive_E_Or_QNumericLiteralNegative_E_C)); ;} break; case 174: #line 5365 "SPARQLParser.yy" { (yyval.p_MultiplicativeExpression) = new MultiplicativeExpression((yysemantic_stack_[(2) - (1)].p_UnaryExpression), (yysemantic_stack_[(2) - (2)].p__Q_O_QGT_TIMES_E_S_QUnaryExpression_E_Or_QGT_DIVIDE_E_S_QUnaryExpression_E_C_E_Star)); ;} break; case 175: #line 5371 "SPARQLParser.yy" { (yyval.p__O_QGT_TIMES_E_S_QUnaryExpression_E_Or_QGT_DIVIDE_E_S_QUnaryExpression_E_C) = new _O_QGT_TIMES_E_S_QUnaryExpression_E_Or_QGT_DIVIDE_E_S_QUnaryExpression_E_C_rule0((yysemantic_stack_[(2) - (1)].p_GT_TIMES), (yysemantic_stack_[(2) - (2)].p_UnaryExpression)); ;} break; case 176: #line 5375 "SPARQLParser.yy" { (yyval.p__O_QGT_TIMES_E_S_QUnaryExpression_E_Or_QGT_DIVIDE_E_S_QUnaryExpression_E_C) = new _O_QGT_TIMES_E_S_QUnaryExpression_E_Or_QGT_DIVIDE_E_S_QUnaryExpression_E_C_rule1((yysemantic_stack_[(2) - (1)].p_GT_DIVIDE), (yysemantic_stack_[(2) - (2)].p_UnaryExpression)); ;} break; case 177: #line 5381 "SPARQLParser.yy" { (yyval.p__Q_O_QGT_TIMES_E_S_QUnaryExpression_E_Or_QGT_DIVIDE_E_S_QUnaryExpression_E_C_E_Star) = new _Q_O_QGT_TIMES_E_S_QUnaryExpression_E_Or_QGT_DIVIDE_E_S_QUnaryExpression_E_C_E_Star_rule0(); ;} break; case 178: #line 5385 "SPARQLParser.yy" { (yyval.p__Q_O_QGT_TIMES_E_S_QUnaryExpression_E_Or_QGT_DIVIDE_E_S_QUnaryExpression_E_C_E_Star) = new _Q_O_QGT_TIMES_E_S_QUnaryExpression_E_Or_QGT_DIVIDE_E_S_QUnaryExpression_E_C_E_Star_rule1((yysemantic_stack_[(2) - (1)].p__Q_O_QGT_TIMES_E_S_QUnaryExpression_E_Or_QGT_DIVIDE_E_S_QUnaryExpression_E_C_E_Star), (yysemantic_stack_[(2) - (2)].p__O_QGT_TIMES_E_S_QUnaryExpression_E_Or_QGT_DIVIDE_E_S_QUnaryExpression_E_C)); ;} break; case 179: #line 5391 "SPARQLParser.yy" { (yyval.p_UnaryExpression) = new UnaryExpression_rule0((yysemantic_stack_[(2) - (1)].p_GT_NOT), (yysemantic_stack_[(2) - (2)].p_PrimaryExpression)); ;} break; case 180: #line 5395 "SPARQLParser.yy" { (yyval.p_UnaryExpression) = new UnaryExpression_rule1((yysemantic_stack_[(2) - (1)].p_GT_PLUS), (yysemantic_stack_[(2) - (2)].p_PrimaryExpression)); ;} break; case 181: #line 5399 "SPARQLParser.yy" { (yyval.p_UnaryExpression) = new UnaryExpression_rule2((yysemantic_stack_[(2) - (1)].p_GT_MINUS), (yysemantic_stack_[(2) - (2)].p_PrimaryExpression)); ;} break; case 182: #line 5403 "SPARQLParser.yy" { (yyval.p_UnaryExpression) = new UnaryExpression_rule3((yysemantic_stack_[(1) - (1)].p_PrimaryExpression)); ;} break; case 183: #line 5409 "SPARQLParser.yy" { (yyval.p_PrimaryExpression) = new PrimaryExpression_rule0((yysemantic_stack_[(1) - (1)].p_BrackettedExpression)); ;} break; case 184: #line 5413 "SPARQLParser.yy" { (yyval.p_PrimaryExpression) = new PrimaryExpression_rule1((yysemantic_stack_[(1) - (1)].p_BuiltInCall)); ;} break; case 185: #line 5417 "SPARQLParser.yy" { (yyval.p_PrimaryExpression) = new PrimaryExpression_rule2((yysemantic_stack_[(1) - (1)].p_IRIrefOrFunction)); ;} break; case 186: #line 5421 "SPARQLParser.yy" { (yyval.p_PrimaryExpression) = new PrimaryExpression_rule3((yysemantic_stack_[(1) - (1)].p_RDFLiteral)); ;} break; case 187: #line 5425 "SPARQLParser.yy" { (yyval.p_PrimaryExpression) = new PrimaryExpression_rule4((yysemantic_stack_[(1) - (1)].p_NumericLiteral)); ;} break; case 188: #line 5429 "SPARQLParser.yy" { (yyval.p_PrimaryExpression) = new PrimaryExpression_rule5((yysemantic_stack_[(1) - (1)].p_BooleanLiteral)); ;} break; case 189: #line 5433 "SPARQLParser.yy" { (yyval.p_PrimaryExpression) = new PrimaryExpression_rule6((yysemantic_stack_[(1) - (1)].p_Var)); ;} break; case 190: #line 5439 "SPARQLParser.yy" { (yyval.p_BrackettedExpression) = new BrackettedExpression((yysemantic_stack_[(3) - (1)].p_GT_LPAREN), (yysemantic_stack_[(3) - (2)].p_Expression), (yysemantic_stack_[(3) - (3)].p_GT_RPAREN)); ;} break; case 191: #line 5445 "SPARQLParser.yy" { (yyval.p_BuiltInCall) = new BuiltInCall_rule0((yysemantic_stack_[(4) - (1)].p_IT_STR), (yysemantic_stack_[(4) - (2)].p_GT_LPAREN), (yysemantic_stack_[(4) - (3)].p_Expression), (yysemantic_stack_[(4) - (4)].p_GT_RPAREN)); ;} break; case 192: #line 5449 "SPARQLParser.yy" { (yyval.p_BuiltInCall) = new BuiltInCall_rule1((yysemantic_stack_[(4) - (1)].p_IT_LANG), (yysemantic_stack_[(4) - (2)].p_GT_LPAREN), (yysemantic_stack_[(4) - (3)].p_Expression), (yysemantic_stack_[(4) - (4)].p_GT_RPAREN)); ;} break; case 193: #line 5453 "SPARQLParser.yy" { (yyval.p_BuiltInCall) = new BuiltInCall_rule2((yysemantic_stack_[(6) - (1)].p_IT_LANGMATCHES), (yysemantic_stack_[(6) - (2)].p_GT_LPAREN), (yysemantic_stack_[(6) - (3)].p_Expression), (yysemantic_stack_[(6) - (4)].p_GT_COMMA), (yysemantic_stack_[(6) - (5)].p_Expression), (yysemantic_stack_[(6) - (6)].p_GT_RPAREN)); ;} break; case 194: #line 5457 "SPARQLParser.yy" { (yyval.p_BuiltInCall) = new BuiltInCall_rule3((yysemantic_stack_[(4) - (1)].p_IT_DATATYPE), (yysemantic_stack_[(4) - (2)].p_GT_LPAREN), (yysemantic_stack_[(4) - (3)].p_Expression), (yysemantic_stack_[(4) - (4)].p_GT_RPAREN)); ;} break; case 195: #line 5461 "SPARQLParser.yy" { (yyval.p_BuiltInCall) = new BuiltInCall_rule4((yysemantic_stack_[(4) - (1)].p_IT_BOUND), (yysemantic_stack_[(4) - (2)].p_GT_LPAREN), (yysemantic_stack_[(4) - (3)].p_Var), (yysemantic_stack_[(4) - (4)].p_GT_RPAREN)); ;} break; case 196: #line 5465 "SPARQLParser.yy" { (yyval.p_BuiltInCall) = new BuiltInCall_rule5((yysemantic_stack_[(6) - (1)].p_IT_sameTerm), (yysemantic_stack_[(6) - (2)].p_GT_LPAREN), (yysemantic_stack_[(6) - (3)].p_Expression), (yysemantic_stack_[(6) - (4)].p_GT_COMMA), (yysemantic_stack_[(6) - (5)].p_Expression), (yysemantic_stack_[(6) - (6)].p_GT_RPAREN)); ;} break; case 197: #line 5469 "SPARQLParser.yy" { (yyval.p_BuiltInCall) = new BuiltInCall_rule6((yysemantic_stack_[(4) - (1)].p_IT_isIRI), (yysemantic_stack_[(4) - (2)].p_GT_LPAREN), (yysemantic_stack_[(4) - (3)].p_Expression), (yysemantic_stack_[(4) - (4)].p_GT_RPAREN)); ;} break; case 198: #line 5473 "SPARQLParser.yy" { (yyval.p_BuiltInCall) = new BuiltInCall_rule7((yysemantic_stack_[(4) - (1)].p_IT_isURI), (yysemantic_stack_[(4) - (2)].p_GT_LPAREN), (yysemantic_stack_[(4) - (3)].p_Expression), (yysemantic_stack_[(4) - (4)].p_GT_RPAREN)); ;} break; case 199: #line 5477 "SPARQLParser.yy" { (yyval.p_BuiltInCall) = new BuiltInCall_rule8((yysemantic_stack_[(4) - (1)].p_IT_isBLANK), (yysemantic_stack_[(4) - (2)].p_GT_LPAREN), (yysemantic_stack_[(4) - (3)].p_Expression), (yysemantic_stack_[(4) - (4)].p_GT_RPAREN)); ;} break; case 200: #line 5481 "SPARQLParser.yy" { (yyval.p_BuiltInCall) = new BuiltInCall_rule9((yysemantic_stack_[(4) - (1)].p_IT_isLITERAL), (yysemantic_stack_[(4) - (2)].p_GT_LPAREN), (yysemantic_stack_[(4) - (3)].p_Expression), (yysemantic_stack_[(4) - (4)].p_GT_RPAREN)); ;} break; case 201: #line 5485 "SPARQLParser.yy" { (yyval.p_BuiltInCall) = new BuiltInCall_rule10((yysemantic_stack_[(1) - (1)].p_RegexExpression)); ;} break; case 202: #line 5491 "SPARQLParser.yy" { (yyval.p_RegexExpression) = new RegexExpression((yysemantic_stack_[(7) - (1)].p_IT_REGEX), (yysemantic_stack_[(7) - (2)].p_GT_LPAREN), (yysemantic_stack_[(7) - (3)].p_Expression), (yysemantic_stack_[(7) - (4)].p_GT_COMMA), (yysemantic_stack_[(7) - (5)].p_Expression), (yysemantic_stack_[(7) - (6)].p__Q_O_QGT_COMMA_E_S_QExpression_E_C_E_Opt), (yysemantic_stack_[(7) - (7)].p_GT_RPAREN)); ;} break; case 203: #line 5497 "SPARQLParser.yy" { (yyval.p__Q_O_QGT_COMMA_E_S_QExpression_E_C_E_Opt) = new _Q_O_QGT_COMMA_E_S_QExpression_E_C_E_Opt_rule0(); ;} break; case 204: #line 5501 "SPARQLParser.yy" { (yyval.p__Q_O_QGT_COMMA_E_S_QExpression_E_C_E_Opt) = new _Q_O_QGT_COMMA_E_S_QExpression_E_C_E_Opt_rule1((yysemantic_stack_[(1) - (1)].p__O_QGT_COMMA_E_S_QExpression_E_C)); ;} break; case 205: #line 5507 "SPARQLParser.yy" { (yyval.p_IRIrefOrFunction) = new IRIrefOrFunction((yysemantic_stack_[(2) - (1)].p_IRIref), (yysemantic_stack_[(2) - (2)].p__QArgList_E_Opt)); ;} break; case 206: #line 5513 "SPARQLParser.yy" { (yyval.p__QArgList_E_Opt) = new _QArgList_E_Opt_rule0(); ;} break; case 207: #line 5517 "SPARQLParser.yy" { (yyval.p__QArgList_E_Opt) = new _QArgList_E_Opt_rule1((yysemantic_stack_[(1) - (1)].p_ArgList)); ;} break; case 208: #line 5523 "SPARQLParser.yy" { (yyval.p_RDFLiteral) = new RDFLiteral((yysemantic_stack_[(2) - (1)].p_String), (yysemantic_stack_[(2) - (2)].p__Q_O_QLANGTAG_E_Or_QGT_DTYPE_E_S_QIRIref_E_C_E_Opt)); ;} break; case 209: #line 5529 "SPARQLParser.yy" { (yyval.p__O_QGT_DTYPE_E_S_QIRIref_E_C) = new _O_QGT_DTYPE_E_S_QIRIref_E_C((yysemantic_stack_[(2) - (1)].p_GT_DTYPE), (yysemantic_stack_[(2) - (2)].p_IRIref)); ;} break; case 210: #line 5535 "SPARQLParser.yy" { (yyval.p__O_QLANGTAG_E_Or_QGT_DTYPE_E_S_QIRIref_E_C) = new _O_QLANGTAG_E_Or_QGT_DTYPE_E_S_QIRIref_E_C_rule0((yysemantic_stack_[(1) - (1)].p_LANGTAG)); ;} break; case 211: #line 5539 "SPARQLParser.yy" { (yyval.p__O_QLANGTAG_E_Or_QGT_DTYPE_E_S_QIRIref_E_C) = new _O_QLANGTAG_E_Or_QGT_DTYPE_E_S_QIRIref_E_C_rule1((yysemantic_stack_[(1) - (1)].p__O_QGT_DTYPE_E_S_QIRIref_E_C)); ;} break; case 212: #line 5545 "SPARQLParser.yy" { (yyval.p__Q_O_QLANGTAG_E_Or_QGT_DTYPE_E_S_QIRIref_E_C_E_Opt) = new _Q_O_QLANGTAG_E_Or_QGT_DTYPE_E_S_QIRIref_E_C_E_Opt_rule0(); ;} break; case 213: #line 5549 "SPARQLParser.yy" { (yyval.p__Q_O_QLANGTAG_E_Or_QGT_DTYPE_E_S_QIRIref_E_C_E_Opt) = new _Q_O_QLANGTAG_E_Or_QGT_DTYPE_E_S_QIRIref_E_C_E_Opt_rule1((yysemantic_stack_[(1) - (1)].p__O_QLANGTAG_E_Or_QGT_DTYPE_E_S_QIRIref_E_C)); ;} break; case 214: #line 5555 "SPARQLParser.yy" { (yyval.p_NumericLiteral) = new NumericLiteral_rule0((yysemantic_stack_[(1) - (1)].p_NumericLiteralUnsigned)); ;} break; case 215: #line 5559 "SPARQLParser.yy" { (yyval.p_NumericLiteral) = new NumericLiteral_rule1((yysemantic_stack_[(1) - (1)].p_NumericLiteralPositive)); ;} break; case 216: #line 5563 "SPARQLParser.yy" { (yyval.p_NumericLiteral) = new NumericLiteral_rule2((yysemantic_stack_[(1) - (1)].p_NumericLiteralNegative)); ;} break; case 217: #line 5569 "SPARQLParser.yy" { (yyval.p_NumericLiteralUnsigned) = new NumericLiteralUnsigned_rule0((yysemantic_stack_[(1) - (1)].p_INTEGER)); ;} break; case 218: #line 5573 "SPARQLParser.yy" { (yyval.p_NumericLiteralUnsigned) = new NumericLiteralUnsigned_rule1((yysemantic_stack_[(1) - (1)].p_DECIMAL)); ;} break; case 219: #line 5577 "SPARQLParser.yy" { (yyval.p_NumericLiteralUnsigned) = new NumericLiteralUnsigned_rule2((yysemantic_stack_[(1) - (1)].p_DOUBLE)); ;} break; case 220: #line 5583 "SPARQLParser.yy" { (yyval.p_NumericLiteralPositive) = new NumericLiteralPositive_rule0((yysemantic_stack_[(1) - (1)].p_INTEGER_POSITIVE)); ;} break; case 221: #line 5587 "SPARQLParser.yy" { (yyval.p_NumericLiteralPositive) = new NumericLiteralPositive_rule1((yysemantic_stack_[(1) - (1)].p_DECIMAL_POSITIVE)); ;} break; case 222: #line 5591 "SPARQLParser.yy" { (yyval.p_NumericLiteralPositive) = new NumericLiteralPositive_rule2((yysemantic_stack_[(1) - (1)].p_DOUBLE_POSITIVE)); ;} break; case 223: #line 5597 "SPARQLParser.yy" { (yyval.p_NumericLiteralNegative) = new NumericLiteralNegative_rule0((yysemantic_stack_[(1) - (1)].p_INTEGER_NEGATIVE)); ;} break; case 224: #line 5601 "SPARQLParser.yy" { (yyval.p_NumericLiteralNegative) = new NumericLiteralNegative_rule1((yysemantic_stack_[(1) - (1)].p_DECIMAL_NEGATIVE)); ;} break; case 225: #line 5605 "SPARQLParser.yy" { (yyval.p_NumericLiteralNegative) = new NumericLiteralNegative_rule2((yysemantic_stack_[(1) - (1)].p_DOUBLE_NEGATIVE)); ;} break; case 226: #line 5611 "SPARQLParser.yy" { (yyval.p_BooleanLiteral) = new BooleanLiteral_rule0((yysemantic_stack_[(1) - (1)].p_IT_true)); ;} break; case 227: #line 5615 "SPARQLParser.yy" { (yyval.p_BooleanLiteral) = new BooleanLiteral_rule1((yysemantic_stack_[(1) - (1)].p_IT_false)); ;} break; case 228: #line 5621 "SPARQLParser.yy" { (yyval.p_String) = new String_rule0((yysemantic_stack_[(1) - (1)].p_STRING_LITERAL1)); ;} break; case 229: #line 5625 "SPARQLParser.yy" { (yyval.p_String) = new String_rule1((yysemantic_stack_[(1) - (1)].p_STRING_LITERAL2)); ;} break; case 230: #line 5629 "SPARQLParser.yy" { (yyval.p_String) = new String_rule2((yysemantic_stack_[(1) - (1)].p_STRING_LITERAL_LONG1)); ;} break; case 231: #line 5633 "SPARQLParser.yy" { (yyval.p_String) = new String_rule3((yysemantic_stack_[(1) - (1)].p_STRING_LITERAL_LONG2)); ;} break; case 232: #line 5639 "SPARQLParser.yy" { (yyval.p_IRIref) = new IRIref_rule0((yysemantic_stack_[(1) - (1)].p_IRI_REF)); ;} break; case 233: #line 5643 "SPARQLParser.yy" { (yyval.p_IRIref) = new IRIref_rule1((yysemantic_stack_[(1) - (1)].p_PrefixedName)); ;} break; case 234: #line 5649 "SPARQLParser.yy" { (yyval.p_PrefixedName) = new PrefixedName_rule0((yysemantic_stack_[(1) - (1)].p_PNAME_LN)); ;} break; case 235: #line 5653 "SPARQLParser.yy" { (yyval.p_PrefixedName) = new PrefixedName_rule1((yysemantic_stack_[(1) - (1)].p_PNAME_NS)); ;} break; case 236: #line 5659 "SPARQLParser.yy" { (yyval.p_BlankNode) = new BlankNode_rule0((yysemantic_stack_[(1) - (1)].p_BLANK_NODE_LABEL)); ;} break; case 237: #line 5663 "SPARQLParser.yy" { (yyval.p_BlankNode) = new BlankNode_rule1((yysemantic_stack_[(1) - (1)].p_ANON)); ;} break; /* Line 675 of lalr1.cc. */ #line 2064 "SPARQLParser.cc" default: break; } 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: /* If not already recovering from an error, report this error. */ if (!yyerrstatus_) { ++yynerrs_; error (yylloc, yysyntax_error_ (yystate, yytoken)); } yyerror_range[0] = yylloc; if (yyerrstatus_ == 3) { /* If just tried and failed to reuse look-ahead 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 look-ahead 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[0] = 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 (yyn != yypact_ninf_) { 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[0] = yylocation_stack_[0]; yydestruct_ ("Error: popping", yystos_[yystate], &yysemantic_stack_[0], &yylocation_stack_[0]); yypop_ (); yystate = yystate_stack_[0]; YY_STACK_PRINT (); } if (yyn == yyfinal_) goto yyacceptlab; yyerror_range[1] = yylloc; // Using YYLLOC is tempting, but would change the location of // the look-ahead. YYLOC is available though. YYLLOC_DEFAULT (yyloc, (yyerror_range - 1), 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 != yyeof_ && yychar != yyempty_) 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 SPARQLParser::yysyntax_error_ (int yystate, int tok) { std::string res; YYUSE (yystate); #if YYERROR_VERBOSE int yyn = yypact_[yystate]; if (yypact_ninf_ < yyn && yyn <= yylast_) { /* Start YYX at -YYN if negative to avoid negative indexes in YYCHECK. */ 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_; int count = 0; for (int x = yyxbegin; x < yyxend; ++x) if (yycheck_[x + yyn] == x && x != yyterror_) ++count; // FIXME: This method of building the message is not compatible // with internationalization. It should work like yacc.c does it. // That is, first build a string that looks like this: // "syntax error, unexpected %s or %s or %s" // Then, invoke YY_ on this string. // Finally, use the string as a format to output // yytname_[tok], etc. // Until this gets fixed, this message appears in English only. res = "syntax error, unexpected "; res += yytnamerr_ (yytname_[tok]); if (count < 5) { count = 0; for (int x = yyxbegin; x < yyxend; ++x) if (yycheck_[x + yyn] == x && x != yyterror_) { res += (!count++) ? ", expecting " : " or "; res += yytnamerr_ (yytname_[x]); } } } else #endif res = YY_("syntax error"); return res; } /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing STATE-NUM. */ const short int SPARQLParser::yypact_ninf_ = -146; const short int SPARQLParser::yypact_[] = { 6, -36, 31, 94, -146, -146, -146, -146, 104, 16, 5, -146, -146, -146, -146, -146, -146, 38, -146, -146, -146, 27, 247, -146, -146, -146, -146, -146, -146, -146, 165, -146, -146, -146, -146, -146, 141, -12, -146, -146, 72, -146, -146, 247, -17, -146, -146, -146, -146, -146, -146, -146, -146, -146, -146, -146, -146, -146, -146, -146, -146, -146, -146, 25, -146, 34, -17, -146, -146, -17, -146, -146, -146, -146, -146, -146, -146, -146, 18, -146, -146, 141, -146, 7, 62, -146, -146, -146, 33, 2, -146, 141, -146, 192, -146, -146, -146, 56, 247, -146, -146, 247, -146, -146, -146, -146, -146, -146, 53, -146, -146, -146, -146, 80, 80, -146, 53, -146, -146, -146, -146, -146, 247, -146, -146, 80, -146, -146, -146, -146, -146, -146, -146, -146, 84, -146, 148, -146, -146, -146, -146, -146, 98, -146, 118, 124, 400, 102, 107, -146, -146, -146, 158, 172, 152, 247, -146, -146, -17, -146, 247, -146, -146, -146, 301, 169, 171, 183, 184, 194, 195, 200, 206, 207, 208, 209, 400, -146, 210, -146, -146, -146, -146, -146, -146, -146, -146, 1, -146, -146, -146, -146, -146, -146, -146, 33, 165, 429, -146, 218, -146, -146, -146, -146, -146, -146, -146, -146, -146, 247, -146, 336, 336, 336, -146, 212, -146, -146, -146, -146, 143, -146, -146, -146, -146, -146, -146, -146, -146, -146, -146, 1, 301, 301, 301, 301, 72, 301, 301, 301, 301, 301, 301, -146, -146, 301, -146, -146, -146, -146, 33, -146, 217, -146, 247, -146, -146, -146, -146, -146, 211, 213, 301, 301, 301, 301, 301, 301, -146, -146, 86, 24, -146, -146, 215, 229, 219, 245, 248, 220, 251, 253, 254, 255, 249, -146, -146, 33, -146, -146, 301, -146, 301, -146, -146, -146, -146, -146, -146, -146, 301, 301, -146, -146, -146, 301, 301, -146, -146, -146, 301, -146, -146, 301, -146, -146, -146, -146, 301, 135, -146, -146, -146, -146, -146, -146, -146, 256, 258, 261, 301, -146, -146, -146, -146, -146, 260, -146, -146 }; /* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE doesn't specify something else to do. Zero means the default is an error. */ const unsigned char SPARQLParser::yydefact_[] = { 8, 0, 0, 0, 10, 9, 12, 1, 17, 0, 0, 23, 2, 3, 4, 5, 6, 7, 15, 16, 18, 0, 102, 23, 30, 232, 235, 234, 139, 140, 29, 23, 27, 137, 138, 233, 41, 0, 11, 22, 21, 23, 19, 0, 0, 226, 227, 236, 217, 218, 219, 220, 221, 222, 223, 224, 225, 228, 229, 230, 231, 146, 237, 0, 103, 106, 118, 128, 127, 0, 135, 136, 142, 143, 214, 215, 216, 144, 212, 141, 145, 41, 28, 31, 0, 42, 24, 33, 0, 0, 20, 41, 134, 0, 131, 133, 126, 0, 0, 125, 101, 102, 107, 104, 119, 109, 117, 108, 0, 210, 211, 213, 208, 44, 44, 32, 0, 34, 35, 36, 37, 39, 68, 40, 13, 44, 130, 132, 129, 115, 122, 124, 105, 209, 0, 25, 46, 45, 26, 38, 75, 69, 79, 14, 110, 120, 0, 0, 0, 43, 47, 48, 49, 51, 0, 68, 80, 77, 112, 116, 0, 123, 60, 61, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 55, 56, 0, 58, 59, 63, 93, 64, 91, 92, 201, 0, 65, 66, 53, 50, 54, 52, 67, 0, 0, 0, 88, 72, 76, 70, 81, 83, 82, 71, 78, 113, 114, 0, 121, 0, 0, 0, 189, 0, 147, 150, 154, 156, 164, 166, 172, 177, 182, 183, 184, 185, 186, 187, 188, 206, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 57, 62, 0, 99, 94, 95, 84, 0, 90, 86, 73, 68, 111, 180, 181, 179, 190, 148, 152, 0, 0, 0, 0, 0, 0, 165, 157, 167, 174, 207, 205, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 97, 85, 0, 89, 74, 0, 151, 0, 155, 158, 159, 160, 161, 162, 163, 0, 0, 173, 170, 171, 0, 0, 178, 191, 192, 0, 194, 195, 0, 197, 198, 199, 200, 0, 0, 87, 149, 153, 168, 169, 175, 176, 0, 0, 203, 0, 100, 98, 193, 196, 204, 0, 96, 202 }; /* YYPGOTO[NTERM-NUM]. */ const short int SPARQLParser::yypgoto_[] = { -146, -146, -146, -146, -146, -146, -146, -146, -146, -146, -146, -146, -146, 20, -146, -146, -146, -146, -146, -146, -146, -146, -146, -146, 175, 36, -146, -98, -146, -146, -146, -146, -146, -146, -146, -146, 116, -146, -146, -146, 140, 142, -143, -145, -146, -146, -146, -146, -146, -146, -146, -146, -146, -146, -146, -146, -146, -146, 99, -146, 64, -32, -146, -146, -146, 197, -146, -146, -146, -15, -28, -146, -146, -146, -146, -146, -146, 91, -146, -146, 144, 145, -40, -146, -146, -146, -29, -38, -6, -4, -146, -31, -146, -146, -146, 11, -146, -146, 10, -146, -146, -146, -47, -146, -146, -146, -107, -146, -146, -109, -80, -50, -33, -146, -146, -146, -146, -21, -146, -146, -146, -20, -146, 35, 44, -14, -146, -10, -146, -146 }; /* YYDEFGOTO[NTERM-NUM]. */ const short int SPARQLParser::yydefgoto_[] = { -1, 2, 12, 3, 4, 17, 5, 38, 13, 20, 21, 40, 41, 36, 14, 15, 30, 31, 114, 16, 86, 117, 118, 119, 120, 87, 88, 135, 136, 149, 150, 190, 192, 151, 137, 176, 177, 178, 179, 180, 152, 153, 123, 140, 199, 254, 200, 154, 141, 156, 157, 201, 202, 203, 204, 288, 252, 205, 181, 182, 247, 332, 319, 248, 23, 63, 64, 102, 103, 142, 97, 207, 208, 159, 144, 105, 106, 129, 161, 145, 130, 98, 66, 67, 68, 93, 131, 69, 99, 214, 71, 215, 216, 291, 260, 217, 293, 261, 218, 219, 268, 269, 220, 221, 302, 270, 222, 307, 271, 223, 224, 225, 226, 186, 336, 227, 273, 228, 110, 111, 112, 229, 74, 75, 76, 230, 78, 231, 35, 80 }; /* 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 zero, do what YYDEFACT says. */ const signed char SPARQLParser::yytable_ninf_ = -42; const short int SPARQLParser::yytable_[] = { 34, 72, 73, 92, 32, 95, 33, 65, 77, 1, 206, 198, 79, 24, 94, 96, 138, 42, 70, 84, 34, 85, 72, 73, 82, 6, 33, 143, -41, 77, 245, 7, 305, 79, 34, 39, 90, 22, 104, 70, 33, 107, 37, 81, 25, 26, 27, 100, 28, 29, 89, 83, 249, 92, 122, 95, 34, 101, 92, 34, 95, 91, 33, 124, 127, 33, 25, 26, 27, 306, 28, 29, 72, 73, 121, 116, 108, 72, 73, 77, 72, 73, 246, 79, 77, 109, 65, 77, 79, 70, 128, 79, 28, 29, 70, 134, 184, 70, 133, 8, 146, 72, 73, 9, 10, 11, 121, 286, 77, 289, 18, 19, 79, 185, 25, 26, 27, 113, 70, 115, 92, 155, 95, 25, 26, 27, 184, 125, 244, 300, 301, 256, 257, 258, 72, 73, 187, 28, 29, 72, 73, 77, 183, 185, 320, 79, 77, 184, 34, 158, 79, 70, 160, 84, 33, 85, 70, 51, 52, 53, 54, 55, 56, 330, 185, 331, 187, 147, 148, 92, 188, 95, 183, 122, 194, 189, 195, 196, 148, 197, 262, 263, 264, 265, 266, 267, 34, 187, 72, 73, 250, 147, 33, 323, 324, 77, 325, 326, 232, 79, 233, 274, 275, 276, 277, 70, 279, 280, 281, 282, 283, 284, 234, 235, 285, 294, 295, 296, 297, 298, 299, 43, 126, 236, 237, 44, 25, 26, 27, 238, 28, 29, 278, 72, 73, 239, 240, 241, 242, 164, 77, 253, 259, 287, 79, 308, 290, 310, 313, 292, 70, 45, 46, 25, 26, 27, 47, 28, 29, 309, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 311, 43, 318, 312, 327, 44, 314, 328, 315, 316, 317, 333, 329, 334, 330, 338, 139, 243, 193, 191, 272, 251, 335, 132, 337, 255, 321, 322, 209, 210, 303, 45, 46, 25, 26, 27, 47, 28, 29, 304, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 164, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 211, 212, 0, 213, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 0, 45, 46, 25, 26, 27, 164, 28, 29, 0, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 0, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 0, 45, 46, 25, 26, 27, 0, 28, 29, 0, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 162, 163, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 164, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 164, 0, 0, 25, 26, 27, 0, 28, 29, 0, 0, 0, 0, 0, 0, 0, 0, 0, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 0, 0, 0, 25, 26, 27 }; /* YYCHECK. */ const short int SPARQLParser::yycheck_[] = { 10, 22, 22, 43, 10, 43, 10, 22, 22, 3, 155, 154, 22, 8, 43, 32, 114, 21, 22, 12, 30, 14, 43, 43, 30, 61, 30, 125, 21, 43, 29, 0, 8, 43, 44, 8, 40, 21, 66, 43, 44, 69, 4, 23, 61, 62, 63, 22, 65, 66, 62, 31, 195, 93, 21, 93, 66, 23, 98, 69, 98, 41, 66, 61, 93, 69, 61, 62, 63, 45, 65, 66, 93, 93, 84, 13, 58, 98, 98, 93, 101, 101, 81, 93, 98, 67, 101, 101, 98, 93, 34, 101, 65, 66, 98, 15, 146, 101, 108, 5, 16, 122, 122, 9, 10, 11, 116, 250, 122, 254, 6, 7, 122, 146, 61, 62, 63, 81, 122, 83, 160, 23, 160, 61, 62, 63, 176, 91, 178, 43, 44, 211, 212, 213, 155, 155, 146, 65, 66, 160, 160, 155, 146, 176, 287, 155, 160, 197, 158, 31, 160, 155, 28, 12, 158, 14, 160, 71, 72, 73, 74, 75, 76, 28, 197, 30, 176, 19, 20, 209, 68, 209, 176, 21, 22, 68, 24, 25, 20, 27, 37, 38, 39, 40, 41, 42, 196, 197, 209, 209, 196, 19, 196, 300, 301, 209, 305, 306, 29, 209, 29, 232, 233, 234, 235, 209, 237, 238, 239, 240, 241, 242, 29, 29, 245, 262, 263, 264, 265, 266, 267, 29, 30, 29, 29, 33, 61, 62, 63, 29, 65, 66, 236, 254, 254, 29, 29, 29, 29, 29, 254, 23, 30, 26, 254, 30, 35, 28, 28, 36, 254, 59, 60, 61, 62, 63, 64, 65, 66, 30, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 30, 29, 28, 30, 310, 33, 30, 313, 30, 30, 30, 30, 318, 30, 28, 30, 116, 176, 153, 152, 231, 197, 329, 101, 330, 209, 290, 292, 158, 160, 270, 59, 60, 61, 62, 63, 64, 65, 66, 270, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 29, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 43, 44, -1, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, -1, 59, 60, 61, 62, 63, 29, 65, 66, -1, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, -1, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, -1, 59, 60, 61, 62, 63, -1, 65, 66, -1, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 17, 18, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 29, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 29, -1, -1, 61, 62, 63, -1, 65, 66, -1, -1, -1, -1, -1, -1, -1, -1, -1, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, -1, -1, -1, 61, 62, 63 }; /* STOS_[STATE-NUM] -- The (internal number of the) accessing symbol of state STATE-NUM. */ const unsigned char SPARQLParser::yystos_[] = { 0, 3, 84, 86, 87, 89, 61, 0, 5, 9, 10, 11, 85, 91, 97, 98, 102, 88, 6, 7, 92, 93, 21, 147, 8, 61, 62, 63, 65, 66, 99, 100, 171, 172, 210, 211, 96, 4, 90, 8, 94, 95, 172, 29, 33, 59, 60, 64, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 148, 149, 152, 165, 166, 167, 170, 172, 173, 200, 204, 205, 206, 207, 208, 209, 210, 212, 96, 171, 96, 12, 14, 103, 108, 109, 62, 172, 96, 165, 168, 169, 170, 32, 153, 164, 171, 22, 23, 150, 151, 153, 158, 159, 153, 58, 67, 201, 202, 203, 108, 101, 108, 13, 104, 105, 106, 107, 210, 21, 125, 61, 108, 30, 169, 34, 160, 163, 169, 148, 210, 15, 110, 111, 117, 110, 107, 126, 131, 152, 110, 157, 162, 16, 19, 20, 112, 113, 116, 123, 124, 130, 23, 132, 133, 31, 156, 28, 161, 17, 18, 29, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 118, 119, 120, 121, 122, 141, 142, 172, 194, 195, 196, 210, 68, 68, 114, 124, 115, 123, 22, 24, 25, 27, 125, 127, 129, 134, 135, 136, 137, 140, 126, 154, 155, 164, 163, 43, 44, 46, 172, 174, 175, 178, 181, 182, 185, 186, 189, 192, 193, 194, 195, 198, 200, 204, 208, 210, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 119, 194, 29, 81, 143, 146, 125, 171, 141, 139, 23, 128, 160, 193, 193, 193, 30, 177, 180, 37, 38, 39, 40, 41, 42, 183, 184, 188, 191, 143, 199, 174, 174, 174, 174, 172, 174, 174, 174, 174, 174, 174, 174, 125, 26, 138, 126, 35, 176, 36, 179, 185, 185, 185, 185, 185, 185, 43, 44, 187, 206, 207, 8, 45, 190, 30, 30, 28, 30, 30, 28, 30, 30, 30, 30, 28, 145, 125, 178, 181, 189, 189, 192, 192, 174, 174, 174, 28, 30, 144, 30, 30, 144, 197, 174, 30 }; #if YYDEBUG /* TOKEN_NUMBER_[YYLEX-NUM] -- Internal symbol number corresponding to YYLEX-NUM. */ const unsigned short int SPARQLParser::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 }; #endif /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ const unsigned char SPARQLParser::yyr1_[] = { 0, 83, 84, 85, 85, 85, 85, 86, 87, 87, 88, 88, 89, 90, 91, 92, 92, 93, 93, 94, 94, 95, 95, 96, 96, 97, 98, 99, 99, 100, 100, 101, 101, 102, 103, 104, 104, 105, 106, 107, 108, 109, 109, 110, 111, 111, 112, 112, 113, 114, 114, 115, 115, 116, 116, 117, 118, 118, 119, 119, 120, 120, 121, 122, 122, 123, 124, 125, 126, 126, 127, 127, 128, 128, 129, 130, 130, 131, 132, 133, 133, 134, 134, 134, 135, 136, 137, 138, 139, 139, 140, 141, 141, 141, 142, 143, 144, 145, 145, 146, 146, 147, 148, 148, 149, 150, 151, 151, 152, 152, 153, 154, 155, 155, 156, 157, 157, 158, 159, 159, 160, 161, 162, 162, 163, 164, 164, 165, 165, 166, 167, 168, 168, 169, 169, 170, 170, 171, 171, 172, 172, 173, 173, 173, 173, 173, 173, 174, 175, 176, 177, 177, 178, 179, 180, 180, 181, 182, 183, 183, 183, 183, 183, 183, 184, 184, 185, 186, 187, 187, 187, 187, 188, 188, 189, 190, 190, 191, 191, 192, 192, 192, 192, 193, 193, 193, 193, 193, 193, 193, 194, 195, 195, 195, 195, 195, 195, 195, 195, 195, 195, 195, 196, 197, 197, 198, 199, 199, 200, 201, 202, 202, 203, 203, 204, 204, 204, 205, 205, 205, 206, 206, 206, 207, 207, 207, 208, 208, 209, 209, 209, 209, 210, 210, 211, 211, 212, 212 }; /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ const unsigned char SPARQLParser::yyr2_[] = { 0, 2, 2, 1, 1, 1, 1, 2, 0, 1, 0, 2, 2, 3, 6, 1, 1, 0, 1, 1, 2, 1, 1, 0, 2, 5, 5, 1, 2, 1, 1, 0, 1, 3, 2, 1, 1, 1, 2, 1, 2, 0, 1, 2, 0, 1, 0, 1, 1, 0, 1, 0, 1, 2, 2, 3, 1, 2, 1, 1, 1, 1, 2, 1, 1, 2, 2, 4, 0, 1, 1, 1, 0, 1, 3, 0, 2, 2, 2, 0, 1, 1, 1, 1, 2, 3, 2, 2, 0, 2, 2, 1, 1, 1, 2, 1, 2, 0, 2, 1, 4, 3, 0, 1, 2, 2, 0, 1, 2, 2, 3, 2, 0, 1, 2, 0, 2, 1, 0, 1, 2, 2, 0, 2, 1, 1, 1, 1, 1, 3, 3, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 0, 2, 2, 2, 0, 2, 1, 2, 2, 2, 2, 2, 2, 2, 0, 1, 1, 2, 2, 2, 1, 1, 0, 2, 2, 2, 2, 0, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 3, 4, 4, 6, 4, 4, 6, 4, 4, 4, 4, 1, 7, 0, 1, 2, 0, 1, 2, 2, 1, 1, 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 }; #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 SPARQLParser::yytname_[] = { "\"end of file\"", "error", "$undefined", "IT_BASE", "IT_PREFIX", "IT_SELECT", "IT_DISTINCT", "IT_REDUCED", "GT_TIMES", "IT_CONSTRUCT", "IT_DESCRIBE", "IT_ASK", "IT_FROM", "IT_NAMED", "IT_WHERE", "IT_ORDER", "IT_BY", "IT_ASC", "IT_DESC", "IT_LIMIT", "IT_OFFSET", "GT_LCURLEY", "GT_RCURLEY", "GT_DOT", "IT_OPTIONAL", "IT_GRAPH", "IT_UNION", "IT_FILTER", "GT_COMMA", "GT_LPAREN", "GT_RPAREN", "GT_SEMI", "IT_a", "GT_LBRACKET", "GT_RBRACKET", "GT_OR", "GT_AND", "GT_EQUAL", "GT_NEQUAL", "GT_LT", "GT_GT", "GT_LE", "GT_GE", "GT_PLUS", "GT_MINUS", "GT_DIVIDE", "GT_NOT", "IT_STR", "IT_LANG", "IT_LANGMATCHES", "IT_DATATYPE", "IT_BOUND", "IT_sameTerm", "IT_isIRI", "IT_isURI", "IT_isBLANK", "IT_isLITERAL", "IT_REGEX", "GT_DTYPE", "IT_true", "IT_false", "IRI_REF", "PNAME_NS", "PNAME_LN", "BLANK_NODE_LABEL", "VAR1", "VAR2", "LANGTAG", "INTEGER", "DECIMAL", "DOUBLE", "INTEGER_POSITIVE", "DECIMAL_POSITIVE", "DOUBLE_POSITIVE", "INTEGER_NEGATIVE", "DECIMAL_NEGATIVE", "DOUBLE_NEGATIVE", "STRING_LITERAL1", "STRING_LITERAL2", "STRING_LITERAL_LONG1", "STRING_LITERAL_LONG2", "NIL", "ANON", "$accept", "Query", "_O_QSelectQuery_E_Or_QConstructQuery_E_Or_QDescribeQuery_E_Or_QAskQuery_E_C", "Prologue", "_QBaseDecl_E_Opt", "_QPrefixDecl_E_Star", "BaseDecl", "PrefixDecl", "SelectQuery", "_O_QIT_DISTINCT_E_Or_QIT_REDUCED_E_C", "_Q_O_QIT_DISTINCT_E_Or_QIT_REDUCED_E_C_E_Opt", "_QVar_E_Plus", "_O_QVar_E_Plus_Or_QGT_TIMES_E_C", "_QDatasetClause_E_Star", "ConstructQuery", "DescribeQuery", "_QVarOrIRIref_E_Plus", "_O_QVarOrIRIref_E_Plus_Or_QGT_TIMES_E_C", "_QWhereClause_E_Opt", "AskQuery", "DatasetClause", "_O_QDefaultGraphClause_E_Or_QNamedGraphClause_E_C", "DefaultGraphClause", "NamedGraphClause", "SourceSelector", "WhereClause", "_QIT_WHERE_E_Opt", "SolutionModifier", "_QOrderClause_E_Opt", "_QLimitOffsetClauses_E_Opt", "LimitOffsetClauses", "_QOffsetClause_E_Opt", "_QLimitClause_E_Opt", "_O_QLimitClause_E_S_QOffsetClause_E_Opt_Or_QOffsetClause_E_S_QLimitClause_E_Opt_C", "OrderClause", "_QOrderCondition_E_Plus", "OrderCondition", "_O_QIT_ASC_E_Or_QIT_DESC_E_C", "_O_QIT_ASC_E_Or_QIT_DESC_E_S_QBrackettedExpression_E_C", "_O_QConstraint_E_Or_QVar_E_C", "LimitClause", "OffsetClause", "GroupGraphPattern", "_QTriplesBlock_E_Opt", "_O_QGraphPatternNotTriples_E_Or_QFilter_E_C", "_QGT_DOT_E_Opt", "_O_QGraphPatternNotTriples_E_Or_QFilter_E_S_QGT_DOT_E_Opt_S_QTriplesBlock_E_Opt_C", "_Q_O_QGraphPatternNotTriples_E_Or_QFilter_E_S_QGT_DOT_E_Opt_S_QTriplesBlock_E_Opt_C_E_Star", "TriplesBlock", "_O_QGT_DOT_E_S_QTriplesBlock_E_Opt_C", "_Q_O_QGT_DOT_E_S_QTriplesBlock_E_Opt_C_E_Opt", "GraphPatternNotTriples", "OptionalGraphPattern", "GraphGraphPattern", "GroupOrUnionGraphPattern", "_O_QIT_UNION_E_S_QGroupGraphPattern_E_C", "_Q_O_QIT_UNION_E_S_QGroupGraphPattern_E_C_E_Star", "Filter", "Constraint", "FunctionCall", "ArgList", "_O_QGT_COMMA_E_S_QExpression_E_C", "_Q_O_QGT_COMMA_E_S_QExpression_E_C_E_Star", "_O_QNIL_E_Or_QGT_LPAREN_E_S_QExpression_E_S_QGT_COMMA_E_S_QExpression_E_Star_S_QGT_RPAREN_E_C", "ConstructTemplate", "_QConstructTriples_E_Opt", "ConstructTriples", "_O_QGT_DOT_E_S_QConstructTriples_E_Opt_C", "_Q_O_QGT_DOT_E_S_QConstructTriples_E_Opt_C_E_Opt", "TriplesSameSubject", "PropertyListNotEmpty", "_O_QVerb_E_S_QObjectList_E_C", "_Q_O_QVerb_E_S_QObjectList_E_C_E_Opt", "_O_QGT_SEMI_E_S_QVerb_E_S_QObjectList_E_Opt_C", "_Q_O_QGT_SEMI_E_S_QVerb_E_S_QObjectList_E_Opt_C_E_Star", "PropertyList", "_QPropertyListNotEmpty_E_Opt", "ObjectList", "_O_QGT_COMMA_E_S_QObject_E_C", "_Q_O_QGT_COMMA_E_S_QObject_E_C_E_Star", "Object", "Verb", "TriplesNode", "BlankNodePropertyList", "Collection", "_QGraphNode_E_Plus", "GraphNode", "VarOrTerm", "VarOrIRIref", "Var", "GraphTerm", "Expression", "ConditionalOrExpression", "_O_QGT_OR_E_S_QConditionalAndExpression_E_C", "_Q_O_QGT_OR_E_S_QConditionalAndExpression_E_C_E_Star", "ConditionalAndExpression", "_O_QGT_AND_E_S_QValueLogical_E_C", "_Q_O_QGT_AND_E_S_QValueLogical_E_C_E_Star", "ValueLogical", "RelationalExpression", "_O_QGT_EQUAL_E_S_QNumericExpression_E_Or_QGT_NEQUAL_E_S_QNumericExpression_E_Or_QGT_LT_E_S_QNumericExpression_E_Or_QGT_GT_E_S_QNumericExpression_E_Or_QGT_LE_E_S_QNumericExpression_E_Or_QGT_GE_E_S_QNumericExpression_E_C", "_Q_O_QGT_EQUAL_E_S_QNumericExpression_E_Or_QGT_NEQUAL_E_S_QNumericExpression_E_Or_QGT_LT_E_S_QNumericExpression_E_Or_QGT_GT_E_S_QNumericExpression_E_Or_QGT_LE_E_S_QNumericExpression_E_Or_QGT_GE_E_S_QNumericExpression_E_C_E_Opt", "NumericExpression", "AdditiveExpression", "_O_QGT_PLUS_E_S_QMultiplicativeExpression_E_Or_QGT_MINUS_E_S_QMultiplicativeExpression_E_Or_QNumericLiteralPositive_E_Or_QNumericLiteralNegative_E_C", "_Q_O_QGT_PLUS_E_S_QMultiplicativeExpression_E_Or_QGT_MINUS_E_S_QMultiplicativeExpression_E_Or_QNumericLiteralPositive_E_Or_QNumericLiteralNegative_E_C_E_Star", "MultiplicativeExpression", "_O_QGT_TIMES_E_S_QUnaryExpression_E_Or_QGT_DIVIDE_E_S_QUnaryExpression_E_C", "_Q_O_QGT_TIMES_E_S_QUnaryExpression_E_Or_QGT_DIVIDE_E_S_QUnaryExpression_E_C_E_Star", "UnaryExpression", "PrimaryExpression", "BrackettedExpression", "BuiltInCall", "RegexExpression", "_Q_O_QGT_COMMA_E_S_QExpression_E_C_E_Opt", "IRIrefOrFunction", "_QArgList_E_Opt", "RDFLiteral", "_O_QGT_DTYPE_E_S_QIRIref_E_C", "_O_QLANGTAG_E_Or_QGT_DTYPE_E_S_QIRIref_E_C", "_Q_O_QLANGTAG_E_Or_QGT_DTYPE_E_S_QIRIref_E_C_E_Opt", "NumericLiteral", "NumericLiteralUnsigned", "NumericLiteralPositive", "NumericLiteralNegative", "BooleanLiteral", "String", "IRIref", "PrefixedName", "BlankNode", 0 }; #endif #if YYDEBUG /* YYRHS -- A `-1'-separated list of the rules' RHS. */ const SPARQLParser::rhs_number_type SPARQLParser::yyrhs_[] = { 84, 0, -1, 86, 85, -1, 91, -1, 97, -1, 98, -1, 102, -1, 87, 88, -1, -1, 89, -1, -1, 88, 90, -1, 3, 61, -1, 4, 62, 61, -1, 5, 93, 95, 96, 108, 110, -1, 6, -1, 7, -1, -1, 92, -1, 172, -1, 94, 172, -1, 94, -1, 8, -1, -1, 96, 103, -1, 9, 147, 96, 108, 110, -1, 10, 100, 96, 101, 110, -1, 171, -1, 99, 171, -1, 99, -1, 8, -1, -1, 108, -1, 11, 96, 108, -1, 12, 104, -1, 105, -1, 106, -1, 107, -1, 13, 107, -1, 210, -1, 109, 125, -1, -1, 14, -1, 111, 112, -1, -1, 117, -1, -1, 113, -1, 116, -1, -1, 124, -1, -1, 123, -1, 123, 114, -1, 124, 115, -1, 15, 16, 118, -1, 119, -1, 118, 119, -1, 121, -1, 122, -1, 17, -1, 18, -1, 120, 194, -1, 141, -1, 172, -1, 19, 68, -1, 20, 68, -1, 21, 126, 130, 22, -1, -1, 131, -1, 134, -1, 140, -1, -1, 23, -1, 127, 128, 126, -1, -1, 130, 129, -1, 152, 133, -1, 23, 126, -1, -1, 132, -1, 135, -1, 137, -1, 136, -1, 24, 125, -1, 25, 171, 125, -1, 125, 139, -1, 26, 125, -1, -1, 139, 138, -1, 27, 141, -1, 194, -1, 195, -1, 142, -1, 210, 143, -1, 146, -1, 28, 174, -1, -1, 145, 144, -1, 81, -1, 29, 174, 145, 30, -1, 21, 148, 22, -1, -1, 149, -1, 152, 151, -1, 23, 148, -1, -1, 150, -1, 170, 153, -1, 165, 158, -1, 164, 160, 157, -1, 164, 160, -1, -1, 154, -1, 31, 155, -1, -1, 157, 156, -1, 159, -1, -1, 153, -1, 163, 162, -1, 28, 163, -1, -1, 162, 161, -1, 169, -1, 171, -1, 32, -1, 167, -1, 166, -1, 33, 153, 34, -1, 29, 168, 30, -1, 169, -1, 168, 169, -1, 170, -1, 165, -1, 172, -1, 173, -1, 172, -1, 210, -1, 65, -1, 66, -1, 210, -1, 200, -1, 204, -1, 208, -1, 212, -1, 81, -1, 175, -1, 178, 177, -1, 35, 178, -1, -1, 177, 176, -1, 181, 180, -1, 36, 181, -1, -1, 180, 179, -1, 182, -1, 185, 184, -1, 37, 185, -1, 38, 185, -1, 39, 185, -1, 40, 185, -1, 41, 185, -1, 42, 185, -1, -1, 183, -1, 186, -1, 189, 188, -1, 43, 189, -1, 44, 189, -1, 206, -1, 207, -1, -1, 188, 187, -1, 192, 191, -1, 8, 192, -1, 45, 192, -1, -1, 191, 190, -1, 46, 193, -1, 43, 193, -1, 44, 193, -1, 193, -1, 194, -1, 195, -1, 198, -1, 200, -1, 204, -1, 208, -1, 172, -1, 29, 174, 30, -1, 47, 29, 174, 30, -1, 48, 29, 174, 30, -1, 49, 29, 174, 28, 174, 30, -1, 50, 29, 174, 30, -1, 51, 29, 172, 30, -1, 52, 29, 174, 28, 174, 30, -1, 53, 29, 174, 30, -1, 54, 29, 174, 30, -1, 55, 29, 174, 30, -1, 56, 29, 174, 30, -1, 196, -1, 57, 29, 174, 28, 174, 197, 30, -1, -1, 144, -1, 210, 199, -1, -1, 143, -1, 209, 203, -1, 58, 210, -1, 67, -1, 201, -1, -1, 202, -1, 205, -1, 206, -1, 207, -1, 68, -1, 69, -1, 70, -1, 71, -1, 72, -1, 73, -1, 74, -1, 75, -1, 76, -1, 59, -1, 60, -1, 77, -1, 78, -1, 79, -1, 80, -1, 61, -1, 211, -1, 63, -1, 62, -1, 64, -1, 82, -1 }; /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in YYRHS. */ const unsigned short int SPARQLParser::yyprhs_[] = { 0, 0, 3, 6, 8, 10, 12, 14, 17, 18, 20, 21, 24, 27, 31, 38, 40, 42, 43, 45, 47, 50, 52, 54, 55, 58, 64, 70, 72, 75, 77, 79, 80, 82, 86, 89, 91, 93, 95, 98, 100, 103, 104, 106, 109, 110, 112, 113, 115, 117, 118, 120, 121, 123, 126, 129, 133, 135, 138, 140, 142, 144, 146, 149, 151, 153, 156, 159, 164, 165, 167, 169, 171, 172, 174, 178, 179, 182, 185, 188, 189, 191, 193, 195, 197, 200, 204, 207, 210, 211, 214, 217, 219, 221, 223, 226, 228, 231, 232, 235, 237, 242, 246, 247, 249, 252, 255, 256, 258, 261, 264, 268, 271, 272, 274, 277, 278, 281, 283, 284, 286, 289, 292, 293, 296, 298, 300, 302, 304, 306, 310, 314, 316, 319, 321, 323, 325, 327, 329, 331, 333, 335, 337, 339, 341, 343, 345, 347, 349, 352, 355, 356, 359, 362, 365, 366, 369, 371, 374, 377, 380, 383, 386, 389, 392, 393, 395, 397, 400, 403, 406, 408, 410, 411, 414, 417, 420, 423, 424, 427, 430, 433, 436, 438, 440, 442, 444, 446, 448, 450, 452, 456, 461, 466, 473, 478, 483, 490, 495, 500, 505, 510, 512, 520, 521, 523, 526, 527, 529, 532, 535, 537, 539, 540, 542, 544, 546, 548, 550, 552, 554, 556, 558, 560, 562, 564, 566, 568, 570, 572, 574, 576, 578, 580, 582, 584, 586, 588 }; /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */ const unsigned short int SPARQLParser::yyrline_[] = { 0, 4467, 4467, 4473, 4477, 4481, 4485, 4491, 4497, 4501, 4507, 4511, 4517, 4523, 4529, 4535, 4539, 4545, 4549, 4555, 4559, 4565, 4569, 4575, 4579, 4585, 4591, 4597, 4601, 4607, 4611, 4617, 4621, 4627, 4633, 4639, 4643, 4649, 4655, 4661, 4667, 4673, 4677, 4683, 4689, 4693, 4699, 4703, 4709, 4715, 4719, 4725, 4729, 4735, 4739, 4745, 4751, 4755, 4761, 4765, 4771, 4775, 4781, 4787, 4791, 4797, 4803, 4809, 4815, 4819, 4825, 4829, 4835, 4839, 4845, 4851, 4855, 4861, 4867, 4873, 4877, 4883, 4887, 4891, 4897, 4903, 4909, 4915, 4921, 4925, 4931, 4937, 4941, 4945, 4951, 4957, 4963, 4969, 4973, 4979, 4983, 4989, 4995, 4999, 5005, 5011, 5017, 5021, 5027, 5031, 5037, 5043, 5049, 5053, 5059, 5065, 5069, 5075, 5081, 5085, 5091, 5097, 5103, 5107, 5113, 5119, 5123, 5129, 5133, 5139, 5145, 5151, 5155, 5161, 5165, 5171, 5175, 5181, 5185, 5191, 5195, 5201, 5205, 5209, 5213, 5217, 5221, 5227, 5233, 5239, 5245, 5249, 5255, 5261, 5267, 5271, 5277, 5283, 5289, 5293, 5297, 5301, 5305, 5309, 5315, 5319, 5325, 5331, 5337, 5341, 5345, 5349, 5355, 5359, 5365, 5371, 5375, 5381, 5385, 5391, 5395, 5399, 5403, 5409, 5413, 5417, 5421, 5425, 5429, 5433, 5439, 5445, 5449, 5453, 5457, 5461, 5465, 5469, 5473, 5477, 5481, 5485, 5491, 5497, 5501, 5507, 5513, 5517, 5523, 5529, 5535, 5539, 5545, 5549, 5555, 5559, 5563, 5569, 5573, 5577, 5583, 5587, 5591, 5597, 5601, 5605, 5611, 5615, 5621, 5625, 5629, 5633, 5639, 5643, 5649, 5653, 5659, 5663 }; // Print the state stack on the debug stream. void SPARQLParser::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 SPARQLParser::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 << "), "; /* 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. */ SPARQLParser::token_number_type SPARQLParser::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, 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, 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 }; if ((unsigned int) t <= yyuser_token_number_max_) return translate_table[t]; else return yyundef_token_; } const int SPARQLParser::yyeof_ = 0; const int SPARQLParser::yylast_ = 492; const int SPARQLParser::yynnts_ = 130; const int SPARQLParser::yyempty_ = -2; const int SPARQLParser::yyfinal_ = 7; const int SPARQLParser::yyterror_ = 1; const int SPARQLParser::yyerrcode_ = 256; const int SPARQLParser::yyntokens_ = 83; const unsigned int SPARQLParser::yyuser_token_number_max_ = 337; const SPARQLParser::token_number_type SPARQLParser::yyundef_token_ = 2; } // namespace SPARQLNS #line 5736 "SPARQLParser.yy" /*** Additional Code ***/ void SPARQLNS::SPARQLParser::error(const SPARQLParser::location_type& l, const std::string& m) { driver.error(l, m); } /* START yacker-specific test harness */ std::ostream* _Trace = NULL; Query* StupidGlobal = NULL; const char * _Production::toStr(std::ofstream* out, size_t argc, ...) { va_list bases; char ** rets = new char*[argc]; size_t * sizes = new size_t[argc]; size_t size = 0; va_start(bases, argc); for (size_t i = 0; i < argc; i++) { _Base* base = va_arg(bases, _Base*); rets[i] = (char*)base->toStr(out); sizes[i] = strlen(rets[i]); size += sizes[i]; } va_end(bases); char * ret = new char[size+argc]; // lens plus ' 's plus \0 ret[0] = 0; // in case there are no args size_t nowAt = 0; for (size_t i = 0; i < argc; i++) { strncpy(ret+nowAt, rets[i], sizes[i]); delete rets[i]; nowAt += sizes[i]; ret[nowAt++] = (i == argc - 1) ? '\0' : ' '; } return ret; } #define tab 2 char const * yit = "yacker:implicit-terminal"; #define lyit strlen(yit) #define ns "\n xmlns=\"http://www.w3.org/2005/01/yacker/uploads/SPARQL/\"\n xmlns:yacker=\"http://www.w3.org/2005/01/yacker/\"" #define lns sizeof(ns)-1 /* strlen(ns) */ const char * _Production::toXml(size_t depth, std::ofstream* out, size_t argc, ...) { va_list bases; char ** rets = new char*[argc]; size_t * sizes = new size_t[argc]; size_t size = depth == 0 ? lns : 0; va_start(bases, argc); unsigned leaderLen = depth*tab; char* leader = new char[leaderLen+1]; for (size_t i = 0; i < leaderLen; i++) leader[i] = ' '; leader[leaderLen] = 0; for (size_t i = 0; i < argc; i++) { _Base* base = va_arg(bases, _Base*); rets[i] = (char*)base->toXml(depth+1, out); sizes[i] = strlen(rets[i]); size += sizes[i]; } va_end(bases); char * ret = new char[leaderLen*2 + argc*2+8 + strlen(getProductionName())*2 + size]; // @@explain size_t nowAt = 0; strcpy(ret, leader); nowAt += leaderLen; openXmlFrame(ret, &nowAt, depth); for (size_t i = 0; i < argc; i++) { strncpy(ret+nowAt, rets[i], sizes[i]); delete rets[i]; nowAt += sizes[i]; if (i == argc - 1) ret[nowAt] = '\0'; } strcat(ret+leaderLen, leader); nowAt += leaderLen; closeXmlFrame(ret, &nowAt); return ret; } void _Production::openXmlFrame (char* ret, size_t* pNowAt, size_t depth) { strcat(ret+*pNowAt, "<"); *pNowAt += 1; strcat(ret+*pNowAt, getProductionName()); *pNowAt += strlen(getProductionName()); if (depth == 0) { strcat(ret+*pNowAt, ns); *pNowAt += lns; } strcat(ret+*pNowAt, ">\n"); *pNowAt += 2; } void _Production::closeXmlFrame (char* ret, size_t* pNowAt) { strcat(ret+*pNowAt, "\n"); *pNowAt += 2; } void _GenProduction::openXmlFrame (char*, size_t*, size_t) { } void _GenProduction::closeXmlFrame (char*, size_t*) { } void _Production::trace(const char * name, size_t argc, ...) { if (!_Trace) return; *_Trace << " " << name << ":"; va_list bases; va_start(bases, argc); for (size_t argNo = 0; argNo < argc; argNo++) { _Base* parm = va_arg(bases, _Base*); const char * parmName = parm->getProductionName(); size_t parmSize = parm->toAbsorb(); *_Trace << " " << parmName << "(" << parmSize << ")"; } va_end(bases); *_Trace << std::endl; va_start(bases, argc); for (size_t argNo = 0; argNo < argc; argNo++) { _Base* parm = va_arg(bases, _Base*); const char * parmName = parm->getProductionName(); size_t parmSize = parm->toAbsorb(); for (size_t j = 0; j < parmSize; j++) { const char* s = parm->absorb(j)->toStr(); *_Trace << " " << parmName << "(" << j << "): " << s << std::endl; } } va_end(bases); } void _Token::trace() { if (!_Trace) return; *_Trace << "shift (" << getProductionName() << ", " << getToken() << ")" << std::endl; } void _Terminal::trace() { if (!_Trace) return; *_Trace << "shift (" << getProductionName() << ", " << terminal << ")" << std::endl; } _GenProduction::_GenProduction (const char* productionName, size_t argc, ...) { size = 0; vals = NULL; va_list bases; va_start(bases, argc); for (size_t argNo = 0; argNo < argc; argNo++) { _Base* base = va_arg(bases, _Base*); if (base->getProductionName() == productionName) { size += base->toAbsorb(); } else { size += 1; } } va_end(bases); if (argc) { vals = new _Base*[size]; size_t valsNo = 0; va_start(bases, argc); for (size_t argNo = 0; argNo < argc; argNo++) { _Base* base = va_arg(bases, _Base*); if (base->getProductionName() == productionName) { size_t toAbsorb = base->toAbsorb(); for (size_t j = 0; j < toAbsorb; j++) vals[valsNo++] = base->absorb(j); // delete base; // had to move to caller so it could toString it first. } else { vals[valsNo++] = base; } } va_end(bases); } } const char* _GenProduction::toStr (std::ofstream* out) { char ** rets = new char*[size]; size_t * sizes = new size_t[size]; size_t strSize = 0; for (size_t i = 0; i < size; i++) { _Base* base = vals[i]; rets[i] = (char*)base->toStr(out); sizes[i] = strlen(rets[i]); strSize += sizes[i]; } char * ret = new char[strSize+size]; // lens plus ' 's plus \0 size_t nowAt = 0; for (size_t i = 0; i < size; i++) { strncpy(ret+nowAt, rets[i], sizes[i]); delete rets[i]; nowAt += sizes[i]; ret[nowAt++] = (i == size - 1) ? '\0' : ' '; } return ret; } const char* _GenProduction::toXml (size_t depth, std::ofstream* out) { char ** rets = new char*[size]; size_t * sizes = new size_t[size]; size_t strSize = depth == 0 ? lns : 0; unsigned leaderLen = depth*tab; char* leader = new char[leaderLen+1]; for (size_t i = 0; i < leaderLen; i++) leader[i] = ' '; leader[leaderLen] = 0; for (size_t i = 0; i < size; i++) { _Base* base = vals[i]; rets[i] = (char*)base->toXml(depth, out); sizes[i] = strlen(rets[i]); strSize += sizes[i]; } char * ret = new char[size*2+8 + strSize]; // @@explain size_t nowAt = 0; openXmlFrame(ret, &nowAt, depth); for (size_t i = 0; i < size; i++) { strncpy(ret+nowAt, rets[i], sizes[i]); delete rets[i]; nowAt += sizes[i]; } ret[nowAt++] = '\0'; closeXmlFrame(ret+nowAt, &nowAt); return ret; } const char* _Token::toStr(std::ofstream*) { const char * ret = new char[strlen(getToken())+1]; strcpy((char*)ret, getToken()); return ret; } const char* _Token::toXml(size_t depth, std::ofstream*) { unsigned leaderLen = depth*tab; char* leader = new char[leaderLen+1]; for (size_t i = 0; i < leaderLen; i++) leader[i] = ' '; leader[leaderLen] = 0; char * ret = new char[leaderLen+lyit*2+6 + strlen(getToken())+1]; strcpy(ret, leader); strcat(ret, "<"); strcat(ret, yit); strcat(ret, ">"); strcat(ret, (char*)getToken()); strcat(ret, "\n"); return (const char*)ret; } const char* _Terminal::toStr(std::ofstream*) { const char * ret = new char[strlen(terminal)+1]; strcpy((char*)ret, terminal); return ret; } const char* _Terminal::toXml(size_t depth, std::ofstream*) { unsigned leaderLen = depth*tab; char* leader = new char[leaderLen+1]; for (size_t i = 0; i < leaderLen; i++) leader[i] = ' '; leader[leaderLen] = 0; char * ret = new char[leaderLen+strlen(getProductionName())*2+6 + strlen(terminal)+1]; strcpy(ret, leader); strcat(ret, "<"); strcat(ret, getProductionName()); strcat(ret, ">"); strcat(ret, (char*)terminal); strcat(ret, "\n"); return (const char*)ret; } /* END yacker-specific test harness */ /* START Driver (@@ stand-alone would allow it to be shared with other parsers */ namespace SPARQLNS { Driver::Driver(class SPARQLContext& _context) : trace_scanning(false), trace_parsing(false), context(_context) { } bool Driver::parse_stream(std::istream& in, const std::string& sname) { streamname = sname; SPARQLScanner scanner(&in); scanner.set_debug(trace_scanning); this->lexer = &scanner; SPARQLParser parser(*this); parser.set_debug_level(trace_parsing); return (parser.parse()); } bool Driver::parse_file(const std::string &filename) { std::ifstream in(filename.c_str()); return parse_stream(in, filename); } bool Driver::parse_string(const std::string &input, const std::string& sname) { std::istringstream iss(input); return parse_stream(iss, sname); } void Driver::error(const class location& l, const std::string& m) { std::cerr << l << ": " << m << std::endl; } void Driver::error(const std::string& m) { std::cerr << m << std::endl; } } // namespace SPARQLNS /* END Driver */ /* START main */ #include // #include "SPARQLFrob.h" #include #include #include #include #include int main(int argc,char **argv) { SPARQLNS::SPARQLContext context; SPARQLNS::Driver driver(context); boost::iostreams::stream_buffer* buf; if (char* tmp = getenv("TRACE_FD")) { std::istringstream is(tmp); int fd; is >> fd; buf = new boost::iostreams::stream_buffer(fd); if (!(_Trace = new std::ostream(buf))) std::cerr << "couldn't open trace fd " << fd << std::endl; } std::istream* yyin; const char* inputId; if (argc > 1) { inputId = argv[1]; yyin = new std::ifstream(argv[1], std::ifstream::in); } else { inputId = ""; yyin = &std::cin; } std::string str(inputId); int result = driver.parse_stream(*yyin, str); if (result) std::cerr << "Error: " << inputId << " did not contain a valid SPARQL string." << std::endl; else std::cout << StupidGlobal->toXml(0); if (_Trace) delete _Trace; return result; }; /* END main */