rails-graphql 0.1.0

data/ext/graphqlparser/c/GraphQLParser.h

@@ -0,0 +1,54 @@
+/**
+ * Copyright 2019-present, GraphQL Foundation
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <stdio.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * This file provides C wrappers for ../GraphQLParser.h.
+ */
+
+struct GraphQLAstNode;
+
+/**
+ * Parse the given GraphQL source string, returning an AST. Returns
+ * NULL on error. Return value must be freed with
+ * graphql_node_free(). If NULL is returned and error is not NULL, an
+ * error message is placed in error and must be freed with
+ * graphql_error_free().
+ */
+struct GraphQLAstNode *graphql_parse_string(
+    const char *text, const char **error);
+
+struct GraphQLAstNode *graphql_parse_string_with_experimental_schema_support(
+    const char *text, const char **error);
+
+/**
+ * Read and parse GraphQL source from the given file, returning an
+ * AST. Returns nullptr on error. Return value must be freed with
+ * graphql_node_free(). If NULL is returned and error is not NULL, an
+ * error message is placed in error and must be freed with
+ * graphql_error_free().
+ */
+struct GraphQLAstNode *graphql_parse_file(FILE *file, const char **error);
+
+struct GraphQLAstNode *graphql_parse_file_with_experimental_schema_support(
+    FILE *file, const char **error);
+
+/**
+ * Frees an error.
+ */
+void graphql_error_free(const char *error);
+
+#ifdef __cplusplus
+}
+#endif

data/ext/graphqlparser/dump_json_ast.cpp

