1 // A Bison parser, made by GNU Bison 3.0.5. 2 3 // Skeleton interface for Bison LALR(1) parsers in C++ 4 5 // Copyright (C) 2002-2015, 2018 Free Software Foundation, Inc. 6 7 // This program is free software: you can redistribute it and/or modify 8 // it under the terms of the GNU General Public License as published by 9 // the Free Software Foundation, either version 3 of the License, or 10 // (at your option) any later version. 11 12 // This program is distributed in the hope that it will be useful, 13 // but WITHOUT ANY WARRANTY; without even the implied warranty of 14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 // GNU General Public License for more details. 16 17 // You should have received a copy of the GNU General Public License 18 // along with this program. If not, see <http://www.gnu.org/licenses/>. 19 20 // As a special exception, you may create a larger work that contains 21 // part or all of the Bison parser skeleton and distribute that work 22 // under terms of your choice, so long as that work isn't itself a 23 // parser generator using the skeleton or a modified version thereof 24 // as a parser skeleton. Alternatively, if you modify or redistribute 25 // the parser skeleton itself, you may (at your option) remove this 26 // special exception, which will cause the skeleton and the resulting 27 // Bison output files to be licensed under the GNU General Public 28 // License without this special exception. 29 30 // This special exception was added by the Free Software Foundation in 31 // version 2.2 of Bison. 32 33 /** 34 ** \file parser.tab.hpp 35 ** Define the yy::parser class. 36 */ 37 38 // C++ LALR(1) parser skeleton written by Akim Demaille. 39 40 #ifndef YY_YY_PARSER_TAB_HPP_INCLUDED 41 # define YY_YY_PARSER_TAB_HPP_INCLUDED 42 // // "%code requires" blocks. 43 #line 20 "parser.ypp" // lalr1.cc:394 44 45 #include <cstdlib> 46 #include <cstring> 47 #include <iostream> 48 #include <sstream> 49 #include <string> 50 51 #include "Ast.h" 52 53 using facebook::graphql::ast::Node; 54 using facebook::graphql::ast::Name; 55 using facebook::graphql::ast::Definition; 56 using facebook::graphql::ast::Document; 57 using facebook::graphql::ast::OperationDefinition; 58 using facebook::graphql::ast::VariableDefinition; 59 using facebook::graphql::ast::Variable; 60 using facebook::graphql::ast::SelectionSet; 61 using facebook::graphql::ast::Selection; 62 using facebook::graphql::ast::Field; 63 using facebook::graphql::ast::Argument; 64 using facebook::graphql::ast::FragmentSpread; 65 using facebook::graphql::ast::InlineFragment; 66 using facebook::graphql::ast::FragmentDefinition; 67 using facebook::graphql::ast::Value; 68 using facebook::graphql::ast::IntValue; 69 using facebook::graphql::ast::FloatValue; 70 using facebook::graphql::ast::StringValue; 71 using facebook::graphql::ast::BooleanValue; 72 using facebook::graphql::ast::NullValue; 73 using facebook::graphql::ast::EnumValue; 74 using facebook::graphql::ast::ListValue; 75 using facebook::graphql::ast::ObjectValue; 76 using facebook::graphql::ast::ObjectField; 77 using facebook::graphql::ast::Directive; 78 using facebook::graphql::ast::Type; 79 using facebook::graphql::ast::NamedType; 80 using facebook::graphql::ast::ListType; 81 using facebook::graphql::ast::NonNullType; 82 83 // Experimental schema support. 84 using facebook::graphql::ast::SchemaDefinition; 85 using facebook::graphql::ast::ScalarTypeDefinition; 86 using facebook::graphql::ast::ObjectTypeDefinition; 87 using facebook::graphql::ast::InterfaceTypeDefinition; 88 using facebook::graphql::ast::UnionTypeDefinition; 89 using facebook::graphql::ast::EnumTypeDefinition; 90 using facebook::graphql::ast::InputObjectTypeDefinition; 91 using facebook::graphql::ast::TypeExtensionDefinition; 92 using facebook::graphql::ast::DirectiveDefinition; 93 using facebook::graphql::ast::SchemaDefinition; 94 using facebook::graphql::ast::OperationTypeDefinition; 95 using facebook::graphql::ast::ScalarTypeDefinition; 96 using facebook::graphql::ast::ObjectTypeDefinition; 97 using facebook::graphql::ast::FieldDefinition; 98 using facebook::graphql::ast::InputValueDefinition; 99 using facebook::graphql::ast::InterfaceTypeDefinition; 100 using facebook::graphql::ast::UnionTypeDefinition; 101 using facebook::graphql::ast::EnumTypeDefinition; 102 using facebook::graphql::ast::EnumValueDefinition; 103 using facebook::graphql::ast::InputObjectTypeDefinition; 104 using facebook::graphql::ast::TypeExtensionDefinition; 105 using facebook::graphql::ast::DirectiveDefinition; 106 107 union yystype { \ 108 const char *str; \ 109 const char *heapStr; \ 110 Name *name; \ 111 Definition *definition; \ 112 Document *document; \ 113 OperationDefinition *operationDefinition; \ 114 VariableDefinition *variableDefinition; \ 115 Variable *variable; \ 116 SelectionSet *selectionSet; \ 117 Selection *selection; \ 118 Field *field; \ 119 Argument *argument; \ 120 FragmentSpread *fragmentSpread; \ 121 InlineFragment *inlineFragment; \ 122 FragmentDefinition *fragmentDefinition; \ 123 Value *value; \ 124 IntValue *intValue; \ 125 FloatValue *floatValue; \ 126 StringValue *stringValue; \ 127 BooleanValue *booleanValue; \ 128 NullValue *nullValue; \ 129 EnumValue *enumValue; \ 130 ListValue *arrayValue; \ 131 ObjectValue *objectValue; \ 132 ObjectField *objectField; \ 133 Directive *directive; \ 134 Type *type; \ 135 NamedType *namedType; \ 136 ListType *listType; \ 137 NonNullType *nonNullType; \ 138 \ 139 std::vector<std::unique_ptr<Definition>> *definitionList; \ 140 std::vector<std::unique_ptr<VariableDefinition>> *variableDefinitionList; \ 141 std::vector<std::unique_ptr<Selection>> *selectionList; \ 142 std::vector<std::unique_ptr<Field>> *fieldList; \ 143 std::vector<std::unique_ptr<Argument>> *argumentList; \ 144 std::vector<std::unique_ptr<Value>> *valueList; \ 145 std::vector<std::unique_ptr<ObjectField>> *objectFieldList; \ 146 std::vector<std::unique_ptr<Directive>> *directiveList; \ 147 \ 148 SchemaDefinition *schemaDefinition; \ 149 ScalarTypeDefinition *scalarTypeDefinition; \ 150 ObjectTypeDefinition *objectTypeDefinition; \ 151 InterfaceTypeDefinition *interfaceTypeDefinition; \ 152 UnionTypeDefinition *unionTypeDefinition; \ 153 EnumTypeDefinition *enumTypeDefinition; \ 154 InputObjectTypeDefinition *inputObjectTypeDefinition; \ 155 TypeExtensionDefinition *typeExtensionDefinition; \ 156 DirectiveDefinition *directiveDefinition; \ 157 OperationTypeDefinition *operationTypeDefinition; \ 158 InputValueDefinition *inputValueDefinition; \ 159 FieldDefinition *fieldDefinition; \ 160 EnumValueDefinition *enumValueDefinition; \ 161 \ 162 std::vector<std::unique_ptr<OperationTypeDefinition>> *operationTypeDefinitionList; \ 163 std::vector<std::unique_ptr<NamedType>> *typeNameList; \ 164 std::vector<std::unique_ptr<InputValueDefinition>> *inputValueDefinitionList; \ 165 std::vector<std::unique_ptr<FieldDefinition>> *fieldDefinitionList; \ 166 std::vector<std::unique_ptr<Name>> *nameList; \ 167 std::vector<std::unique_ptr<EnumValueDefinition>> *enumValueDefinitionList; \ 168 }; 169 170 #define YYSTYPE union yystype 171 #define YYLTYPE yy::location 172 173 174 #line 175 "parser.tab.hpp" // lalr1.cc:394 175 176 177 # include <cstdlib> // std::abort 178 # include <iostream> 179 # include <stdexcept> 180 # include <string> 181 # include <vector> 182 # include "stack.hh" 183 # include "location.hh" 184 185 186 #ifndef YY_ATTRIBUTE 187 # if (defined __GNUC__ \ 188 && (2 < __GNUC__ || (__GNUC__ == 2 && 96 <= __GNUC_MINOR__))) \ 189 || defined __SUNPRO_C && 0x5110 <= __SUNPRO_C 190 # define YY_ATTRIBUTE(Spec) __attribute__(Spec) 191 # else 192 # define YY_ATTRIBUTE(Spec) /* empty */ 193 # endif 194 #endif 195 196 #ifndef YY_ATTRIBUTE_PURE 197 # define YY_ATTRIBUTE_PURE YY_ATTRIBUTE ((__pure__)) 198 #endif 199 200 #ifndef YY_ATTRIBUTE_UNUSED 201 # define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__)) 202 #endif 203 204 #if !defined _Noreturn \ 205 && (!defined __STDC_VERSION__ || __STDC_VERSION__ < 201112) 206 # if defined _MSC_VER && 1200 <= _MSC_VER 207 # define _Noreturn __declspec (noreturn) 208 # else 209 # define _Noreturn YY_ATTRIBUTE ((__noreturn__)) 210 # endif 211 #endif 212 213 /* Suppress unused-variable warnings by "using" E. */ 214 #if ! defined lint || defined __GNUC__ 215 # define YYUSE(E) ((void) (E)) 216 #else 217 # define YYUSE(E) /* empty */ 218 #endif 219 220 #if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__ 221 /* Suppress an incorrect diagnostic about yylval being uninitialized. */ 222 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \ 223 _Pragma ("GCC diagnostic push") \ 224 _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\ 225 _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"") 226 # define YY_IGNORE_MAYBE_UNINITIALIZED_END \ 227 _Pragma ("GCC diagnostic pop") 228 #else 229 # define YY_INITIAL_VALUE(Value) Value 230 #endif 231 #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 232 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 233 # define YY_IGNORE_MAYBE_UNINITIALIZED_END 234 #endif 235 #ifndef YY_INITIAL_VALUE 236 # define YY_INITIAL_VALUE(Value) /* Nothing. */ 237 #endif 238 239 /* Debug traces. */ 240 #ifndef YYDEBUG 241 # define YYDEBUG 0 242 #endif 243 244 245 namespace yy { 246 #line 247 "parser.tab.hpp" // lalr1.cc:394 247 248 249 250 251 252 /// A Bison parser. 253 class GraphQLParserImpl 254 { 255 public: 256 #ifndef YYSTYPE 257 /// Symbol semantic values. 258 259 #else 260 typedef YYSTYPE semantic_type; 261 #endif 262 /// Symbol locations. 263 typedef location location_type; 264 265 /// Syntax errors thrown from user actions. 266 struct syntax_error : std::runtime_error 267 { 268 syntax_error (const location_type& l, const std::string& m); 269 location_type location; 270 }; 271 272 /// Tokens. 273 struct token 274 { 275 enum yytokentype 276 { 277 TOK_EOF = 0, 278 TOK_DIRECTIVE = 258, 279 TOK_ENUM = 259, 280 TOK_EXTEND = 260, 281 TOK_FALSE = 261, 282 TOK_FRAGMENT = 262, 283 TOK_IMPLEMENTS = 263, 284 TOK_INPUT = 264, 285 TOK_INTERFACE = 265, 286 TOK_MUTATION = 266, 287 TOK_NULL = 267, 288 TOK_QUERY = 268, 289 TOK_ON = 269, 290 TOK_SCALAR = 270, 291 TOK_SCHEMA = 271, 292 TOK_SUBSCRIPTION = 272, 293 TOK_TRUE = 273, 294 TOK_TYPE = 274, 295 TOK_UNION = 275, 296 TOK_BANG = 276, 297 TOK_LPAREN = 277, 298 TOK_RPAREN = 278, 299 TOK_ELLIPSIS = 279, 300 TOK_COLON = 280, 301 TOK_EQUAL = 281, 302 TOK_AT = 282, 303 TOK_LBRACKET = 283, 304 TOK_RBRACKET = 284, 305 TOK_LBRACE = 285, 306 TOK_PIPE = 286, 307 TOK_RBRACE = 287, 308 TOK_VARIABLE = 288, 309 TOK_INTEGER = 289, 310 TOK_FLOAT = 290, 311 TOK_STRING = 291, 312 TOK_IDENTIFIER = 292 313 }; 314 }; 315 316 /// (External) token type, as returned by yylex. 317 typedef token::yytokentype token_type; 318 319 /// Symbol type: an internal symbol number. 320 typedef int symbol_number_type; 321 322 /// The symbol type number to denote an empty symbol. 323 enum { empty_symbol = -2 }; 324 325 /// Internal symbol number for tokens (subsumed by symbol_number_type). 326 typedef unsigned char token_number_type; 327 328 /// A complete symbol. 329 /// 330 /// Expects its Base type to provide access to the symbol type 331 /// via type_get(). 332 /// 333 /// Provide access to semantic value and location. 334 template <typename Base> 335 struct basic_symbol : Base 336 { 337 /// Alias to Base. 338 typedef Base super_type; 339 340 /// Default constructor. 341 basic_symbol (); 342 343 /// Copy constructor. 344 basic_symbol (const basic_symbol& other); 345 346 /// Constructor for valueless symbols. 347 basic_symbol (typename Base::kind_type t, 348 const location_type& l); 349 350 /// Constructor for symbols with semantic value. 351 basic_symbol (typename Base::kind_type t, 352 const semantic_type& v, 353 const location_type& l); 354 355 /// Destroy the symbol. 356 ~basic_symbol (); 357 358 /// Destroy contents, and record that is empty. 359 void clear (); 360 361 /// Whether empty. 362 bool empty () const; 363 364 /// Destructive move, \a s is emptied into this. 365 void move (basic_symbol& s); 366 367 /// The semantic value. 368 semantic_type value; 369 370 /// The location. 371 location_type location; 372 373 private: 374 /// Assignment operator. 375 basic_symbol& operator= (const basic_symbol& other); 376 }; 377 378 /// Type access provider for token (enum) based symbols. 379 struct by_type 380 { 381 /// Default constructor. 382 by_type (); 383 384 /// Copy constructor. 385 by_type (const by_type& other); 386 387 /// The symbol type as needed by the constructor. 388 typedef token_type kind_type; 389 390 /// Constructor from (external) token numbers. 391 by_type (kind_type t); 392 393 /// Record that this symbol is empty. 394 void clear (); 395 396 /// Steal the symbol type from \a that. 397 void move (by_type& that); 398 399 /// The (internal) type number (corresponding to \a type). 400 /// \a empty when empty. 401 symbol_number_type type_get () const; 402 403 /// The token. 404 token_type token () const; 405 406 /// The symbol type. 407 /// \a empty_symbol when empty. 408 /// An int, not token_number_type, to be able to store empty_symbol. 409 int type; 410 }; 411 412 /// "External" symbols: returned by the scanner. 413 typedef basic_symbol<by_type> symbol_type; 414 415 416 /// Build a parser object. 417 GraphQLParserImpl (bool enableSchema_yyarg, Node **outAST_yyarg, const char **outError_yyarg, void *scanner_yyarg); 418 virtual ~GraphQLParserImpl (); 419 420 /// Parse. 421 /// \returns 0 iff parsing succeeded. 422 virtual int parse (); 423 424 #if YYDEBUG 425 /// The current debugging stream. 426 std::ostream& debug_stream () const YY_ATTRIBUTE_PURE; 427 /// Set the current debugging stream. 428 void set_debug_stream (std::ostream &); 429 430 /// Type for debugging levels. 431 typedef int debug_level_type; 432 /// The current debugging level. 433 debug_level_type debug_level () const YY_ATTRIBUTE_PURE; 434 /// Set the current debugging level. 435 void set_debug_level (debug_level_type l); 436 #endif 437 438 /// Report a syntax error. 439 /// \param loc where the syntax error is found. 440 /// \param msg a description of the syntax error. 441 virtual void error (const location_type& loc, const std::string& msg); 442 443 /// Report a syntax error. 444 void error (const syntax_error& err); 445 446 private: 447 /// This class is not copyable. 448 GraphQLParserImpl (const GraphQLParserImpl&); 449 GraphQLParserImpl& operator= (const GraphQLParserImpl&); 450 451 /// State numbers. 452 typedef int state_type; 453 454 /// Generate an error message. 455 /// \param yystate the state where the error occurred. 456 /// \param yyla the lookahead token. 457 virtual std::string yysyntax_error_ (state_type yystate, 458 const symbol_type& yyla) const; 459 460 /// Compute post-reduction state. 461 /// \param yystate the current state 462 /// \param yysym the nonterminal to push on the stack 463 state_type yy_lr_goto_state_ (state_type yystate, int yysym); 464 465 /// Whether the given \c yypact_ value indicates a defaulted state. 466 /// \param yyvalue the value to check 467 static bool yy_pact_value_is_default_ (int yyvalue); 468 469 /// Whether the given \c yytable_ value indicates a syntax error. 470 /// \param yyvalue the value to check 471 static bool yy_table_value_is_error_ (int yyvalue); 472 473 static const short int yypact_ninf_; 474 static const signed char yytable_ninf_; 475 476 /// Convert a scanner token number \a t to a symbol number. 477 static token_number_type yytranslate_ (int t); 478 479 // Tables. 480 // YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing 481 // STATE-NUM. 482 static const short int yypact_[]; 483 484 // YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM. 485 // Performed when YYTABLE does not specify something else to do. Zero 486 // means the default is an error. 487 static const unsigned char yydefact_[]; 488 489 // YYPGOTO[NTERM-NUM]. 490 static const short int yypgoto_[]; 491 492 // YYDEFGOTO[NTERM-NUM]. 493 static const short int yydefgoto_[]; 494 495 // YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If 496 // positive, shift that token. If negative, reduce the rule whose 497 // number is the opposite. If YYTABLE_NINF, syntax error. 498 static const unsigned short int yytable_[]; 499 500 static const short int yycheck_[]; 501 502 // YYSTOS[STATE-NUM] -- The (internal number of the) accessing 503 // symbol of state STATE-NUM. 504 static const unsigned char yystos_[]; 505 506 // YYR1[YYN] -- Symbol number of symbol that rule YYN derives. 507 static const unsigned char yyr1_[]; 508 509 // YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. 510 static const unsigned char yyr2_[]; 511 512 513 /// Convert the symbol name \a n to a form suitable for a diagnostic. 514 static std::string yytnamerr_ (const char *n); 515 516 517 /// For a symbol, its name in clear. 518 static const char* const yytname_[]; 519 #if YYDEBUG 520 // YYRLINE[YYN] -- Source line where rule number YYN was defined. 521 static const unsigned short int yyrline_[]; 522 /// Report on the debug stream that the rule \a r is going to be reduced. 523 virtual void yy_reduce_print_ (int r); 524 /// Print the state stack on the debug stream. 525 virtual void yystack_print_ (); 526 527 // Debugging. 528 int yydebug_; 529 std::ostream* yycdebug_; 530 531 /// \brief Display a symbol type, value and location. 532 /// \param yyo The output stream. 533 /// \param yysym The symbol. 534 template <typename Base> 535 void yy_print_ (std::ostream& yyo, const basic_symbol<Base>& yysym) const; 536 #endif 537 538 /// \brief Reclaim the memory associated to a symbol. 539 /// \param yymsg Why this token is reclaimed. 540 /// If null, print nothing. 541 /// \param yysym The symbol. 542 template <typename Base> 543 void yy_destroy_ (const char* yymsg, basic_symbol<Base>& yysym) const; 544 545 private: 546 /// Type access provider for state based symbols. 547 struct by_state 548 { 549 /// Default constructor. 550 by_state (); 551 552 /// The symbol type as needed by the constructor. 553 typedef state_type kind_type; 554 555 /// Constructor. 556 by_state (kind_type s); 557 558 /// Copy constructor. 559 by_state (const by_state& other); 560 561 /// Record that this symbol is empty. 562 void clear (); 563 564 /// Steal the symbol type from \a that. 565 void move (by_state& that); 566 567 /// The (internal) type number (corresponding to \a state). 568 /// \a empty_symbol when empty. 569 symbol_number_type type_get () const; 570 571 /// The state number used to denote an empty symbol. 572 enum { empty_state = -1 }; 573 574 /// The state. 575 /// \a empty when empty. 576 state_type state; 577 }; 578 579 /// "Internal" symbol: element of the stack. 580 struct stack_symbol_type : basic_symbol<by_state> 581 { 582 /// Superclass. 583 typedef basic_symbol<by_state> super_type; 584 /// Construct an empty symbol. 585 stack_symbol_type (); 586 /// Copy construct. 587 stack_symbol_type (const stack_symbol_type& that); 588 /// Steal the contents from \a sym to build this. 589 stack_symbol_type (state_type s, symbol_type& sym); 590 /// Assignment, needed by push_back. 591 stack_symbol_type& operator= (const stack_symbol_type& that); 592 }; 593 594 /// Stack type. 595 typedef stack<stack_symbol_type> stack_type; 596 597 /// The stack. 598 stack_type yystack_; 599 600 /// Push a new state on the stack. 601 /// \param m a debug message to display 602 /// if null, no trace is output. 603 /// \param s the symbol 604 /// \warning the contents of \a s.value is stolen. 605 void yypush_ (const char* m, stack_symbol_type& s); 606 607 /// Push a new look ahead token on the state on the stack. 608 /// \param m a debug message to display 609 /// if null, no trace is output. 610 /// \param s the state 611 /// \param sym the symbol (for its value and location). 612 /// \warning the contents of \a s.value is stolen. 613 void yypush_ (const char* m, state_type s, symbol_type& sym); 614 615 /// Pop \a n symbols the three stacks. 616 void yypop_ (unsigned n = 1); 617 618 /// Constants. 619 enum 620 { 621 yyeof_ = 0, 622 yylast_ = 955, ///< Last index in yytable_. 623 yynnts_ = 79, ///< Number of nonterminal symbols. 624 yyfinal_ = 74, ///< Termination state number. 625 yyterror_ = 1, 626 yyerrcode_ = 256, 627 yyntokens_ = 38 ///< Number of tokens. 628 }; 629 630 631 // User arguments. 632 bool enableSchema; 633 Node **outAST; 634 const char **outError; 635 void *scanner; 636 }; 637 638 639 640 } // yy 641 #line 642 "parser.tab.hpp" // lalr1.cc:394 642 643 644 645 646 #endif // !YY_YY_PARSER_TAB_HPP_INCLUDED 647