@@ -0,0 +1,48 @@
+/**
+ * Copyright 2019-present, GraphQL Foundation
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include "AstNode.h"
+#include "GraphQLParser.h"
+#include "c/GraphQLAstToJSON.h"
+
+#include <cstdio>
+#include <cstdlib>
+#include <iostream>
+
+
+using std::cout;
+using std::cerr;
+using std::endl;
+using std::fopen;
+using std::fclose;
+using std::free;
+
+
+int main(int argc, char **argv) {
+  const char *error;
+  FILE * in;
+  if (argc > 1) {
+    in = fopen(argv[1], "r"); // NOLINT
+  } else {
+    in = stdin;
+  }
+  auto AST = facebook::graphql::parseFile(in, &error);
+  if (argc > 1) {
+    fclose(in);
+  }
+  if (!AST) {
+    cerr << "Parser failed with error: " << error << endl;
+    free((void *)error);  // NOLINT
+    return 1;
+  }
+
+  const char *json = graphql_ast_to_json(reinterpret_cast<const struct GraphQLAstNode *>(AST.get()));
+  puts(json);
+  free((void *)json);  // NOLINT
+
+  return 0;
+}

data/ext/graphqlparser/lexer.lpp

@@ -0,0 +1,324 @@
+/**
+ * Copyright 2019-present, GraphQL Foundation
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+%{
+#include <algorithm>
+#include <cassert>
+#include <cctype>
+#include <climits>
+#include <cstdio>
+#include <string>
+#include <vector>
+#include "location.hh"
+#include "position.hh"
+#include "parser.tab.hpp"
+#include "syntaxdefs.h"
+
+// Keep track of token lengths.
+#define YY_USER_ACTION yyextra->loc.columns(yyleng);
+
+static void escape(char c, char *buf);
+
+static std::string clean_up_block_string(const std::string &str);
+
+%}
+
+%option bison-bridge bison-locations
+%option noyywrap batch noinput nounput
+%option reentrant
+%option extra-type="struct LexerExtra *"
+
+%x STRING_STATE
+%x BLOCK_STRING_STATE
+%x C_COMMENT_STATE
+%x LINE_COMMENT_STATE
+
+FLOAT -?(0|[1-9][0-9]*)(\.[0-9]+)?([eE][+-]?[0-9]+)?
+INTEGER -?(0|[1-9][0-9]*)
+IDENTIFIER [_A-Za-z][_0-9A-Za-z]*
+VARIABLE $[_0-9A-Za-z]+
+BOM \xef\xbb\xbf
+CRLF \r\n
+BADCHAR [\x00-\x08\x0b\x0c\x0e-\x1f]
+GOODCHAR [^\x00-\x08\x0b\x0c\x0e-\x1f]
+STRINGCHAR [^\x00-\x1f\\\x22]
+
+blank [ \t,]
+newline [\n\r]
+notnewline [^\n\r]
+
+%%
+
+%{
+  yyextra->loc.step();
+%}
+
+<STRING_STATE>{
+  \"    {
+    BEGIN(INITIAL);
+    yylval->str = yyextra->str.c_str();
+    *yylloc = yyextra->loc;
+    return yy::GraphQLParserImpl::token::TOK_STRING;
+  }
+
+  {newline} {
+    throw make_error(yyextra->loc, "Unterminated string");
+  }
+
+  <<EOF>> {
+    throw make_error(yyextra->loc, "Unterminated string at EOF");
+  }
+
+  {STRINGCHAR}+  {
+    char *p = yytext;
+    while (*p) {
+      yyextra->str.push_back(*p++);
+    }
+  }
+
+  \\\" { yyextra->str.push_back('"'); }
+  \\\\ { yyextra->str.push_back('\\'); }
+  \\\/ { yyextra->str.push_back('/'); }
+  \\n { yyextra->str.push_back('\n'); }
+  \\t { yyextra->str.push_back('\t'); }
+  \\r { yyextra->str.push_back('\r'); }
+  \\b { yyextra->str.push_back('\b'); }
+  \\f { yyextra->str.push_back('\f'); }
+
+  \\u[0-9A-Fa-f]{4} {
+    int ch;
+    sscanf(yytext + 2, "%x", &ch);
+    yyextra->str.push_back(ch);
+  }
+
+  \\u { throw make_error(yyextra->loc, "bad Unicode escape sequence"); }
+  \\. { throw make_error(yyextra->loc, std::string("bad escape sequence \\") + yytext[1]); }
+
+}
+
+<BLOCK_STRING_STATE>{
+  <<EOF>> {
+     throw make_error(yyextra->loc, "Unterminated block string at EOF");
+  }
+
+  {BADCHAR} {
+     throw make_error(yyextra->loc, std::string("Invalid character ") + yytext[0]);
+  }
+
+  {GOODCHAR} {
+    /* Can't use {GOODCHAR}+ because that would be a better match for
+       """ than the explicit rule! */
+    yyextra->str.push_back(*yytext);
+  }
+
+  \\\"\"\" {
+    yyextra->str.append(3, '"');
+  }
+
+  \"\"\" {
+    BEGIN(INITIAL);
+    yyextra->str = clean_up_block_string(yyextra->str);
+    yylval->str = yyextra->str.c_str();
+    *yylloc = yyextra->loc;
+    return yy::GraphQLParserImpl::token::TOK_STRING;
+  }
+}
+
+<LINE_COMMENT_STATE>{
+  {CRLF} { yyextra->loc.lines(yyleng / 2); yyextra->loc.step(); BEGIN(INITIAL); }
+  {newline} { yyextra->loc.lines(yyleng); yyextra->loc.step(); BEGIN(INITIAL); }
+  {notnewline}+ /* eat comment character */
+}
+
+<INITIAL>{
+  {blank}+ { yyextra->loc.step(); }
+  {BOM}+ { yyextra->loc.step(); yyextra->loc.step(); yyextra->loc.step(); }
+  {CRLF}+ { yyextra->loc.lines(yyleng / 2); yyextra->loc.step(); }
+  {newline}+ { yyextra->loc.lines(yyleng); yyextra->loc.step(); }
+
+  # {yyextra->loc.step(); BEGIN(LINE_COMMENT_STATE); }
+
+  directive   { yylval->str = yytext; *yylloc = yyextra->loc; return yy::GraphQLParserImpl::token::TOK_DIRECTIVE; }
+  enum   { yylval->str = yytext; *yylloc = yyextra->loc; return yy::GraphQLParserImpl::token::TOK_ENUM; }
+  extend   { yylval->str = yytext; *yylloc = yyextra->loc; return yy::GraphQLParserImpl::token::TOK_EXTEND; }
+  false   { yylval->str = yytext; *yylloc = yyextra->loc; return yy::GraphQLParserImpl::token::TOK_FALSE; }
+  fragment { yylval->str = yytext; *yylloc = yyextra->loc; return yy::GraphQLParserImpl::token::TOK_FRAGMENT; }
+  implements { yylval->str = yytext; *yylloc = yyextra->loc; return yy::GraphQLParserImpl::token::TOK_IMPLEMENTS; }
+  input { yylval->str = yytext; *yylloc = yyextra->loc; return yy::GraphQLParserImpl::token::TOK_INPUT; }
+  interface { yylval->str = yytext; *yylloc = yyextra->loc; return yy::GraphQLParserImpl::token::TOK_INTERFACE; }
+  mutation { yylval->str = yytext; *yylloc = yyextra->loc; return yy::GraphQLParserImpl::token::TOK_MUTATION; }
+  null { yylval->str = yytext; *yylloc = yyextra->loc; return yy::GraphQLParserImpl::token::TOK_NULL; }
+  on { yylval->str = yytext; *yylloc = yyextra->loc; return yy::GraphQLParserImpl::token::TOK_ON; }
+  query { yylval->str = yytext; *yylloc = yyextra->loc; return yy::GraphQLParserImpl::token::TOK_QUERY; }
+  scalar { yylval->str = yytext; *yylloc = yyextra->loc; return yy::GraphQLParserImpl::token::TOK_SCALAR; }
+  schema { yylval->str = yytext; *yylloc = yyextra->loc; return yy::GraphQLParserImpl::token::TOK_SCHEMA; }
+  subscription { yylval->str = yytext; *yylloc = yyextra->loc; return yy::GraphQLParserImpl::token::TOK_SUBSCRIPTION; }
+  true { yylval->str = yytext; *yylloc = yyextra->loc; return yy::GraphQLParserImpl::token::TOK_TRUE; }
+  type { yylval->str = yytext; *yylloc = yyextra->loc; return yy::GraphQLParserImpl::token::TOK_TYPE; }
+  union { yylval->str = yytext; *yylloc = yyextra->loc; return yy::GraphQLParserImpl::token::TOK_UNION; }
+
+  {INTEGER} { yylval->str = yytext; *yylloc = yyextra->loc; return yy::GraphQLParserImpl::token::TOK_INTEGER; }
+  {FLOAT} { yylval->str = yytext; *yylloc = yyextra->loc; return yy::GraphQLParserImpl::token::TOK_FLOAT; }
+  {IDENTIFIER} { yylval->str = yytext; *yylloc = yyextra->loc; return yy::GraphQLParserImpl::token::TOK_IDENTIFIER; }
+  {VARIABLE} { yylval->str = yytext + 1; *yylloc = yyextra->loc; return yy::GraphQLParserImpl::token::TOK_VARIABLE; }
+
+  "!" { *yylloc = yyextra->loc; return yy::GraphQLParserImpl::token::TOK_BANG; }
+  "(" { *yylloc = yyextra->loc; return yy::GraphQLParserImpl::token::TOK_LPAREN; }
+  ")" { *yylloc = yyextra->loc; return yy::GraphQLParserImpl::token::TOK_RPAREN; }
+  "..." { *yylloc = yyextra->loc; return yy::GraphQLParserImpl::token::TOK_ELLIPSIS; }
+  ":" { *yylloc = yyextra->loc; return yy::GraphQLParserImpl::token::TOK_COLON; }
+  "=" { *yylloc = yyextra->loc; return yy::GraphQLParserImpl::token::TOK_EQUAL; }
+  "@" { *yylloc = yyextra->loc; return yy::GraphQLParserImpl::token::TOK_AT; }
+  "[" { *yylloc = yyextra->loc; return yy::GraphQLParserImpl::token::TOK_LBRACKET; }
+  "]" { *yylloc = yyextra->loc; return yy::GraphQLParserImpl::token::TOK_RBRACKET; }
+  "{" { *yylloc = yyextra->loc; return yy::GraphQLParserImpl::token::TOK_LBRACE; }
+  "|" { *yylloc = yyextra->loc; return yy::GraphQLParserImpl::token::TOK_PIPE; }
+  "}" { *yylloc = yyextra->loc; return yy::GraphQLParserImpl::token::TOK_RBRACE; }
+
+
+  <<EOF>> { *yylloc = yyextra->loc; return yy::GraphQLParserImpl::token::TOK_EOF; }
+
+  \"\"\" {
+    BEGIN(BLOCK_STRING_STATE);
+    yyextra->str.clear();
+  }
+
+  \"   {
+    BEGIN(STRING_STATE);
+    yyextra->str.clear();
+  }
+}
+
+<INITIAL,STRING_STATE,LINE_COMMENT_STATE>. {
+  char buf[6];
+  escape(yytext[0], buf);
+  throw make_error(
+    yyextra->loc,
+    std::string("unrecognized character ") + buf);
+}
+
+%%
+
+static void escape(char c, char *buf) {
+  if (std::isgraph(c)) {
+    *buf = c;
+    buf[1] = '\0';
+  } else {
+    buf[0] = '\\';
+    buf[2] = '\0';
+    switch (c) {
+    case '\a':
+      buf[1] = 'a';
+      break;
+    case '\b':
+      buf[1] = 'b';
+      break;
+    case '\f':
+      buf[1] = 'f';
+      break;
+    case '\n':
+      buf[1] = 'n';
+      break;
+    case '\r':
+      buf[1] = 'r';
+      break;
+    case '\t':
+      buf[1] = 't';
+      break;
+    case '\v':
+      buf[1] = 'v';
+      break;
+    default:
+      buf[1] = 'x';
+      std::snprintf(buf + 2, 3, "%x", ((int)c & 0xFF));
+      break;
+    }
+  }
+}
+
+static std::vector<std::string> splitLines(const std::string &str) {
+  std::vector<std::string> lines;
+  auto it = str.begin();
+  while (it != str.end()) {
+    static char terminators[2] = {'\r', '\n'};
+    auto nextIt = std::find_first_of(it, str.end(), terminators, terminators + sizeof(terminators));
+    lines.emplace_back(str.data() + (it - str.begin()), nextIt - it);
+    if (nextIt != str.end()) {
+      auto advancedIt = nextIt + 1;
+      if (advancedIt != str.end()) {
+        if (*nextIt == '\r' && *advancedIt == '\n') {
+          ++advancedIt;
+        }
+      }
+      nextIt = std::move(advancedIt);
+    }
+    it = std::move(nextIt);
+  }
+  return lines;
+}
+
+static int count_leading_whitespace(const std::string &str) {
+  auto pos = str.find_first_not_of(" \t", 0, strlen(" \t"));
+  if (pos == std::string::npos) {
+    return str.length();
+  }
+  return pos;
+}
+
+static bool is_all_whitespace(const std::string &str) {
+  return count_leading_whitespace(str) == str.length();
+}
+
+static std::string clean_up_block_string(const std::string &str) {
+  auto lines = splitLines(str);
+  bool first = true;
+  int commonIndent = INT_MAX;
+  for (const auto &line : lines) {
+    if (first) {
+      first = false;
+      continue;
+    }
+    const auto indent = count_leading_whitespace(line);
+    if (indent < line.length()) {
+      if (indent < commonIndent) {
+        commonIndent = indent;
+      }
+    }
+  }
+  if (commonIndent != INT_MAX) {
+    first = true;
+    for (auto &line : lines) {
+      if (first) {
+        first = false;
+        continue;
+      }
+      line.erase(0, commonIndent);
+    }
+  }
+
+  const auto firstNonBlankIt = std::find_if(lines.begin(), lines.end(), [](const std::string &line) {
+      return !is_all_whitespace(line);
+  });
+  lines.erase(lines.begin(), firstNonBlankIt);
+
+  const auto firstNonBlankReverseIt = std::find_if(lines.rbegin(), lines.rend(), [](const std::string &line) {
+      return !is_all_whitespace(line);
+  });
+  lines.erase(lines.end() - (firstNonBlankReverseIt - lines.rbegin()), lines.end());
+
+  std::string formatted;
+  first = true;
+  for (const auto &line: lines) {
+    if (first) {
+      first = false;
+    } else {
+      formatted.push_back('\n');
+    }
+    formatted.append(line);
+  }
+  return formatted;
+}

data/ext/graphqlparser/parser.ypp

@@ -0,0 +1,693 @@
+/**
+ * Copyright 2019-present, GraphQL Foundation
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+%require "3"
+
+%skeleton "lalr1.cc"
+
+%defines
+%define parser_class_name {GraphQLParserImpl}
+
+%define api.token.prefix {TOK_}
+
+%define parse.error verbose
+
+%code requires
+{
+#include <cstdlib>
+#include <cstring>
+#include <iostream>
+#include <sstream>
+#include <string>
+
+#include "Ast.h"
+
+using facebook::graphql::ast::Node;
+using facebook::graphql::ast::Name;
+using facebook::graphql::ast::Definition;
+using facebook::graphql::ast::Document;
+using facebook::graphql::ast::OperationDefinition;
+using facebook::graphql::ast::VariableDefinition;
+using facebook::graphql::ast::Variable;
+using facebook::graphql::ast::SelectionSet;
+using facebook::graphql::ast::Selection;
+using facebook::graphql::ast::Field;
+using facebook::graphql::ast::Argument;
+using facebook::graphql::ast::FragmentSpread;
+using facebook::graphql::ast::InlineFragment;
+using facebook::graphql::ast::FragmentDefinition;
+using facebook::graphql::ast::Value;
+using facebook::graphql::ast::IntValue;
+using facebook::graphql::ast::FloatValue;
+using facebook::graphql::ast::StringValue;
+using facebook::graphql::ast::BooleanValue;
+using facebook::graphql::ast::NullValue;
+using facebook::graphql::ast::EnumValue;
+using facebook::graphql::ast::ListValue;
+using facebook::graphql::ast::ObjectValue;
+using facebook::graphql::ast::ObjectField;
+using facebook::graphql::ast::Directive;
+using facebook::graphql::ast::Type;
+using facebook::graphql::ast::NamedType;
+using facebook::graphql::ast::ListType;
+using facebook::graphql::ast::NonNullType;
+
+// Experimental schema support.
+using facebook::graphql::ast::SchemaDefinition;
+using facebook::graphql::ast::ScalarTypeDefinition;
+using facebook::graphql::ast::ObjectTypeDefinition;
+using facebook::graphql::ast::InterfaceTypeDefinition;
+using facebook::graphql::ast::UnionTypeDefinition;
+using facebook::graphql::ast::EnumTypeDefinition;
+using facebook::graphql::ast::InputObjectTypeDefinition;
+using facebook::graphql::ast::TypeExtensionDefinition;
+using facebook::graphql::ast::DirectiveDefinition;
+using facebook::graphql::ast::SchemaDefinition;
+using facebook::graphql::ast::OperationTypeDefinition;
+using facebook::graphql::ast::ScalarTypeDefinition;
+using facebook::graphql::ast::ObjectTypeDefinition;
+using facebook::graphql::ast::FieldDefinition;
+using facebook::graphql::ast::InputValueDefinition;
+using facebook::graphql::ast::InterfaceTypeDefinition;
+using facebook::graphql::ast::UnionTypeDefinition;
+using facebook::graphql::ast::EnumTypeDefinition;
+using facebook::graphql::ast::EnumValueDefinition;
+using facebook::graphql::ast::InputObjectTypeDefinition;
+using facebook::graphql::ast::TypeExtensionDefinition;
+using facebook::graphql::ast::DirectiveDefinition;
+
+union yystype {                                         \
+    const char *str;                                    \
+    const char *heapStr;                                \
+    Name *name;                                         \
+    Definition *definition;                             \
+    Document *document;                                 \
+    OperationDefinition *operationDefinition;           \
+    VariableDefinition *variableDefinition;             \
+    Variable *variable;                                 \
+    SelectionSet *selectionSet;                     \
+    Selection *selection;                           \
+    Field *field;                                   \
+    Argument *argument;                             \
+    FragmentSpread *fragmentSpread;                 \
+    InlineFragment *inlineFragment;                 \
+    FragmentDefinition *fragmentDefinition;         \
+    Value *value;                                   \
+    IntValue *intValue;                             \
+    FloatValue *floatValue;                         \
+    StringValue *stringValue;                       \
+    BooleanValue *booleanValue;                     \
+    NullValue *nullValue;                           \
+    EnumValue *enumValue;                           \
+    ListValue *arrayValue;                          \
+    ObjectValue *objectValue;                       \
+    ObjectField *objectField;                       \
+    Directive *directive;                           \
+    Type *type;                                     \
+    NamedType *namedType;                           \
+    ListType *listType;                             \
+    NonNullType *nonNullType;                       \
+    \
+    std::vector<std::unique_ptr<Definition>> *definitionList;       \
+    std::vector<std::unique_ptr<VariableDefinition>> *variableDefinitionList; \
+    std::vector<std::unique_ptr<Selection>> *selectionList;         \
+    std::vector<std::unique_ptr<Field>> *fieldList;                 \
+    std::vector<std::unique_ptr<Argument>> *argumentList;           \
+    std::vector<std::unique_ptr<Value>> *valueList;                 \
+    std::vector<std::unique_ptr<ObjectField>> *objectFieldList;     \
+    std::vector<std::unique_ptr<Directive>> *directiveList;         \
+                                                                    \
+    SchemaDefinition *schemaDefinition;                             \
+    ScalarTypeDefinition *scalarTypeDefinition;                     \
+    ObjectTypeDefinition *objectTypeDefinition;                     \
+    InterfaceTypeDefinition *interfaceTypeDefinition;               \
+    UnionTypeDefinition *unionTypeDefinition;                       \
+    EnumTypeDefinition *enumTypeDefinition;                         \
+    InputObjectTypeDefinition *inputObjectTypeDefinition;           \
+    TypeExtensionDefinition *typeExtensionDefinition;               \
+    DirectiveDefinition *directiveDefinition;                       \
+    OperationTypeDefinition *operationTypeDefinition;               \
+    InputValueDefinition *inputValueDefinition;                     \
+    FieldDefinition *fieldDefinition;                               \
+    EnumValueDefinition *enumValueDefinition;                       \
+    \
+    std::vector<std::unique_ptr<OperationTypeDefinition>> *operationTypeDefinitionList; \
+    std::vector<std::unique_ptr<NamedType>> *typeNameList;          \
+    std::vector<std::unique_ptr<InputValueDefinition>> *inputValueDefinitionList; \
+    std::vector<std::unique_ptr<FieldDefinition>> *fieldDefinitionList; \
+    std::vector<std::unique_ptr<Name>> *nameList;          \
+    std::vector<std::unique_ptr<EnumValueDefinition>> *enumValueDefinitionList; \
+};
+
+#define YYSTYPE union yystype
+#define YYLTYPE yy::location
+
+}
+
+%lex-param { void *scanner }
+%parse-param { bool enableSchema } { Node **outAST } { const char **outError } { void *scanner }
+
+%locations
+
+%code
+{
+#include "lexer.h"
+#include "syntaxdefs.h"
+}
+
+%token EOF 0
+%token <str> DIRECTIVE "directive"
+%token <str> ENUM "enum"
+%token <str> EXTEND "extend"
+%token <str> FALSE "false"
+%token <str> FRAGMENT "fragment"
+%token <str> IMPLEMENTS "implements"
+%token <str> INPUT "input"
+%token <str> INTERFACE "interface"
+%token <str> MUTATION "mutation"
+%token <str> NULL "null"
+%token <str> QUERY "query"
+%token <str> ON "on"
+%token <str> SCALAR "scalar"
+%token <str> SCHEMA "schema"
+%token <str> SUBSCRIPTION "subscription"
+%token <str> TRUE "true"
+%token <str> TYPE "type"
+%token <str> UNION "union"
+%token BANG "!"
+%token LPAREN "("
+%token RPAREN ")"
+%token ELLIPSIS "..."
+%token COLON ":"
+%token EQUAL "="
+%token AT "@"
+%token LBRACKET "["
+%token RBRACKET "]"
+%token LBRACE "{"
+%token PIPE "|"
+%token RBRACE "}"
+
+%token <str> VARIABLE
+%token <str> INTEGER
+%token <str> FLOAT
+%token <str> STRING
+%token <str> IDENTIFIER
+
+%type <variable> variable
+%type <intValue> int_value
+%type <floatValue> float_value
+%type <stringValue> string_value
+
+%type <document> start
+%type <document> document
+%type <name> fragment_name
+%type <name> name
+%type <name> name_opt
+
+%type <definitionList> definition_list
+%type <definition> definition
+%type <definition> schema_gate
+
+%type <operationDefinition> operation_definition
+%type <variableDefinitionList> variable_definitions
+%type <variableDefinitionList> variable_definition_list
+%type <variableDefinition> variable_definition
+%type <value> default_value_opt
+%type <value> default_value
+%type <selectionSet> selection_set
+%type <selectionSet> selection_set_opt
+%type <selectionList> selection_list
+%type <selection> selection
+%type <field> field
+%type <argumentList> arguments_opt
+%type <argumentList> arguments
+%type <argumentList> argument_list
+%type <argument> argument
+
+%type <fragmentSpread> fragment_spread
+%type <inlineFragment> inline_fragment
+%type <fragmentDefinition> fragment_definition
+%type <namedType> type_condition
+
+%type <value> value
+%type <value> value_const
+%type <booleanValue> boolean_value
+%type <nullValue> null_value
+%type <enumValue> enum_value
+%type <arrayValue> list_value
+%type <arrayValue> list_value_const
+%type <valueList> value_list
+%type <valueList> value_const_list
+%type <objectValue> object_value
+%type <objectValue> object_value_const
+%type <objectFieldList> object_field_list
+%type <objectFieldList> object_field_const_list
+%type <objectField> object_field
+%type <objectField> object_field_const
+
+
+%type <directiveList> directives
+%type <directiveList> directives_opt
+%type <directiveList> directive_list
+%type <directive> directive
+
+%type <type> type
+%type <namedType> type_name
+%type <listType> list_type
+%type <nonNullType> non_null_type
+
+%type <heapStr> operation_type
+
+%type <schemaDefinition> schema_definition;
+%type <scalarTypeDefinition> scalar_type_definition;
+%type <objectTypeDefinition> object_type_definition;
+%type <interfaceTypeDefinition> interface_type_definition;
+%type <unionTypeDefinition> union_type_definition;
+%type <enumTypeDefinition> enum_type_definition;
+%type <inputObjectTypeDefinition> input_object_type_definition;
+%type <typeExtensionDefinition> type_extension_definition;
+%type <directiveDefinition> directive_definition;
+%type <operationTypeDefinition> operation_type_definition;
+%type <operationTypeDefinitionList> operation_type_definition_list;
+%type <typeNameList> type_name_list;
+%type <typeNameList> implements_interfaces_opt;
+%type <typeNameList> union_members;
+%type <fieldDefinition> field_definition;
+%type <fieldDefinitionList> field_definition_list;
+%type <inputValueDefinitionList> arguments_definition_opt; 
+%type <inputValueDefinitionList> arguments_definition;
+%type <inputValueDefinitionList> input_value_definition_list;
+%type <inputValueDefinition> input_value_definition;
+%type <enumValueDefinition> enum_value_definition;
+%type <nameList> directive_locations;
+%type <enumValueDefinitionList> enum_value_definition_list;
+
+%destructor { } <str>
+%destructor { free((void *)$$); } <heapStr>
+%destructor { } <document>  /* we steal it and put it in outAST, don't free! */
+%destructor { delete $$; } <*>
+
+%printer { yyoutput << $$; } <str>
+
+%%
+
+start:          document  { *outAST = $1; }
+        ;
+
+/* All of the non-identifier tokens are to accommodate various flavors
+   of name that don't include those tokens. */
+fragment_name:  DIRECTIVE { $$ = new Name(@1, strdup($1)); }
+        |       ENUM { $$ = new Name(@1, strdup($1)); }
+        |       EXTEND { $$ = new Name(@1, strdup($1)); }
+        |       FALSE { $$ = new Name(@1, strdup($1)); }
+        |       FRAGMENT { $$ = new Name(@1, strdup($1)); }
+        |       IDENTIFIER { $$ = new Name(@1, strdup($1)); }
+        |       IMPLEMENTS { $$ = new Name(@1, strdup($1)); }
+        |       INPUT { $$ = new Name(@1, strdup($1)); }
+        |       INTERFACE { $$ = new Name(@1, strdup($1)); }
+        |       MUTATION { $$ = new Name(@1, strdup($1)); }
+        |       NULL { $$ = new Name(@1, strdup($1)); }
+        |       QUERY { $$ = new Name(@1, strdup($1)); }
+        |       SCALAR { $$ = new Name(@1, strdup($1)); }
+        |       SCHEMA { $$ = new Name(@1, strdup($1)); }
+        |       SUBSCRIPTION { $$ = new Name(@1, strdup($1)); }
+        |       TRUE { $$ = new Name(@1, strdup($1)); }
+        |       TYPE { $$ = new Name(@1, strdup($1)); }
+        |       UNION { $$ = new Name(@1, strdup($1)); }
+        ;
+
+name: fragment_name
+        |       ON { $$ = new Name(@1, strdup($1)); }
+        ;
+
+name_opt:
+                %empty {$$ = nullptr;}
+        |       name
+        ;
+
+/* 2.2 Document */
+
+document:       definition_list { $$ = new Document(@$, $1); }
+        ;
+                
+definition_list:definition { $$ = new std::vector<std::unique_ptr<Definition>>(); $$->emplace_back($1); }
+        |       definition_list definition { $1->emplace_back($2); $$ = $1; }
+        ;
+
+definition:     operation_definition { $$ = static_cast<Definition *>($1); }
+        |       fragment_definition { $$ = static_cast<Definition *>($1); }
+        |       schema_gate {
+            if (!enableSchema) {
+              error(@$, "schema support disabled");
+              // %destructor doesn't work with YYERROR. See
+              // https://www.gnu.org/software/bison/manual/html_node/Destructor-Decl.html
+              delete $$;
+              YYERROR;
+            }
+            $$ = static_cast<Definition *>($1);
+          }
+        ;
+
+schema_gate:    schema_definition { $$ = static_cast<Definition *>($1); }
+        |       scalar_type_definition { $$ = static_cast<Definition *>($1); }
+        |       object_type_definition { $$ = static_cast<Definition *>($1); }
+        |       interface_type_definition { $$ = static_cast<Definition *>($1); }
+        |       union_type_definition { $$ = static_cast<Definition *>($1); }
+        |       enum_type_definition { $$ = static_cast<Definition *>($1); }
+        |       input_object_type_definition { $$ = static_cast<Definition *>($1); }
+        |       type_extension_definition { $$ = static_cast<Definition *>($1); }
+        |       directive_definition { $$ = static_cast<Definition *>($1); }
+        ;
+
+
+/* 2.2.1 Operations */
+operation_definition:
+                selection_set { $$ = new OperationDefinition(@$, strdup("query"), nullptr, nullptr, nullptr, $1); }
+        |       operation_type name_opt selection_set { $$ = new OperationDefinition(@$, $1, $2, nullptr, nullptr, $3); }
+        |       operation_type name_opt variable_definitions selection_set { $$ = new OperationDefinition(@$, $1, $2, $3, nullptr, $4); }
+        |       operation_type name_opt directives selection_set { $$ = new OperationDefinition(@$, $1, $2, nullptr, $3, $4); }
+        |       operation_type name_opt variable_definitions directives selection_set { $$ = new OperationDefinition(@$, $1, $2, $3, $4, $5); }
+        ;
+
+operation_type: QUERY { $$ = strdup($1); }
+        |       MUTATION { $$ = strdup($1); }
+        |       SUBSCRIPTION { $$ = strdup($1); }
+        ;
+
+variable_definitions:
+                "(" variable_definition_list ")" { $$ = $2; }
+        ;
+
+variable_definition_list:
+                variable_definition { $$ = new std::vector<std::unique_ptr<VariableDefinition>>(); $$->emplace_back($1); }
+        |       variable_definition_list variable_definition { $1->emplace_back($2); $$ = $1; }
+        ;
+
+variable:       VARIABLE { $$ = new Variable(@$, new Name(@1, strdup($1))); }
+        ;
+
+variable_definition:
+                variable ":" type default_value_opt { $$ = new VariableDefinition(@$, $1, $3, $4); }
+        ;
+
+default_value_opt:
+                %empty { $$ = nullptr; }
+        |       default_value
+        ;
+
+default_value:  "=" value_const { $$ = $2; }
+        ;
+
+selection_set:
+                  "{" selection_list "}" { $$ = new SelectionSet(@$, $2); }
+        ;
+
+selection_set_opt:
+                %empty { $$ = nullptr; }
+        |       selection_set
+        ;
+selection_list: selection { $$ = new std::vector<std::unique_ptr<Selection>>(); $$->emplace_back($1); }
+        |       selection_list selection { $1->emplace_back($2); $$ = $1; }
+        ;
+
+selection:      field { $$ = static_cast<Selection *>($1); }
+        |       fragment_spread { $$ = static_cast<Selection *>($1); }
+        |       inline_fragment { $$ = static_cast<Selection *>($1); }
+        ;
+
+field:          name arguments_opt directives_opt selection_set_opt { $$ = new Field(@$, nullptr, $1, $2, $3, $4); }
+        |       name ":" name arguments_opt directives_opt selection_set_opt { $$ = new Field(@$, $1, $3, $4, $5, $6); }
+        ;
+
+arguments:      "(" argument_list ")" { $$ = $2; }
+        ;
+
+arguments_opt:  %empty { $$ = nullptr; }
+        |       arguments { $$ = $1; }
+        ;
+
+argument_list:  argument { $$ = new std::vector<std::unique_ptr<Argument>>(); $$->emplace_back($1); }
+        |       argument_list argument { $1->emplace_back($2); $$ = $1; }
+        ;
+
+argument:       name ":" value { $$ = new Argument(@$, $1, $3); }
+        ;
+
+/* 2.2.6 Fragments */
+fragment_spread:
+                "..." fragment_name directives_opt { $$ = new FragmentSpread(@$, $2, $3); }
+        ;
+
+inline_fragment:
+                "..." "on" type_condition directives_opt selection_set { $$ = new InlineFragment(@$, $3, $4, $5); }
+        |       "..." directives_opt selection_set { $$ = new InlineFragment(@$, nullptr, $2, $3); }
+        ;
+
+fragment_definition:
+                "fragment" fragment_name "on" type_condition directives_opt selection_set { $$ = new FragmentDefinition(@$, $2, $4, $5, $6); }
+        ;
+
+type_condition: type_name
+        ;
+
+/* 2.2.7 Input Values */
+value:          variable { $$ = static_cast<Value *>($1); }
+        |       int_value { $$ = static_cast<Value *>($1); }
+        |       float_value { $$ = static_cast<Value *>($1); }
+        |       string_value { $$ = static_cast<Value *>($1); }
+        |       boolean_value { $$ = static_cast<Value *>($1); }
+        |       null_value { $$ = static_cast<Value *>($1); }
+        |       enum_value { $$ = static_cast<Value *>($1); }
+        |       list_value { $$ = static_cast<Value *>($1); }
+        |       object_value { $$ = static_cast<Value *>($1); }
+        ;
+
+int_value:      INTEGER { $$ = new IntValue(@$, strdup($1)); }
+        ;
+
+float_value:    FLOAT { $$ = new FloatValue(@$, strdup($1)); }
+        ;
+
+string_value:   STRING { $$ = new StringValue(@$, strdup($1)); }
+        ;
+
+value_const:    int_value { $$ = static_cast<Value *>($1); }
+        |       float_value { $$ = static_cast<Value *>($1); }
+        |       string_value { $$ = static_cast<Value *>($1); }
+        |       boolean_value { $$ = static_cast<Value *>($1); }
+        |       null_value { $$ = static_cast<Value *>($1); }
+        |       enum_value { $$ = static_cast<Value *>($1); }
+        |       list_value_const { $$ = static_cast<Value *>($1); }
+        |       object_value_const { $$ = static_cast<Value *>($1); }
+        ;
+
+boolean_value:  TRUE { $$ = new BooleanValue(@$, true); }
+        |       FALSE { $$ = new BooleanValue(@$, false); }
+        ;
+
+null_value:     NULL { $$ = new NullValue(@$); }
+        ;
+
+enum_value:     DIRECTIVE { $$ = new EnumValue(@$, strdup($1)); }
+        |       ENUM { $$ = new EnumValue(@$, strdup($1)); }
+        |       EXTEND { $$ = new EnumValue(@$, strdup($1)); }
+        |       FRAGMENT { $$ = new EnumValue(@$, strdup($1)); }
+        |       IDENTIFIER { $$ = new EnumValue(@$, strdup($1)); }
+        |       IMPLEMENTS { $$ = new EnumValue(@$, strdup($1)); }
+        |       INPUT { $$ = new EnumValue(@$, strdup($1)); }
+        |       INTERFACE { $$ = new EnumValue(@$, strdup($1)); }
+        |       MUTATION { $$ = new EnumValue(@$, strdup($1)); }
+        |       ON { $$ = new EnumValue(@$, strdup($1)); }
+        |       QUERY { $$ = new EnumValue(@$, strdup($1)); }
+        |       SCALAR { $$ = new EnumValue(@$, strdup($1)); }
+        |       SCHEMA { $$ = new EnumValue(@$, strdup($1)); }
+        |       SUBSCRIPTION { $$ = new EnumValue(@$, strdup($1)); }
+        |       TYPE { $$ = new EnumValue(@$, strdup($1)); }
+        |       UNION { $$ = new EnumValue(@$, strdup($1)); }
+        ;
+
+/* 2.2.7.6 List Value */
+
+/* REVIEW: the empty case is inefficient; consider implementing
+   ListValue manually. Don't forget to also do list_value_const. */
+list_value:    "[" "]" { $$ = new ListValue(@$, new std::vector<std::unique_ptr<Value>>()); }
+        |       "[" value_list "]" { $$ = new ListValue(@$, $2); }
+        ;
+
+value_list:     value { $$ = new std::vector<std::unique_ptr<Value>>(); $$->emplace_back($1); }
+        |       value_list value { $1->emplace_back($2); $$ = $1; }
+        ;
+
+list_value_const:
+                "[" "]" { $$ = new ListValue(@$, new std::vector<std::unique_ptr<Value>>()); }
+        |       "[" value_const_list "]" { $$ = new ListValue(@$, $2); }
+        ;
+
+value_const_list:
+                value_const { $$ = new std::vector<std::unique_ptr<Value>>(); $$->emplace_back($1); }
+        |       value_const_list value_const { $1->emplace_back($2); $$ = $1; }
+        ;
+
+/* 2.2.7.7 Object Value */
+/* REVIEW: Inefficient, like ListValue. */
+object_value:   "{" "}" { $$ = new ObjectValue(@$, new std::vector<std::unique_ptr<ObjectField>>()); }
+        |       "{" object_field_list "}" { $$ = new ObjectValue(@$, $2); }
+        ;
+
+object_field_list:
+                object_field { $$ = new std::vector<std::unique_ptr<ObjectField>>(); $$->emplace_back($1); }
+        |       object_field_list object_field { $1->emplace_back($2); $$ = $1; }
+        ;
+
+object_field:   name ":" value { $$ = new ObjectField(@$, $1, $3); }
+        ;
+
+object_value_const:
+                "{" "}" { $$ = new ObjectValue(@$, new std::vector<std::unique_ptr<ObjectField>>()); }
+        |       "{" object_field_const_list "}" { $$ = new ObjectValue(@$, $2); }
+        ;
+
+object_field_const_list:
+                object_field_const { $$ = new std::vector<std::unique_ptr<ObjectField>>(); $$->emplace_back($1); }
+        |       object_field_const_list object_field_const { $1->emplace_back($2); $$ = $1; }
+        ;
+
+object_field_const: name ":" value_const { $$ = new ObjectField(@$, $1, $3); }
+        ;
+
+/* 2.2.10 Directives */
+
+directives:     directive_list
+        ;
+
+directives_opt: %empty { $$ = nullptr; }
+        |       directives
+        ;
+
+directive_list: directive { $$ = new std::vector<std::unique_ptr<Directive>>(); $$->emplace_back($1); }
+        |       directive_list directive { $1->emplace_back($2); $$ = $1; }
+        ;
+
+directive:      "@" name arguments_opt { $$ = new Directive(@$, $2, $3); }
+        ;
+
+/* 2.2.9 Types */
+
+type:           type_name { $$ = static_cast<Type *>($1); }
+        |       list_type { $$ = static_cast<Type *>($1); }
+        |       non_null_type { $$ = static_cast<Type *>($1); }
+        ;
+
+type_name:      name { $$ = new NamedType(@$, $1); }
+        ;
+
+list_type:      "[" type "]" { $$ = new ListType(@$, $2); }
+        ;
+
+non_null_type:  type_name "!" { $$ = new NonNullType(@$, $1); }
+        |       list_type "!" { $$ = new NonNullType(@$, $1); }
+        ;
+
+/* Experimental schema parsing support. */
+
+schema_definition: SCHEMA directives_opt "{" operation_type_definition_list "}" { $$ = new SchemaDefinition(@$, $2, $4); }
+                ;
+
+operation_type_definition_list:
+                operation_type_definition { $$ = new std::vector<std::unique_ptr<OperationTypeDefinition>>(); $$->emplace_back($1); }
+        |       operation_type_definition_list operation_type_definition { $1->emplace_back($2); $$ = $1; }
+        ;
+
+operation_type_definition:
+                operation_type ":" type_name { $$ = new OperationTypeDefinition(@$, $1, $3); }
+                ;
+
+scalar_type_definition: SCALAR name directives_opt { $$ = new ScalarTypeDefinition(@$, $2, $3); }
+                ;
+
+object_type_definition: TYPE name implements_interfaces_opt directives_opt "{" field_definition_list "}" { $$ = new ObjectTypeDefinition(@$, $2, $3, $4, $6); }
+                ;
+
+implements_interfaces_opt: %empty { $$ = nullptr; }
+        |       IMPLEMENTS type_name_list { $$ = $2; }
+                ;
+
+type_name_list: type_name { $$ = new std::vector<std::unique_ptr<NamedType>>(); $$->emplace_back($1); }
+        |       type_name_list type_name { $1->emplace_back($2); $$ = $1; }
+                ;
+
+field_definition: name arguments_definition_opt ":" type directives_opt { $$ = new FieldDefinition(@$, $1, $2, $4, $5); }
+                ;
+
+field_definition_list:
+                        field_definition { $$ = new std::vector<std::unique_ptr<FieldDefinition>>(); $$->emplace_back($1); }
+        |       field_definition_list field_definition { $1->emplace_back($2); $$ = $1; }
+        ;
+
+arguments_definition_opt: %empty { $$ = nullptr; }
+        |       arguments_definition { $$ = $1; }
+                ;
+
+arguments_definition: "(" input_value_definition_list ")" { $$ = $2; }
+                ;
+
+input_value_definition_list: input_value_definition { $$ = new std::vector<std::unique_ptr<InputValueDefinition>>(); $$->emplace_back($1); }
+        |       input_value_definition_list input_value_definition { $1->emplace_back($2); $$ = $1; }
+                ;
+
+input_value_definition: name ":" type default_value_opt directives_opt { $$ = new InputValueDefinition(@$, $1, $3, $4, $5); }
+
+interface_type_definition: INTERFACE name directives_opt "{" field_definition_list "}" { $$ = new InterfaceTypeDefinition(@$, $2, $3, $5); }
+                ;
+
+union_type_definition: UNION name directives_opt "=" union_members { $$ = new UnionTypeDefinition(@$, $2, $3, $5); }
+                ;
+
+union_members:  type_name { $$ = new std::vector<std::unique_ptr<NamedType>>();  $$->emplace_back($1); }
+        |       union_members "|" type_name { $1->emplace_back($3); $$ = $1; }
+        ;
+
+enum_type_definition: ENUM name directives_opt "{" enum_value_definition_list "}" { $$ = new EnumTypeDefinition(@$, $2, $3, $5); }
+                ;
+
+enum_value_definition: name directives_opt { $$ = new EnumValueDefinition(@$, $1, $2); }
+                ;
+
+enum_value_definition_list:
+                enum_value_definition { $$ = new std::vector<std::unique_ptr<EnumValueDefinition>>(); $$->emplace_back($1); }
+        |       enum_value_definition_list enum_value_definition { $1->emplace_back($2); $$ = $1; }
+        ;
+
+input_object_type_definition: INPUT name directives_opt "{" input_value_definition_list "}" { $$ = new InputObjectTypeDefinition(@$, $2, $3, $5); }
+                ;
+
+type_extension_definition: EXTEND object_type_definition { $$ = new TypeExtensionDefinition(@$, $2); }
+                ;
+
+directive_definition: DIRECTIVE "@" name arguments_definition_opt ON directive_locations { $$ = new DirectiveDefinition(@$, $3, $4, $6); }
+                ;
+
+directive_locations:
+                name { $$ = new std::vector<std::unique_ptr<Name>>(); $$->emplace_back($1); }
+        |       directive_locations "|" name { $1->emplace_back($3); $$ = $1; }
+        ;
+
+%%
+
+void yy::GraphQLParserImpl::error(const yy::location &loc, const std::string &str) {
+  std::ostringstream out;
+  out << loc << ": " << str;
+  if (outError) {
+    *outError = strdup(out.str().c_str());
+  }
+}
+
+/* Workaround for syntax_error ctor being marked inline, which causes link
+   errors if used from lexer.lpp. */
+yy::GraphQLParserImpl::syntax_error make_error(const yy::location &loc, const std::string &str) {
+  return yy::GraphQLParserImpl::syntax_error(loc, str);
+}