From 1428ce0639f7ec715ce4707c2a3ef7ddbfb2fdbe Mon Sep 17 00:00:00 2001
From: Marko Budiselic <marko.budiselic@memgraph.io>
Date: Sat, 11 Mar 2017 13:47:11 +0100
Subject: [PATCH 01/16] Add basic interpreter skeleton.
---
src/query/frontend/ast/ast.hpp | 43 ++++++++++
src/query/frontend/interpret/interpret.hpp | 18 ++++
src/query/frontend/logical/operator.hpp | 82 +++++++++++++++++++
src/query/frontend/typecheck/symbol_table.hpp | 34 ++++++++
4 files changed, 177 insertions(+)
create mode 100644 src/query/frontend/ast/ast.hpp
create mode 100644 src/query/frontend/interpret/interpret.hpp
create mode 100644 src/query/frontend/logical/operator.hpp
create mode 100644 src/query/frontend/typecheck/symbol_table.hpp
diff --git a/src/query/frontend/ast/ast.hpp b/src/query/frontend/ast/ast.hpp
new file mode 100644
index 000000000..ef2f9dd30
--- /dev/null
+++ b/src/query/frontend/ast/ast.hpp
@@ -0,0 +1,43 @@
+#pragma once
+
+#include <memory>
+#include <vector>
+
+#include "database/graph_db.hpp"
+
+namespace query {
+
+template <typename T>
+using sptr = std::shared_ptr<T>;
+
+template <typename T>
+using uptr = std::unique_ptr<T>;
+
+class Tree {
+public:
+ Tree(const int uid) : uid_(uid) {}
+ int uid() const { return uid_; }
+private:
+ const int uid_;
+};
+
+class Expr : public Tree {
+};
+
+class Ident : public Tree {
+public:
+ std::string identifier_;
+};
+
+class Part {
+};
+
+class NodePart : public Part {
+public:
+ Ident identifier_;
+ // TODO: Mislav call GraphDb::label(label_name) to populate labels_!
+ std::vector<GraphDb::Label> labels_;
+ // TODO: properties
+};
+
+}
diff --git a/src/query/frontend/interpret/interpret.hpp b/src/query/frontend/interpret/interpret.hpp
new file mode 100644
index 000000000..7a2240094
--- /dev/null
+++ b/src/query/frontend/interpret/interpret.hpp
@@ -0,0 +1,18 @@
+#pragma once
+
+#include <vector>
+
+#include "query/backend/cpp/typed_value.hpp"
+
+class Frame {
+ public:
+ Frame(int size) : size_(size), elems_(size_) {}
+
+ auto& operator[](int pos) { return elems_[pos]; }
+ const auto& operator[](int pos) const { return elems_[pos]; }
+
+ private:
+ int size_;
+ std::vector<TypedValue> elems_;
+};
+
diff --git a/src/query/frontend/logical/operator.hpp b/src/query/frontend/logical/operator.hpp
new file mode 100644
index 000000000..96deb7132
--- /dev/null
+++ b/src/query/frontend/logical/operator.hpp
@@ -0,0 +1,82 @@
+#pragma once
+
+#include <memory>
+#include <vector>
+
+#include "database/graph_db_accessor.hpp"
+#include "query/frontend/ast/ast.hpp"
+#include "query/frontend/interpret/interpret.hpp"
+#include "query/frontend/typecheck/symbol_table.hpp"
+
+namespace query {
+class Cursor {
+ public:
+ virtual bool pull(Frame&, SymbolTable&) = 0;
+ virtual ~Cursor() {}
+};
+
+class LogicalOperator {
+ public:
+ auto children() { return children_; };
+ virtual uptr<Cursor> MakeCursor(GraphDbAccessor db) = 0;
+ virtual ~LogicalOperator() {}
+
+ protected:
+ std::vector<std::shared_ptr<LogicalOperator>> children_;
+};
+
+class ScanAll : public LogicalOperator {
+ public:
+ ScanAll(sptr<NodePart> node_part) : node_part_(node_part) {}
+
+ private:
+ class ScanAllCursor : public Cursor {
+ public:
+ ScanAllCursor(ScanAll& parent, GraphDbAccessor db)
+ : parent_(parent), db_(db), vertices_(db.vertices()) {}
+ bool pull(Frame& frame, SymbolTable& symbol_table) override {
+ while (vertices_ != vertices_.end()) {
+ auto& vertex = *vertices_++;
+ if (evaluate(frame, symbol_table, vertex)) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ private:
+ ScanAll& parent_;
+ GraphDbAccessor db_;
+ decltype(db_.vertices()) vertices_;
+
+ bool evaluate(Frame& frame, SymbolTable& symbol_table,
+ VertexAccessor& vertex) {
+ auto node_part = parent_.node_part_;
+ for (auto label : node_part->labels_) {
+ if (!vertex.has_label(label)) return false;
+ }
+ frame[symbol_table[parent_.node_part_->identifier_].position_] = vertex;
+ return true;
+ }
+ };
+
+ public:
+ uptr<Cursor> MakeCursor(GraphDbAccessor db) override {
+ return new ScanAllCursor(*this, db);
+ }
+
+ friend class ScanAll::ScanAllCursor;
+ sptr<NodePart> node_part_;
+};
+
+class Produce : public LogicalOperator {
+ public:
+ Produce(sptr<LogicalOperator> op, std::vector<sptr<Expr>> exprs)
+ : exprs_(exprs) {
+ children_.emplace_back(op);
+ }
+
+ private:
+ std::vector<sptr<Expr>> exprs_;
+};
+}
diff --git a/src/query/frontend/typecheck/symbol_table.hpp b/src/query/frontend/typecheck/symbol_table.hpp
new file mode 100644
index 000000000..f5305fc89
--- /dev/null
+++ b/src/query/frontend/typecheck/symbol_table.hpp
@@ -0,0 +1,34 @@
+#pragma once
+
+#include <map>
+#include <string>
+
+#include "query/frontend/ast/ast.hpp"
+
+namespace query {
+struct Symbol {
+ Symbol(std::string& name, int position) : name_(name), position_(position) {}
+ std::string name_;
+ int position_;
+};
+
+class SymbolTable {
+ public:
+ Symbol CreateSymbol(std::string& name) {
+ int position = position_++;
+ return Symbol(name, position);
+ }
+
+ void AssignSymbol(const Tree& tree, Symbol symbol) {
+ table_[tree.uid()] = symbol;
+ }
+
+ auto& operator[](const Tree& tree) { return table_[tree.uid()]; }
+
+ int max_position() const { return position_; }
+
+ private:
+ int position_{0};
+ std::map<int, Symbol> table_;
+};
+}
From ef764e036716d1faca7382388ca61df109947dad Mon Sep 17 00:00:00 2001
From: Teon Banek <theongugl@gmail.com>
Date: Sat, 11 Mar 2017 14:39:13 +0100
Subject: [PATCH 02/16] Add ProduceCursor and Evaluate to expression
---
CMakeLists.txt | 1 +
src/query/backend/cpp/typed_value.hpp | 2 +-
src/query/frontend/ast/ast.cpp | 10 ++++++++++
src/query/frontend/ast/ast.hpp | 11 +++++++++--
src/query/frontend/interpret/interpret.hpp | 3 +++
src/query/frontend/logical/operator.hpp | 17 +++++++++++++++--
6 files changed, 39 insertions(+), 5 deletions(-)
create mode 100644 src/query/frontend/ast/ast.cpp
diff --git a/CMakeLists.txt b/CMakeLists.txt
index d56da56fe..5f00a3439 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -350,6 +350,7 @@ set(memgraph_src_files
${src_dir}/query/stripper.cpp
${src_dir}/query/backend/cpp/cypher_main_visitor.cpp
${src_dir}/query/backend/cpp/typed_value.cpp
+ ${src_dir}/query/frontend/ast/ast.cpp
)
# -----------------------------------------------------------------------------
diff --git a/src/query/backend/cpp/typed_value.hpp b/src/query/backend/cpp/typed_value.hpp
index 3f3845863..aadd7aa41 100644
--- a/src/query/backend/cpp/typed_value.hpp
+++ b/src/query/backend/cpp/typed_value.hpp
@@ -25,7 +25,7 @@ typedef traversal_template::Path<VertexAccessor, EdgeAccessor> Path;
* TypedValue::Type. Each such type corresponds to exactly one C++ type.
*/
class TypedValue : public TotalOrdering<TypedValue, TypedValue, TypedValue> {
- private:
+ public:
/** Private default constructor, makes Null */
TypedValue() : type_(Type::Null) {}
diff --git a/src/query/frontend/ast/ast.cpp b/src/query/frontend/ast/ast.cpp
new file mode 100644
index 000000000..34abc30dc
--- /dev/null
+++ b/src/query/frontend/ast/ast.cpp
@@ -0,0 +1,10 @@
+#include "query/frontend/interpret/interpret.hpp"
+#include "query/frontend/typecheck/symbol_table.hpp"
+
+namespace query {
+
+TypedValue Ident::Evaluate(Frame& frame, SymbolTable& symbol_table) {
+ return frame[symbol_table[*this].position_];
+}
+
+}
diff --git a/src/query/frontend/ast/ast.hpp b/src/query/frontend/ast/ast.hpp
index ef2f9dd30..f35538258 100644
--- a/src/query/frontend/ast/ast.hpp
+++ b/src/query/frontend/ast/ast.hpp
@@ -4,6 +4,7 @@
#include <vector>
#include "database/graph_db.hpp"
+#include "query/backend/cpp/typed_value.hpp"
namespace query {
@@ -13,6 +14,9 @@ using sptr = std::shared_ptr<T>;
template <typename T>
using uptr = std::unique_ptr<T>;
+class Frame;
+class SymbolTable;
+
class Tree {
public:
Tree(const int uid) : uid_(uid) {}
@@ -22,11 +26,14 @@ private:
};
class Expr : public Tree {
+ public:
+ virtual TypedValue Evaluate(Frame&, SymbolTable&) = 0;
};
-class Ident : public Tree {
+class Ident : public Expr {
public:
- std::string identifier_;
+ std::string identifier_;
+ TypedValue Evaluate(Frame& frame, SymbolTable& symbol_table) override;
};
class Part {
diff --git a/src/query/frontend/interpret/interpret.hpp b/src/query/frontend/interpret/interpret.hpp
index 7a2240094..b965a0394 100644
--- a/src/query/frontend/interpret/interpret.hpp
+++ b/src/query/frontend/interpret/interpret.hpp
@@ -4,6 +4,8 @@
#include "query/backend/cpp/typed_value.hpp"
+namespace query {
+
class Frame {
public:
Frame(int size) : size_(size), elems_(size_) {}
@@ -16,3 +18,4 @@ class Frame {
std::vector<TypedValue> elems_;
};
+}
diff --git a/src/query/frontend/logical/operator.hpp b/src/query/frontend/logical/operator.hpp
index 96deb7132..df3721250 100644
--- a/src/query/frontend/logical/operator.hpp
+++ b/src/query/frontend/logical/operator.hpp
@@ -55,14 +55,15 @@ class ScanAll : public LogicalOperator {
for (auto label : node_part->labels_) {
if (!vertex.has_label(label)) return false;
}
- frame[symbol_table[parent_.node_part_->identifier_].position_] = vertex;
+ frame[symbol_table[node_part->identifier_].position_] = vertex;
return true;
}
};
public:
uptr<Cursor> MakeCursor(GraphDbAccessor db) override {
- return new ScanAllCursor(*this, db);
+ Cursor* cursor = new ScanAllCursor(*this, db);
+ return uptr<Cursor>(cursor);
}
friend class ScanAll::ScanAllCursor;
@@ -77,6 +78,18 @@ class Produce : public LogicalOperator {
}
private:
+ class ProduceCursor : public Cursor {
+ public:
+ ProduceCursor(Produce& parent) : parent_(parent) {}
+ bool pull(Frame &frame, SymbolTable& symbol_table) override {
+ for (auto expr : parent_.exprs_) {
+ frame[symbol_table[*expr].position_] = expr->Evaluate(frame, symbol_table);
+ }
+ return true;
+ }
+ private:
+ Produce& parent_;
+ };
std::vector<sptr<Expr>> exprs_;
};
}
From 7d883ff008c888055a5b8b4594ebb02f796e2218 Mon Sep 17 00:00:00 2001
From: Teon Banek <theongugl@gmail.com>
Date: Sat, 11 Mar 2017 14:42:11 +0100
Subject: [PATCH 03/16] Remove using uptr and sptr
---
src/query/frontend/ast/ast.hpp | 6 ------
src/query/frontend/logical/operator.hpp | 12 ++++++------
2 files changed, 6 insertions(+), 12 deletions(-)
diff --git a/src/query/frontend/ast/ast.hpp b/src/query/frontend/ast/ast.hpp
index f35538258..63f5d4772 100644
--- a/src/query/frontend/ast/ast.hpp
+++ b/src/query/frontend/ast/ast.hpp
@@ -8,12 +8,6 @@
namespace query {
-template <typename T>
-using sptr = std::shared_ptr<T>;
-
-template <typename T>
-using uptr = std::unique_ptr<T>;
-
class Frame;
class SymbolTable;
diff --git a/src/query/frontend/logical/operator.hpp b/src/query/frontend/logical/operator.hpp
index df3721250..70b50c6e7 100644
--- a/src/query/frontend/logical/operator.hpp
+++ b/src/query/frontend/logical/operator.hpp
@@ -18,7 +18,7 @@ class Cursor {
class LogicalOperator {
public:
auto children() { return children_; };
- virtual uptr<Cursor> MakeCursor(GraphDbAccessor db) = 0;
+ virtual std::unique_ptr<Cursor> MakeCursor(GraphDbAccessor db) = 0;
virtual ~LogicalOperator() {}
protected:
@@ -61,18 +61,18 @@ class ScanAll : public LogicalOperator {
};
public:
- uptr<Cursor> MakeCursor(GraphDbAccessor db) override {
+ std::unique_ptr<Cursor> MakeCursor(GraphDbAccessor db) override {
Cursor* cursor = new ScanAllCursor(*this, db);
- return uptr<Cursor>(cursor);
+ return std::unique_ptr<Cursor>(cursor);
}
friend class ScanAll::ScanAllCursor;
- sptr<NodePart> node_part_;
+ std::shared_ptr<NodePart> node_part_;
};
class Produce : public LogicalOperator {
public:
- Produce(sptr<LogicalOperator> op, std::vector<sptr<Expr>> exprs)
+ Produce(std::shared_ptr<LogicalOperator> op, std::vector<std::shared_ptr<Expr>> exprs)
: exprs_(exprs) {
children_.emplace_back(op);
}
@@ -90,6 +90,6 @@ class Produce : public LogicalOperator {
private:
Produce& parent_;
};
- std::vector<sptr<Expr>> exprs_;
+ std::vector<std::shared_ptr<Expr>> exprs_;
};
}
From 425e1f89071680bccf5dccb9a113a54dfb38f0db Mon Sep 17 00:00:00 2001
From: Teon Banek <theongugl@gmail.com>
Date: Sat, 11 Mar 2017 15:35:38 +0100
Subject: [PATCH 04/16] Correct iterator usage
---
src/query/frontend/logical/operator.hpp | 11 +++++++----
1 file changed, 7 insertions(+), 4 deletions(-)
diff --git a/src/query/frontend/logical/operator.hpp b/src/query/frontend/logical/operator.hpp
index 70b50c6e7..103209e0e 100644
--- a/src/query/frontend/logical/operator.hpp
+++ b/src/query/frontend/logical/operator.hpp
@@ -27,16 +27,18 @@ class LogicalOperator {
class ScanAll : public LogicalOperator {
public:
- ScanAll(sptr<NodePart> node_part) : node_part_(node_part) {}
+ ScanAll(std::shared_ptr<NodePart> node_part) : node_part_(node_part) {}
private:
class ScanAllCursor : public Cursor {
public:
ScanAllCursor(ScanAll& parent, GraphDbAccessor db)
- : parent_(parent), db_(db), vertices_(db.vertices()) {}
+ : parent_(parent), db_(db), vertices_(db.vertices()),
+ vertices_it_(vertices_.begin()) {}
+
bool pull(Frame& frame, SymbolTable& symbol_table) override {
- while (vertices_ != vertices_.end()) {
- auto& vertex = *vertices_++;
+ while (vertices_it_ != vertices_.end()) {
+ auto vertex = *vertices_it_++;
if (evaluate(frame, symbol_table, vertex)) {
return true;
}
@@ -48,6 +50,7 @@ class ScanAll : public LogicalOperator {
ScanAll& parent_;
GraphDbAccessor db_;
decltype(db_.vertices()) vertices_;
+ decltype(vertices_.begin()) vertices_it_;
bool evaluate(Frame& frame, SymbolTable& symbol_table,
VertexAccessor& vertex) {
From 3adce8313c15de40922d5baa9a76072efd208001 Mon Sep 17 00:00:00 2001
From: Teon Banek <theongugl@gmail.com>
Date: Sat, 11 Mar 2017 15:39:02 +0100
Subject: [PATCH 05/16] Add default constructor for Symbol
SymbolTable should probably have different methods for adding a Symbol
to the table, instead of [] operator.
---
src/query/frontend/typecheck/symbol_table.hpp | 5 +----
1 file changed, 1 insertion(+), 4 deletions(-)
diff --git a/src/query/frontend/typecheck/symbol_table.hpp b/src/query/frontend/typecheck/symbol_table.hpp
index f5305fc89..3b934456f 100644
--- a/src/query/frontend/typecheck/symbol_table.hpp
+++ b/src/query/frontend/typecheck/symbol_table.hpp
@@ -7,6 +7,7 @@
namespace query {
struct Symbol {
+ Symbol() {}
Symbol(std::string& name, int position) : name_(name), position_(position) {}
std::string name_;
int position_;
@@ -19,10 +20,6 @@ class SymbolTable {
return Symbol(name, position);
}
- void AssignSymbol(const Tree& tree, Symbol symbol) {
- table_[tree.uid()] = symbol;
- }
-
auto& operator[](const Tree& tree) { return table_[tree.uid()]; }
int max_position() const { return position_; }
From 8d8a1cef6a15e23bbdd459a8b1855b1d42e213f8 Mon Sep 17 00:00:00 2001
From: Mislav Bradac <mislav.bradac@memgraph.io>
Date: Sat, 11 Mar 2017 15:51:22 +0100
Subject: [PATCH 06/16] Add basic ast types
---
src/query/backend/cpp/code_generator.hpp | 15 ---
src/query/context.hpp | 15 +++
src/query/frontend/ast/ast.hpp | 51 +++++++---
.../ast}/cypher_main_visitor.cpp | 0
.../ast}/cypher_main_visitor.hpp | 96 ++++++++++---------
.../ast}/named_antlr_tokens.hpp | 0
6 files changed, 103 insertions(+), 74 deletions(-)
delete mode 100644 src/query/backend/cpp/code_generator.hpp
create mode 100644 src/query/context.hpp
rename src/query/{backend/cpp => frontend/ast}/cypher_main_visitor.cpp (100%)
rename src/query/{backend/cpp => frontend/ast}/cypher_main_visitor.hpp (74%)
rename src/query/{backend/cpp => frontend/ast}/named_antlr_tokens.hpp (100%)
diff --git a/src/query/backend/cpp/code_generator.hpp b/src/query/backend/cpp/code_generator.hpp
deleted file mode 100644
index 78d11f77c..000000000
--- a/src/query/backend/cpp/code_generator.hpp
+++ /dev/null
@@ -1,15 +0,0 @@
-#pragma once
-
-#include <string>
-#include <vector>
-#include "query/frontend/opencypher/generated/CypherBaseVisitor.h"
-#include "antlr4-runtime.h"
-
-using antlropencypher::CypherParser;
-
-class CodeGenerator {
- void GenerateExpresssion();
-
- private:
- std::string code_;
-};
diff --git a/src/query/context.hpp b/src/query/context.hpp
new file mode 100644
index 000000000..eea60317c
--- /dev/null
+++ b/src/query/context.hpp
@@ -0,0 +1,15 @@
+#pragma once
+
+#include "antlr4-runtime.h"
+#include "query/frontend/ast/cypher_main_visitor.hpp"
+
+class Context {
+ int uid_counter;
+};
+
+class HighLevelAstConversion {
+ void Apply(const Context &ctx, antlr4::tree::ParseTree *tree) {
+ query::frontend::CypherMainVisitor visitor(ctx);
+ visitor.visit(tree);
+ }
+};
diff --git a/src/query/frontend/ast/ast.hpp b/src/query/frontend/ast/ast.hpp
index 63f5d4772..e2c201227 100644
--- a/src/query/frontend/ast/ast.hpp
+++ b/src/query/frontend/ast/ast.hpp
@@ -13,32 +13,59 @@ class SymbolTable;
class Tree {
public:
- Tree(const int uid) : uid_(uid) {}
- int uid() const { return uid_; }
+ Tree(const int uid) : uid_(uid) {}
+ int uid() const { return uid_; }
+
private:
- const int uid_;
+ const int uid_;
};
class Expr : public Tree {
- public:
- virtual TypedValue Evaluate(Frame&, SymbolTable&) = 0;
+public:
+ virtual TypedValue Evaluate(Frame &, SymbolTable &) = 0;
};
class Ident : public Expr {
public:
std::string identifier_;
- TypedValue Evaluate(Frame& frame, SymbolTable& symbol_table) override;
+ TypedValue Evaluate(Frame &frame, SymbolTable &symbol_table) override;
};
-class Part {
-};
+class Part {};
class NodePart : public Part {
public:
- Ident identifier_;
- // TODO: Mislav call GraphDb::label(label_name) to populate labels_!
- std::vector<GraphDb::Label> labels_;
- // TODO: properties
+ Ident identifier_;
+ // TODO: Mislav call GraphDb::label(label_name) to populate labels_!
+ std::vector<GraphDb::Label> labels_;
+ // TODO: properties
};
+class EdgePart : public Part {
+public:
+ Ident identifier_;
+ // TODO: finish this: properties, types...
+};
+
+class Clause : public Tree {};
+
+class Pattern : public Tree {
+public:
+ std::vector<std::unique_ptr<Part>> node_parts_;
+};
+
+class Query : public Tree {
+public:
+ std::vector<std::unique_ptr<Clause>> clauses_;
+};
+
+class Match : public Clause {
+public:
+ std::vector<std::unique_ptr<Pattern>> patterns_;
+};
+
+class Return : public Clause {
+public:
+ std::vector<std::unique_ptr<Expr>> exprs_;
+};
}
diff --git a/src/query/backend/cpp/cypher_main_visitor.cpp b/src/query/frontend/ast/cypher_main_visitor.cpp
similarity index 100%
rename from src/query/backend/cpp/cypher_main_visitor.cpp
rename to src/query/frontend/ast/cypher_main_visitor.cpp
diff --git a/src/query/backend/cpp/cypher_main_visitor.hpp b/src/query/frontend/ast/cypher_main_visitor.hpp
similarity index 74%
rename from src/query/backend/cpp/cypher_main_visitor.hpp
rename to src/query/frontend/ast/cypher_main_visitor.hpp
index 3dfab0a5d..70101c05a 100644
--- a/src/query/backend/cpp/cypher_main_visitor.hpp
+++ b/src/query/frontend/ast/cypher_main_visitor.hpp
@@ -1,17 +1,17 @@
#pragma once
-#include <string>
-#include "query/frontend/opencypher/generated/CypherBaseVisitor.h"
#include "antlr4-runtime.h"
#include "query/backend/cpp/compiler_structures.hpp"
+#include "query/frontend/opencypher/generated/CypherBaseVisitor.h"
+#include <string>
-namespace backend {
-namespace cpp {
+namespace query {
+namespace frontend {
using antlropencypher::CypherParser;
class CypherMainVisitor : public antlropencypher::CypherBaseVisitor {
- private:
+private:
// Return new output code id.
// TODO: Should we generate ids with more readable names: node_1,
// relationship_5, temporary_2...?
@@ -21,8 +21,9 @@ class CypherMainVisitor : public antlropencypher::CypherBaseVisitor {
}
template <typename TExpression>
- antlrcpp::Any LeftAssociativeOperatorExpression(
- std::vector<TExpression *> children, std::vector<Function> ops) {
+ antlrcpp::Any
+ LeftAssociativeOperatorExpression(std::vector<TExpression *> children,
+ std::vector<Function> ops) {
assert(children.size());
std::vector<std::string> children_ids;
@@ -41,8 +42,9 @@ class CypherMainVisitor : public antlropencypher::CypherBaseVisitor {
}
template <typename TExpression>
- antlrcpp::Any LeftAssociativeOperatorExpression(
- std::vector<TExpression *> children, Function op) {
+ antlrcpp::Any
+ LeftAssociativeOperatorExpression(std::vector<TExpression *> children,
+ Function op) {
return LeftAssociativeOperatorExpression(
children, std::vector<Function>((int)children.size() - 1, op));
}
@@ -53,8 +55,8 @@ class CypherMainVisitor : public antlropencypher::CypherBaseVisitor {
*
* @return string - node id.
*/
- antlrcpp::Any visitNodePattern(
- CypherParser::NodePatternContext *ctx) override;
+ antlrcpp::Any
+ visitNodePattern(CypherParser::NodePatternContext *ctx) override;
/**
* @return vector<string> labels.
@@ -75,8 +77,8 @@ class CypherMainVisitor : public antlropencypher::CypherBaseVisitor {
/**
* @return string.
*/
- antlrcpp::Any visitSymbolicName(
- CypherParser::SymbolicNameContext *ctx) override;
+ antlrcpp::Any
+ visitSymbolicName(CypherParser::SymbolicNameContext *ctx) override;
/**
* @return vector<PatternPart> pattern.
@@ -90,16 +92,16 @@ class CypherMainVisitor : public antlropencypher::CypherBaseVisitor {
*
* @return string - pattern part id.
*/
- antlrcpp::Any visitPatternPart(
- CypherParser::PatternPartContext *ctx) override;
+ antlrcpp::Any
+ visitPatternPart(CypherParser::PatternPartContext *ctx) override;
/**
* Creates PatternPart.
*
* @return PatternPart.
*/
- antlrcpp::Any visitPatternElement(
- CypherParser::PatternElementContext *ctx) override;
+ antlrcpp::Any
+ visitPatternElement(CypherParser::PatternElementContext *ctx) override;
/**
* @return pair<string, string> - node and relationship ids.
@@ -125,14 +127,14 @@ class CypherMainVisitor : public antlropencypher::CypherBaseVisitor {
/**
* @return vector<string>.
*/
- antlrcpp::Any visitRelationshipTypes(
- CypherParser::RelationshipTypesContext *ctx) override;
+ antlrcpp::Any
+ visitRelationshipTypes(CypherParser::RelationshipTypesContext *ctx) override;
/**
* @return pair<int64_t, int64_t>.
*/
- antlrcpp::Any visitRangeLiteral(
- CypherParser::RangeLiteralContext *ctx) override;
+ antlrcpp::Any
+ visitRangeLiteral(CypherParser::RangeLiteralContext *ctx) override;
/**
* Top level expression.
@@ -146,40 +148,40 @@ class CypherMainVisitor : public antlropencypher::CypherBaseVisitor {
*
* @return string - expression id.
*/
- antlrcpp::Any visitExpression12(
- CypherParser::Expression12Context *ctx) override;
+ antlrcpp::Any
+ visitExpression12(CypherParser::Expression12Context *ctx) override;
/**
* XOR.
*
* @return string - expression id.
*/
- antlrcpp::Any visitExpression11(
- CypherParser::Expression11Context *ctx) override;
+ antlrcpp::Any
+ visitExpression11(CypherParser::Expression11Context *ctx) override;
/**
* AND.
*
* @return string - expression id.
*/
- antlrcpp::Any visitExpression10(
- CypherParser::Expression10Context *ctx) override;
+ antlrcpp::Any
+ visitExpression10(CypherParser::Expression10Context *ctx) override;
/**
* NOT.
*
* @return string - expression id.
*/
- antlrcpp::Any visitExpression9(
- CypherParser::Expression9Context *ctx) override;
+ antlrcpp::Any
+ visitExpression9(CypherParser::Expression9Context *ctx) override;
/**
* Comparisons.
*
* @return string - expression id.
*/
- antlrcpp::Any visitExpression8(
- CypherParser::Expression8Context *ctx) override;
+ antlrcpp::Any
+ visitExpression8(CypherParser::Expression8Context *ctx) override;
/**
* Never call this. Everything related to generating code for comparison
@@ -193,48 +195,48 @@ class CypherMainVisitor : public antlropencypher::CypherBaseVisitor {
*
* @return string - expression id.
*/
- antlrcpp::Any visitExpression7(
- CypherParser::Expression7Context *ctx) override;
+ antlrcpp::Any
+ visitExpression7(CypherParser::Expression7Context *ctx) override;
/**
* Multiplication, division, modding.
*
* @return string - expression id.
*/
- antlrcpp::Any visitExpression6(
- CypherParser::Expression6Context *ctx) override;
+ antlrcpp::Any
+ visitExpression6(CypherParser::Expression6Context *ctx) override;
/**
* Power.
*
* @return string - expression id.
*/
- antlrcpp::Any visitExpression5(
- CypherParser::Expression5Context *ctx) override;
+ antlrcpp::Any
+ visitExpression5(CypherParser::Expression5Context *ctx) override;
/**
* Unary minus and plus.
*
* @return string - expression id.
*/
- antlrcpp::Any visitExpression4(
- CypherParser::Expression4Context *ctx) override;
+ antlrcpp::Any
+ visitExpression4(CypherParser::Expression4Context *ctx) override;
/**
* Element of a list, range of a list...
*
* @return string - expression id.
*/
- antlrcpp::Any visitExpression3(
- CypherParser::Expression3Context *ctx) override;
+ antlrcpp::Any
+ visitExpression3(CypherParser::Expression3Context *ctx) override;
/**
* Property lookup, test for node labels existence...
*
* @return string - expression id.
*/
- antlrcpp::Any visitExpression2(
- CypherParser::Expression2Context *ctx) override;
+ antlrcpp::Any
+ visitExpression2(CypherParser::Expression2Context *ctx) override;
/**
* Literals, params, list comprehension...
@@ -265,10 +267,10 @@ class CypherMainVisitor : public antlropencypher::CypherBaseVisitor {
/**
* @return int64_t.
*/
- antlrcpp::Any visitIntegerLiteral(
- CypherParser::IntegerLiteralContext *ctx) override;
+ antlrcpp::Any
+ visitIntegerLiteral(CypherParser::IntegerLiteralContext *ctx) override;
- public:
+public:
// TODO: These temporary getters should eventually be replaced with
// something
// else once we figure out where and how those strctures will be used.
@@ -278,7 +280,7 @@ class CypherMainVisitor : public antlropencypher::CypherBaseVisitor {
const auto &ids_map() const { return ids_map_; }
const auto &symbol_table() const { return symbol_table_; }
- private:
+private:
// Mapping of ids (nodes, relationships, values, lists ...) from
// query
// code to id that is used in generated code;
diff --git a/src/query/backend/cpp/named_antlr_tokens.hpp b/src/query/frontend/ast/named_antlr_tokens.hpp
similarity index 100%
rename from src/query/backend/cpp/named_antlr_tokens.hpp
rename to src/query/frontend/ast/named_antlr_tokens.hpp
From fbf70de089c066f154bd90623dae7ed312bb11ee Mon Sep 17 00:00:00 2001
From: Teon Banek <theongugl@gmail.com>
Date: Sat, 11 Mar 2017 17:57:10 +0100
Subject: [PATCH 07/16] Add type checker which fills symbols for Ident
---
CMakeLists.txt | 2 +-
src/query/frontend/ast/ast.hpp | 90 ++++++++++++++++++-
.../frontend/ast/cypher_main_visitor.cpp | 2 +-
src/query/frontend/typecheck/typecheck.hpp | 73 +++++++++++++++
4 files changed, 164 insertions(+), 3 deletions(-)
create mode 100644 src/query/frontend/typecheck/typecheck.hpp
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 5f00a3439..72999f286 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -348,7 +348,7 @@ set(memgraph_src_files
${src_dir}/database/graph_db.cpp
${src_dir}/database/graph_db_accessor.cpp
${src_dir}/query/stripper.cpp
- ${src_dir}/query/backend/cpp/cypher_main_visitor.cpp
+ ${src_dir}/query/frontend/ast/cypher_main_visitor.cpp
${src_dir}/query/backend/cpp/typed_value.cpp
${src_dir}/query/frontend/ast/ast.cpp
)
diff --git a/src/query/frontend/ast/ast.hpp b/src/query/frontend/ast/ast.hpp
index e2c201227..18ce5da4c 100644
--- a/src/query/frontend/ast/ast.hpp
+++ b/src/query/frontend/ast/ast.hpp
@@ -11,10 +11,49 @@ namespace query {
class Frame;
class SymbolTable;
+// Forward declares for TreeVisitorBase
+class Query;
+class Ident;
+class Match;
+class Return;
+class Pattern;
+class NodePart;
+class EdgePart;
+
+class TreeVisitorBase {
+ public:
+ // Start of the tree is a Query.
+ virtual void PreVisit(Query& query) {}
+ virtual void Visit(Query& query) = 0;
+ virtual void PostVisit(Query& query) {}
+ // Expressions
+ virtual void PreVisit(Ident& ident) {}
+ virtual void Visit(Ident& ident) = 0;
+ virtual void PostVisit(Ident& ident) {}
+ // Clauses
+ virtual void PreVisit(Match& match) {}
+ virtual void Visit(Match& match) = 0;
+ virtual void PostVisit(Match& match) {}
+ virtual void PreVisit(Return& ret) {}
+ virtual void Visit(Return& ret) = 0;
+ virtual void PostVisit(Return& ret) {}
+ // Pattern and its subparts.
+ virtual void PreVisit(Pattern& pattern) {}
+ virtual void Visit(Pattern& pattern) = 0;
+ virtual void PostVisit(Pattern& pattern) {}
+ virtual void PreVisit(NodePart& node_part) {}
+ virtual void Visit(NodePart& node_part) = 0;
+ virtual void PostVisit(NodePart& node_part) {}
+ virtual void PreVisit(EdgePart& edge_part) {}
+ virtual void Visit(EdgePart& edge_part) = 0;
+ virtual void PostVisit(EdgePart& edge_part) {}
+};
+
class Tree {
public:
Tree(const int uid) : uid_(uid) {}
int uid() const { return uid_; }
+ virtual void Accept(TreeVisitorBase& visitor) = 0;
private:
const int uid_;
@@ -29,9 +68,14 @@ class Ident : public Expr {
public:
std::string identifier_;
TypedValue Evaluate(Frame &frame, SymbolTable &symbol_table) override;
+ void Accept(TreeVisitorBase& visitor) override {
+ visitor.PreVisit(*this);
+ visitor.Visit(*this);
+ visitor.PostVisit(*this);
+ }
};
-class Part {};
+class Part : public Tree {};
class NodePart : public Part {
public:
@@ -39,12 +83,24 @@ public:
// TODO: Mislav call GraphDb::label(label_name) to populate labels_!
std::vector<GraphDb::Label> labels_;
// TODO: properties
+ void Accept(TreeVisitorBase& visitor) override {
+ visitor.PreVisit(*this);
+ identifier_.Accept(visitor);
+ visitor.Visit(*this);
+ visitor.PostVisit(*this);
+ }
};
class EdgePart : public Part {
public:
Ident identifier_;
// TODO: finish this: properties, types...
+ void Accept(TreeVisitorBase& visitor) override {
+ visitor.PreVisit(*this);
+ identifier_.Accept(visitor);
+ visitor.Visit(*this);
+ visitor.PostVisit(*this);
+ }
};
class Clause : public Tree {};
@@ -52,20 +108,52 @@ class Clause : public Tree {};
class Pattern : public Tree {
public:
std::vector<std::unique_ptr<Part>> node_parts_;
+ void Accept(TreeVisitorBase& visitor) override {
+ visitor.PreVisit(*this);
+ for (auto& node_part : node_parts_) {
+ node_part->Accept(visitor);
+ }
+ visitor.Visit(*this);
+ visitor.PostVisit(*this);
+ }
};
class Query : public Tree {
public:
std::vector<std::unique_ptr<Clause>> clauses_;
+ void Accept(TreeVisitorBase& visitor) override {
+ visitor.PreVisit(*this);
+ for (auto& clause : clauses_) {
+ clause->Accept(visitor);
+ }
+ visitor.Visit(*this);
+ visitor.PostVisit(*this);
+ }
};
class Match : public Clause {
public:
std::vector<std::unique_ptr<Pattern>> patterns_;
+ void Accept(TreeVisitorBase& visitor) override {
+ visitor.PreVisit(*this);
+ for (auto& pattern : patterns_) {
+ pattern->Accept(visitor);
+ }
+ visitor.Visit(*this);
+ visitor.PostVisit(*this);
+ }
};
class Return : public Clause {
public:
std::vector<std::unique_ptr<Expr>> exprs_;
+ void Accept(TreeVisitorBase& visitor) override {
+ visitor.PreVisit(*this);
+ for (auto& expr : exprs_) {
+ expr->Accept(visitor);
+ }
+ visitor.Visit(*this);
+ visitor.PostVisit(*this);
+ }
};
}
diff --git a/src/query/frontend/ast/cypher_main_visitor.cpp b/src/query/frontend/ast/cypher_main_visitor.cpp
index 368785014..f60b152a7 100644
--- a/src/query/frontend/ast/cypher_main_visitor.cpp
+++ b/src/query/frontend/ast/cypher_main_visitor.cpp
@@ -1,4 +1,4 @@
-#include "query/backend/cpp/cypher_main_visitor.hpp"
+#include "query/frontend/ast/cypher_main_visitor.hpp"
#include <climits>
#include <string>
diff --git a/src/query/frontend/typecheck/typecheck.hpp b/src/query/frontend/typecheck/typecheck.hpp
new file mode 100644
index 000000000..c10558124
--- /dev/null
+++ b/src/query/frontend/typecheck/typecheck.hpp
@@ -0,0 +1,73 @@
+#pragma once
+
+#include "utils/exceptions/basic_exception.hpp"
+#include "query/frontend/ast/ast.hpp"
+#include "query/frontend/typecheck/symbol_table.hpp"
+
+namespace query {
+
+class TypeCheckVisitor : public TreeVisitorBase {
+ public:
+ TypeCheckVisitor(SymbolTable& symbol_table) : symbol_table_(symbol_table_) {}
+
+ // Start of the tree is a Query.
+ void Visit(Query& query) override {}
+ // Expressions
+ void Visit(Ident& ident) override {
+ Symbol symbol;
+ } if (scope_.in_pattern) {
+ symbol = GetOrCreateSymbol(ident.identifier_);
+ } else {
+ if (!HasSymbol(ident.identifier_))
+ // TODO: Special exception for type check
+ throw BasicException("Unbound identifier: " + ident.identifier_);
+ symbol = scope_.variables[ident.identifier_];
+ }
+ symbol_table_[ident] = symbol;
+ }
+ // Clauses
+ void Visit(Match& match) override {}
+ void PreVisit(Return& ret) override {
+ scope_.in_return = true;
+ }
+ void PostVisit(Return& ret) override {
+ scope_.in_return = false;
+ }
+ void Visit(Return& ret) override {}
+ // Pattern and its subparts.
+ void PreVisit(Pattern& pattern) override {
+ scope_.in_pattern = true;
+ }
+ void PostVisit(Pattern& pattern) override {
+ scope_.in_pattern = false;
+ }
+ void Visit(Pattern& pattern) override {}
+ void Visit(NodePart& node_part) override {}
+ void Visit(EdgePart& edge_part) override {}
+
+ private:
+ struct Scope {
+ Scope() : in_pattern(false), in_return(false) {}
+ bool in_pattern;
+ bool in_return;
+ std::map<std::string, Symbol> variables;
+ };
+
+ bool HasSymbol(const std::string& name)
+ {
+ return scope_.variables.find(name) != scope_.variables.end();
+ }
+
+ Symbol GetOrCreateSymbol(const std::string& name)
+ {
+ auto search = scope_.variables.find(name)
+ if (search != scope_.variables.end()) {
+ return *search;
+ }
+ scope_.variables[name] = symbol_table_.CreateSymbol(name);
+ }
+ SymbolTable& symbol_table_;
+ Scope scope_;
+};
+
+}
From 34416bc505961c63453c6045acad38184764b4f3 Mon Sep 17 00:00:00 2001
From: Teon Banek <theongugl@gmail.com>
Date: Sat, 11 Mar 2017 20:49:22 +0100
Subject: [PATCH 08/16] Add basic generation of LogicalOperator tree
---
src/query/frontend/ast/ast.hpp | 4 +-
.../frontend/ast/cypher_main_visitor.cpp | 2 +-
src/query/frontend/logical/operator.hpp | 6 ++
src/query/frontend/logical/planner.hpp | 55 +++++++++++++++++++
src/query/frontend/typecheck/symbol_table.hpp | 4 +-
src/query/frontend/typecheck/typecheck.hpp | 12 ++--
6 files changed, 73 insertions(+), 10 deletions(-)
create mode 100644 src/query/frontend/logical/planner.hpp
diff --git a/src/query/frontend/ast/ast.hpp b/src/query/frontend/ast/ast.hpp
index 18ce5da4c..772e3234d 100644
--- a/src/query/frontend/ast/ast.hpp
+++ b/src/query/frontend/ast/ast.hpp
@@ -107,7 +107,7 @@ class Clause : public Tree {};
class Pattern : public Tree {
public:
- std::vector<std::unique_ptr<Part>> node_parts_;
+ std::vector<std::shared_ptr<NodePart>> node_parts_;
void Accept(TreeVisitorBase& visitor) override {
visitor.PreVisit(*this);
for (auto& node_part : node_parts_) {
@@ -146,7 +146,7 @@ public:
class Return : public Clause {
public:
- std::vector<std::unique_ptr<Expr>> exprs_;
+ std::vector<std::shared_ptr<Expr>> exprs_;
void Accept(TreeVisitorBase& visitor) override {
visitor.PreVisit(*this);
for (auto& expr : exprs_) {
diff --git a/src/query/frontend/ast/cypher_main_visitor.cpp b/src/query/frontend/ast/cypher_main_visitor.cpp
index f60b152a7..c59e9e1d0 100644
--- a/src/query/frontend/ast/cypher_main_visitor.cpp
+++ b/src/query/frontend/ast/cypher_main_visitor.cpp
@@ -7,7 +7,7 @@
#include <vector>
#include "query/backend/cpp/compiler_structures.hpp"
-#include "query/backend/cpp/named_antlr_tokens.hpp"
+#include "query/frontend/ast/named_antlr_tokens.hpp"
#include "utils/assert.hpp"
namespace backend {
diff --git a/src/query/frontend/logical/operator.hpp b/src/query/frontend/logical/operator.hpp
index 103209e0e..b82b735ea 100644
--- a/src/query/frontend/logical/operator.hpp
+++ b/src/query/frontend/logical/operator.hpp
@@ -69,6 +69,7 @@ class ScanAll : public LogicalOperator {
return std::unique_ptr<Cursor>(cursor);
}
+ private:
friend class ScanAll::ScanAllCursor;
std::shared_ptr<NodePart> node_part_;
};
@@ -93,6 +94,11 @@ class Produce : public LogicalOperator {
private:
Produce& parent_;
};
+ public:
+ std::unique_ptr<Cursor> MakeCursor(GraphDbAccessor) override {
+ return std::unique_ptr<Cursor>(new ProduceCursor(*this));
+ }
+ private:
std::vector<std::shared_ptr<Expr>> exprs_;
};
}
diff --git a/src/query/frontend/logical/planner.hpp b/src/query/frontend/logical/planner.hpp
new file mode 100644
index 000000000..479c21ed3
--- /dev/null
+++ b/src/query/frontend/logical/planner.hpp
@@ -0,0 +1,55 @@
+#pragma once
+
+#include <memory>
+#include <stdexcept>
+
+#include "query/frontend/ast/ast.hpp"
+#include "query/frontend/logical/operator.hpp"
+
+namespace query {
+
+std::shared_ptr<LogicalOperator> GenMatch(
+ Match& match, std::shared_ptr<LogicalOperator> current_op)
+{
+ if (current_op) {
+ throw std::runtime_error("Not implemented");
+ }
+ if (match.patterns_.size() != 1) {
+ throw std::runtime_error("Not implemented");
+ }
+ auto& pattern = match.patterns_[0];
+ if (pattern->node_parts_.size() != 1) {
+ throw std::runtime_error("Not implemented");
+ }
+ auto& node_part = pattern->node_parts_[0];
+ return std::shared_ptr<LogicalOperator>(new ScanAll(node_part));
+}
+
+std::shared_ptr<LogicalOperator> GenReturn(
+ Return& ret, std::shared_ptr<LogicalOperator> current_op)
+{
+ if (!current_op) {
+ throw std::runtime_error("Not implemented");
+ }
+ return std::shared_ptr<LogicalOperator>(new Produce(current_op, ret.exprs_));
+}
+
+std::shared_ptr<LogicalOperator> Apply(Query& query)
+{
+ std::shared_ptr<LogicalOperator> current_op;
+ for (auto& clause : query.clauses_) {
+ auto* clause_ptr = clause.get();
+ auto* match = dynamic_cast<Match*>(clause_ptr);
+ auto* ret = dynamic_cast<Return*>(clause_ptr);
+ if (match) {
+ current_op = GenMatch(*match, current_op);
+ } else if (ret) {
+ return GenReturn(*ret, current_op);
+ } else {
+ throw std::runtime_error("Not implemented");
+ }
+ }
+ return current_op;
+}
+
+}
diff --git a/src/query/frontend/typecheck/symbol_table.hpp b/src/query/frontend/typecheck/symbol_table.hpp
index 3b934456f..6fc222705 100644
--- a/src/query/frontend/typecheck/symbol_table.hpp
+++ b/src/query/frontend/typecheck/symbol_table.hpp
@@ -8,14 +8,14 @@
namespace query {
struct Symbol {
Symbol() {}
- Symbol(std::string& name, int position) : name_(name), position_(position) {}
+ Symbol(const std::string& name, int position) : name_(name), position_(position) {}
std::string name_;
int position_;
};
class SymbolTable {
public:
- Symbol CreateSymbol(std::string& name) {
+ Symbol CreateSymbol(const std::string& name) {
int position = position_++;
return Symbol(name, position);
}
diff --git a/src/query/frontend/typecheck/typecheck.hpp b/src/query/frontend/typecheck/typecheck.hpp
index c10558124..a8f66f81c 100644
--- a/src/query/frontend/typecheck/typecheck.hpp
+++ b/src/query/frontend/typecheck/typecheck.hpp
@@ -8,14 +8,14 @@ namespace query {
class TypeCheckVisitor : public TreeVisitorBase {
public:
- TypeCheckVisitor(SymbolTable& symbol_table) : symbol_table_(symbol_table_) {}
+ TypeCheckVisitor(SymbolTable& symbol_table) : symbol_table_(symbol_table) {}
// Start of the tree is a Query.
void Visit(Query& query) override {}
// Expressions
void Visit(Ident& ident) override {
Symbol symbol;
- } if (scope_.in_pattern) {
+ if (scope_.in_pattern) {
symbol = GetOrCreateSymbol(ident.identifier_);
} else {
if (!HasSymbol(ident.identifier_))
@@ -60,11 +60,13 @@ class TypeCheckVisitor : public TreeVisitorBase {
Symbol GetOrCreateSymbol(const std::string& name)
{
- auto search = scope_.variables.find(name)
+ auto search = scope_.variables.find(name);
if (search != scope_.variables.end()) {
- return *search;
+ return search->second;
}
- scope_.variables[name] = symbol_table_.CreateSymbol(name);
+ auto symbol = symbol_table_.CreateSymbol(name);
+ scope_.variables[name] = symbol;
+ return symbol;
}
SymbolTable& symbol_table_;
Scope scope_;
From 9030454132a60deec2b12c5f9a7b3a0df252761e Mon Sep 17 00:00:00 2001
From: Marko Budiselic <marko.budiselic@memgraph.io>
Date: Sat, 11 Mar 2017 16:11:30 +0100
Subject: [PATCH 09/16] Add compiler prototype entry point (work in progress).
---
src/query/entry.hpp | 22 ++++++
tests/manual/compiler_prototype.cpp | 105 ++++++++++++++++++++++++++++
2 files changed, 127 insertions(+)
create mode 100644 src/query/entry.hpp
create mode 100644 tests/manual/compiler_prototype.cpp
diff --git a/src/query/entry.hpp b/src/query/entry.hpp
new file mode 100644
index 000000000..6a5ae25e2
--- /dev/null
+++ b/src/query/entry.hpp
@@ -0,0 +1,22 @@
+#pragma once
+
+#include "database/graph_db_accessor.hpp"
+#include "query/frontend/opencypher/parser.hpp"
+
+namespace query {
+
+template <typename Stream>
+class Engine {
+ public:
+ Engine() {}
+ auto Execute(const std::string &query, GraphDbAccessor &db_accessor,
+ Stream &stream) {
+ frontend::opencypher::Parser parser(query);
+ auto low_level_tree = parser.tree();
+ // high level tree
+ // typechecked tree
+ // logical tree
+ // interpret & stream results
+ }
+};
+}
diff --git a/tests/manual/compiler_prototype.cpp b/tests/manual/compiler_prototype.cpp
new file mode 100644
index 000000000..7907978af
--- /dev/null
+++ b/tests/manual/compiler_prototype.cpp
@@ -0,0 +1,105 @@
+#include <iostream>
+
+#include "dbms/dbms.hpp"
+#include "logging/default.hpp"
+#include "logging/streams/stdout.cpp"
+#include "query/entry.hpp"
+#include "query/backend/cpp/typed_value.hpp"
+
+using std::cout;
+using std::cin;
+using std::endl;
+
+class ConsoleResultStream : public Loggable {
+ public:
+ ConsoleResultStream() : Loggable("ConsoleResultStream") {}
+
+ void Header(const std::vector<std::string>&) { logger.info("header"); }
+
+ void Result(std::vector<TypedValue>& values) {
+ for (auto value : values) {
+ logger.info(" result");
+ }
+ }
+
+ void Summary(const std::map<std::string, TypedValue>&) {
+ logger.info("summary");
+ }
+};
+
+int main(int argc, char* argv[]) {
+ // init arguments
+ REGISTER_ARGS(argc, argv);
+
+ // init logger
+ logging::init_sync();
+ logging::log->pipe(std::make_unique<Stdout>());
+
+ // init db context
+ Dbms dbms;
+ ConsoleResultStream stream;
+ query::Engine<ConsoleResultStream> query_engine;
+
+ // initialize the database
+ auto dba = dbms.active();
+
+ // props
+ auto name = dba.property("name");
+ auto age = dba.property("age");
+ auto type = dba.property("type");
+
+ // vertices
+ auto memgraph = dba.insert_vertex();
+ memgraph.PropsSet(name, "Memgraph");
+ auto teon = dba.insert_vertex();
+ memgraph.PropsSet(name, "Teon");
+ memgraph.PropsSet(age, 26);
+ auto mislav = dba.insert_vertex();
+ memgraph.PropsSet(name, "Mislav");
+ memgraph.PropsSet(age, 22);
+ auto florijan = dba.insert_vertex();
+ memgraph.PropsSet(name, "Florijan");
+ memgraph.PropsSet(age, 31);
+ auto xps_15 = dba.insert_vertex();
+ memgraph.PropsSet(type, "PC");
+ memgraph.PropsSet(name, "Dell XPS 15");
+
+ // edges
+ dba.insert_edge(teon, memgraph, dba.edge_type("MEMBER_OF"));
+ dba.insert_edge(mislav, memgraph, dba.edge_type("MEMBER_OF"));
+ dba.insert_edge(florijan, memgraph, dba.edge_type("MEMBER_OF"));
+
+ dba.insert_edge(teon, mislav, dba.edge_type("FRIEND_OF"));
+ dba.insert_edge(mislav, teon, dba.edge_type("FRIEND_OF"));
+ dba.insert_edge(florijan, mislav, dba.edge_type("FRIEND_OF"));
+ dba.insert_edge(mislav, florijan, dba.edge_type("FRIEND_OF"));
+ dba.insert_edge(florijan, teon, dba.edge_type("FRIEND_OF"));
+ dba.insert_edge(teon, florijan, dba.edge_type("FRIEND_OF"));
+
+ dba.insert_edge(memgraph, xps_15, dba.edge_type("OWNS"));
+
+ dba.insert_edge(teon, xps_15, dba.edge_type("USES"));
+ dba.insert_edge(mislav, xps_15, dba.edge_type("USES"));
+ dba.insert_edge(florijan, xps_15, dba.edge_type("USES"));
+
+ cout << "-- Memgraph Query Engine --" << endl;
+
+ while (true) {
+ // read command
+ cout << "> ";
+ std::string command;
+ std::getline(cin, command);
+ if (command == "quit") break;
+ // execute command / query
+ try {
+ auto db_accessor = dbms.active();
+ query_engine.Execute(command, db_accessor, stream);
+ } catch (const std::exception& e) {
+ cout << e.what() << endl;
+ } catch (...) {
+ // pass
+ }
+ }
+
+ return 0;
+}
From 0eeb1fc5b488b06fb450c8502667d8c7b4ebdd36 Mon Sep 17 00:00:00 2001
From: Marko Budiselic <marko.budiselic@memgraph.io>
Date: Sat, 11 Mar 2017 21:02:03 +0100
Subject: [PATCH 10/16] Basic interpreter implementation.
---
src/query/context.hpp | 40 +++++++++++-
src/query/entry.hpp | 33 ++++++++--
src/query/frontend/ast/ast.cpp | 3 +
src/query/frontend/ast/ast.hpp | 31 ++++++----
src/query/frontend/logical/operator.hpp | 82 ++++++++++++++++++++-----
tests/manual/compiler_prototype.cpp | 17 -----
6 files changed, 155 insertions(+), 51 deletions(-)
diff --git a/src/query/context.hpp b/src/query/context.hpp
index eea60317c..92e4b609e 100644
--- a/src/query/context.hpp
+++ b/src/query/context.hpp
@@ -1,14 +1,52 @@
#pragma once
#include "antlr4-runtime.h"
+#include "database/graph_db_accessor.hpp"
#include "query/frontend/ast/cypher_main_visitor.hpp"
+class TypedcheckedTree {};
+
+class LogicalPlan {};
+
+class Context;
+
+class LogicalPlanGenerator {
+ public:
+ std::vector<LogicalPlan> Generate(TypedcheckedTree&, Context&) {
+ return {LogicalPlan()};
+ }
+};
+
+struct Config {
+ LogicalPlanGenerator logical_plan_generator;
+};
+
class Context {
+ public:
int uid_counter;
+ Context(Config config, GraphDbAccessor& db_accessor)
+ : config(config), db_accessor(db_accessor) {}
+
+ Config config;
+ GraphDbAccessor& db_accessor;
+};
+
+class LogicalPlanner {
+ public:
+ LogicalPlanner(Context ctx) : ctx_(ctx) {}
+
+ LogicalPlan Apply(TypedcheckedTree typedchecked_tree) {
+ return ctx_.config.logical_plan_generator.Generate(typedchecked_tree,
+ ctx_)[0];
+ }
+
+ private:
+ Context ctx_;
};
class HighLevelAstConversion {
- void Apply(const Context &ctx, antlr4::tree::ParseTree *tree) {
+ public:
+ void Apply(const Context& ctx, antlr4::tree::ParseTree* tree) {
query::frontend::CypherMainVisitor visitor(ctx);
visitor.visit(tree);
}
diff --git a/src/query/entry.hpp b/src/query/entry.hpp
index 6a5ae25e2..373a5d5fc 100644
--- a/src/query/entry.hpp
+++ b/src/query/entry.hpp
@@ -2,21 +2,44 @@
#include "database/graph_db_accessor.hpp"
#include "query/frontend/opencypher/parser.hpp"
+#include "query/context.hpp"
namespace query {
template <typename Stream>
class Engine {
public:
- Engine() {}
+ Engine() {
+ }
auto Execute(const std::string &query, GraphDbAccessor &db_accessor,
Stream &stream) {
- frontend::opencypher::Parser parser(query);
+ Config config;
+ Context ctx(config, db_accessor);
+ ::frontend::opencypher::Parser parser(query);
auto low_level_tree = parser.tree();
- // high level tree
- // typechecked tree
- // logical tree
+ auto high_level_tree = low2high_tree.Apply(ctx, low_level_tree);
+ TypedcheckedTree typechecked_tree;
+ auto logical_plan = LogicalPlanner(ctx).Apply(typechecked_tree);
+
// interpret & stream results
+ // generate frame based on symbol table max_position
+ Frame frame(size);
+ auto cursor = logical_plan.MakeCursor(frame);
+ logical_plan.WriteHeader(stream);
+ auto symbols = logical_plan.OutputSymbols(symbol_table);
+ while (cursor.pull(frame, context)) {
+ std::vector<TypedValue> values(symbols.size());
+ for (auto symbol : symbols) {
+ values.emplace_back(frame[symbol]);
+ }
+ stream.Result(values);
+ }
+ stream.Summary({"type": "r"});
+
}
+private:
+ Context ctx;
+ HighLevelAstConversion low2high_tree;
+
};
}
diff --git a/src/query/frontend/ast/ast.cpp b/src/query/frontend/ast/ast.cpp
index 34abc30dc..a6a32fbeb 100644
--- a/src/query/frontend/ast/ast.cpp
+++ b/src/query/frontend/ast/ast.cpp
@@ -7,4 +7,7 @@ TypedValue Ident::Evaluate(Frame& frame, SymbolTable& symbol_table) {
return frame[symbol_table[*this].position_];
}
+void NamedExpr::Evaluate(Frame& frame, SymbolTable& symbol_table) {
+ frame[symbol_table[*ident_].position_] = expr_->Evaluate(frame, symbol_table);
+}
}
diff --git a/src/query/frontend/ast/ast.hpp b/src/query/frontend/ast/ast.hpp
index 772e3234d..fb1ea4efd 100644
--- a/src/query/frontend/ast/ast.hpp
+++ b/src/query/frontend/ast/ast.hpp
@@ -50,24 +50,24 @@ class TreeVisitorBase {
};
class Tree {
-public:
+ public:
Tree(const int uid) : uid_(uid) {}
int uid() const { return uid_; }
virtual void Accept(TreeVisitorBase& visitor) = 0;
-private:
+ private:
const int uid_;
};
class Expr : public Tree {
-public:
- virtual TypedValue Evaluate(Frame &, SymbolTable &) = 0;
+ public:
+ virtual TypedValue Evaluate(Frame&, SymbolTable&) = 0;
};
class Ident : public Expr {
-public:
+ public:
std::string identifier_;
- TypedValue Evaluate(Frame &frame, SymbolTable &symbol_table) override;
+ TypedValue Evaluate(Frame& frame, SymbolTable& symbol_table) override;
void Accept(TreeVisitorBase& visitor) override {
visitor.PreVisit(*this);
visitor.Visit(*this);
@@ -77,8 +77,15 @@ public:
class Part : public Tree {};
+class NamedExpr : public Tree {
+ public:
+ std::shared_ptr<Ident> ident_;
+ std::shared_ptr<Expr> expr_;
+ void Evaluate(Frame& frame, SymbolTable& symbol_table);
+};
+
class NodePart : public Part {
-public:
+ public:
Ident identifier_;
// TODO: Mislav call GraphDb::label(label_name) to populate labels_!
std::vector<GraphDb::Label> labels_;
@@ -92,7 +99,7 @@ public:
};
class EdgePart : public Part {
-public:
+ public:
Ident identifier_;
// TODO: finish this: properties, types...
void Accept(TreeVisitorBase& visitor) override {
@@ -106,7 +113,7 @@ public:
class Clause : public Tree {};
class Pattern : public Tree {
-public:
+ public:
std::vector<std::shared_ptr<NodePart>> node_parts_;
void Accept(TreeVisitorBase& visitor) override {
visitor.PreVisit(*this);
@@ -119,7 +126,7 @@ public:
};
class Query : public Tree {
-public:
+ public:
std::vector<std::unique_ptr<Clause>> clauses_;
void Accept(TreeVisitorBase& visitor) override {
visitor.PreVisit(*this);
@@ -132,7 +139,7 @@ public:
};
class Match : public Clause {
-public:
+ public:
std::vector<std::unique_ptr<Pattern>> patterns_;
void Accept(TreeVisitorBase& visitor) override {
visitor.PreVisit(*this);
@@ -145,7 +152,7 @@ public:
};
class Return : public Clause {
-public:
+ public:
std::vector<std::shared_ptr<Expr>> exprs_;
void Accept(TreeVisitorBase& visitor) override {
visitor.PreVisit(*this);
diff --git a/src/query/frontend/logical/operator.hpp b/src/query/frontend/logical/operator.hpp
index b82b735ea..829666443 100644
--- a/src/query/frontend/logical/operator.hpp
+++ b/src/query/frontend/logical/operator.hpp
@@ -9,6 +9,24 @@
#include "query/frontend/typecheck/symbol_table.hpp"
namespace query {
+
+class ConsoleResultStream : public Loggable {
+ public:
+ ConsoleResultStream() : Loggable("ConsoleResultStream") {}
+
+ void Header(const std::vector<std::string>&) { logger.info("header"); }
+
+ void Result(std::vector<TypedValue>& values) {
+ for (auto value : values) {
+ logger.info(" result");
+ }
+ }
+
+ void Summary(const std::map<std::string, TypedValue>&) {
+ logger.info("summary");
+ }
+};
+
class Cursor {
public:
virtual bool pull(Frame&, SymbolTable&) = 0;
@@ -19,6 +37,10 @@ class LogicalOperator {
public:
auto children() { return children_; };
virtual std::unique_ptr<Cursor> MakeCursor(GraphDbAccessor db) = 0;
+ virtual void WriteHeader(ConsoleResultStream&) {}
+ virtual std::vector<Symbol> OutputSymbols(SymbolTable& symbol_table) {
+ return {};
+ }
virtual ~LogicalOperator() {}
protected:
@@ -32,8 +54,10 @@ class ScanAll : public LogicalOperator {
private:
class ScanAllCursor : public Cursor {
public:
- ScanAllCursor(ScanAll& parent, GraphDbAccessor db)
- : parent_(parent), db_(db), vertices_(db.vertices()),
+ ScanAllCursor(ScanAll& self, GraphDbAccessor db)
+ : self_(self),
+ db_(db),
+ vertices_(db.vertices()),
vertices_it_(vertices_.begin()) {}
bool pull(Frame& frame, SymbolTable& symbol_table) override {
@@ -47,14 +71,14 @@ class ScanAll : public LogicalOperator {
}
private:
- ScanAll& parent_;
+ ScanAll& self_;
GraphDbAccessor db_;
decltype(db_.vertices()) vertices_;
decltype(vertices_.begin()) vertices_it_;
bool evaluate(Frame& frame, SymbolTable& symbol_table,
VertexAccessor& vertex) {
- auto node_part = parent_.node_part_;
+ auto node_part = self_.node_part_;
for (auto label : node_part->labels_) {
if (!vertex.has_label(label)) return false;
}
@@ -65,8 +89,7 @@ class ScanAll : public LogicalOperator {
public:
std::unique_ptr<Cursor> MakeCursor(GraphDbAccessor db) override {
- Cursor* cursor = new ScanAllCursor(*this, db);
- return std::unique_ptr<Cursor>(cursor);
+ return std::make_unique<Cursor>(ScanAllCursor(*this, db));
}
private:
@@ -76,29 +99,56 @@ class ScanAll : public LogicalOperator {
class Produce : public LogicalOperator {
public:
- Produce(std::shared_ptr<LogicalOperator> op, std::vector<std::shared_ptr<Expr>> exprs)
- : exprs_(exprs) {
- children_.emplace_back(op);
+ Produce(std::shared_ptr<LogicalOperator> input,
+ std::vector<std::shared_ptr<NamedExpr>> exprs)
+ : input_(input), exprs_(exprs) {
+ children_.emplace_back(input);
}
+ void WriteHeader(ConsoleResultStream& stream) override {
+ // TODO: write real result
+ stream.Header({"n"});
+ }
+
+ std::unique_ptr<Cursor> MakeCursor(GraphDbAccessor db) override {
+ return std::make_unique<Cursor>(ProduceCursor(*this, db));
+ }
+
+ std::vector<Symbol> OutputSymbols(SymbolTable& symbol_table) override {
+ std::vector<Symbol> result(exprs_.size());
+ for (auto named_expr : exprs_) {
+ result.emplace_back(symbol_table[*named_expr->ident_]);
+ }
+ return result;
+}
+
private:
class ProduceCursor : public Cursor {
public:
- ProduceCursor(Produce& parent) : parent_(parent) {}
- bool pull(Frame &frame, SymbolTable& symbol_table) override {
- for (auto expr : parent_.exprs_) {
- frame[symbol_table[*expr].position_] = expr->Evaluate(frame, symbol_table);
+ ProduceCursor(Produce& self, GraphDbAccessor db)
+ : self_(self), self_cursor_(self_.MakeCursor(db)) {}
+ bool pull(Frame& frame, SymbolTable& symbol_table) override {
+ if (self_cursor_->pull(frame, symbol_table)) {
+ for (auto expr : self_.exprs_) {
+ expr->Evaluate(frame, symbol_table);
+ }
+ return true;
}
- return true;
+ return false;
}
+
private:
- Produce& parent_;
+ Produce& self_;
+ std::unique_ptr<Cursor> self_cursor_;
};
+
public:
std::unique_ptr<Cursor> MakeCursor(GraphDbAccessor) override {
return std::unique_ptr<Cursor>(new ProduceCursor(*this));
}
+
private:
- std::vector<std::shared_ptr<Expr>> exprs_;
+ std::shared_ptr<LogicalOperator> input_;
+ std::vector<std::shared_ptr<NamedExpr>> exprs_;
};
}
diff --git a/tests/manual/compiler_prototype.cpp b/tests/manual/compiler_prototype.cpp
index 7907978af..665acc041 100644
--- a/tests/manual/compiler_prototype.cpp
+++ b/tests/manual/compiler_prototype.cpp
@@ -10,23 +10,6 @@ using std::cout;
using std::cin;
using std::endl;
-class ConsoleResultStream : public Loggable {
- public:
- ConsoleResultStream() : Loggable("ConsoleResultStream") {}
-
- void Header(const std::vector<std::string>&) { logger.info("header"); }
-
- void Result(std::vector<TypedValue>& values) {
- for (auto value : values) {
- logger.info(" result");
- }
- }
-
- void Summary(const std::map<std::string, TypedValue>&) {
- logger.info("summary");
- }
-};
-
int main(int argc, char* argv[]) {
// init arguments
REGISTER_ARGS(argc, argv);
From 10062b143c332b1b92dd1c5321ef0650d0d63e45 Mon Sep 17 00:00:00 2001
From: Marko Budiselic <marko.budiselic@memgraph.io>
Date: Sat, 11 Mar 2017 21:21:09 +0100
Subject: [PATCH 11/16] Interpreter merge.
---
src/query/entry.hpp | 48 +++++++++++++++++++++++++++------------------
1 file changed, 29 insertions(+), 19 deletions(-)
diff --git a/src/query/entry.hpp b/src/query/entry.hpp
index 373a5d5fc..c55b0e1bf 100644
--- a/src/query/entry.hpp
+++ b/src/query/entry.hpp
@@ -1,45 +1,55 @@
#pragma once
#include "database/graph_db_accessor.hpp"
-#include "query/frontend/opencypher/parser.hpp"
#include "query/context.hpp"
+#include "query/frontend/opencypher/parser.hpp"
+#include "query/frontend/typecheck/typecheck.hpp"
namespace query {
template <typename Stream>
class Engine {
public:
- Engine() {
- }
+ Engine() {}
auto Execute(const std::string &query, GraphDbAccessor &db_accessor,
Stream &stream) {
Config config;
Context ctx(config, db_accessor);
+
+ // query -> AST
::frontend::opencypher::Parser parser(query);
auto low_level_tree = parser.tree();
- auto high_level_tree = low2high_tree.Apply(ctx, low_level_tree);
- TypedcheckedTree typechecked_tree;
- auto logical_plan = LogicalPlanner(ctx).Apply(typechecked_tree);
- // interpret & stream results
+ // AST -> high level tree
+ auto high_level_tree = low2high_tree.Apply(ctx, low_level_tree);
+
+ // symbol table fill
+ SymbolTable symbol_table;
+ TypeCheckVisitor typecheck_visitor;
+ high_level_tree.Accept(typecheck_visitor);
+
+ // high level tree -> logical plan
+ auto logical_plan = query::Apply(high_level_tree);
+
// generate frame based on symbol table max_position
- Frame frame(size);
+ Frame frame(symbol_table.max_position());
+
+ // interpret
auto cursor = logical_plan.MakeCursor(frame);
logical_plan.WriteHeader(stream);
auto symbols = logical_plan.OutputSymbols(symbol_table);
while (cursor.pull(frame, context)) {
- std::vector<TypedValue> values(symbols.size());
- for (auto symbol : symbols) {
- values.emplace_back(frame[symbol]);
- }
- stream.Result(values);
+ std::vector<TypedValue> values(symbols.size());
+ for (auto symbol : symbols) {
+ values.emplace_back(frame[symbol]);
+ }
+ stream.Result(values);
}
- stream.Summary({"type": "r"});
-
+ stream.Summary({"type" : "r"});
}
-private:
- Context ctx;
- HighLevelAstConversion low2high_tree;
-
+
+ private:
+ Context ctx;
+ HighLevelAstConversion low2high_tree;
};
}
From bce605851d9e453c74c119d887fd2ceb40ac458a Mon Sep 17 00:00:00 2001
From: Teon Banek <theongugl@gmail.com>
Date: Sat, 11 Mar 2017 21:49:50 +0100
Subject: [PATCH 12/16] Handle NamedExpr in TypeCheckVisitor
---
src/query/frontend/ast/ast.hpp | 13 ++++++-
src/query/frontend/logical/operator.hpp | 9 ++---
src/query/frontend/typecheck/typecheck.hpp | 42 +++++++++++++++++++---
3 files changed, 51 insertions(+), 13 deletions(-)
diff --git a/src/query/frontend/ast/ast.hpp b/src/query/frontend/ast/ast.hpp
index fb1ea4efd..1022b0ed9 100644
--- a/src/query/frontend/ast/ast.hpp
+++ b/src/query/frontend/ast/ast.hpp
@@ -13,6 +13,7 @@ class SymbolTable;
// Forward declares for TreeVisitorBase
class Query;
+class NamedExpr;
class Ident;
class Match;
class Return;
@@ -27,6 +28,9 @@ class TreeVisitorBase {
virtual void Visit(Query& query) = 0;
virtual void PostVisit(Query& query) {}
// Expressions
+ virtual void PreVisit(NamedExpr&) {}
+ virtual void Visit(NamedExpr&) = 0;
+ virtual void PostVisit(NamedExpr&) {}
virtual void PreVisit(Ident& ident) {}
virtual void Visit(Ident& ident) = 0;
virtual void PostVisit(Ident& ident) {}
@@ -82,6 +86,13 @@ class NamedExpr : public Tree {
std::shared_ptr<Ident> ident_;
std::shared_ptr<Expr> expr_;
void Evaluate(Frame& frame, SymbolTable& symbol_table);
+ void Accept(TreeVisitorBase& visitor) override {
+ visitor.PreVisit(*this);
+ ident_->Accept(visitor);
+ expr_->Accept(visitor);
+ visitor.Visit(*this);
+ visitor.PostVisit(*this);
+ }
};
class NodePart : public Part {
@@ -153,7 +164,7 @@ class Match : public Clause {
class Return : public Clause {
public:
- std::vector<std::shared_ptr<Expr>> exprs_;
+ std::vector<std::shared_ptr<NamedExpr>> exprs_;
void Accept(TreeVisitorBase& visitor) override {
visitor.PreVisit(*this);
for (auto& expr : exprs_) {
diff --git a/src/query/frontend/logical/operator.hpp b/src/query/frontend/logical/operator.hpp
index 829666443..dd18dbf36 100644
--- a/src/query/frontend/logical/operator.hpp
+++ b/src/query/frontend/logical/operator.hpp
@@ -89,7 +89,7 @@ class ScanAll : public LogicalOperator {
public:
std::unique_ptr<Cursor> MakeCursor(GraphDbAccessor db) override {
- return std::make_unique<Cursor>(ScanAllCursor(*this, db));
+ return std::unique_ptr<Cursor>(new ScanAllCursor(*this, db));
}
private:
@@ -111,7 +111,7 @@ class Produce : public LogicalOperator {
}
std::unique_ptr<Cursor> MakeCursor(GraphDbAccessor db) override {
- return std::make_unique<Cursor>(ProduceCursor(*this, db));
+ return std::unique_ptr<Cursor>(new ProduceCursor(*this, db));
}
std::vector<Symbol> OutputSymbols(SymbolTable& symbol_table) override {
@@ -142,11 +142,6 @@ class Produce : public LogicalOperator {
std::unique_ptr<Cursor> self_cursor_;
};
- public:
- std::unique_ptr<Cursor> MakeCursor(GraphDbAccessor) override {
- return std::unique_ptr<Cursor>(new ProduceCursor(*this));
- }
-
private:
std::shared_ptr<LogicalOperator> input_;
std::vector<std::shared_ptr<NamedExpr>> exprs_;
diff --git a/src/query/frontend/typecheck/typecheck.hpp b/src/query/frontend/typecheck/typecheck.hpp
index a8f66f81c..9923e6ee3 100644
--- a/src/query/frontend/typecheck/typecheck.hpp
+++ b/src/query/frontend/typecheck/typecheck.hpp
@@ -13,9 +13,21 @@ class TypeCheckVisitor : public TreeVisitorBase {
// Start of the tree is a Query.
void Visit(Query& query) override {}
// Expressions
+ void PreVisit(NamedExpr& named_expr) override {
+ scope_.in_named_expr = true;
+ }
+ void Visit(NamedExpr& named_expr) override {}
void Visit(Ident& ident) override {
Symbol symbol;
- if (scope_.in_pattern) {
+ if (scope_.in_named_expr) {
+ // TODO: Handle this better, so that the `with` variables aren't
+ // shadowed.
+ if (HasSymbol(ident.identifier_)) {
+ scope_.revert_variable = true;
+ scope_.old_symbol = scope_.variables[ident.identifier_];
+ }
+ symbol = CreateSymbol(ident.identifier_);
+ } else if (scope_.in_pattern) {
symbol = GetOrCreateSymbol(ident.identifier_);
} else {
if (!HasSymbol(ident.identifier_))
@@ -25,6 +37,15 @@ class TypeCheckVisitor : public TreeVisitorBase {
}
symbol_table_[ident] = symbol;
}
+ void PostVisit(Ident& ident) override {
+ if (scope_.in_named_expr) {
+ if (scope_.revert_variable) {
+ scope_.variables[ident.identifier_] = scope_.old_symbol;
+ }
+ scope_.in_named_expr = false;
+ scope_.revert_variable = false;
+ }
+ }
// Clauses
void Visit(Match& match) override {}
void PreVisit(Return& ret) override {
@@ -47,9 +68,14 @@ class TypeCheckVisitor : public TreeVisitorBase {
private:
struct Scope {
- Scope() : in_pattern(false), in_return(false) {}
+ Scope()
+ : in_pattern(false), in_return(false), in_named_expr(false),
+ revert_variable(false) {}
bool in_pattern;
bool in_return;
+ bool in_named_expr;
+ bool revert_variable;
+ Symbol old_symbol;
std::map<std::string, Symbol> variables;
};
@@ -58,16 +84,22 @@ class TypeCheckVisitor : public TreeVisitorBase {
return scope_.variables.find(name) != scope_.variables.end();
}
+ Symbol CreateSymbol(const std::string &name)
+ {
+ auto symbol = symbol_table_.CreateSymbol(name);
+ scope_.variables[name] = symbol;
+ return symbol;
+ }
+
Symbol GetOrCreateSymbol(const std::string& name)
{
auto search = scope_.variables.find(name);
if (search != scope_.variables.end()) {
return search->second;
}
- auto symbol = symbol_table_.CreateSymbol(name);
- scope_.variables[name] = symbol;
- return symbol;
+ return CreateSymbol(name);
}
+
SymbolTable& symbol_table_;
Scope scope_;
};
From cfd2eae9d02735abb074015c596203d9733be418 Mon Sep 17 00:00:00 2001
From: Teon Banek <theongugl@gmail.com>
Date: Sat, 11 Mar 2017 23:05:38 +0100
Subject: [PATCH 13/16] Use make_*_ptr to construct pointers
---
src/query/frontend/logical/operator.hpp | 4 ++--
src/query/frontend/logical/planner.hpp | 4 ++--
2 files changed, 4 insertions(+), 4 deletions(-)
diff --git a/src/query/frontend/logical/operator.hpp b/src/query/frontend/logical/operator.hpp
index dd18dbf36..b0e8f99c0 100644
--- a/src/query/frontend/logical/operator.hpp
+++ b/src/query/frontend/logical/operator.hpp
@@ -89,7 +89,7 @@ class ScanAll : public LogicalOperator {
public:
std::unique_ptr<Cursor> MakeCursor(GraphDbAccessor db) override {
- return std::unique_ptr<Cursor>(new ScanAllCursor(*this, db));
+ return std::make_unique<ScanAllCursor>(*this, db);
}
private:
@@ -111,7 +111,7 @@ class Produce : public LogicalOperator {
}
std::unique_ptr<Cursor> MakeCursor(GraphDbAccessor db) override {
- return std::unique_ptr<Cursor>(new ProduceCursor(*this, db));
+ return std::make_unique<ProduceCursor>(*this, db);
}
std::vector<Symbol> OutputSymbols(SymbolTable& symbol_table) override {
diff --git a/src/query/frontend/logical/planner.hpp b/src/query/frontend/logical/planner.hpp
index 479c21ed3..6e049dda2 100644
--- a/src/query/frontend/logical/planner.hpp
+++ b/src/query/frontend/logical/planner.hpp
@@ -22,7 +22,7 @@ std::shared_ptr<LogicalOperator> GenMatch(
throw std::runtime_error("Not implemented");
}
auto& node_part = pattern->node_parts_[0];
- return std::shared_ptr<LogicalOperator>(new ScanAll(node_part));
+ return std::make_shared<ScanAll>(node_part);
}
std::shared_ptr<LogicalOperator> GenReturn(
@@ -31,7 +31,7 @@ std::shared_ptr<LogicalOperator> GenReturn(
if (!current_op) {
throw std::runtime_error("Not implemented");
}
- return std::shared_ptr<LogicalOperator>(new Produce(current_op, ret.exprs_));
+ return std::make_shared<Produce>(current_op, ret.exprs_);
}
std::shared_ptr<LogicalOperator> Apply(Query& query)
From 026e0e6fbd18696c11fab28b4d7610a231b52861 Mon Sep 17 00:00:00 2001
From: Mislav Bradac <mislav.bradac@memgraph.io>
Date: Sat, 11 Mar 2017 21:19:57 +0100
Subject: [PATCH 14/16] Implement ast generation by cypher visitor
---
CMakeLists.txt | 1 +
src/query/backend/cpp/generator.hpp | 10 +-
src/query/context.cpp | 11 +
src/query/context.hpp | 36 +-
src/query/engine.hpp | 13 +-
src/query/frontend/ast/ast.cpp | 4 +-
src/query/frontend/ast/ast.hpp | 166 ++--
.../frontend/ast/cypher_main_visitor.cpp | 719 +++++++++---------
.../frontend/ast/cypher_main_visitor.hpp | 270 ++++---
tests/unit/cypher_main_visitor.cpp | 18 +-
10 files changed, 648 insertions(+), 600 deletions(-)
create mode 100644 src/query/context.cpp
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 72999f286..4327311e1 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -349,6 +349,7 @@ set(memgraph_src_files
${src_dir}/database/graph_db_accessor.cpp
${src_dir}/query/stripper.cpp
${src_dir}/query/frontend/ast/cypher_main_visitor.cpp
+ ${src_dir}/query/context.cpp
${src_dir}/query/backend/cpp/typed_value.cpp
${src_dir}/query/frontend/ast/ast.cpp
)
diff --git a/src/query/backend/cpp/generator.hpp b/src/query/backend/cpp/generator.hpp
index d823cf4ac..df3f08236 100644
--- a/src/query/backend/cpp/generator.hpp
+++ b/src/query/backend/cpp/generator.hpp
@@ -1,8 +1,8 @@
#pragma once
-#include <experimental/filesystem>
#include "antlr4-runtime.h"
-#include "query/backend/cpp/cypher_main_visitor.hpp"
+#include "query/frontend/ast/cypher_main_visitor.hpp"
+#include <experimental/filesystem>
namespace fs = std::experimental::filesystem;
@@ -13,8 +13,8 @@ namespace cpp {
using namespace antlr4;
class GeneratorException : public BasicException {
- public:
- using BasicException::BasicException;
+public:
+ using BasicException::BasicException;
GeneratorException() : BasicException("") {}
};
@@ -23,7 +23,7 @@ class GeneratorException : public BasicException {
* C++.
*/
class Generator {
- public:
+public:
/**
* Generates cpp code inside file on the path.
*/
diff --git a/src/query/context.cpp b/src/query/context.cpp
new file mode 100644
index 000000000..177a37cb7
--- /dev/null
+++ b/src/query/context.cpp
@@ -0,0 +1,11 @@
+#include "query/context.hpp"
+#include "query/frontend/ast/cypher_main_visitor.hpp"
+
+namespace query {
+
+void HighLevelAstConversion::Apply(Context &ctx,
+ antlr4::tree::ParseTree *tree) {
+ query::frontend::CypherMainVisitor visitor(ctx);
+ visitor.visit(tree);
+}
+}
diff --git a/src/query/context.hpp b/src/query/context.hpp
index 92e4b609e..4c73f17ad 100644
--- a/src/query/context.hpp
+++ b/src/query/context.hpp
@@ -2,7 +2,8 @@
#include "antlr4-runtime.h"
#include "database/graph_db_accessor.hpp"
-#include "query/frontend/ast/cypher_main_visitor.hpp"
+
+namespace query {
class TypedcheckedTree {};
@@ -11,8 +12,8 @@ class LogicalPlan {};
class Context;
class LogicalPlanGenerator {
- public:
- std::vector<LogicalPlan> Generate(TypedcheckedTree&, Context&) {
+public:
+ std::vector<LogicalPlan> Generate(TypedcheckedTree &, Context &) {
return {LogicalPlan()};
}
};
@@ -22,32 +23,31 @@ struct Config {
};
class Context {
- public:
- int uid_counter;
- Context(Config config, GraphDbAccessor& db_accessor)
- : config(config), db_accessor(db_accessor) {}
+public:
+ Context(Config config, GraphDbAccessor &db_accessor)
+ : config_(config), db_accessor_(db_accessor) {}
+ int next_uid() { return uid_counter_++; }
- Config config;
- GraphDbAccessor& db_accessor;
+ Config config_;
+ GraphDbAccessor &db_accessor_;
+ int uid_counter_ = 0;
};
class LogicalPlanner {
- public:
+public:
LogicalPlanner(Context ctx) : ctx_(ctx) {}
LogicalPlan Apply(TypedcheckedTree typedchecked_tree) {
- return ctx_.config.logical_plan_generator.Generate(typedchecked_tree,
- ctx_)[0];
+ return ctx_.config_.logical_plan_generator.Generate(typedchecked_tree,
+ ctx_)[0];
}
- private:
+private:
Context ctx_;
};
class HighLevelAstConversion {
- public:
- void Apply(const Context& ctx, antlr4::tree::ParseTree* tree) {
- query::frontend::CypherMainVisitor visitor(ctx);
- visitor.visit(tree);
- }
+public:
+ void Apply(Context &ctx, antlr4::tree::ParseTree *tree);
};
+}
diff --git a/src/query/engine.hpp b/src/query/engine.hpp
index 1f1fba69a..d7ae8445c 100644
--- a/src/query/engine.hpp
+++ b/src/query/engine.hpp
@@ -26,12 +26,11 @@ namespace fs = std::experimental::filesystem;
* the results should be returned (more optimal then just return
* the whole result set)
*/
-template <typename Stream>
-class QueryEngine : public Loggable {
- private:
+template <typename Stream> class QueryEngine : public Loggable {
+private:
using QueryPlanLib = DynamicLib<QueryPlanTrait<Stream>>;
- public:
+public:
QueryEngine() : Loggable("QueryEngine") {}
/**
@@ -104,12 +103,12 @@ class QueryEngine : public Loggable {
*
* @return size_t the number of loaded query plans
*/
- auto Size() { // TODO: const once whan ConcurrentMap::Accessor becomes const
+ auto Size() { // TODO: const once whan ConcurrentMap::Accessor becomes const
return query_plans.access().size();
}
// return query_plans.access().size(); }
- private:
+private:
/**
* Loads query plan eather from hardcoded folder or from the file that is
* generated in this method.
@@ -176,7 +175,7 @@ class QueryEngine : public Loggable {
// TODO: underlying object has to be live during query execution
// fix that when Antler will be introduced into the database
- auto query_plan_instance = query_plan->instance(); // because of move
+ auto query_plan_instance = query_plan->instance(); // because of move
plans_accessor.insert(hash, std::move(query_plan));
// return an instance of runnable code (PlanInterface)
diff --git a/src/query/frontend/ast/ast.cpp b/src/query/frontend/ast/ast.cpp
index a6a32fbeb..0b961d6c1 100644
--- a/src/query/frontend/ast/ast.cpp
+++ b/src/query/frontend/ast/ast.cpp
@@ -3,11 +3,11 @@
namespace query {
-TypedValue Ident::Evaluate(Frame& frame, SymbolTable& symbol_table) {
+TypedValue Ident::Evaluate(Frame &frame, SymbolTable &symbol_table) {
return frame[symbol_table[*this].position_];
}
-void NamedExpr::Evaluate(Frame& frame, SymbolTable& symbol_table) {
+void NamedExpr::Evaluate(Frame &frame, SymbolTable &symbol_table) {
frame[symbol_table[*ident_].position_] = expr_->Evaluate(frame, symbol_table);
}
}
diff --git a/src/query/frontend/ast/ast.hpp b/src/query/frontend/ast/ast.hpp
index 1022b0ed9..b7617a746 100644
--- a/src/query/frontend/ast/ast.hpp
+++ b/src/query/frontend/ast/ast.hpp
@@ -22,139 +22,161 @@ class NodePart;
class EdgePart;
class TreeVisitorBase {
- public:
+public:
// Start of the tree is a Query.
- virtual void PreVisit(Query& query) {}
- virtual void Visit(Query& query) = 0;
- virtual void PostVisit(Query& query) {}
+ virtual void PreVisit(Query &) {}
+ virtual void Visit(Query &query) = 0;
+ virtual void PostVisit(Query &) {}
// Expressions
- virtual void PreVisit(NamedExpr&) {}
- virtual void Visit(NamedExpr&) = 0;
- virtual void PostVisit(NamedExpr&) {}
- virtual void PreVisit(Ident& ident) {}
- virtual void Visit(Ident& ident) = 0;
- virtual void PostVisit(Ident& ident) {}
+ virtual void PreVisit(NamedExpr &) {}
+ virtual void Visit(NamedExpr &) = 0;
+ virtual void PostVisit(NamedExpr &) {}
+ virtual void PreVisit(Ident &) {}
+ virtual void Visit(Ident &ident) = 0;
+ virtual void PostVisit(Ident &) {}
// Clauses
- virtual void PreVisit(Match& match) {}
- virtual void Visit(Match& match) = 0;
- virtual void PostVisit(Match& match) {}
- virtual void PreVisit(Return& ret) {}
- virtual void Visit(Return& ret) = 0;
- virtual void PostVisit(Return& ret) {}
+ virtual void PreVisit(Match &) {}
+ virtual void Visit(Match &match) = 0;
+ virtual void PostVisit(Match &) {}
+ virtual void PreVisit(Return &) {}
+ virtual void Visit(Return &ret) = 0;
+ virtual void PostVisit(Return &) {}
// Pattern and its subparts.
- virtual void PreVisit(Pattern& pattern) {}
- virtual void Visit(Pattern& pattern) = 0;
- virtual void PostVisit(Pattern& pattern) {}
- virtual void PreVisit(NodePart& node_part) {}
- virtual void Visit(NodePart& node_part) = 0;
- virtual void PostVisit(NodePart& node_part) {}
- virtual void PreVisit(EdgePart& edge_part) {}
- virtual void Visit(EdgePart& edge_part) = 0;
- virtual void PostVisit(EdgePart& edge_part) {}
+ virtual void PreVisit(Pattern &) {}
+ virtual void Visit(Pattern &pattern) = 0;
+ virtual void PostVisit(Pattern &) {}
+ virtual void PreVisit(NodePart &) {}
+ virtual void Visit(NodePart &node_part) = 0;
+ virtual void PostVisit(NodePart &) {}
+ virtual void PreVisit(EdgePart &) {}
+ virtual void Visit(EdgePart &edge_part) = 0;
+ virtual void PostVisit(EdgePart &) {}
};
class Tree {
- public:
- Tree(const int uid) : uid_(uid) {}
+public:
+ Tree(int uid) : uid_(uid) {}
int uid() const { return uid_; }
- virtual void Accept(TreeVisitorBase& visitor) = 0;
+ virtual void Accept(TreeVisitorBase &visitor) = 0;
- private:
+private:
const int uid_;
};
class Expr : public Tree {
- public:
- virtual TypedValue Evaluate(Frame&, SymbolTable&) = 0;
+public:
+ Expr(int uid) : Tree(uid) {}
+ virtual TypedValue Evaluate(Frame &, SymbolTable &) = 0;
};
class Ident : public Expr {
- public:
- std::string identifier_;
- TypedValue Evaluate(Frame& frame, SymbolTable& symbol_table) override;
- void Accept(TreeVisitorBase& visitor) override {
+public:
+ Ident(int) = delete;
+ Ident(int uid, const std::string &identifier)
+ : Expr(uid), identifier_(identifier) {}
+
+ TypedValue Evaluate(Frame &frame, SymbolTable &symbol_table) override;
+ void Accept(TreeVisitorBase &visitor) override {
visitor.PreVisit(*this);
visitor.Visit(*this);
visitor.PostVisit(*this);
}
+
+ std::string identifier_;
};
-class Part : public Tree {};
+class Part : public Tree {
+public:
+ Part(int uid) : Tree(uid) {}
+};
class NamedExpr : public Tree {
- public:
- std::shared_ptr<Ident> ident_;
- std::shared_ptr<Expr> expr_;
- void Evaluate(Frame& frame, SymbolTable& symbol_table);
- void Accept(TreeVisitorBase& visitor) override {
+public:
+ NamedExpr(int uid) : Tree(uid) {}
+ void Evaluate(Frame &frame, SymbolTable &symbol_table);
+ void Accept(TreeVisitorBase &visitor) override {
visitor.PreVisit(*this);
ident_->Accept(visitor);
expr_->Accept(visitor);
visitor.Visit(*this);
visitor.PostVisit(*this);
}
+
+ std::shared_ptr<Ident> ident_;
+ std::shared_ptr<Expr> expr_;
};
class NodePart : public Part {
- public:
- Ident identifier_;
- // TODO: Mislav call GraphDb::label(label_name) to populate labels_!
- std::vector<GraphDb::Label> labels_;
- // TODO: properties
- void Accept(TreeVisitorBase& visitor) override {
+public:
+ NodePart(int uid) : Part(uid) {}
+ void Accept(TreeVisitorBase &visitor) override {
visitor.PreVisit(*this);
- identifier_.Accept(visitor);
+ identifier_->Accept(visitor);
visitor.Visit(*this);
visitor.PostVisit(*this);
}
+
+ std::shared_ptr<Ident> identifier_;
+ std::vector<GraphDb::Label> labels_;
};
class EdgePart : public Part {
- public:
- Ident identifier_;
- // TODO: finish this: properties, types...
- void Accept(TreeVisitorBase& visitor) override {
+public:
+ enum class Direction { LEFT, RIGHT, BOTH };
+
+ EdgePart(int uid) : Part(uid) {}
+ void Accept(TreeVisitorBase &visitor) override {
visitor.PreVisit(*this);
- identifier_.Accept(visitor);
+ identifier_->Accept(visitor);
visitor.Visit(*this);
visitor.PostVisit(*this);
}
+
+ Direction direction = Direction::BOTH;
+ std::shared_ptr<Ident> identifier_;
};
-class Clause : public Tree {};
+class Clause : public Tree {
+public:
+ Clause(int uid) : Tree(uid) {}
+};
class Pattern : public Tree {
- public:
- std::vector<std::shared_ptr<NodePart>> node_parts_;
- void Accept(TreeVisitorBase& visitor) override {
+public:
+ Pattern(int uid) : Tree(uid) {}
+ void Accept(TreeVisitorBase &visitor) override {
visitor.PreVisit(*this);
- for (auto& node_part : node_parts_) {
- node_part->Accept(visitor);
+ for (auto &part : parts_) {
+ part->Accept(visitor);
}
visitor.Visit(*this);
visitor.PostVisit(*this);
}
+ std::shared_ptr<Ident> identifier_;
+ std::vector<std::shared_ptr<Part>> parts_;
};
class Query : public Tree {
- public:
- std::vector<std::unique_ptr<Clause>> clauses_;
- void Accept(TreeVisitorBase& visitor) override {
+public:
+ Query(int uid) : Tree(uid) {}
+ void Accept(TreeVisitorBase &visitor) override {
visitor.PreVisit(*this);
- for (auto& clause : clauses_) {
+ for (auto &clause : clauses_) {
clause->Accept(visitor);
}
visitor.Visit(*this);
visitor.PostVisit(*this);
}
+ std::vector<std::shared_ptr<Clause>> clauses_;
};
class Match : public Clause {
- public:
- std::vector<std::unique_ptr<Pattern>> patterns_;
- void Accept(TreeVisitorBase& visitor) override {
+public:
+ Match(int uid) : Clause(uid) {}
+ std::vector<std::shared_ptr<Pattern>> patterns_;
+ void Accept(TreeVisitorBase &visitor) override {
visitor.PreVisit(*this);
- for (auto& pattern : patterns_) {
+ for (auto &pattern : patterns_) {
pattern->Accept(visitor);
}
visitor.Visit(*this);
@@ -163,15 +185,19 @@ class Match : public Clause {
};
class Return : public Clause {
- public:
+public:
+ Return(int uid) : Clause(uid) {}
std::vector<std::shared_ptr<NamedExpr>> exprs_;
- void Accept(TreeVisitorBase& visitor) override {
+ void Accept(TreeVisitorBase &visitor) override {
visitor.PreVisit(*this);
- for (auto& expr : exprs_) {
+ for (auto &expr : exprs_) {
expr->Accept(visitor);
}
visitor.Visit(*this);
visitor.PostVisit(*this);
}
+
+ std::shared_ptr<Ident> identifier_;
+ std::vector<std::shared_ptr<NamedExpr>> named_exprs_;
};
}
diff --git a/src/query/frontend/ast/cypher_main_visitor.cpp b/src/query/frontend/ast/cypher_main_visitor.cpp
index c59e9e1d0..cd94df5cb 100644
--- a/src/query/frontend/ast/cypher_main_visitor.cpp
+++ b/src/query/frontend/ast/cypher_main_visitor.cpp
@@ -6,103 +6,132 @@
#include <utility>
#include <vector>
-#include "query/backend/cpp/compiler_structures.hpp"
+#include "database/graph_db.hpp"
#include "query/frontend/ast/named_antlr_tokens.hpp"
#include "utils/assert.hpp"
-namespace backend {
-namespace cpp {
+namespace query {
+namespace frontend {
namespace {
// Map children tokens of antlr node to Function enum.
-std::vector<Function> MapTokensToOperators(
- antlr4::ParserRuleContext *node,
- const std::unordered_map<size_t, Function> token_to_operator) {
- std::vector<antlr4::tree::TerminalNode *> tokens;
- for (const auto &x : token_to_operator) {
- tokens.insert(tokens.end(), node->getTokens(x.first).begin(),
- node->getTokens(x.first).end());
- }
- sort(tokens.begin(), tokens.end(), [](antlr4::tree::TerminalNode *a,
- antlr4::tree::TerminalNode *b) {
- return a->getSourceInterval().startsBeforeDisjoint(b->getSourceInterval());
- });
- std::vector<Function> ops;
- for (auto *token : tokens) {
- auto it = token_to_operator.find(token->getSymbol()->getType());
- debug_assert(it != token_to_operator.end(),
- "Wrong mapping sent to function.");
- ops.push_back(it->second);
- }
- return ops;
-}
+// std::vector<Function> MapTokensToOperators(
+// antlr4::ParserRuleContext *node,
+// const std::unordered_map<size_t, Function> token_to_operator) {
+// std::vector<antlr4::tree::TerminalNode *> tokens;
+// for (const auto &x : token_to_operator) {
+// tokens.insert(tokens.end(), node->getTokens(x.first).begin(),
+// node->getTokens(x.first).end());
+// }
+// sort(tokens.begin(), tokens.end(), [](antlr4::tree::TerminalNode *a,
+// antlr4::tree::TerminalNode *b) {
+// return
+// a->getSourceInterval().startsBeforeDisjoint(b->getSourceInterval());
+// });
+// std::vector<Function> ops;
+// for (auto *token : tokens) {
+// auto it = token_to_operator.find(token->getSymbol()->getType());
+// debug_assert(it != token_to_operator.end(),
+// "Wrong mapping sent to function.");
+// ops.push_back(it->second);
+// }
+// return ops;
+//}
}
-antlrcpp::Any CypherMainVisitor::visitNodePattern(
- CypherParser::NodePatternContext *ctx) {
- bool new_node = true;
- Node node;
- if (ctx->variable()) {
- auto variable = ctx->variable()->accept(this).as<std::string>();
- auto &curr_id_map = ids_map_.back();
- if (curr_id_map.find(variable) != curr_id_map.end()) {
- if (!symbol_table_[curr_id_map[variable]].is<Node>()) {
- throw SemanticException();
- }
- new_node = false;
- node = symbol_table_[curr_id_map[variable]].as<Node>();
- } else {
- node.output_id = new_id();
- curr_id_map[variable] = node.output_id;
- }
- } else {
- node.output_id = new_id();
+antlrcpp::Any
+CypherMainVisitor::visitSingleQuery(CypherParser::SingleQueryContext *ctx) {
+ auto children = ctx->children;
+ query_ = std::make_shared<Query>(ctx_.next_uid());
+ for (auto *child : children) {
+ query_->clauses_.push_back(child->accept(this));
}
- if (!new_node && (ctx->nodeLabels() || ctx->properties())) {
- // If variable is already declared, we cannot list properties or labels.
- // This is slightly incompatible with neo4j. In neo4j it is valid to write
- // MATCH (n {a: 5})--(n {b: 10}) which is equivalent to MATCH(n {a:5, b:
- // 10})--(n). Neo4j also allows MATCH (n) RETURN (n {x: 5}) which is
- // equivalent to MATCH (n) RETURN ({x: 5}).
- // TODO: The way in which we are storing nodes is not suitable for optional
- // match. For example: MATCH (n {a: 5}) OPTIONAL MATCH (n {b: 10}) RETURN
- // n.a, n.b. would not work. Think more about that case.
- throw SemanticException();
+ return query_;
+}
+
+antlrcpp::Any
+CypherMainVisitor::visitCypherMatch(CypherParser::CypherMatchContext *ctx) {
+ auto match = std::make_shared<Match>(ctx_.next_uid());
+ if (ctx->OPTIONAL() || ctx->where()) {
+ throw std::exception();
+ }
+ match->patterns_ =
+ ctx->pattern()->accept(this).as<std::vector<std::shared_ptr<Pattern>>>();
+ return match;
+}
+
+antlrcpp::Any
+CypherMainVisitor::visitReturnItems(CypherParser::ReturnItemsContext *ctx) {
+ auto return_clause = std::make_shared<Return>(ctx_.next_uid());
+ for (auto *item : ctx->returnItem()) {
+ return_clause->named_exprs_.push_back(item->accept(this));
+ }
+ return return_clause;
+}
+
+antlrcpp::Any
+CypherMainVisitor::visitReturnItem(CypherParser::ReturnItemContext *ctx) {
+ auto named_expr = std::make_shared<NamedExpr>(ctx_.next_uid());
+ if (ctx->variable()) {
+ named_expr->ident_ =
+ std::make_shared<Ident>(ctx_.next_uid(), ctx->variable()->accept(this));
+ } else {
+ named_expr->ident_ =
+ std::make_shared<Ident>(ctx_.next_uid(), ctx->getText());
+ }
+ named_expr->expr_ = ctx->expression()->accept(this);
+ return named_expr;
+}
+
+antlrcpp::Any
+CypherMainVisitor::visitNodePattern(CypherParser::NodePatternContext *ctx) {
+ auto node = new NodePart(ctx_.next_uid());
+ if (ctx->variable()) {
+ std::string variable = ctx->variable()->accept(this);
+ node->identifier_ =
+ std::make_shared<Ident>(ctx_.next_uid(), kUserIdentPrefix + variable);
+ } else {
+ node->identifier_ = std::make_shared<Ident>(
+ ctx_.next_uid(), kAnonIdentPrefix + std::to_string(next_ident_id_++));
}
if (ctx->nodeLabels()) {
- node.labels =
- ctx->nodeLabels()->accept(this).as<std::vector<std::string>>();
+ std::vector<std::string> labels = ctx->nodeLabels()->accept(this);
+ for (const auto &label : labels) {
+ node->labels_.push_back(ctx_.db_accessor_.label(label));
+ }
}
if (ctx->properties()) {
- node.properties = ctx->properties()
- ->accept(this)
- .as<std::unordered_map<std::string, std::string>>();
+ throw std::exception();
+ // node.properties = ctx->properties()
+ // ->accept(this)
+ // .as<std::unordered_map<std::string,
+ // std::string>>();
}
- symbol_table_[node.output_id] = node;
- return node.output_id;
+ return (Part *)node;
}
-antlrcpp::Any CypherMainVisitor::visitNodeLabels(
- CypherParser::NodeLabelsContext *ctx) {
+antlrcpp::Any
+CypherMainVisitor::visitNodeLabels(CypherParser::NodeLabelsContext *ctx) {
std::vector<std::string> labels;
for (auto *node_label : ctx->nodeLabel()) {
- labels.push_back(node_label->accept(this).as<std::string>());
+ labels.push_back(node_label->accept(this));
}
return labels;
}
-antlrcpp::Any CypherMainVisitor::visitProperties(
- CypherParser::PropertiesContext *ctx) {
+antlrcpp::Any
+CypherMainVisitor::visitProperties(CypherParser::PropertiesContext *ctx) {
if (!ctx->mapLiteral()) {
// If child is not mapLiteral that means child is params. At the moment
// memgraph doesn't support params.
- throw SemanticException();
+ throw std::exception();
}
return ctx->mapLiteral()->accept(this);
}
-antlrcpp::Any CypherMainVisitor::visitMapLiteral(
- CypherParser::MapLiteralContext *ctx) {
+antlrcpp::Any
+CypherMainVisitor::visitMapLiteral(CypherParser::MapLiteralContext *ctx) {
+ throw std::exception();
std::unordered_map<std::string, std::string> map;
for (int i = 0; i < (int)ctx->propertyKeyName().size(); ++i) {
map[ctx->propertyKeyName()[i]->accept(this).as<std::string>()] =
@@ -111,40 +140,38 @@ antlrcpp::Any CypherMainVisitor::visitMapLiteral(
return map;
}
-antlrcpp::Any CypherMainVisitor::visitSymbolicName(
- CypherParser::SymbolicNameContext *ctx) {
+antlrcpp::Any
+CypherMainVisitor::visitSymbolicName(CypherParser::SymbolicNameContext *ctx) {
if (ctx->EscapedSymbolicName()) {
// We don't allow at this point for variable to be EscapedSymbolicName
// because we would have t ofigure out how escaping works since same
// variable can be referenced in two ways: escaped and unescaped.
- throw SemanticException();
+ throw std::exception();
}
return std::string(ctx->getText());
}
-antlrcpp::Any CypherMainVisitor::visitPattern(
- CypherParser::PatternContext *ctx) {
- std::vector<std::string> pattern;
+antlrcpp::Any
+CypherMainVisitor::visitPattern(CypherParser::PatternContext *ctx) {
+ std::vector<std::shared_ptr<Pattern>> patterns;
for (auto *pattern_part : ctx->patternPart()) {
- pattern.push_back(pattern_part->accept(this).as<std::string>());
+ patterns.push_back(pattern_part->accept(this));
}
- return pattern;
+ return patterns;
}
-antlrcpp::Any CypherMainVisitor::visitPatternPart(
- CypherParser::PatternPartContext *ctx) {
- PatternPart pattern_part =
- ctx->anonymousPatternPart()->accept(this).as<PatternPart>();
+antlrcpp::Any
+CypherMainVisitor::visitPatternPart(CypherParser::PatternPartContext *ctx) {
+ std::shared_ptr<Pattern> pattern = ctx->anonymousPatternPart()->accept(this);
if (ctx->variable()) {
- std::string variable = ctx->variable()->accept(this).as<std::string>();
- auto &curr_id_map = ids_map_.back();
- if (curr_id_map.find(variable) != curr_id_map.end()) {
- throw SemanticException();
- }
- curr_id_map[variable] = pattern_part.output_id;
+ std::string variable = ctx->variable()->accept(this);
+ pattern->identifier_ =
+ std::make_shared<Ident>(ctx_.next_uid(), kUserIdentPrefix + variable);
+ } else {
+ pattern->identifier_ = std::make_shared<Ident>(
+ ctx_.next_uid(), kAnonIdentPrefix + std::to_string(next_ident_id_++));
}
- symbol_table_[pattern_part.output_id] = pattern_part;
- return pattern_part.output_id;
+ return pattern;
}
antlrcpp::Any CypherMainVisitor::visitPatternElement(
@@ -152,88 +179,67 @@ antlrcpp::Any CypherMainVisitor::visitPatternElement(
if (ctx->patternElement()) {
return ctx->patternElement()->accept(this);
}
- PatternPart pattern_part;
- pattern_part.output_id = new_id();
- pattern_part.nodes.push_back(
- ctx->nodePattern()->accept(this).as<std::string>());
+ auto pattern = std::shared_ptr<Pattern>();
+ pattern->parts_.push_back(
+ ctx->nodePattern()->accept(this).as<std::shared_ptr<Part>>());
for (auto *pattern_element_chain : ctx->patternElementChain()) {
- auto element = pattern_element_chain->accept(this)
- .as<std::pair<std::string, std::string>>();
- pattern_part.relationships.push_back(element.first);
- pattern_part.nodes.push_back(element.second);
+ auto element =
+ pattern_element_chain->accept(this)
+ .as<std::pair<std::shared_ptr<Part>, std::shared_ptr<Part>>>();
+ pattern->parts_.push_back(element.first);
+ pattern->parts_.push_back(element.second);
}
- return pattern_part;
+ return pattern;
}
antlrcpp::Any CypherMainVisitor::visitPatternElementChain(
CypherParser::PatternElementChainContext *ctx) {
- return std::pair<std::string, std::string>(
- ctx->relationshipPattern()->accept(this).as<std::string>(),
- ctx->nodePattern()->accept(this).as<std::string>());
+ return std::pair<std::shared_ptr<Part>, std::shared_ptr<Part>>(
+ ctx->relationshipPattern()->accept(this).as<std::shared_ptr<Part>>(),
+ ctx->nodePattern()->accept(this).as<std::shared_ptr<Part>>());
}
antlrcpp::Any CypherMainVisitor::visitRelationshipPattern(
CypherParser::RelationshipPatternContext *ctx) {
- bool new_relationship = true;
- Relationship relationship;
+ auto edge = std::make_shared<EdgePart>(ctx_.next_uid());
if (ctx->relationshipDetail()) {
if (ctx->relationshipDetail()->variable()) {
- auto variable =
- ctx->relationshipDetail()->variable()->accept(this).as<std::string>();
- auto &curr_id_map = ids_map_.back();
- if (curr_id_map.find(variable) != curr_id_map.end()) {
- if (!symbol_table_[curr_id_map[variable]].is<Relationship>()) {
- throw SemanticException();
- }
- new_relationship = false;
- relationship = symbol_table_[curr_id_map[variable]].as<Relationship>();
- } else {
- relationship.output_id = new_id();
- curr_id_map[variable] = relationship.output_id;
- }
- }
- if (!new_relationship && (ctx->relationshipDetail()->relationshipTypes() ||
- ctx->relationshipDetail()->properties() ||
- ctx->relationshipDetail()->rangeLiteral())) {
- // Neo4j doesn't allow multiple edges with same variable name, but if we
- // are going to support different types of morphisms then there is no
- // reason to disallow that.
- throw SemanticException();
- }
- if (ctx->relationshipDetail()->relationshipTypes()) {
- relationship.types = ctx->relationshipDetail()
- ->relationshipTypes()
- ->accept(this)
- .as<std::vector<std::string>>();
- }
- if (ctx->relationshipDetail()->properties()) {
- relationship.properties =
- ctx->relationshipDetail()
- ->properties()
- ->accept(this)
- .as<std::unordered_map<std::string, std::string>>();
- }
- if (ctx->relationshipDetail()->rangeLiteral()) {
- relationship.has_range = true;
- auto range = ctx->relationshipDetail()
- ->rangeLiteral()
- ->accept(this)
- .as<std::pair<int64_t, int64_t>>();
- relationship.lower_bound = range.first;
- relationship.upper_bound = range.second;
+ std::string variable =
+ ctx->relationshipDetail()->variable()->accept(this);
+ edge->identifier_ =
+ std::make_shared<Ident>(ctx_.next_uid(), kUserIdentPrefix + variable);
+ } else {
+ edge->identifier_ = std::make_shared<Ident>(
+ ctx_.next_uid(), kAnonIdentPrefix + std::to_string(next_ident_id_++));
}
}
+ if (ctx->relationshipDetail()->relationshipTypes()) {
+ throw std::exception();
+ }
+ if (ctx->relationshipDetail()->properties()) {
+ throw std::exception();
+ }
+ if (ctx->relationshipDetail()->rangeLiteral()) {
+ throw std::exception();
+ // relationship.has_range = true;
+ // auto range = ctx->relationshipDetail()
+ // ->rangeLiteral()
+ // ->accept(this)
+ // .as<std::pair<int64_t, int64_t>>();
+ // relationship.lower_bound = range.first;
+ // relationship.upper_bound = range.second;
+ }
+
if (ctx->leftArrowHead() && !ctx->rightArrowHead()) {
- relationship.direction = Relationship::Direction::LEFT;
+ edge->direction = EdgePart::Direction::LEFT;
} else if (!ctx->leftArrowHead() && ctx->rightArrowHead()) {
- relationship.direction = Relationship::Direction::RIGHT;
+ edge->direction = EdgePart::Direction::RIGHT;
} else {
// <-[]-> and -[]- is the same thing as far as we understand openCypher
// grammar.
- relationship.direction = Relationship::Direction::BOTH;
+ edge->direction = EdgePart::Direction::BOTH;
}
- symbol_table_[relationship.output_id] = relationship;
- return relationship.output_id;
+ return std::shared_ptr<Part>(edge);
}
antlrcpp::Any CypherMainVisitor::visitRelationshipDetail(
@@ -251,8 +257,8 @@ antlrcpp::Any CypherMainVisitor::visitRelationshipTypes(
return types;
}
-antlrcpp::Any CypherMainVisitor::visitRangeLiteral(
- CypherParser::RangeLiteralContext *ctx) {
+antlrcpp::Any
+CypherMainVisitor::visitRangeLiteral(CypherParser::RangeLiteralContext *ctx) {
if (ctx->integerLiteral().size() == 0U) {
// -[*]-
return std::pair<int64_t, int64_t>(1LL, LLONG_MAX);
@@ -279,194 +285,201 @@ antlrcpp::Any CypherMainVisitor::visitRangeLiteral(
}
}
-antlrcpp::Any CypherMainVisitor::visitExpression(
- CypherParser::ExpressionContext *ctx) {
+antlrcpp::Any
+CypherMainVisitor::visitExpression(CypherParser::ExpressionContext *ctx) {
return visitChildren(ctx);
}
-// OR.
-antlrcpp::Any CypherMainVisitor::visitExpression12(
- CypherParser::Expression12Context *ctx) {
- return LeftAssociativeOperatorExpression(ctx->expression11(),
- Function::LOGICAL_OR);
-}
-
-// XOR.
-antlrcpp::Any CypherMainVisitor::visitExpression11(
- CypherParser::Expression11Context *ctx) {
- return LeftAssociativeOperatorExpression(ctx->expression10(),
- Function::LOGICAL_XOR);
-}
-
-// AND.
-antlrcpp::Any CypherMainVisitor::visitExpression10(
- CypherParser::Expression10Context *ctx) {
- return LeftAssociativeOperatorExpression(ctx->expression9(),
- Function::LOGICAL_AND);
-}
-
-// NOT.
-antlrcpp::Any CypherMainVisitor::visitExpression9(
- CypherParser::Expression9Context *ctx) {
- // TODO: make template similar to LeftAssociativeOperatorExpression for unary
- // expresssions.
- auto operand = ctx->expression8()->accept(this).as<std::string>();
- for (int i = 0; i < (int)ctx->NOT().size(); ++i) {
- auto lhs_id = new_id();
- symbol_table_[lhs_id] = SimpleExpression{Function::LOGICAL_NOT, {operand}};
- operand = lhs_id;
- }
- return operand;
-}
-
-// Comparisons.
-antlrcpp::Any CypherMainVisitor::visitExpression8(
- CypherParser::Expression8Context *ctx) {
- if (!ctx->partialComparisonExpression().size()) {
- // There is no comparison operators. We generate expression7.
- return ctx->expression7()->accept(this);
- }
-
- // There is at least one comparison. We need to generate code for each of
- // them. We don't call visitPartialComparisonExpression but do everything in
- // this function and call expression7-s directly. Since every expression7
- // can be generated twice (because it can appear in two comparisons) code
- // generated by whole subtree of expression7 must not have any sideeffects.
- // We handle chained comparisons as defined by mathematics, neo4j handles
- // them in a very interesting, illogical and incomprehensible way. For
- // example in neo4j:
- // 1 < 2 < 3 -> true,
- // 1 < 2 < 3 < 4 -> false,
- // 5 > 3 < 5 > 3 -> true,
- // 4 <= 5 < 7 > 6 -> false
- // All of those comparisons evaluate to true in memgraph.
- std::vector<std::string> children_ids;
- children_ids.push_back(ctx->expression7()->accept(this).as<std::string>());
- auto partial_comparison_expressions = ctx->partialComparisonExpression();
- for (auto *child : partial_comparison_expressions) {
- children_ids.push_back(child->accept(this).as<std::string>());
- }
-
- // Make all comparisons.
- std::string first_operand = children_ids[0];
- std::vector<std::string> comparison_ids;
- for (int i = 0; i < (int)partial_comparison_expressions.size(); ++i) {
- auto *expr = partial_comparison_expressions[i];
- auto op = [](CypherParser::PartialComparisonExpressionContext *expr) {
- if (expr->getToken(kEqTokenId, 0)) {
- return Function::EQ;
- } else if (expr->getToken(kNeTokenId1, 0) ||
- expr->getToken(kNeTokenId2, 0)) {
- return Function::NE;
- } else if (expr->getToken(kLtTokenId, 0)) {
- return Function::LT;
- } else if (expr->getToken(kGtTokenId, 0)) {
- return Function::GT;
- } else if (expr->getToken(kLeTokenId, 0)) {
- return Function::LE;
- } else if (expr->getToken(kGeTokenId, 0)) {
- return Function::GE;
- }
- assert(false);
- return Function::GE;
- }(expr);
- auto lhs_id = new_id();
- symbol_table_[lhs_id] =
- SimpleExpression{op, {first_operand, children_ids[i + 1]}};
- first_operand = lhs_id;
- comparison_ids.push_back(lhs_id);
- }
-
- first_operand = comparison_ids[0];
- // Calculate logical and of results of comparisons.
- for (int i = 1; i < (int)comparison_ids.size(); ++i) {
- auto lhs_id = new_id();
- symbol_table_[lhs_id] = SimpleExpression{
- Function::LOGICAL_AND, {first_operand, comparison_ids[i]}};
- first_operand = lhs_id;
- }
- return first_operand;
-}
-
-antlrcpp::Any CypherMainVisitor::visitPartialComparisonExpression(
- CypherParser::PartialComparisonExpressionContext *) {
- debug_assert(false, "Should never be called. See documentation in hpp.");
- return 0;
-}
-
-// Addition and subtraction.
-antlrcpp::Any CypherMainVisitor::visitExpression7(
- CypherParser::Expression7Context *ctx) {
- return LeftAssociativeOperatorExpression(
- ctx->expression6(),
- MapTokensToOperators(ctx, {{kPlusTokenId, Function::ADDITION},
- {kMinusTokenId, Function::SUBTRACTION}}));
-}
-
-// Multiplication, division, modding.
-antlrcpp::Any CypherMainVisitor::visitExpression6(
- CypherParser::Expression6Context *ctx) {
- return LeftAssociativeOperatorExpression(
- ctx->expression5(),
- MapTokensToOperators(ctx, {{kMultTokenId, Function::MULTIPLICATION},
- {kDivTokenId, Function::DIVISION},
- {kModTokenId, Function::MODULO}}));
-}
-
-// Power.
-antlrcpp::Any CypherMainVisitor::visitExpression5(
- CypherParser::Expression5Context *ctx) {
- if (ctx->expression4().size() > 1u) {
- // TODO: implement power operator. In neo4j power is right associative and
- // int^int -> float.
- throw SemanticException();
- }
- return visitChildren(ctx);
-}
-
-// Unary minus and plus.
-antlrcpp::Any CypherMainVisitor::visitExpression4(
- CypherParser::Expression4Context *ctx) {
- auto ops =
- MapTokensToOperators(ctx, {{kUnaryPlusTokenId, Function::UNARY_PLUS},
- {kUnaryMinusTokenId, Function::UNARY_MINUS}});
- auto operand = ctx->expression3()->accept(this).as<std::string>();
- for (int i = 0; i < (int)ops.size(); ++i) {
- auto lhs_id = new_id();
- symbol_table_[lhs_id] = SimpleExpression{ops[i], {operand}};
- operand = lhs_id;
- }
- return operand;
-}
-
-antlrcpp::Any CypherMainVisitor::visitExpression3(
- CypherParser::Expression3Context *ctx) {
- // If there is only one child we don't need to generate any code in this since
- // that child is expression2. Other operations are not implemented at the
- // moment.
- // TODO: implement this.
- if (ctx->children.size() > 1u) {
- throw SemanticException();
- }
- return visitChildren(ctx);
-}
-
-antlrcpp::Any CypherMainVisitor::visitExpression2(
- CypherParser::Expression2Context *ctx) {
- if (ctx->nodeLabels().size()) {
- // TODO: Implement this. We don't currently support label checking in
- // expresssion.
- throw SemanticException();
- }
- auto operand = ctx->atom()->accept(this).as<std::string>();
- for (int i = 0; i < (int)ctx->propertyLookup().size(); ++i) {
- auto lhs_id = new_id();
- symbol_table_[lhs_id] =
- SimpleExpression{Function::PROPERTY_GETTER, {operand}};
- operand = lhs_id;
- }
- return operand;
-}
+//// OR.
+// antlrcpp::Any
+// CypherMainVisitor::visitExpression12(CypherParser::Expression12Context *ctx)
+// {
+// return LeftAssociativeOperatorExpression(ctx->expression11(),
+// Function::LOGICAL_OR);
+//}
+//
+//// XOR.
+// antlrcpp::Any
+// CypherMainVisitor::visitExpression11(CypherParser::Expression11Context *ctx)
+// {
+// return LeftAssociativeOperatorExpression(ctx->expression10(),
+// Function::LOGICAL_XOR);
+//}
+//
+//// AND.
+// antlrcpp::Any
+// CypherMainVisitor::visitExpression10(CypherParser::Expression10Context *ctx)
+// {
+// return LeftAssociativeOperatorExpression(ctx->expression9(),
+// Function::LOGICAL_AND);
+//}
+//
+//// NOT.
+// antlrcpp::Any
+// CypherMainVisitor::visitExpression9(CypherParser::Expression9Context *ctx) {
+// // TODO: make template similar to LeftAssociativeOperatorExpression for
+// unary
+// // expresssions.
+// auto operand = ctx->expression8()->accept(this).as<std::string>();
+// for (int i = 0; i < (int)ctx->NOT().size(); ++i) {
+// auto lhs_id = new_id();
+// symbol_table_[lhs_id] = SimpleExpression{Function::LOGICAL_NOT,
+// {operand}};
+// operand = lhs_id;
+// }
+// return operand;
+//}
+//
+//// Comparisons.
+// antlrcpp::Any
+// CypherMainVisitor::visitExpression8(CypherParser::Expression8Context *ctx) {
+// if (!ctx->partialComparisonExpression().size()) {
+// // There is no comparison operators. We generate expression7.
+// return ctx->expression7()->accept(this);
+// }
+//
+// // There is at least one comparison. We need to generate code for each of
+// // them. We don't call visitPartialComparisonExpression but do everything in
+// // this function and call expression7-s directly. Since every expression7
+// // can be generated twice (because it can appear in two comparisons) code
+// // generated by whole subtree of expression7 must not have any sideeffects.
+// // We handle chained comparisons as defined by mathematics, neo4j handles
+// // them in a very interesting, illogical and incomprehensible way. For
+// // example in neo4j:
+// // 1 < 2 < 3 -> true,
+// // 1 < 2 < 3 < 4 -> false,
+// // 5 > 3 < 5 > 3 -> true,
+// // 4 <= 5 < 7 > 6 -> false
+// // All of those comparisons evaluate to true in memgraph.
+// std::vector<std::string> children_ids;
+// children_ids.push_back(ctx->expression7()->accept(this).as<std::string>());
+// auto partial_comparison_expressions = ctx->partialComparisonExpression();
+// for (auto *child : partial_comparison_expressions) {
+// children_ids.push_back(child->accept(this).as<std::string>());
+// }
+//
+// // Make all comparisons.
+// std::string first_operand = children_ids[0];
+// std::vector<std::string> comparison_ids;
+// for (int i = 0; i < (int)partial_comparison_expressions.size(); ++i) {
+// auto *expr = partial_comparison_expressions[i];
+// auto op = [](CypherParser::PartialComparisonExpressionContext *expr) {
+// if (expr->getToken(kEqTokenId, 0)) {
+// return Function::EQ;
+// } else if (expr->getToken(kNeTokenId1, 0) ||
+// expr->getToken(kNeTokenId2, 0)) {
+// return Function::NE;
+// } else if (expr->getToken(kLtTokenId, 0)) {
+// return Function::LT;
+// } else if (expr->getToken(kGtTokenId, 0)) {
+// return Function::GT;
+// } else if (expr->getToken(kLeTokenId, 0)) {
+// return Function::LE;
+// } else if (expr->getToken(kGeTokenId, 0)) {
+// return Function::GE;
+// }
+// assert(false);
+// return Function::GE;
+// }(expr);
+// auto lhs_id = new_id();
+// symbol_table_[lhs_id] =
+// SimpleExpression{op, {first_operand, children_ids[i + 1]}};
+// first_operand = lhs_id;
+// comparison_ids.push_back(lhs_id);
+// }
+//
+// first_operand = comparison_ids[0];
+// // Calculate logical and of results of comparisons.
+// for (int i = 1; i < (int)comparison_ids.size(); ++i) {
+// auto lhs_id = new_id();
+// symbol_table_[lhs_id] = SimpleExpression{
+// Function::LOGICAL_AND, {first_operand, comparison_ids[i]}};
+// first_operand = lhs_id;
+// }
+// return first_operand;
+//}
+//
+// antlrcpp::Any CypherMainVisitor::visitPartialComparisonExpression(
+// CypherParser::PartialComparisonExpressionContext *) {
+// debug_assert(false, "Should never be called. See documentation in hpp.");
+// return 0;
+//}
+//
+//// Addition and subtraction.
+// antlrcpp::Any
+// CypherMainVisitor::visitExpression7(CypherParser::Expression7Context *ctx) {
+// return LeftAssociativeOperatorExpression(
+// ctx->expression6(),
+// MapTokensToOperators(ctx, {{kPlusTokenId, Function::ADDITION},
+// {kMinusTokenId, Function::SUBTRACTION}}));
+//}
+//
+//// Multiplication, division, modding.
+// antlrcpp::Any
+// CypherMainVisitor::visitExpression6(CypherParser::Expression6Context *ctx) {
+// return LeftAssociativeOperatorExpression(
+// ctx->expression5(),
+// MapTokensToOperators(ctx, {{kMultTokenId, Function::MULTIPLICATION},
+// {kDivTokenId, Function::DIVISION},
+// {kModTokenId, Function::MODULO}}));
+//}
+//
+//// Power.
+// antlrcpp::Any
+// CypherMainVisitor::visitExpression5(CypherParser::Expression5Context *ctx) {
+// if (ctx->expression4().size() > 1u) {
+// // TODO: implement power operator. In neo4j power is right associative and
+// // int^int -> float.
+// throw SemanticException();
+// }
+// return visitChildren(ctx);
+//}
+//
+//// Unary minus and plus.
+// antlrcpp::Any
+// CypherMainVisitor::visitExpression4(CypherParser::Expression4Context *ctx) {
+// auto ops =
+// MapTokensToOperators(ctx, {{kUnaryPlusTokenId, Function::UNARY_PLUS},
+// {kUnaryMinusTokenId,
+// Function::UNARY_MINUS}});
+// auto operand = ctx->expression3()->accept(this).as<std::string>();
+// for (int i = 0; i < (int)ops.size(); ++i) {
+// auto lhs_id = new_id();
+// symbol_table_[lhs_id] = SimpleExpression{ops[i], {operand}};
+// operand = lhs_id;
+// }
+// return operand;
+//}
+//
+// antlrcpp::Any
+// CypherMainVisitor::visitExpression3(CypherParser::Expression3Context *ctx) {
+// // If there is only one child we don't need to generate any code in this
+// since
+// // that child is expression2. Other operations are not implemented at the
+// // moment.
+// // TODO: implement this.
+// if (ctx->children.size() > 1u) {
+// throw SemanticException();
+// }
+// return visitChildren(ctx);
+//}
+//
+// antlrcpp::Any
+// CypherMainVisitor::visitExpression2(CypherParser::Expression2Context *ctx) {
+// if (ctx->nodeLabels().size()) {
+// // TODO: Implement this. We don't currently support label checking in
+// // expresssion.
+// throw SemanticException();
+// }
+// auto operand = ctx->atom()->accept(this).as<std::string>();
+// for (int i = 0; i < (int)ctx->propertyLookup().size(); ++i) {
+// auto lhs_id = new_id();
+// symbol_table_[lhs_id] =
+// SimpleExpression{Function::PROPERTY_GETTER, {operand}};
+// operand = lhs_id;
+// }
+// return operand;
+//}
antlrcpp::Any CypherMainVisitor::visitAtom(CypherParser::AtomContext *ctx) {
if (ctx->literal()) {
@@ -479,10 +492,11 @@ antlrcpp::Any CypherMainVisitor::visitAtom(CypherParser::AtomContext *ctx) {
// appear only in tests and real queries will be stripped.
// TODO: Either parse it correctly or raise exception. If exception is
// raised it tests should also use params instead of literals.
- auto text = ctx->literal()->getText();
- auto lhs_id = new_id();
- symbol_table_[lhs_id] = SimpleExpression{Function::LITERAL, {text}};
- return lhs_id;
+ // auto text = ctx->literal()->getText();
+ // auto lhs_id = new_id();
+ // symbol_table_[lhs_id] = SimpleExpression{Function::LITERAL, {text}};
+ // return lhs_id;
+ throw std::exception();
} else if (ctx->parameter()) {
// This is once again potential security risk. We shouldn't output text
// given in user query as parameter name directly to the code. Stripper
@@ -490,25 +504,20 @@ antlrcpp::Any CypherMainVisitor::visitAtom(CypherParser::AtomContext *ctx) {
// allow only parameters with numeric names. At the moment this is not a
// problem since we don't accept user's parameters but only ours.
// TODO: revise this.
- auto text = ctx->literal()->getText();
- auto lhs_id = new_id();
- symbol_table_[lhs_id] = SimpleExpression{Function::PARAMETER, {text}};
- return lhs_id;
+ // auto text = ctx->literal()->getText();
+ // auto lhs_id = new_id();
+ // symbol_table_[lhs_id] = SimpleExpression{Function::PARAMETER, {text}};
+ throw std::exception();
+ // return lhs_id;
} else if (ctx->parenthesizedExpression()) {
return ctx->parenthesizedExpression()->accept(this);
} else if (ctx->variable()) {
- // TODO: revise this. Is it possible in some atom to use not declared
- // variable. Is it correct to always use last ids_map?
- auto &curr_id_map = ids_map_.back();
- auto variable = ctx->variable()->accept(this).as<std::string>();
- if (curr_id_map.find(variable) == curr_id_map.end()) {
- throw SemanticException();
- }
- return curr_id_map[variable];
+ std::string variable = ctx->variable()->accept(this);
+ return std::make_shared<Ident>(ctx_.next_uid(), variable);
}
// TODO: Implement this. We don't support comprehensions, functions,
// filtering... at the moment.
- throw SemanticException();
+ throw std::exception();
}
antlrcpp::Any CypherMainVisitor::visitIntegerLiteral(
@@ -517,7 +526,7 @@ antlrcpp::Any CypherMainVisitor::visitIntegerLiteral(
try {
t = std::stoll(ctx->getText(), 0, 0);
} catch (std::out_of_range) {
- throw SemanticException();
+ throw std::exception();
}
return t;
}
diff --git a/src/query/frontend/ast/cypher_main_visitor.hpp b/src/query/frontend/ast/cypher_main_visitor.hpp
index 70101c05a..b5dd3acbb 100644
--- a/src/query/frontend/ast/cypher_main_visitor.hpp
+++ b/src/query/frontend/ast/cypher_main_visitor.hpp
@@ -1,53 +1,64 @@
#pragma once
-#include "antlr4-runtime.h"
-#include "query/backend/cpp/compiler_structures.hpp"
-#include "query/frontend/opencypher/generated/CypherBaseVisitor.h"
#include <string>
+#include <unordered_set>
+
+#include "antlr4-runtime.h"
+#include "query/context.hpp"
+#include "query/frontend/ast/ast.hpp"
+#include "query/frontend/opencypher/generated/CypherBaseVisitor.h"
namespace query {
namespace frontend {
+using query::Context;
using antlropencypher::CypherParser;
class CypherMainVisitor : public antlropencypher::CypherBaseVisitor {
+public:
+ CypherMainVisitor(Context &ctx) : ctx_(ctx) {}
+
private:
- // Return new output code id.
- // TODO: Should we generate ids with more readable names: node_1,
- // relationship_5, temporary_2...?
- std::string new_id() const {
- static int next_id = 0;
- return "id" + std::to_string(next_id++);
- }
+ // template <typename TExpression>
+ // antlrcpp::Any
+ // LeftAssociativeOperatorExpression(std::vector<TExpression *> children,
+ // std::vector<Function> ops) {
+ // assert(children.size());
+ // std::vector<std::string> children_ids;
+ //
+ // for (auto *child : children) {
+ // children_ids.push_back(child->accept(this).template
+ // as<std::string>());
+ // }
+ //
+ // std::string first_operand = children_ids[0];
+ // for (int i = 0; i < (int)ops.size(); ++i) {
+ // auto lhs_id = new_id();
+ // symbol_table_[lhs_id] =
+ // SimpleExpression{ops[i], {first_operand, children_ids[i + 1]}};
+ // first_operand = lhs_id;
+ // }
+ // return first_operand;
+ // }
+ //
+ // template <typename TExpression>
+ // antlrcpp::Any
+ // LeftAssociativeOperatorExpression(std::vector<TExpression *> children,
+ // Function op) {
+ // return LeftAssociativeOperatorExpression(
+ // children, std::vector<Function>((int)children.size() - 1, op));
+ // }
- template <typename TExpression>
antlrcpp::Any
- LeftAssociativeOperatorExpression(std::vector<TExpression *> children,
- std::vector<Function> ops) {
- assert(children.size());
- std::vector<std::string> children_ids;
+ visitSingleQuery(CypherParser::SingleQueryContext *ctx) override;
- for (auto *child : children) {
- children_ids.push_back(child->accept(this).template as<std::string>());
- }
-
- std::string first_operand = children_ids[0];
- for (int i = 0; i < (int)ops.size(); ++i) {
- auto lhs_id = new_id();
- symbol_table_[lhs_id] =
- SimpleExpression{ops[i], {first_operand, children_ids[i + 1]}};
- first_operand = lhs_id;
- }
- return first_operand;
- }
-
- template <typename TExpression>
antlrcpp::Any
- LeftAssociativeOperatorExpression(std::vector<TExpression *> children,
- Function op) {
- return LeftAssociativeOperatorExpression(
- children, std::vector<Function>((int)children.size() - 1, op));
- }
+ visitCypherMatch(CypherParser::CypherMatchContext *ctx) override;
+
+ antlrcpp::Any
+ visitReturnItems(CypherParser::ReturnItemsContext *ctx) override;
+
+ antlrcpp::Any visitReturnItem(CypherParser::ReturnItemContext *ctx) override;
/**
* Creates Node and stores it in symbol_table_. If variable is defined it is
@@ -143,100 +154,100 @@ private:
*/
antlrcpp::Any visitExpression(CypherParser::ExpressionContext *ctx) override;
- /**
- * OR.
- *
- * @return string - expression id.
- */
- antlrcpp::Any
- visitExpression12(CypherParser::Expression12Context *ctx) override;
+ ///**
+ //* OR.
+ //*
+ //* @return string - expression id.
+ //*/
+ // antlrcpp::Any
+ // visitExpression12(CypherParser::Expression12Context *ctx) override;
- /**
- * XOR.
- *
- * @return string - expression id.
- */
- antlrcpp::Any
- visitExpression11(CypherParser::Expression11Context *ctx) override;
+ ///**
+ //* XOR.
+ //*
+ //* @return string - expression id.
+ //*/
+ // antlrcpp::Any
+ // visitExpression11(CypherParser::Expression11Context *ctx) override;
- /**
- * AND.
- *
- * @return string - expression id.
- */
- antlrcpp::Any
- visitExpression10(CypherParser::Expression10Context *ctx) override;
+ ///**
+ //* AND.
+ //*
+ //* @return string - expression id.
+ //*/
+ // antlrcpp::Any
+ // visitExpression10(CypherParser::Expression10Context *ctx) override;
- /**
- * NOT.
- *
- * @return string - expression id.
- */
- antlrcpp::Any
- visitExpression9(CypherParser::Expression9Context *ctx) override;
+ ///**
+ //* NOT.
+ //*
+ //* @return string - expression id.
+ //*/
+ // antlrcpp::Any
+ // visitExpression9(CypherParser::Expression9Context *ctx) override;
- /**
- * Comparisons.
- *
- * @return string - expression id.
- */
- antlrcpp::Any
- visitExpression8(CypherParser::Expression8Context *ctx) override;
+ ///**
+ //* Comparisons.
+ //*
+ //* @return string - expression id.
+ //*/
+ // antlrcpp::Any
+ // visitExpression8(CypherParser::Expression8Context *ctx) override;
- /**
- * Never call this. Everything related to generating code for comparison
- * operators should be done in visitExpression8.
- */
- antlrcpp::Any visitPartialComparisonExpression(
- CypherParser::PartialComparisonExpressionContext *ctx) override;
+ ///**
+ //* Never call this. Everything related to generating code for comparison
+ //* operators should be done in visitExpression8.
+ //*/
+ // antlrcpp::Any visitPartialComparisonExpression(
+ // CypherParser::PartialComparisonExpressionContext *ctx) override;
- /**
- * Addition and subtraction.
- *
- * @return string - expression id.
- */
- antlrcpp::Any
- visitExpression7(CypherParser::Expression7Context *ctx) override;
+ ///**
+ //* Addition and subtraction.
+ //*
+ //* @return string - expression id.
+ //*/
+ // antlrcpp::Any
+ // visitExpression7(CypherParser::Expression7Context *ctx) override;
- /**
- * Multiplication, division, modding.
- *
- * @return string - expression id.
- */
- antlrcpp::Any
- visitExpression6(CypherParser::Expression6Context *ctx) override;
+ ///**
+ //* Multiplication, division, modding.
+ //*
+ //* @return string - expression id.
+ //*/
+ // antlrcpp::Any
+ // visitExpression6(CypherParser::Expression6Context *ctx) override;
- /**
- * Power.
- *
- * @return string - expression id.
- */
- antlrcpp::Any
- visitExpression5(CypherParser::Expression5Context *ctx) override;
+ ///**
+ //* Power.
+ //*
+ //* @return string - expression id.
+ //*/
+ // antlrcpp::Any
+ // visitExpression5(CypherParser::Expression5Context *ctx) override;
- /**
- * Unary minus and plus.
- *
- * @return string - expression id.
- */
- antlrcpp::Any
- visitExpression4(CypherParser::Expression4Context *ctx) override;
+ ///**
+ //* Unary minus and plus.
+ //*
+ //* @return string - expression id.
+ //*/
+ // antlrcpp::Any
+ // visitExpression4(CypherParser::Expression4Context *ctx) override;
- /**
- * Element of a list, range of a list...
- *
- * @return string - expression id.
- */
- antlrcpp::Any
- visitExpression3(CypherParser::Expression3Context *ctx) override;
+ ///**
+ //* Element of a list, range of a list...
+ //*
+ //* @return string - expression id.
+ //*/
+ // antlrcpp::Any
+ // visitExpression3(CypherParser::Expression3Context *ctx) override;
- /**
- * Property lookup, test for node labels existence...
- *
- * @return string - expression id.
- */
- antlrcpp::Any
- visitExpression2(CypherParser::Expression2Context *ctx) override;
+ ///**
+ //* Property lookup, test for node labels existence...
+ //*
+ //* @return string - expression id.
+ //*/
+ // antlrcpp::Any
+ // visitExpression2(CypherParser::Expression2Context *ctx) override;
/**
* Literals, params, list comprehension...
@@ -270,25 +281,12 @@ private:
antlrcpp::Any
visitIntegerLiteral(CypherParser::IntegerLiteralContext *ctx) override;
-public:
- // TODO: These temporary getters should eventually be replaced with
- // something
- // else once we figure out where and how those strctures will be used.
- // Currently there are needed for testing. cypher_main_visitor test should
- // be
- // refactored once these getters are deleted.
- const auto &ids_map() const { return ids_map_; }
- const auto &symbol_table() const { return symbol_table_; }
-
private:
- // Mapping of ids (nodes, relationships, values, lists ...) from
- // query
- // code to id that is used in generated code;
- std::vector<std::unordered_map<std::string, std::string>> ids_map_{1};
-
- // Mapping of output (generated) code ids to appropriate parser
- // structure.
- std::unordered_map<std::string, antlrcpp::Any> symbol_table_;
+ Context &ctx_;
+ int next_ident_id_;
+ const std::string kUserIdentPrefix = "u_";
+ const std::string kAnonIdentPrefix = "a_";
+ std::shared_ptr<Query> query_;
};
}
}
diff --git a/tests/unit/cypher_main_visitor.cpp b/tests/unit/cypher_main_visitor.cpp
index f1b6682b3..0c8bcb7b5 100644
--- a/tests/unit/cypher_main_visitor.cpp
+++ b/tests/unit/cypher_main_visitor.cpp
@@ -1,19 +1,22 @@
+#include <algorithm>
#include <climits>
#include <string>
-#include <vector>
#include <unordered_map>
-#include <algorithm>
+#include <vector>
+
#include "antlr4-runtime.h"
-#include "gtest/gtest.h"
#include "gmock/gmock.h"
-#include "query/backend/cpp/cypher_main_visitor.cpp"
+#include "query/context.hpp"
+#include "query/frontend/ast/cypher_main_visitor.hpp"
#include "query/frontend/opencypher/parser.hpp"
+#include "gtest/gtest.h"
using namespace ::testing;
namespace {
-using namespace backend::cpp;
+using query::Context;
+using namespace query::frontend;
class ParserTables {
template <typename T>
@@ -27,7 +30,7 @@ class ParserTables {
return filtered;
}
- public:
+public:
ParserTables(const std::string &query) {
frontend::opencypher::Parser parser(query);
auto *tree = parser.tree();
@@ -86,7 +89,8 @@ void CompareRelationships(
relationship_property_keys,
UnorderedElementsAreArray(property_keys.begin(), property_keys.end()));
ASSERT_EQ(relationship.has_range, has_range);
- if (!has_range) return;
+ if (!has_range)
+ return;
ASSERT_EQ(relationship.lower_bound, lower_bound);
ASSERT_EQ(relationship.upper_bound, upper_bound);
}
From 1f75572d5ec62a29ee0218feee903a366839d01c Mon Sep 17 00:00:00 2001
From: Marko Budiselic <marko.budiselic@memgraph.io>
Date: Sun, 12 Mar 2017 00:04:10 +0100
Subject: [PATCH 15/16] it compilesga -A!
---
src/communication/bolt/v1/states/executor.hpp | 12 +-
src/query/backend/cpp/generator.hpp | 38 -
src/query/context.cpp | 3 +-
src/query/context.hpp | 3 +-
src/query/engine.hpp | 5 +-
src/query/entry.hpp | 26 +-
.../frontend/ast/cypher_main_visitor.hpp | 3 +
src/query/frontend/logical/operator.hpp | 2 +-
src/query/frontend/logical/planner.hpp | 4 +-
tests/manual/compiler_prototype.cpp | 5 +-
tests/unit/cypher_main_visitor.cpp | 684 +++++++++---------
11 files changed, 376 insertions(+), 409 deletions(-)
delete mode 100644 src/query/backend/cpp/generator.hpp
diff --git a/src/communication/bolt/v1/states/executor.hpp b/src/communication/bolt/v1/states/executor.hpp
index 09a4f227c..07058fc37 100644
--- a/src/communication/bolt/v1/states/executor.hpp
+++ b/src/communication/bolt/v1/states/executor.hpp
@@ -61,12 +61,12 @@ State state_executor_run(RecordStream<Socket> &output_stream, BoltDecoder &decod
{{"code", "Memgraph.SyntaxException"}, {"message", "Syntax error"}});
output_stream.send();
return ERROR;
- } catch (const backend::cpp::GeneratorException &e) {
- output_stream.write_failure(
- {{"code", "Memgraph.GeneratorException"},
- {"message", "Unsupported query"}});
- output_stream.send();
- return ERROR;
+ // } catch (const backend::cpp::GeneratorException &e) {
+ // output_stream.write_failure(
+ // {{"code", "Memgraph.GeneratorException"},
+ // {"message", "Unsupported query"}});
+ // output_stream.send();
+ // return ERROR;
} catch (const QueryEngineException &e) {
output_stream.write_failure(
{{"code", "Memgraph.QueryEngineException"},
diff --git a/src/query/backend/cpp/generator.hpp b/src/query/backend/cpp/generator.hpp
deleted file mode 100644
index df3f08236..000000000
--- a/src/query/backend/cpp/generator.hpp
+++ /dev/null
@@ -1,38 +0,0 @@
-#pragma once
-
-#include "antlr4-runtime.h"
-#include "query/frontend/ast/cypher_main_visitor.hpp"
-#include <experimental/filesystem>
-
-namespace fs = std::experimental::filesystem;
-
-namespace backend {
-
-namespace cpp {
-
-using namespace antlr4;
-
-class GeneratorException : public BasicException {
-public:
- using BasicException::BasicException;
- GeneratorException() : BasicException("") {}
-};
-
-/**
- * Traverse Antlr tree::ParseTree generated from Cypher grammar and generate
- * C++.
- */
-class Generator {
-public:
- /**
- * Generates cpp code inside file on the path.
- */
- Generator(tree::ParseTree *tree, const std::string &query,
- const uint64_t stripped_hash, const fs::path &path) {
- throw GeneratorException("unsupported query");
- CypherMainVisitor visitor;
- visitor.visit(tree);
- }
-};
-}
-}
diff --git a/src/query/context.cpp b/src/query/context.cpp
index 177a37cb7..10accd9b9 100644
--- a/src/query/context.cpp
+++ b/src/query/context.cpp
@@ -3,9 +3,10 @@
namespace query {
-void HighLevelAstConversion::Apply(Context &ctx,
+std::shared_ptr<Query> HighLevelAstConversion::Apply(Context &ctx,
antlr4::tree::ParseTree *tree) {
query::frontend::CypherMainVisitor visitor(ctx);
visitor.visit(tree);
+ return visitor.query();
}
}
diff --git a/src/query/context.hpp b/src/query/context.hpp
index 4c73f17ad..e065c27fd 100644
--- a/src/query/context.hpp
+++ b/src/query/context.hpp
@@ -10,6 +10,7 @@ class TypedcheckedTree {};
class LogicalPlan {};
class Context;
+class Query;
class LogicalPlanGenerator {
public:
@@ -48,6 +49,6 @@ private:
class HighLevelAstConversion {
public:
- void Apply(Context &ctx, antlr4::tree::ParseTree *tree);
+ std::shared_ptr<Query> Apply(Context &ctx, antlr4::tree::ParseTree *tree);
};
}
diff --git a/src/query/engine.hpp b/src/query/engine.hpp
index d7ae8445c..7626d0fe6 100644
--- a/src/query/engine.hpp
+++ b/src/query/engine.hpp
@@ -7,7 +7,6 @@ namespace fs = std::experimental::filesystem;
#include "data_structures/concurrent/concurrent_map.hpp"
#include "database/graph_db.hpp"
#include "logging/loggable.hpp"
-#include "query/backend/cpp/generator.hpp"
#include "query/exception/query_engine.hpp"
#include "query/frontend/opencypher/parser.hpp"
#include "query/plan_compiler.hpp"
@@ -137,8 +136,8 @@ private:
std::to_string(stripped.hash) + ".cpp");
frontend::opencypher::Parser parser(stripped.query);
- backend::cpp::Generator(parser.tree(), stripped.query, stripped.hash,
- generated_path);
+ // backend::cpp::Generator(parser.tree(), stripped.query, stripped.hash,
+ // generated_path);
return LoadCpp(generated_path, stripped.hash);
}
diff --git a/src/query/entry.hpp b/src/query/entry.hpp
index c55b0e1bf..29b23451f 100644
--- a/src/query/entry.hpp
+++ b/src/query/entry.hpp
@@ -1,5 +1,8 @@
#pragma once
+#include "query/frontend/interpret/interpret.hpp"
+#include "query/frontend/logical/planner.hpp"
+#include "query/context.hpp"
#include "database/graph_db_accessor.hpp"
#include "query/context.hpp"
#include "query/frontend/opencypher/parser.hpp"
@@ -21,35 +24,32 @@ class Engine {
auto low_level_tree = parser.tree();
// AST -> high level tree
+ HighLevelAstConversion low2high_tree;
auto high_level_tree = low2high_tree.Apply(ctx, low_level_tree);
// symbol table fill
SymbolTable symbol_table;
- TypeCheckVisitor typecheck_visitor;
- high_level_tree.Accept(typecheck_visitor);
+ TypeCheckVisitor typecheck_visitor(symbol_table);
+ high_level_tree->Accept(typecheck_visitor);
// high level tree -> logical plan
- auto logical_plan = query::Apply(high_level_tree);
+ auto logical_plan = Apply(*high_level_tree);
// generate frame based on symbol table max_position
Frame frame(symbol_table.max_position());
// interpret
- auto cursor = logical_plan.MakeCursor(frame);
- logical_plan.WriteHeader(stream);
- auto symbols = logical_plan.OutputSymbols(symbol_table);
- while (cursor.pull(frame, context)) {
+ auto cursor = logical_plan->MakeCursor(db_accessor);
+ logical_plan->WriteHeader(stream);
+ auto symbols = logical_plan->OutputSymbols(symbol_table);
+ while (cursor->pull(frame, symbol_table)) {
std::vector<TypedValue> values(symbols.size());
for (auto symbol : symbols) {
- values.emplace_back(frame[symbol]);
+ values.emplace_back(frame[symbol.position_]);
}
stream.Result(values);
}
- stream.Summary({"type" : "r"});
+ stream.Summary({{std::string("type"), TypedValue("r")}});
}
-
- private:
- Context ctx;
- HighLevelAstConversion low2high_tree;
};
}
diff --git a/src/query/frontend/ast/cypher_main_visitor.hpp b/src/query/frontend/ast/cypher_main_visitor.hpp
index b5dd3acbb..ae0569ca8 100644
--- a/src/query/frontend/ast/cypher_main_visitor.hpp
+++ b/src/query/frontend/ast/cypher_main_visitor.hpp
@@ -281,6 +281,9 @@ private:
antlrcpp::Any
visitIntegerLiteral(CypherParser::IntegerLiteralContext *ctx) override;
+public:
+ std::shared_ptr<Query> query() { return query_; }
+
private:
Context &ctx_;
int next_ident_id_;
diff --git a/src/query/frontend/logical/operator.hpp b/src/query/frontend/logical/operator.hpp
index b0e8f99c0..228cfc2bf 100644
--- a/src/query/frontend/logical/operator.hpp
+++ b/src/query/frontend/logical/operator.hpp
@@ -82,7 +82,7 @@ class ScanAll : public LogicalOperator {
for (auto label : node_part->labels_) {
if (!vertex.has_label(label)) return false;
}
- frame[symbol_table[node_part->identifier_].position_] = vertex;
+ frame[symbol_table[*node_part->identifier_].position_] = vertex;
return true;
}
};
diff --git a/src/query/frontend/logical/planner.hpp b/src/query/frontend/logical/planner.hpp
index 6e049dda2..dded0b299 100644
--- a/src/query/frontend/logical/planner.hpp
+++ b/src/query/frontend/logical/planner.hpp
@@ -18,10 +18,10 @@ std::shared_ptr<LogicalOperator> GenMatch(
throw std::runtime_error("Not implemented");
}
auto& pattern = match.patterns_[0];
- if (pattern->node_parts_.size() != 1) {
+ if (pattern->parts_.size() != 1) {
throw std::runtime_error("Not implemented");
}
- auto& node_part = pattern->node_parts_[0];
+ auto node_part = std::dynamic_pointer_cast<NodePart>(pattern->parts_[0]);
return std::make_shared<ScanAll>(node_part);
}
diff --git a/tests/manual/compiler_prototype.cpp b/tests/manual/compiler_prototype.cpp
index 665acc041..0763cacc1 100644
--- a/tests/manual/compiler_prototype.cpp
+++ b/tests/manual/compiler_prototype.cpp
@@ -5,6 +5,7 @@
#include "logging/streams/stdout.cpp"
#include "query/entry.hpp"
#include "query/backend/cpp/typed_value.hpp"
+#include "query/frontend/logical/operator.hpp"
using std::cout;
using std::cin;
@@ -20,8 +21,8 @@ int main(int argc, char* argv[]) {
// init db context
Dbms dbms;
- ConsoleResultStream stream;
- query::Engine<ConsoleResultStream> query_engine;
+ query::ConsoleResultStream stream;
+ query::Engine<query::ConsoleResultStream> query_engine;
// initialize the database
auto dba = dbms.active();
diff --git a/tests/unit/cypher_main_visitor.cpp b/tests/unit/cypher_main_visitor.cpp
index 0c8bcb7b5..955ad7bc4 100644
--- a/tests/unit/cypher_main_visitor.cpp
+++ b/tests/unit/cypher_main_visitor.cpp
@@ -13,348 +13,348 @@
using namespace ::testing;
-namespace {
-
-using query::Context;
-using namespace query::frontend;
-
-class ParserTables {
- template <typename T>
- auto FilterAnies(std::unordered_map<std::string, antlrcpp::Any> map) {
- std::unordered_map<std::string, T> filtered;
- for (auto x : map) {
- if (x.second.is<T>()) {
- filtered[x.first] = x.second.as<T>();
- }
- }
- return filtered;
- }
-
-public:
- ParserTables(const std::string &query) {
- frontend::opencypher::Parser parser(query);
- auto *tree = parser.tree();
- CypherMainVisitor visitor;
- visitor.visit(tree);
- identifiers_map_ = visitor.ids_map().back();
- symbol_table_ = visitor.symbol_table();
- pattern_parts_ = FilterAnies<PatternPart>(symbol_table_);
- nodes_ = FilterAnies<Node>(symbol_table_);
- relationships_ = FilterAnies<Relationship>(symbol_table_);
- }
-
- std::unordered_map<std::string, std::string> identifiers_map_;
- std::unordered_map<std::string, antlrcpp::Any> symbol_table_;
- std::unordered_map<std::string, PatternPart> pattern_parts_;
- std::unordered_map<std::string, Node> nodes_;
- std::unordered_map<std::string, Relationship> relationships_;
-};
-
-// TODO: Once expression evaluation is implemented, we should also test if
-// property values are equal.
-void CompareNodes(std::pair<std::string, Node> node_entry,
- std::vector<std::string> labels,
- std::vector<std::string> property_keys) {
- auto node = node_entry.second;
- ASSERT_EQ(node_entry.first, node.output_id);
- ASSERT_THAT(node.labels,
- UnorderedElementsAreArray(labels.begin(), labels.end()));
- std::vector<std::string> node_property_keys;
- for (auto x : node.properties) {
- node_property_keys.push_back(x.first);
- }
- ASSERT_THAT(
- node_property_keys,
- UnorderedElementsAreArray(property_keys.begin(), property_keys.end()));
-}
-
-// If has_range is false, lower and upper bound values are ignored.
-// TODO: Once expression evaluation is implemented, we should also test if
-// property values are equal.
-void CompareRelationships(
- std::pair<std::string, Relationship> relationship_entry,
- Relationship::Direction direction, std::vector<std::string> types,
- std::vector<std::string> property_keys, bool has_range,
- int64_t lower_bound = 1LL, int64_t upper_bound = LLONG_MAX) {
- auto relationship = relationship_entry.second;
- ASSERT_EQ(relationship_entry.first, relationship.output_id);
- ASSERT_EQ(relationship.direction, direction);
- ASSERT_THAT(relationship.types,
- UnorderedElementsAreArray(types.begin(), types.end()));
- std::vector<std::string> relationship_property_keys;
- for (auto x : relationship.properties) {
- relationship_property_keys.push_back(x.first);
- }
- ASSERT_THAT(
- relationship_property_keys,
- UnorderedElementsAreArray(property_keys.begin(), property_keys.end()));
- ASSERT_EQ(relationship.has_range, has_range);
- if (!has_range)
- return;
- ASSERT_EQ(relationship.lower_bound, lower_bound);
- ASSERT_EQ(relationship.upper_bound, upper_bound);
-}
-
-// SyntaxException on incorrect syntax.
-TEST(CompilerStructuresTest, SyntaxException) {
- ASSERT_THROW(ParserTables("CREATE ()-[*1...2]-()"),
- frontend::opencypher::SyntaxException);
-}
-
-// Empty node.
-TEST(CompilerStructuresTest, NodePatternEmpty) {
- ParserTables parser("CREATE ()");
- ASSERT_EQ(parser.identifiers_map_.size(), 0U);
- ASSERT_EQ(parser.nodes_.size(), 1U);
- CompareNodes(*parser.nodes_.begin(), {}, {});
-}
-
-// Node with variable.
-TEST(CompilerStructuresTest, NodePatternVariable) {
- ParserTables parser("CREATE (var)");
- ASSERT_EQ(parser.identifiers_map_.size(), 1U);
- ASSERT_NE(parser.identifiers_map_.find("var"), parser.identifiers_map_.end());
- ASSERT_EQ(parser.nodes_.size(), 1U);
- auto output_identifier = parser.identifiers_map_["var"];
- ASSERT_NE(parser.nodes_.find(output_identifier), parser.nodes_.end());
- CompareNodes(*parser.nodes_.begin(), {}, {});
-}
-
-// Node with labels.
-TEST(CompilerStructuresTest, NodePatternLabels) {
- ParserTables parser("CREATE (:label1:label2:label3)");
- ASSERT_EQ(parser.identifiers_map_.size(), 0U);
- ASSERT_EQ(parser.nodes_.size(), 1U);
- CompareNodes(*parser.nodes_.begin(), {"label1", "label2", "label3"}, {});
-}
-
-// Node with properties.
-TEST(CompilerStructuresTest, NodePatternProperties) {
- ParserTables parser("CREATE ({age: 5, name: \"John\", surname: \"Smith\"})");
- ASSERT_EQ(parser.identifiers_map_.size(), 0U);
- ASSERT_EQ(parser.nodes_.size(), 1U);
- CompareNodes(*parser.nodes_.begin(), {}, {"age", "name", "surname"});
-}
-
-// Relationship without relationship details.
-TEST(CompilerStructuresTest, RelationshipPatternNoDetails) {
- ParserTables parser("CREATE ()--()");
- ASSERT_EQ(parser.identifiers_map_.size(), 0U);
- ASSERT_EQ(parser.relationships_.size(), 1U);
- CompareRelationships(*parser.relationships_.begin(),
- Relationship::Direction::BOTH, {}, {}, false);
-}
-
-// Relationship with empty relationship details.
-TEST(CompilerStructuresTest, RelationshipPatternEmptyDetails) {
- ParserTables parser("CREATE ()-[]-()");
- ASSERT_EQ(parser.identifiers_map_.size(), 0U);
- ASSERT_EQ(parser.relationships_.size(), 1U);
- CompareRelationships(*parser.relationships_.begin(),
- Relationship::Direction::BOTH, {}, {}, false);
-}
-
-// Relationship with left direction.
-TEST(CompilerStructuresTest, RelationshipPatternLeftDirection) {
- ParserTables parser("CREATE ()<--()");
- ASSERT_EQ(parser.identifiers_map_.size(), 0U);
- ASSERT_EQ(parser.relationships_.size(), 1U);
- CompareRelationships(*parser.relationships_.begin(),
- Relationship::Direction::LEFT, {}, {}, false);
-}
-
-// Relationship with right direction.
-TEST(CompilerStructuresTest, RelationshipPatternRightDirection) {
- ParserTables parser("CREATE ()-[]->()");
- ASSERT_EQ(parser.identifiers_map_.size(), 0U);
- ASSERT_EQ(parser.relationships_.size(), 1U);
- CompareRelationships(*parser.relationships_.begin(),
- Relationship::Direction::RIGHT, {}, {}, false);
-}
-
-// Relationship with both directions.
-TEST(CompilerStructuresTest, RelationshipPatternBothDirection) {
- ParserTables parser("CREATE ()<-[]->()");
- ASSERT_EQ(parser.identifiers_map_.size(), 0U);
- ASSERT_EQ(parser.relationships_.size(), 1U);
- CompareRelationships(*parser.relationships_.begin(),
- Relationship::Direction::BOTH, {}, {}, false);
-}
-
-// Relationship with unbounded variable range.
-TEST(CompilerStructuresTest, RelationshipPatternUnbounded) {
- ParserTables parser("CREATE ()-[*]-()");
- ASSERT_EQ(parser.identifiers_map_.size(), 0U);
- ASSERT_EQ(parser.relationships_.size(), 1U);
- CompareRelationships(*parser.relationships_.begin(),
- Relationship::Direction::BOTH, {}, {}, true, 1,
- LLONG_MAX);
-}
-
-// Relationship with lower bounded variable range.
-TEST(CompilerStructuresTest, RelationshipPatternLowerBounded) {
- ParserTables parser("CREATE ()-[*5..]-()");
- ASSERT_EQ(parser.identifiers_map_.size(), 0U);
- ASSERT_EQ(parser.relationships_.size(), 1U);
- CompareRelationships(*parser.relationships_.begin(),
- Relationship::Direction::BOTH, {}, {}, true, 5,
- LLONG_MAX);
-}
-
-// Relationship with upper bounded variable range.
-TEST(CompilerStructuresTest, RelationshipPatternUpperBounded) {
- ParserTables parser("CREATE ()-[*..10]-()");
- ASSERT_EQ(parser.identifiers_map_.size(), 0U);
- ASSERT_EQ(parser.relationships_.size(), 1U);
- CompareRelationships(*parser.relationships_.begin(),
- Relationship::Direction::BOTH, {}, {}, true, 1, 10);
-}
-
-// Relationship with lower and upper bounded variable range.
-TEST(CompilerStructuresTest, RelationshipPatternLowerUpperBounded) {
- ParserTables parser("CREATE ()-[*5..10]-()");
- ASSERT_EQ(parser.identifiers_map_.size(), 0U);
- ASSERT_EQ(parser.relationships_.size(), 1U);
- CompareRelationships(*parser.relationships_.begin(),
- Relationship::Direction::BOTH, {}, {}, true, 5, 10);
-}
-
-// Relationship with fixed number of edges.
-TEST(CompilerStructuresTest, RelationshipPatternFixedRange) {
- ParserTables parser("CREATE ()-[*10]-()");
- ASSERT_EQ(parser.identifiers_map_.size(), 0U);
- ASSERT_EQ(parser.relationships_.size(), 1U);
- CompareRelationships(*parser.relationships_.begin(),
- Relationship::Direction::BOTH, {}, {}, true, 10, 10);
-}
-
-// Relationship with invalid bound (larger than long long).
-TEST(CompilerStructuresTest, RelationshipPatternInvalidBound) {
- ASSERT_THROW(
- ParserTables parser("CREATE ()-[*100000000000000000000000000]-()"),
- SemanticException);
-}
-
-// Relationship with variable
-TEST(CompilerStructuresTest, RelationshipPatternVariable) {
- ParserTables parser("CREATE ()-[var]-()");
- ASSERT_EQ(parser.identifiers_map_.size(), 1U);
- ASSERT_NE(parser.identifiers_map_.find("var"), parser.identifiers_map_.end());
- ASSERT_EQ(parser.relationships_.size(), 1U);
- auto output_identifier = parser.identifiers_map_["var"];
- ASSERT_NE(parser.relationships_.find(output_identifier),
- parser.relationships_.end());
- CompareRelationships(*parser.relationships_.begin(),
- Relationship::Direction::BOTH, {}, {}, false);
-}
-
-// Relationship with labels.
-TEST(CompilerStructuresTest, RelationshipPatternLabels) {
- ParserTables parser("CREATE ()-[:label1|label2|:label3]-()");
- ASSERT_EQ(parser.identifiers_map_.size(), 0U);
- ASSERT_EQ(parser.relationships_.size(), 1U);
- CompareRelationships(*parser.relationships_.begin(),
- Relationship::Direction::BOTH,
- {"label1", "label2", "label3"}, {}, false);
-}
-
-// Relationship with properties.
-TEST(CompilerStructuresTest, RelationshipPatternProperties) {
- ParserTables parser(
- "CREATE ()-[{age: 5, name: \"John\", surname: \"Smith\"}]-()");
- ASSERT_EQ(parser.identifiers_map_.size(), 0U);
- ASSERT_EQ(parser.relationships_.size(), 1U);
- CompareRelationships(*parser.relationships_.begin(),
- Relationship::Direction::BOTH, {},
- {"age", "name", "surname"}, false);
-}
-
-// PatternPart.
-TEST(CompilerStructuresTest, PatternPart) {
- ParserTables parser("CREATE ()--()");
- ASSERT_EQ(parser.identifiers_map_.size(), 0U);
- ASSERT_EQ(parser.pattern_parts_.size(), 1U);
- ASSERT_EQ(parser.relationships_.size(), 1U);
- ASSERT_EQ(parser.nodes_.size(), 2U);
- ASSERT_EQ(parser.pattern_parts_.begin()->second.nodes.size(), 2U);
- ASSERT_EQ(parser.pattern_parts_.begin()->second.relationships.size(), 1U);
-}
-
-// PatternPart in braces.
-TEST(CompilerStructuresTest, PatternPartBraces) {
- ParserTables parser("CREATE ((()--()))");
- ASSERT_EQ(parser.identifiers_map_.size(), 0U);
- ASSERT_EQ(parser.pattern_parts_.size(), 1U);
- ASSERT_EQ(parser.relationships_.size(), 1U);
- ASSERT_EQ(parser.nodes_.size(), 2U);
- ASSERT_EQ(parser.pattern_parts_.begin()->second.nodes.size(), 2U);
- ASSERT_EQ(parser.pattern_parts_.begin()->second.relationships.size(), 1U);
-}
-
-// PatternPart with variable.
-TEST(CompilerStructuresTest, PatternPartVariable) {
- ParserTables parser("CREATE var=()--()");
- ASSERT_EQ(parser.identifiers_map_.size(), 1U);
- ASSERT_EQ(parser.pattern_parts_.size(), 1U);
- ASSERT_EQ(parser.relationships_.size(), 1U);
- ASSERT_EQ(parser.nodes_.size(), 2U);
- ASSERT_EQ(parser.pattern_parts_.begin()->second.nodes.size(), 2U);
- ASSERT_EQ(parser.pattern_parts_.begin()->second.relationships.size(), 1U);
- ASSERT_NE(parser.identifiers_map_.find("var"), parser.identifiers_map_.end());
- auto output_identifier = parser.identifiers_map_["var"];
- ASSERT_NE(parser.pattern_parts_.find(output_identifier),
- parser.pattern_parts_.end());
-}
-
-// Multiple nodes with same variable and properties.
-TEST(CompilerStructuresTest, MultipleNodesWithVariableAndProperties) {
- ASSERT_THROW(ParserTables parser("CREATE (a {b: 5})-[]-(a {c: 5})"),
- SemanticException);
-}
-
-// Multiple nodes with same variable name.
-TEST(CompilerStructuresTest, MultipleNodesWithVariable) {
- ParserTables parser("CREATE (a {b: 5, c: 5})-[]-(a)");
- ASSERT_EQ(parser.identifiers_map_.size(), 1U);
- ASSERT_EQ(parser.pattern_parts_.size(), 1U);
- ASSERT_EQ(parser.relationships_.size(), 1U);
- ASSERT_EQ(parser.nodes_.size(), 1U);
- auto pattern_part = parser.pattern_parts_.begin()->second;
- ASSERT_EQ(pattern_part.nodes.size(), 2U);
- ASSERT_EQ(pattern_part.relationships.size(), 1U);
- ASSERT_EQ(pattern_part.nodes[0], pattern_part.nodes[1]);
-}
-
-// Multiple relationships with same variable name and properties.
-TEST(CompilerStructuresTest, MultipleRelationshipsWithVariableAndProperties) {
- ASSERT_THROW(ParserTables parser("CREATE ()-[e {a: 5}]-()-[e {c: 5}]-()"),
- SemanticException);
-}
-
-// Multiple relationships with same variable name.
-TEST(CompilerStructuresTest, MultipleRelationshipsWithVariable) {
- ParserTables parser("CREATE ()-[a {a: 5}]-()-[a]-()");
- ASSERT_EQ(parser.identifiers_map_.size(), 1U);
- ASSERT_EQ(parser.pattern_parts_.size(), 1U);
- ASSERT_EQ(parser.relationships_.size(), 1U);
- ASSERT_EQ(parser.nodes_.size(), 3U);
- auto pattern_part = parser.pattern_parts_.begin()->second;
- ASSERT_EQ(pattern_part.nodes.size(), 3U);
- ASSERT_EQ(pattern_part.relationships.size(), 2U);
- ASSERT_NE(pattern_part.nodes[0], pattern_part.nodes[1]);
- ASSERT_NE(pattern_part.nodes[1], pattern_part.nodes[2]);
- ASSERT_NE(pattern_part.nodes[0], pattern_part.nodes[2]);
- ASSERT_EQ(pattern_part.relationships[0], pattern_part.relationships[1]);
-}
-
-// Different structures (nodes, realtionships, patterns) with same variable
-// name.
-TEST(CompilerStructuresTest, DifferentTypesWithVariable) {
- ASSERT_THROW(ParserTables parser("CREATE a=(a)"), SemanticException);
- ASSERT_THROW(ParserTables parser("CREATE (a)-[a]-()"), SemanticException);
- ASSERT_THROW(ParserTables parser("CREATE a=()-[a]-()"), SemanticException);
-}
-}
+// namespace {
+//
+// using query::Context;
+// using namespace query::frontend;
+//
+// class ParserTables {
+// template <typename T>
+// auto FilterAnies(std::unordered_map<std::string, antlrcpp::Any> map) {
+// std::unordered_map<std::string, T> filtered;
+// for (auto x : map) {
+// if (x.second.is<T>()) {
+// filtered[x.first] = x.second.as<T>();
+// }
+// }
+// return filtered;
+// }
+//
+// public:
+// ParserTables(const std::string &query) {
+// frontend::opencypher::Parser parser(query);
+// auto *tree = parser.tree();
+// CypherMainVisitor visitor;
+// visitor.visit(tree);
+// identifiers_map_ = visitor.ids_map().back();
+// symbol_table_ = visitor.symbol_table();
+// pattern_parts_ = FilterAnies<PatternPart>(symbol_table_);
+// nodes_ = FilterAnies<Node>(symbol_table_);
+// relationships_ = FilterAnies<Relationship>(symbol_table_);
+// }
+//
+// std::unordered_map<std::string, std::string> identifiers_map_;
+// std::unordered_map<std::string, antlrcpp::Any> symbol_table_;
+// std::unordered_map<std::string, PatternPart> pattern_parts_;
+// std::unordered_map<std::string, Node> nodes_;
+// std::unordered_map<std::string, Relationship> relationships_;
+// };
+//
+// // TODO: Once expression evaluation is implemented, we should also test if
+// // property values are equal.
+// void CompareNodes(std::pair<std::string, Node> node_entry,
+// std::vector<std::string> labels,
+// std::vector<std::string> property_keys) {
+// auto node = node_entry.second;
+// ASSERT_EQ(node_entry.first, node.output_id);
+// ASSERT_THAT(node.labels,
+// UnorderedElementsAreArray(labels.begin(), labels.end()));
+// std::vector<std::string> node_property_keys;
+// for (auto x : node.properties) {
+// node_property_keys.push_back(x.first);
+// }
+// ASSERT_THAT(
+// node_property_keys,
+// UnorderedElementsAreArray(property_keys.begin(), property_keys.end()));
+// }
+//
+// // If has_range is false, lower and upper bound values are ignored.
+// // TODO: Once expression evaluation is implemented, we should also test if
+// // property values are equal.
+// void CompareRelationships(
+// std::pair<std::string, Relationship> relationship_entry,
+// Relationship::Direction direction, std::vector<std::string> types,
+// std::vector<std::string> property_keys, bool has_range,
+// int64_t lower_bound = 1LL, int64_t upper_bound = LLONG_MAX) {
+// auto relationship = relationship_entry.second;
+// ASSERT_EQ(relationship_entry.first, relationship.output_id);
+// ASSERT_EQ(relationship.direction, direction);
+// ASSERT_THAT(relationship.types,
+// UnorderedElementsAreArray(types.begin(), types.end()));
+// std::vector<std::string> relationship_property_keys;
+// for (auto x : relationship.properties) {
+// relationship_property_keys.push_back(x.first);
+// }
+// ASSERT_THAT(
+// relationship_property_keys,
+// UnorderedElementsAreArray(property_keys.begin(), property_keys.end()));
+// ASSERT_EQ(relationship.has_range, has_range);
+// if (!has_range)
+// return;
+// ASSERT_EQ(relationship.lower_bound, lower_bound);
+// ASSERT_EQ(relationship.upper_bound, upper_bound);
+// }
+//
+// // SyntaxException on incorrect syntax.
+// TEST(CompilerStructuresTest, SyntaxException) {
+// ASSERT_THROW(ParserTables("CREATE ()-[*1...2]-()"),
+// frontend::opencypher::SyntaxException);
+// }
+//
+// // Empty node.
+// TEST(CompilerStructuresTest, NodePatternEmpty) {
+// ParserTables parser("CREATE ()");
+// ASSERT_EQ(parser.identifiers_map_.size(), 0U);
+// ASSERT_EQ(parser.nodes_.size(), 1U);
+// CompareNodes(*parser.nodes_.begin(), {}, {});
+// }
+//
+// // Node with variable.
+// TEST(CompilerStructuresTest, NodePatternVariable) {
+// ParserTables parser("CREATE (var)");
+// ASSERT_EQ(parser.identifiers_map_.size(), 1U);
+// ASSERT_NE(parser.identifiers_map_.find("var"), parser.identifiers_map_.end());
+// ASSERT_EQ(parser.nodes_.size(), 1U);
+// auto output_identifier = parser.identifiers_map_["var"];
+// ASSERT_NE(parser.nodes_.find(output_identifier), parser.nodes_.end());
+// CompareNodes(*parser.nodes_.begin(), {}, {});
+// }
+//
+// // Node with labels.
+// TEST(CompilerStructuresTest, NodePatternLabels) {
+// ParserTables parser("CREATE (:label1:label2:label3)");
+// ASSERT_EQ(parser.identifiers_map_.size(), 0U);
+// ASSERT_EQ(parser.nodes_.size(), 1U);
+// CompareNodes(*parser.nodes_.begin(), {"label1", "label2", "label3"}, {});
+// }
+//
+// // Node with properties.
+// TEST(CompilerStructuresTest, NodePatternProperties) {
+// ParserTables parser("CREATE ({age: 5, name: \"John\", surname: \"Smith\"})");
+// ASSERT_EQ(parser.identifiers_map_.size(), 0U);
+// ASSERT_EQ(parser.nodes_.size(), 1U);
+// CompareNodes(*parser.nodes_.begin(), {}, {"age", "name", "surname"});
+// }
+//
+// // Relationship without relationship details.
+// TEST(CompilerStructuresTest, RelationshipPatternNoDetails) {
+// ParserTables parser("CREATE ()--()");
+// ASSERT_EQ(parser.identifiers_map_.size(), 0U);
+// ASSERT_EQ(parser.relationships_.size(), 1U);
+// CompareRelationships(*parser.relationships_.begin(),
+// Relationship::Direction::BOTH, {}, {}, false);
+// }
+//
+// // Relationship with empty relationship details.
+// TEST(CompilerStructuresTest, RelationshipPatternEmptyDetails) {
+// ParserTables parser("CREATE ()-[]-()");
+// ASSERT_EQ(parser.identifiers_map_.size(), 0U);
+// ASSERT_EQ(parser.relationships_.size(), 1U);
+// CompareRelationships(*parser.relationships_.begin(),
+// Relationship::Direction::BOTH, {}, {}, false);
+// }
+//
+// // Relationship with left direction.
+// TEST(CompilerStructuresTest, RelationshipPatternLeftDirection) {
+// ParserTables parser("CREATE ()<--()");
+// ASSERT_EQ(parser.identifiers_map_.size(), 0U);
+// ASSERT_EQ(parser.relationships_.size(), 1U);
+// CompareRelationships(*parser.relationships_.begin(),
+// Relationship::Direction::LEFT, {}, {}, false);
+// }
+//
+// // Relationship with right direction.
+// TEST(CompilerStructuresTest, RelationshipPatternRightDirection) {
+// ParserTables parser("CREATE ()-[]->()");
+// ASSERT_EQ(parser.identifiers_map_.size(), 0U);
+// ASSERT_EQ(parser.relationships_.size(), 1U);
+// CompareRelationships(*parser.relationships_.begin(),
+// Relationship::Direction::RIGHT, {}, {}, false);
+// }
+//
+// // Relationship with both directions.
+// TEST(CompilerStructuresTest, RelationshipPatternBothDirection) {
+// ParserTables parser("CREATE ()<-[]->()");
+// ASSERT_EQ(parser.identifiers_map_.size(), 0U);
+// ASSERT_EQ(parser.relationships_.size(), 1U);
+// CompareRelationships(*parser.relationships_.begin(),
+// Relationship::Direction::BOTH, {}, {}, false);
+// }
+//
+// // Relationship with unbounded variable range.
+// TEST(CompilerStructuresTest, RelationshipPatternUnbounded) {
+// ParserTables parser("CREATE ()-[*]-()");
+// ASSERT_EQ(parser.identifiers_map_.size(), 0U);
+// ASSERT_EQ(parser.relationships_.size(), 1U);
+// CompareRelationships(*parser.relationships_.begin(),
+// Relationship::Direction::BOTH, {}, {}, true, 1,
+// LLONG_MAX);
+// }
+//
+// // Relationship with lower bounded variable range.
+// TEST(CompilerStructuresTest, RelationshipPatternLowerBounded) {
+// ParserTables parser("CREATE ()-[*5..]-()");
+// ASSERT_EQ(parser.identifiers_map_.size(), 0U);
+// ASSERT_EQ(parser.relationships_.size(), 1U);
+// CompareRelationships(*parser.relationships_.begin(),
+// Relationship::Direction::BOTH, {}, {}, true, 5,
+// LLONG_MAX);
+// }
+//
+// // Relationship with upper bounded variable range.
+// TEST(CompilerStructuresTest, RelationshipPatternUpperBounded) {
+// ParserTables parser("CREATE ()-[*..10]-()");
+// ASSERT_EQ(parser.identifiers_map_.size(), 0U);
+// ASSERT_EQ(parser.relationships_.size(), 1U);
+// CompareRelationships(*parser.relationships_.begin(),
+// Relationship::Direction::BOTH, {}, {}, true, 1, 10);
+// }
+//
+// // Relationship with lower and upper bounded variable range.
+// TEST(CompilerStructuresTest, RelationshipPatternLowerUpperBounded) {
+// ParserTables parser("CREATE ()-[*5..10]-()");
+// ASSERT_EQ(parser.identifiers_map_.size(), 0U);
+// ASSERT_EQ(parser.relationships_.size(), 1U);
+// CompareRelationships(*parser.relationships_.begin(),
+// Relationship::Direction::BOTH, {}, {}, true, 5, 10);
+// }
+//
+// // Relationship with fixed number of edges.
+// TEST(CompilerStructuresTest, RelationshipPatternFixedRange) {
+// ParserTables parser("CREATE ()-[*10]-()");
+// ASSERT_EQ(parser.identifiers_map_.size(), 0U);
+// ASSERT_EQ(parser.relationships_.size(), 1U);
+// CompareRelationships(*parser.relationships_.begin(),
+// Relationship::Direction::BOTH, {}, {}, true, 10, 10);
+// }
+//
+// // Relationship with invalid bound (larger than long long).
+// TEST(CompilerStructuresTest, RelationshipPatternInvalidBound) {
+// ASSERT_THROW(
+// ParserTables parser("CREATE ()-[*100000000000000000000000000]-()"),
+// SemanticException);
+// }
+//
+// // Relationship with variable
+// TEST(CompilerStructuresTest, RelationshipPatternVariable) {
+// ParserTables parser("CREATE ()-[var]-()");
+// ASSERT_EQ(parser.identifiers_map_.size(), 1U);
+// ASSERT_NE(parser.identifiers_map_.find("var"), parser.identifiers_map_.end());
+// ASSERT_EQ(parser.relationships_.size(), 1U);
+// auto output_identifier = parser.identifiers_map_["var"];
+// ASSERT_NE(parser.relationships_.find(output_identifier),
+// parser.relationships_.end());
+// CompareRelationships(*parser.relationships_.begin(),
+// Relationship::Direction::BOTH, {}, {}, false);
+// }
+//
+// // Relationship with labels.
+// TEST(CompilerStructuresTest, RelationshipPatternLabels) {
+// ParserTables parser("CREATE ()-[:label1|label2|:label3]-()");
+// ASSERT_EQ(parser.identifiers_map_.size(), 0U);
+// ASSERT_EQ(parser.relationships_.size(), 1U);
+// CompareRelationships(*parser.relationships_.begin(),
+// Relationship::Direction::BOTH,
+// {"label1", "label2", "label3"}, {}, false);
+// }
+//
+// // Relationship with properties.
+// TEST(CompilerStructuresTest, RelationshipPatternProperties) {
+// ParserTables parser(
+// "CREATE ()-[{age: 5, name: \"John\", surname: \"Smith\"}]-()");
+// ASSERT_EQ(parser.identifiers_map_.size(), 0U);
+// ASSERT_EQ(parser.relationships_.size(), 1U);
+// CompareRelationships(*parser.relationships_.begin(),
+// Relationship::Direction::BOTH, {},
+// {"age", "name", "surname"}, false);
+// }
+//
+// // PatternPart.
+// TEST(CompilerStructuresTest, PatternPart) {
+// ParserTables parser("CREATE ()--()");
+// ASSERT_EQ(parser.identifiers_map_.size(), 0U);
+// ASSERT_EQ(parser.pattern_parts_.size(), 1U);
+// ASSERT_EQ(parser.relationships_.size(), 1U);
+// ASSERT_EQ(parser.nodes_.size(), 2U);
+// ASSERT_EQ(parser.pattern_parts_.begin()->second.nodes.size(), 2U);
+// ASSERT_EQ(parser.pattern_parts_.begin()->second.relationships.size(), 1U);
+// }
+//
+// // PatternPart in braces.
+// TEST(CompilerStructuresTest, PatternPartBraces) {
+// ParserTables parser("CREATE ((()--()))");
+// ASSERT_EQ(parser.identifiers_map_.size(), 0U);
+// ASSERT_EQ(parser.pattern_parts_.size(), 1U);
+// ASSERT_EQ(parser.relationships_.size(), 1U);
+// ASSERT_EQ(parser.nodes_.size(), 2U);
+// ASSERT_EQ(parser.pattern_parts_.begin()->second.nodes.size(), 2U);
+// ASSERT_EQ(parser.pattern_parts_.begin()->second.relationships.size(), 1U);
+// }
+//
+// // PatternPart with variable.
+// TEST(CompilerStructuresTest, PatternPartVariable) {
+// ParserTables parser("CREATE var=()--()");
+// ASSERT_EQ(parser.identifiers_map_.size(), 1U);
+// ASSERT_EQ(parser.pattern_parts_.size(), 1U);
+// ASSERT_EQ(parser.relationships_.size(), 1U);
+// ASSERT_EQ(parser.nodes_.size(), 2U);
+// ASSERT_EQ(parser.pattern_parts_.begin()->second.nodes.size(), 2U);
+// ASSERT_EQ(parser.pattern_parts_.begin()->second.relationships.size(), 1U);
+// ASSERT_NE(parser.identifiers_map_.find("var"), parser.identifiers_map_.end());
+// auto output_identifier = parser.identifiers_map_["var"];
+// ASSERT_NE(parser.pattern_parts_.find(output_identifier),
+// parser.pattern_parts_.end());
+// }
+//
+// // Multiple nodes with same variable and properties.
+// TEST(CompilerStructuresTest, MultipleNodesWithVariableAndProperties) {
+// ASSERT_THROW(ParserTables parser("CREATE (a {b: 5})-[]-(a {c: 5})"),
+// SemanticException);
+// }
+//
+// // Multiple nodes with same variable name.
+// TEST(CompilerStructuresTest, MultipleNodesWithVariable) {
+// ParserTables parser("CREATE (a {b: 5, c: 5})-[]-(a)");
+// ASSERT_EQ(parser.identifiers_map_.size(), 1U);
+// ASSERT_EQ(parser.pattern_parts_.size(), 1U);
+// ASSERT_EQ(parser.relationships_.size(), 1U);
+// ASSERT_EQ(parser.nodes_.size(), 1U);
+// auto pattern_part = parser.pattern_parts_.begin()->second;
+// ASSERT_EQ(pattern_part.nodes.size(), 2U);
+// ASSERT_EQ(pattern_part.relationships.size(), 1U);
+// ASSERT_EQ(pattern_part.nodes[0], pattern_part.nodes[1]);
+// }
+//
+// // Multiple relationships with same variable name and properties.
+// TEST(CompilerStructuresTest, MultipleRelationshipsWithVariableAndProperties) {
+// ASSERT_THROW(ParserTables parser("CREATE ()-[e {a: 5}]-()-[e {c: 5}]-()"),
+// SemanticException);
+// }
+//
+// // Multiple relationships with same variable name.
+// TEST(CompilerStructuresTest, MultipleRelationshipsWithVariable) {
+// ParserTables parser("CREATE ()-[a {a: 5}]-()-[a]-()");
+// ASSERT_EQ(parser.identifiers_map_.size(), 1U);
+// ASSERT_EQ(parser.pattern_parts_.size(), 1U);
+// ASSERT_EQ(parser.relationships_.size(), 1U);
+// ASSERT_EQ(parser.nodes_.size(), 3U);
+// auto pattern_part = parser.pattern_parts_.begin()->second;
+// ASSERT_EQ(pattern_part.nodes.size(), 3U);
+// ASSERT_EQ(pattern_part.relationships.size(), 2U);
+// ASSERT_NE(pattern_part.nodes[0], pattern_part.nodes[1]);
+// ASSERT_NE(pattern_part.nodes[1], pattern_part.nodes[2]);
+// ASSERT_NE(pattern_part.nodes[0], pattern_part.nodes[2]);
+// ASSERT_EQ(pattern_part.relationships[0], pattern_part.relationships[1]);
+// }
+//
+// // Different structures (nodes, realtionships, patterns) with same variable
+// // name.
+// TEST(CompilerStructuresTest, DifferentTypesWithVariable) {
+// ASSERT_THROW(ParserTables parser("CREATE a=(a)"), SemanticException);
+// ASSERT_THROW(ParserTables parser("CREATE (a)-[a]-()"), SemanticException);
+// ASSERT_THROW(ParserTables parser("CREATE a=()-[a]-()"), SemanticException);
+// }
+// }
int main(int argc, char **argv) {
InitGoogleTest(&argc, argv);
From d0abb9f02343dadb70624b8f716ad49a9b187588 Mon Sep 17 00:00:00 2001
From: Marko Budiselic <marko.budiselic@memgraph.io>
Date: Sun, 12 Mar 2017 03:05:31 +0100
Subject: [PATCH 16/16] Interpreter works!
---
.gitignore | 1 +
src/query/backend/cpp/typed_value.hpp | 2 +-
src/query/entry.hpp | 2 +-
src/query/frontend/ast/ast.hpp | 3 +-
.../frontend/ast/cypher_main_visitor.cpp | 27 +-
.../frontend/ast/cypher_main_visitor.hpp | 2 +
src/query/frontend/logical/operator.hpp | 24 +-
src/query/frontend/logical/planner.hpp | 2 +-
.../opencypher/generated/Cypher.tokens | 159 -
.../generated/CypherBaseListener.cpp | 9 -
.../opencypher/generated/CypherBaseListener.h | 269 -
.../generated/CypherBaseVisitor.cpp | 9 -
.../opencypher/generated/CypherBaseVisitor.h | 343 -
.../opencypher/generated/CypherLexer.cpp | 929 --
.../opencypher/generated/CypherLexer.h | 75 -
.../opencypher/generated/CypherLexer.tokens | 159 -
.../opencypher/generated/CypherListener.cpp | 9 -
.../opencypher/generated/CypherListener.h | 262 -
.../opencypher/generated/CypherParser.cpp | 10627 ----------------
.../opencypher/generated/CypherParser.h | 1687 ---
.../opencypher/generated/CypherVisitor.cpp | 9 -
.../opencypher/generated/CypherVisitor.h | 186 -
src/query/frontend/typecheck/typecheck.hpp | 3 +
tests/manual/compiler_prototype.cpp | 29 +-
24 files changed, 60 insertions(+), 14767 deletions(-)
delete mode 100644 src/query/frontend/opencypher/generated/Cypher.tokens
delete mode 100644 src/query/frontend/opencypher/generated/CypherBaseListener.cpp
delete mode 100644 src/query/frontend/opencypher/generated/CypherBaseListener.h
delete mode 100644 src/query/frontend/opencypher/generated/CypherBaseVisitor.cpp
delete mode 100644 src/query/frontend/opencypher/generated/CypherBaseVisitor.h
delete mode 100644 src/query/frontend/opencypher/generated/CypherLexer.cpp
delete mode 100644 src/query/frontend/opencypher/generated/CypherLexer.h
delete mode 100644 src/query/frontend/opencypher/generated/CypherLexer.tokens
delete mode 100644 src/query/frontend/opencypher/generated/CypherListener.cpp
delete mode 100644 src/query/frontend/opencypher/generated/CypherListener.h
delete mode 100644 src/query/frontend/opencypher/generated/CypherParser.cpp
delete mode 100644 src/query/frontend/opencypher/generated/CypherParser.h
delete mode 100644 src/query/frontend/opencypher/generated/CypherVisitor.cpp
delete mode 100644 src/query/frontend/opencypher/generated/CypherVisitor.h
diff --git a/.gitignore b/.gitignore
index 3a852fd9b..ac57d8373 100644
--- a/.gitignore
+++ b/.gitignore
@@ -25,3 +25,4 @@ cmake-build-*
.idea
cmake/DownloadProject/
dist/
+src/query/frontend/opencypher/generated/
diff --git a/src/query/backend/cpp/typed_value.hpp b/src/query/backend/cpp/typed_value.hpp
index aadd7aa41..3b9bae134 100644
--- a/src/query/backend/cpp/typed_value.hpp
+++ b/src/query/backend/cpp/typed_value.hpp
@@ -96,7 +96,7 @@ class TypedValue : public TotalOrdering<TypedValue, TypedValue, TypedValue> {
template <typename T>
T Value() const;
- friend std::ostream& operator<<(std::ostream& stream, const TypedValue& prop);
+ friend std::ostream& operator<<(std::ostream& stream, const TypedValue&prop);
private:
// storage for the value of the property
diff --git a/src/query/entry.hpp b/src/query/entry.hpp
index 29b23451f..59fab4238 100644
--- a/src/query/entry.hpp
+++ b/src/query/entry.hpp
@@ -43,7 +43,7 @@ class Engine {
logical_plan->WriteHeader(stream);
auto symbols = logical_plan->OutputSymbols(symbol_table);
while (cursor->pull(frame, symbol_table)) {
- std::vector<TypedValue> values(symbols.size());
+ std::vector<TypedValue> values;
for (auto symbol : symbols) {
values.emplace_back(frame[symbol.position_]);
}
diff --git a/src/query/frontend/ast/ast.hpp b/src/query/frontend/ast/ast.hpp
index b7617a746..2522186ea 100644
--- a/src/query/frontend/ast/ast.hpp
+++ b/src/query/frontend/ast/ast.hpp
@@ -187,10 +187,9 @@ public:
class Return : public Clause {
public:
Return(int uid) : Clause(uid) {}
- std::vector<std::shared_ptr<NamedExpr>> exprs_;
void Accept(TreeVisitorBase &visitor) override {
visitor.PreVisit(*this);
- for (auto &expr : exprs_) {
+ for (auto &expr : named_exprs_) {
expr->Accept(visitor);
}
visitor.Visit(*this);
diff --git a/src/query/frontend/ast/cypher_main_visitor.cpp b/src/query/frontend/ast/cypher_main_visitor.cpp
index cd94df5cb..036a5c2ca 100644
--- a/src/query/frontend/ast/cypher_main_visitor.cpp
+++ b/src/query/frontend/ast/cypher_main_visitor.cpp
@@ -41,10 +41,9 @@ namespace {
antlrcpp::Any
CypherMainVisitor::visitSingleQuery(CypherParser::SingleQueryContext *ctx) {
- auto children = ctx->children;
- query_ = std::make_shared<Query>(ctx_.next_uid());
- for (auto *child : children) {
- query_->clauses_.push_back(child->accept(this));
+query_ = std::make_shared<Query>(ctx_.next_uid());
+ for (auto *child : ctx->clause()) {
+ query_->clauses_.push_back(child->accept(this).as<std::shared_ptr<Clause>>());
}
return query_;
}
@@ -57,7 +56,11 @@ CypherMainVisitor::visitCypherMatch(CypherParser::CypherMatchContext *ctx) {
}
match->patterns_ =
ctx->pattern()->accept(this).as<std::vector<std::shared_ptr<Pattern>>>();
- return match;
+ return std::shared_ptr<Clause>(std::move(match));
+}
+
+antlrcpp::Any CypherMainVisitor::visitReturnBody(CypherParser::ReturnBodyContext *ctx) {
+return ctx->returnItems()->accept(this);
}
antlrcpp::Any
@@ -66,7 +69,7 @@ CypherMainVisitor::visitReturnItems(CypherParser::ReturnItemsContext *ctx) {
for (auto *item : ctx->returnItem()) {
return_clause->named_exprs_.push_back(item->accept(this));
}
- return return_clause;
+ return std::shared_ptr<Clause>(std::move(return_clause));
}
antlrcpp::Any
@@ -85,7 +88,7 @@ CypherMainVisitor::visitReturnItem(CypherParser::ReturnItemContext *ctx) {
antlrcpp::Any
CypherMainVisitor::visitNodePattern(CypherParser::NodePatternContext *ctx) {
- auto node = new NodePart(ctx_.next_uid());
+ auto node = std::make_shared<NodePart>(ctx_.next_uid());
if (ctx->variable()) {
std::string variable = ctx->variable()->accept(this);
node->identifier_ =
@@ -107,7 +110,7 @@ CypherMainVisitor::visitNodePattern(CypherParser::NodePatternContext *ctx) {
// .as<std::unordered_map<std::string,
// std::string>>();
}
- return (Part *)node;
+ return std::shared_ptr<Part>(std::move(node));
}
antlrcpp::Any
@@ -179,7 +182,7 @@ antlrcpp::Any CypherMainVisitor::visitPatternElement(
if (ctx->patternElement()) {
return ctx->patternElement()->accept(this);
}
- auto pattern = std::shared_ptr<Pattern>();
+ auto pattern = std::make_shared<Pattern>(ctx_.next_uid());
pattern->parts_.push_back(
ctx->nodePattern()->accept(this).as<std::shared_ptr<Part>>());
for (auto *pattern_element_chain : ctx->patternElementChain()) {
@@ -287,7 +290,7 @@ CypherMainVisitor::visitRangeLiteral(CypherParser::RangeLiteralContext *ctx) {
antlrcpp::Any
CypherMainVisitor::visitExpression(CypherParser::ExpressionContext *ctx) {
- return visitChildren(ctx);
+ return visitChildren(ctx);
}
//// OR.
@@ -513,7 +516,9 @@ antlrcpp::Any CypherMainVisitor::visitAtom(CypherParser::AtomContext *ctx) {
return ctx->parenthesizedExpression()->accept(this);
} else if (ctx->variable()) {
std::string variable = ctx->variable()->accept(this);
- return std::make_shared<Ident>(ctx_.next_uid(), variable);
+ return std::shared_ptr<Expr>(std::make_shared<Ident>(ctx_.next_uid(),
+ kUserIdentPrefix +
+ variable));
}
// TODO: Implement this. We don't support comprehensions, functions,
// filtering... at the moment.
diff --git a/src/query/frontend/ast/cypher_main_visitor.hpp b/src/query/frontend/ast/cypher_main_visitor.hpp
index ae0569ca8..04addcd2d 100644
--- a/src/query/frontend/ast/cypher_main_visitor.hpp
+++ b/src/query/frontend/ast/cypher_main_visitor.hpp
@@ -55,6 +55,8 @@ private:
antlrcpp::Any
visitCypherMatch(CypherParser::CypherMatchContext *ctx) override;
+antlrcpp::Any visitReturnBody(CypherParser::ReturnBodyContext *ctx) override;
+
antlrcpp::Any
visitReturnItems(CypherParser::ReturnItemsContext *ctx) override;
diff --git a/src/query/frontend/logical/operator.hpp b/src/query/frontend/logical/operator.hpp
index 228cfc2bf..eeb41cdc9 100644
--- a/src/query/frontend/logical/operator.hpp
+++ b/src/query/frontend/logical/operator.hpp
@@ -1,6 +1,7 @@
#pragma once
#include <memory>
+#include <sstream>
#include <vector>
#include "database/graph_db_accessor.hpp"
@@ -18,7 +19,8 @@ class ConsoleResultStream : public Loggable {
void Result(std::vector<TypedValue>& values) {
for (auto value : values) {
- logger.info(" result");
+ auto va = value.Value<VertexAccessor>();
+ logger.info(" {}", va.labels().size());
}
}
@@ -36,7 +38,7 @@ class Cursor {
class LogicalOperator {
public:
auto children() { return children_; };
- virtual std::unique_ptr<Cursor> MakeCursor(GraphDbAccessor db) = 0;
+ virtual std::unique_ptr<Cursor> MakeCursor(GraphDbAccessor& db) = 0;
virtual void WriteHeader(ConsoleResultStream&) {}
virtual std::vector<Symbol> OutputSymbols(SymbolTable& symbol_table) {
return {};
@@ -54,7 +56,7 @@ class ScanAll : public LogicalOperator {
private:
class ScanAllCursor : public Cursor {
public:
- ScanAllCursor(ScanAll& self, GraphDbAccessor db)
+ ScanAllCursor(ScanAll& self, GraphDbAccessor& db)
: self_(self),
db_(db),
vertices_(db.vertices()),
@@ -72,7 +74,7 @@ class ScanAll : public LogicalOperator {
private:
ScanAll& self_;
- GraphDbAccessor db_;
+ GraphDbAccessor& db_;
decltype(db_.vertices()) vertices_;
decltype(vertices_.begin()) vertices_it_;
@@ -88,7 +90,7 @@ class ScanAll : public LogicalOperator {
};
public:
- std::unique_ptr<Cursor> MakeCursor(GraphDbAccessor db) override {
+ std::unique_ptr<Cursor> MakeCursor(GraphDbAccessor& db) override {
return std::make_unique<ScanAllCursor>(*this, db);
}
@@ -110,23 +112,23 @@ class Produce : public LogicalOperator {
stream.Header({"n"});
}
- std::unique_ptr<Cursor> MakeCursor(GraphDbAccessor db) override {
+ std::unique_ptr<Cursor> MakeCursor(GraphDbAccessor& db) override {
return std::make_unique<ProduceCursor>(*this, db);
}
std::vector<Symbol> OutputSymbols(SymbolTable& symbol_table) override {
- std::vector<Symbol> result(exprs_.size());
+ std::vector<Symbol> result;
for (auto named_expr : exprs_) {
- result.emplace_back(symbol_table[*named_expr->ident_]);
+ result.emplace_back(symbol_table[*named_expr->ident_]);
}
return result;
-}
+ }
private:
class ProduceCursor : public Cursor {
public:
- ProduceCursor(Produce& self, GraphDbAccessor db)
- : self_(self), self_cursor_(self_.MakeCursor(db)) {}
+ ProduceCursor(Produce& self, GraphDbAccessor& db)
+ : self_(self), self_cursor_(self_.input_->MakeCursor(db)) {}
bool pull(Frame& frame, SymbolTable& symbol_table) override {
if (self_cursor_->pull(frame, symbol_table)) {
for (auto expr : self_.exprs_) {
diff --git a/src/query/frontend/logical/planner.hpp b/src/query/frontend/logical/planner.hpp
index dded0b299..ef0f5d6e4 100644
--- a/src/query/frontend/logical/planner.hpp
+++ b/src/query/frontend/logical/planner.hpp
@@ -31,7 +31,7 @@ std::shared_ptr<LogicalOperator> GenReturn(
if (!current_op) {
throw std::runtime_error("Not implemented");
}
- return std::make_shared<Produce>(current_op, ret.exprs_);
+ return std::make_shared<Produce>(current_op, ret.named_exprs_);
}
std::shared_ptr<LogicalOperator> Apply(Query& query)
diff --git a/src/query/frontend/opencypher/generated/Cypher.tokens b/src/query/frontend/opencypher/generated/Cypher.tokens
deleted file mode 100644
index cac3f8383..000000000
--- a/src/query/frontend/opencypher/generated/Cypher.tokens
+++ /dev/null
@@ -1,159 +0,0 @@
-T__0=1
-T__1=2
-T__2=3
-T__3=4
-T__4=5
-T__5=6
-T__6=7
-T__7=8
-T__8=9
-T__9=10
-T__10=11
-T__11=12
-T__12=13
-T__13=14
-T__14=15
-T__15=16
-T__16=17
-T__17=18
-T__18=19
-T__19=20
-T__20=21
-T__21=22
-T__22=23
-T__23=24
-T__24=25
-T__25=26
-T__26=27
-T__27=28
-T__28=29
-T__29=30
-T__30=31
-T__31=32
-T__32=33
-T__33=34
-T__34=35
-T__35=36
-T__36=37
-T__37=38
-T__38=39
-T__39=40
-T__40=41
-T__41=42
-T__42=43
-T__43=44
-T__44=45
-T__45=46
-T__46=47
-StringLiteral=48
-EscapedChar=49
-HexInteger=50
-DecimalInteger=51
-OctalInteger=52
-HexLetter=53
-HexDigit=54
-Digit=55
-NonZeroDigit=56
-NonZeroOctDigit=57
-OctDigit=58
-ZeroDigit=59
-ExponentDecimalReal=60
-RegularDecimalReal=61
-UNION=62
-ALL=63
-OPTIONAL=64
-MATCH=65
-UNWIND=66
-AS=67
-MERGE=68
-ON=69
-CREATE=70
-SET=71
-DETACH=72
-DELETE=73
-REMOVE=74
-WITH=75
-DISTINCT=76
-RETURN=77
-ORDER=78
-BY=79
-L_SKIP=80
-LIMIT=81
-ASCENDING=82
-ASC=83
-DESCENDING=84
-DESC=85
-WHERE=86
-OR=87
-XOR=88
-AND=89
-NOT=90
-IN=91
-STARTS=92
-ENDS=93
-CONTAINS=94
-IS=95
-CYPHERNULL=96
-COUNT=97
-FILTER=98
-EXTRACT=99
-ANY=100
-NONE=101
-SINGLE=102
-TRUE=103
-FALSE=104
-UnescapedSymbolicName=105
-IdentifierStart=106
-IdentifierPart=107
-EscapedSymbolicName=108
-SP=109
-WHITESPACE=110
-Comment=111
-';'=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
-'0'=59
diff --git a/src/query/frontend/opencypher/generated/CypherBaseListener.cpp b/src/query/frontend/opencypher/generated/CypherBaseListener.cpp
deleted file mode 100644
index 80f0fce2f..000000000
--- a/src/query/frontend/opencypher/generated/CypherBaseListener.cpp
+++ /dev/null
@@ -1,9 +0,0 @@
-
-// Generated from /home/mislav/code/memgraph/memgraph/src/query/frontend/opencypher/grammar/Cypher.g4 by ANTLR 4.6
-
-
-#include "CypherBaseListener.h"
-
-
-using namespace antlropencypher;
-
diff --git a/src/query/frontend/opencypher/generated/CypherBaseListener.h b/src/query/frontend/opencypher/generated/CypherBaseListener.h
deleted file mode 100644
index e03e89b78..000000000
--- a/src/query/frontend/opencypher/generated/CypherBaseListener.h
+++ /dev/null
@@ -1,269 +0,0 @@
-
-// Generated from /home/mislav/code/memgraph/memgraph/src/query/frontend/opencypher/grammar/Cypher.g4 by ANTLR 4.6
-
-#pragma once
-
-
-#include "antlr4-runtime.h"
-#include "CypherListener.h"
-
-
-namespace antlropencypher {
-
-/**
- * This class provides an empty implementation of CypherListener,
- * which can be extended to create a listener which only needs to handle a subset
- * of the available methods.
- */
-class CypherBaseListener : public CypherListener {
-public:
-
- virtual void enterCypher(CypherParser::CypherContext * /*ctx*/) override { }
- virtual void exitCypher(CypherParser::CypherContext * /*ctx*/) override { }
-
- virtual void enterStatement(CypherParser::StatementContext * /*ctx*/) override { }
- virtual void exitStatement(CypherParser::StatementContext * /*ctx*/) override { }
-
- virtual void enterQuery(CypherParser::QueryContext * /*ctx*/) override { }
- virtual void exitQuery(CypherParser::QueryContext * /*ctx*/) override { }
-
- virtual void enterRegularQuery(CypherParser::RegularQueryContext * /*ctx*/) override { }
- virtual void exitRegularQuery(CypherParser::RegularQueryContext * /*ctx*/) override { }
-
- virtual void enterSingleQuery(CypherParser::SingleQueryContext * /*ctx*/) override { }
- virtual void exitSingleQuery(CypherParser::SingleQueryContext * /*ctx*/) override { }
-
- virtual void enterCypherUnion(CypherParser::CypherUnionContext * /*ctx*/) override { }
- virtual void exitCypherUnion(CypherParser::CypherUnionContext * /*ctx*/) override { }
-
- virtual void enterClause(CypherParser::ClauseContext * /*ctx*/) override { }
- virtual void exitClause(CypherParser::ClauseContext * /*ctx*/) override { }
-
- virtual void enterCypherMatch(CypherParser::CypherMatchContext * /*ctx*/) override { }
- virtual void exitCypherMatch(CypherParser::CypherMatchContext * /*ctx*/) override { }
-
- virtual void enterUnwind(CypherParser::UnwindContext * /*ctx*/) override { }
- virtual void exitUnwind(CypherParser::UnwindContext * /*ctx*/) override { }
-
- virtual void enterMerge(CypherParser::MergeContext * /*ctx*/) override { }
- virtual void exitMerge(CypherParser::MergeContext * /*ctx*/) override { }
-
- virtual void enterMergeAction(CypherParser::MergeActionContext * /*ctx*/) override { }
- virtual void exitMergeAction(CypherParser::MergeActionContext * /*ctx*/) override { }
-
- virtual void enterCreate(CypherParser::CreateContext * /*ctx*/) override { }
- virtual void exitCreate(CypherParser::CreateContext * /*ctx*/) override { }
-
- virtual void enterSet(CypherParser::SetContext * /*ctx*/) override { }
- virtual void exitSet(CypherParser::SetContext * /*ctx*/) override { }
-
- virtual void enterSetItem(CypherParser::SetItemContext * /*ctx*/) override { }
- virtual void exitSetItem(CypherParser::SetItemContext * /*ctx*/) override { }
-
- virtual void enterCypherDelete(CypherParser::CypherDeleteContext * /*ctx*/) override { }
- virtual void exitCypherDelete(CypherParser::CypherDeleteContext * /*ctx*/) override { }
-
- virtual void enterRemove(CypherParser::RemoveContext * /*ctx*/) override { }
- virtual void exitRemove(CypherParser::RemoveContext * /*ctx*/) override { }
-
- virtual void enterRemoveItem(CypherParser::RemoveItemContext * /*ctx*/) override { }
- virtual void exitRemoveItem(CypherParser::RemoveItemContext * /*ctx*/) override { }
-
- virtual void enterWith(CypherParser::WithContext * /*ctx*/) override { }
- virtual void exitWith(CypherParser::WithContext * /*ctx*/) override { }
-
- virtual void enterCypherReturn(CypherParser::CypherReturnContext * /*ctx*/) override { }
- virtual void exitCypherReturn(CypherParser::CypherReturnContext * /*ctx*/) override { }
-
- virtual void enterReturnBody(CypherParser::ReturnBodyContext * /*ctx*/) override { }
- virtual void exitReturnBody(CypherParser::ReturnBodyContext * /*ctx*/) override { }
-
- virtual void enterReturnItems(CypherParser::ReturnItemsContext * /*ctx*/) override { }
- virtual void exitReturnItems(CypherParser::ReturnItemsContext * /*ctx*/) override { }
-
- virtual void enterReturnItem(CypherParser::ReturnItemContext * /*ctx*/) override { }
- virtual void exitReturnItem(CypherParser::ReturnItemContext * /*ctx*/) override { }
-
- virtual void enterOrder(CypherParser::OrderContext * /*ctx*/) override { }
- virtual void exitOrder(CypherParser::OrderContext * /*ctx*/) override { }
-
- virtual void enterSkip(CypherParser::SkipContext * /*ctx*/) override { }
- virtual void exitSkip(CypherParser::SkipContext * /*ctx*/) override { }
-
- virtual void enterLimit(CypherParser::LimitContext * /*ctx*/) override { }
- virtual void exitLimit(CypherParser::LimitContext * /*ctx*/) override { }
-
- virtual void enterSortItem(CypherParser::SortItemContext * /*ctx*/) override { }
- virtual void exitSortItem(CypherParser::SortItemContext * /*ctx*/) override { }
-
- virtual void enterWhere(CypherParser::WhereContext * /*ctx*/) override { }
- virtual void exitWhere(CypherParser::WhereContext * /*ctx*/) override { }
-
- virtual void enterPattern(CypherParser::PatternContext * /*ctx*/) override { }
- virtual void exitPattern(CypherParser::PatternContext * /*ctx*/) override { }
-
- virtual void enterPatternPart(CypherParser::PatternPartContext * /*ctx*/) override { }
- virtual void exitPatternPart(CypherParser::PatternPartContext * /*ctx*/) override { }
-
- virtual void enterAnonymousPatternPart(CypherParser::AnonymousPatternPartContext * /*ctx*/) override { }
- virtual void exitAnonymousPatternPart(CypherParser::AnonymousPatternPartContext * /*ctx*/) override { }
-
- virtual void enterPatternElement(CypherParser::PatternElementContext * /*ctx*/) override { }
- virtual void exitPatternElement(CypherParser::PatternElementContext * /*ctx*/) override { }
-
- virtual void enterNodePattern(CypherParser::NodePatternContext * /*ctx*/) override { }
- virtual void exitNodePattern(CypherParser::NodePatternContext * /*ctx*/) override { }
-
- virtual void enterPatternElementChain(CypherParser::PatternElementChainContext * /*ctx*/) override { }
- virtual void exitPatternElementChain(CypherParser::PatternElementChainContext * /*ctx*/) override { }
-
- virtual void enterRelationshipPattern(CypherParser::RelationshipPatternContext * /*ctx*/) override { }
- virtual void exitRelationshipPattern(CypherParser::RelationshipPatternContext * /*ctx*/) override { }
-
- virtual void enterRelationshipDetail(CypherParser::RelationshipDetailContext * /*ctx*/) override { }
- virtual void exitRelationshipDetail(CypherParser::RelationshipDetailContext * /*ctx*/) override { }
-
- virtual void enterProperties(CypherParser::PropertiesContext * /*ctx*/) override { }
- virtual void exitProperties(CypherParser::PropertiesContext * /*ctx*/) override { }
-
- virtual void enterRelationshipTypes(CypherParser::RelationshipTypesContext * /*ctx*/) override { }
- virtual void exitRelationshipTypes(CypherParser::RelationshipTypesContext * /*ctx*/) override { }
-
- virtual void enterNodeLabels(CypherParser::NodeLabelsContext * /*ctx*/) override { }
- virtual void exitNodeLabels(CypherParser::NodeLabelsContext * /*ctx*/) override { }
-
- virtual void enterNodeLabel(CypherParser::NodeLabelContext * /*ctx*/) override { }
- virtual void exitNodeLabel(CypherParser::NodeLabelContext * /*ctx*/) override { }
-
- virtual void enterRangeLiteral(CypherParser::RangeLiteralContext * /*ctx*/) override { }
- virtual void exitRangeLiteral(CypherParser::RangeLiteralContext * /*ctx*/) override { }
-
- virtual void enterLabelName(CypherParser::LabelNameContext * /*ctx*/) override { }
- virtual void exitLabelName(CypherParser::LabelNameContext * /*ctx*/) override { }
-
- virtual void enterRelTypeName(CypherParser::RelTypeNameContext * /*ctx*/) override { }
- virtual void exitRelTypeName(CypherParser::RelTypeNameContext * /*ctx*/) override { }
-
- virtual void enterExpression(CypherParser::ExpressionContext * /*ctx*/) override { }
- virtual void exitExpression(CypherParser::ExpressionContext * /*ctx*/) override { }
-
- virtual void enterExpression12(CypherParser::Expression12Context * /*ctx*/) override { }
- virtual void exitExpression12(CypherParser::Expression12Context * /*ctx*/) override { }
-
- virtual void enterExpression11(CypherParser::Expression11Context * /*ctx*/) override { }
- virtual void exitExpression11(CypherParser::Expression11Context * /*ctx*/) override { }
-
- virtual void enterExpression10(CypherParser::Expression10Context * /*ctx*/) override { }
- virtual void exitExpression10(CypherParser::Expression10Context * /*ctx*/) override { }
-
- virtual void enterExpression9(CypherParser::Expression9Context * /*ctx*/) override { }
- virtual void exitExpression9(CypherParser::Expression9Context * /*ctx*/) override { }
-
- virtual void enterExpression8(CypherParser::Expression8Context * /*ctx*/) override { }
- virtual void exitExpression8(CypherParser::Expression8Context * /*ctx*/) override { }
-
- virtual void enterExpression7(CypherParser::Expression7Context * /*ctx*/) override { }
- virtual void exitExpression7(CypherParser::Expression7Context * /*ctx*/) override { }
-
- virtual void enterExpression6(CypherParser::Expression6Context * /*ctx*/) override { }
- virtual void exitExpression6(CypherParser::Expression6Context * /*ctx*/) override { }
-
- virtual void enterExpression5(CypherParser::Expression5Context * /*ctx*/) override { }
- virtual void exitExpression5(CypherParser::Expression5Context * /*ctx*/) override { }
-
- virtual void enterExpression4(CypherParser::Expression4Context * /*ctx*/) override { }
- virtual void exitExpression4(CypherParser::Expression4Context * /*ctx*/) override { }
-
- virtual void enterExpression3(CypherParser::Expression3Context * /*ctx*/) override { }
- virtual void exitExpression3(CypherParser::Expression3Context * /*ctx*/) override { }
-
- virtual void enterExpression2(CypherParser::Expression2Context * /*ctx*/) override { }
- virtual void exitExpression2(CypherParser::Expression2Context * /*ctx*/) override { }
-
- virtual void enterAtom(CypherParser::AtomContext * /*ctx*/) override { }
- virtual void exitAtom(CypherParser::AtomContext * /*ctx*/) override { }
-
- virtual void enterLiteral(CypherParser::LiteralContext * /*ctx*/) override { }
- virtual void exitLiteral(CypherParser::LiteralContext * /*ctx*/) override { }
-
- virtual void enterBooleanLiteral(CypherParser::BooleanLiteralContext * /*ctx*/) override { }
- virtual void exitBooleanLiteral(CypherParser::BooleanLiteralContext * /*ctx*/) override { }
-
- virtual void enterListLiteral(CypherParser::ListLiteralContext * /*ctx*/) override { }
- virtual void exitListLiteral(CypherParser::ListLiteralContext * /*ctx*/) override { }
-
- virtual void enterPartialComparisonExpression(CypherParser::PartialComparisonExpressionContext * /*ctx*/) override { }
- virtual void exitPartialComparisonExpression(CypherParser::PartialComparisonExpressionContext * /*ctx*/) override { }
-
- virtual void enterParenthesizedExpression(CypherParser::ParenthesizedExpressionContext * /*ctx*/) override { }
- virtual void exitParenthesizedExpression(CypherParser::ParenthesizedExpressionContext * /*ctx*/) override { }
-
- virtual void enterRelationshipsPattern(CypherParser::RelationshipsPatternContext * /*ctx*/) override { }
- virtual void exitRelationshipsPattern(CypherParser::RelationshipsPatternContext * /*ctx*/) override { }
-
- virtual void enterFilterExpression(CypherParser::FilterExpressionContext * /*ctx*/) override { }
- virtual void exitFilterExpression(CypherParser::FilterExpressionContext * /*ctx*/) override { }
-
- virtual void enterIdInColl(CypherParser::IdInCollContext * /*ctx*/) override { }
- virtual void exitIdInColl(CypherParser::IdInCollContext * /*ctx*/) override { }
-
- virtual void enterFunctionInvocation(CypherParser::FunctionInvocationContext * /*ctx*/) override { }
- virtual void exitFunctionInvocation(CypherParser::FunctionInvocationContext * /*ctx*/) override { }
-
- virtual void enterFunctionName(CypherParser::FunctionNameContext * /*ctx*/) override { }
- virtual void exitFunctionName(CypherParser::FunctionNameContext * /*ctx*/) override { }
-
- virtual void enterListComprehension(CypherParser::ListComprehensionContext * /*ctx*/) override { }
- virtual void exitListComprehension(CypherParser::ListComprehensionContext * /*ctx*/) override { }
-
- virtual void enterPatternComprehension(CypherParser::PatternComprehensionContext * /*ctx*/) override { }
- virtual void exitPatternComprehension(CypherParser::PatternComprehensionContext * /*ctx*/) override { }
-
- virtual void enterPropertyLookup(CypherParser::PropertyLookupContext * /*ctx*/) override { }
- virtual void exitPropertyLookup(CypherParser::PropertyLookupContext * /*ctx*/) override { }
-
- virtual void enterVariable(CypherParser::VariableContext * /*ctx*/) override { }
- virtual void exitVariable(CypherParser::VariableContext * /*ctx*/) override { }
-
- virtual void enterNumberLiteral(CypherParser::NumberLiteralContext * /*ctx*/) override { }
- virtual void exitNumberLiteral(CypherParser::NumberLiteralContext * /*ctx*/) override { }
-
- virtual void enterMapLiteral(CypherParser::MapLiteralContext * /*ctx*/) override { }
- virtual void exitMapLiteral(CypherParser::MapLiteralContext * /*ctx*/) override { }
-
- virtual void enterParameter(CypherParser::ParameterContext * /*ctx*/) override { }
- virtual void exitParameter(CypherParser::ParameterContext * /*ctx*/) override { }
-
- virtual void enterPropertyExpression(CypherParser::PropertyExpressionContext * /*ctx*/) override { }
- virtual void exitPropertyExpression(CypherParser::PropertyExpressionContext * /*ctx*/) override { }
-
- virtual void enterPropertyKeyName(CypherParser::PropertyKeyNameContext * /*ctx*/) override { }
- virtual void exitPropertyKeyName(CypherParser::PropertyKeyNameContext * /*ctx*/) override { }
-
- virtual void enterIntegerLiteral(CypherParser::IntegerLiteralContext * /*ctx*/) override { }
- virtual void exitIntegerLiteral(CypherParser::IntegerLiteralContext * /*ctx*/) override { }
-
- virtual void enterDoubleLiteral(CypherParser::DoubleLiteralContext * /*ctx*/) override { }
- virtual void exitDoubleLiteral(CypherParser::DoubleLiteralContext * /*ctx*/) override { }
-
- virtual void enterSymbolicName(CypherParser::SymbolicNameContext * /*ctx*/) override { }
- virtual void exitSymbolicName(CypherParser::SymbolicNameContext * /*ctx*/) override { }
-
- virtual void enterLeftArrowHead(CypherParser::LeftArrowHeadContext * /*ctx*/) override { }
- virtual void exitLeftArrowHead(CypherParser::LeftArrowHeadContext * /*ctx*/) override { }
-
- virtual void enterRightArrowHead(CypherParser::RightArrowHeadContext * /*ctx*/) override { }
- virtual void exitRightArrowHead(CypherParser::RightArrowHeadContext * /*ctx*/) override { }
-
- virtual void enterDash(CypherParser::DashContext * /*ctx*/) override { }
- virtual void exitDash(CypherParser::DashContext * /*ctx*/) override { }
-
-
- virtual void enterEveryRule(antlr4::ParserRuleContext * /*ctx*/) override { }
- virtual void exitEveryRule(antlr4::ParserRuleContext * /*ctx*/) override { }
- virtual void visitTerminal(antlr4::tree::TerminalNode * /*node*/) override { }
- virtual void visitErrorNode(antlr4::tree::ErrorNode * /*node*/) override { }
-
-};
-
-} // namespace antlropencypher
diff --git a/src/query/frontend/opencypher/generated/CypherBaseVisitor.cpp b/src/query/frontend/opencypher/generated/CypherBaseVisitor.cpp
deleted file mode 100644
index b2bd2f87d..000000000
--- a/src/query/frontend/opencypher/generated/CypherBaseVisitor.cpp
+++ /dev/null
@@ -1,9 +0,0 @@
-
-// Generated from /home/mislav/code/memgraph/memgraph/src/query/frontend/opencypher/grammar/Cypher.g4 by ANTLR 4.6
-
-
-#include "CypherBaseVisitor.h"
-
-
-using namespace antlropencypher;
-
diff --git a/src/query/frontend/opencypher/generated/CypherBaseVisitor.h b/src/query/frontend/opencypher/generated/CypherBaseVisitor.h
deleted file mode 100644
index 511bdecd5..000000000
--- a/src/query/frontend/opencypher/generated/CypherBaseVisitor.h
+++ /dev/null
@@ -1,343 +0,0 @@
-
-// Generated from /home/mislav/code/memgraph/memgraph/src/query/frontend/opencypher/grammar/Cypher.g4 by ANTLR 4.6
-
-#pragma once
-
-
-#include "antlr4-runtime.h"
-#include "CypherVisitor.h"
-
-
-namespace antlropencypher {
-
-/**
- * This class provides an empty implementation of CypherVisitor, which can be
- * extended to create a visitor which only needs to handle a subset of the available methods.
- */
-class CypherBaseVisitor : public CypherVisitor {
-public:
-
- virtual antlrcpp::Any visitCypher(CypherParser::CypherContext *ctx) override {
- return visitChildren(ctx);
- }
-
- virtual antlrcpp::Any visitStatement(CypherParser::StatementContext *ctx) override {
- return visitChildren(ctx);
- }
-
- virtual antlrcpp::Any visitQuery(CypherParser::QueryContext *ctx) override {
- return visitChildren(ctx);
- }
-
- virtual antlrcpp::Any visitRegularQuery(CypherParser::RegularQueryContext *ctx) override {
- return visitChildren(ctx);
- }
-
- virtual antlrcpp::Any visitSingleQuery(CypherParser::SingleQueryContext *ctx) override {
- return visitChildren(ctx);
- }
-
- virtual antlrcpp::Any visitCypherUnion(CypherParser::CypherUnionContext *ctx) override {
- return visitChildren(ctx);
- }
-
- virtual antlrcpp::Any visitClause(CypherParser::ClauseContext *ctx) override {
- return visitChildren(ctx);
- }
-
- virtual antlrcpp::Any visitCypherMatch(CypherParser::CypherMatchContext *ctx) override {
- return visitChildren(ctx);
- }
-
- virtual antlrcpp::Any visitUnwind(CypherParser::UnwindContext *ctx) override {
- return visitChildren(ctx);
- }
-
- virtual antlrcpp::Any visitMerge(CypherParser::MergeContext *ctx) override {
- return visitChildren(ctx);
- }
-
- virtual antlrcpp::Any visitMergeAction(CypherParser::MergeActionContext *ctx) override {
- return visitChildren(ctx);
- }
-
- virtual antlrcpp::Any visitCreate(CypherParser::CreateContext *ctx) override {
- return visitChildren(ctx);
- }
-
- virtual antlrcpp::Any visitSet(CypherParser::SetContext *ctx) override {
- return visitChildren(ctx);
- }
-
- virtual antlrcpp::Any visitSetItem(CypherParser::SetItemContext *ctx) override {
- return visitChildren(ctx);
- }
-
- virtual antlrcpp::Any visitCypherDelete(CypherParser::CypherDeleteContext *ctx) override {
- return visitChildren(ctx);
- }
-
- virtual antlrcpp::Any visitRemove(CypherParser::RemoveContext *ctx) override {
- return visitChildren(ctx);
- }
-
- virtual antlrcpp::Any visitRemoveItem(CypherParser::RemoveItemContext *ctx) override {
- return visitChildren(ctx);
- }
-
- virtual antlrcpp::Any visitWith(CypherParser::WithContext *ctx) override {
- return visitChildren(ctx);
- }
-
- virtual antlrcpp::Any visitCypherReturn(CypherParser::CypherReturnContext *ctx) override {
- return visitChildren(ctx);
- }
-
- virtual antlrcpp::Any visitReturnBody(CypherParser::ReturnBodyContext *ctx) override {
- return visitChildren(ctx);
- }
-
- virtual antlrcpp::Any visitReturnItems(CypherParser::ReturnItemsContext *ctx) override {
- return visitChildren(ctx);
- }
-
- virtual antlrcpp::Any visitReturnItem(CypherParser::ReturnItemContext *ctx) override {
- return visitChildren(ctx);
- }
-
- virtual antlrcpp::Any visitOrder(CypherParser::OrderContext *ctx) override {
- return visitChildren(ctx);
- }
-
- virtual antlrcpp::Any visitSkip(CypherParser::SkipContext *ctx) override {
- return visitChildren(ctx);
- }
-
- virtual antlrcpp::Any visitLimit(CypherParser::LimitContext *ctx) override {
- return visitChildren(ctx);
- }
-
- virtual antlrcpp::Any visitSortItem(CypherParser::SortItemContext *ctx) override {
- return visitChildren(ctx);
- }
-
- virtual antlrcpp::Any visitWhere(CypherParser::WhereContext *ctx) override {
- return visitChildren(ctx);
- }
-
- virtual antlrcpp::Any visitPattern(CypherParser::PatternContext *ctx) override {
- return visitChildren(ctx);
- }
-
- virtual antlrcpp::Any visitPatternPart(CypherParser::PatternPartContext *ctx) override {
- return visitChildren(ctx);
- }
-
- virtual antlrcpp::Any visitAnonymousPatternPart(CypherParser::AnonymousPatternPartContext *ctx) override {
- return visitChildren(ctx);
- }
-
- virtual antlrcpp::Any visitPatternElement(CypherParser::PatternElementContext *ctx) override {
- return visitChildren(ctx);
- }
-
- virtual antlrcpp::Any visitNodePattern(CypherParser::NodePatternContext *ctx) override {
- return visitChildren(ctx);
- }
-
- virtual antlrcpp::Any visitPatternElementChain(CypherParser::PatternElementChainContext *ctx) override {
- return visitChildren(ctx);
- }
-
- virtual antlrcpp::Any visitRelationshipPattern(CypherParser::RelationshipPatternContext *ctx) override {
- return visitChildren(ctx);
- }
-
- virtual antlrcpp::Any visitRelationshipDetail(CypherParser::RelationshipDetailContext *ctx) override {
- return visitChildren(ctx);
- }
-
- virtual antlrcpp::Any visitProperties(CypherParser::PropertiesContext *ctx) override {
- return visitChildren(ctx);
- }
-
- virtual antlrcpp::Any visitRelationshipTypes(CypherParser::RelationshipTypesContext *ctx) override {
- return visitChildren(ctx);
- }
-
- virtual antlrcpp::Any visitNodeLabels(CypherParser::NodeLabelsContext *ctx) override {
- return visitChildren(ctx);
- }
-
- virtual antlrcpp::Any visitNodeLabel(CypherParser::NodeLabelContext *ctx) override {
- return visitChildren(ctx);
- }
-
- virtual antlrcpp::Any visitRangeLiteral(CypherParser::RangeLiteralContext *ctx) override {
- return visitChildren(ctx);
- }
-
- virtual antlrcpp::Any visitLabelName(CypherParser::LabelNameContext *ctx) override {
- return visitChildren(ctx);
- }
-
- virtual antlrcpp::Any visitRelTypeName(CypherParser::RelTypeNameContext *ctx) override {
- return visitChildren(ctx);
- }
-
- virtual antlrcpp::Any visitExpression(CypherParser::ExpressionContext *ctx) override {
- return visitChildren(ctx);
- }
-
- virtual antlrcpp::Any visitExpression12(CypherParser::Expression12Context *ctx) override {
- return visitChildren(ctx);
- }
-
- virtual antlrcpp::Any visitExpression11(CypherParser::Expression11Context *ctx) override {
- return visitChildren(ctx);
- }
-
- virtual antlrcpp::Any visitExpression10(CypherParser::Expression10Context *ctx) override {
- return visitChildren(ctx);
- }
-
- virtual antlrcpp::Any visitExpression9(CypherParser::Expression9Context *ctx) override {
- return visitChildren(ctx);
- }
-
- virtual antlrcpp::Any visitExpression8(CypherParser::Expression8Context *ctx) override {
- return visitChildren(ctx);
- }
-
- virtual antlrcpp::Any visitExpression7(CypherParser::Expression7Context *ctx) override {
- return visitChildren(ctx);
- }
-
- virtual antlrcpp::Any visitExpression6(CypherParser::Expression6Context *ctx) override {
- return visitChildren(ctx);
- }
-
- virtual antlrcpp::Any visitExpression5(CypherParser::Expression5Context *ctx) override {
- return visitChildren(ctx);
- }
-
- virtual antlrcpp::Any visitExpression4(CypherParser::Expression4Context *ctx) override {
- return visitChildren(ctx);
- }
-
- virtual antlrcpp::Any visitExpression3(CypherParser::Expression3Context *ctx) override {
- return visitChildren(ctx);
- }
-
- virtual antlrcpp::Any visitExpression2(CypherParser::Expression2Context *ctx) override {
- return visitChildren(ctx);
- }
-
- virtual antlrcpp::Any visitAtom(CypherParser::AtomContext *ctx) override {
- return visitChildren(ctx);
- }
-
- virtual antlrcpp::Any visitLiteral(CypherParser::LiteralContext *ctx) override {
- return visitChildren(ctx);
- }
-
- virtual antlrcpp::Any visitBooleanLiteral(CypherParser::BooleanLiteralContext *ctx) override {
- return visitChildren(ctx);
- }
-
- virtual antlrcpp::Any visitListLiteral(CypherParser::ListLiteralContext *ctx) override {
- return visitChildren(ctx);
- }
-
- virtual antlrcpp::Any visitPartialComparisonExpression(CypherParser::PartialComparisonExpressionContext *ctx) override {
- return visitChildren(ctx);
- }
-
- virtual antlrcpp::Any visitParenthesizedExpression(CypherParser::ParenthesizedExpressionContext *ctx) override {
- return visitChildren(ctx);
- }
-
- virtual antlrcpp::Any visitRelationshipsPattern(CypherParser::RelationshipsPatternContext *ctx) override {
- return visitChildren(ctx);
- }
-
- virtual antlrcpp::Any visitFilterExpression(CypherParser::FilterExpressionContext *ctx) override {
- return visitChildren(ctx);
- }
-
- virtual antlrcpp::Any visitIdInColl(CypherParser::IdInCollContext *ctx) override {
- return visitChildren(ctx);
- }
-
- virtual antlrcpp::Any visitFunctionInvocation(CypherParser::FunctionInvocationContext *ctx) override {
- return visitChildren(ctx);
- }
-
- virtual antlrcpp::Any visitFunctionName(CypherParser::FunctionNameContext *ctx) override {
- return visitChildren(ctx);
- }
-
- virtual antlrcpp::Any visitListComprehension(CypherParser::ListComprehensionContext *ctx) override {
- return visitChildren(ctx);
- }
-
- virtual antlrcpp::Any visitPatternComprehension(CypherParser::PatternComprehensionContext *ctx) override {
- return visitChildren(ctx);
- }
-
- virtual antlrcpp::Any visitPropertyLookup(CypherParser::PropertyLookupContext *ctx) override {
- return visitChildren(ctx);
- }
-
- virtual antlrcpp::Any visitVariable(CypherParser::VariableContext *ctx) override {
- return visitChildren(ctx);
- }
-
- virtual antlrcpp::Any visitNumberLiteral(CypherParser::NumberLiteralContext *ctx) override {
- return visitChildren(ctx);
- }
-
- virtual antlrcpp::Any visitMapLiteral(CypherParser::MapLiteralContext *ctx) override {
- return visitChildren(ctx);
- }
-
- virtual antlrcpp::Any visitParameter(CypherParser::ParameterContext *ctx) override {
- return visitChildren(ctx);
- }
-
- virtual antlrcpp::Any visitPropertyExpression(CypherParser::PropertyExpressionContext *ctx) override {
- return visitChildren(ctx);
- }
-
- virtual antlrcpp::Any visitPropertyKeyName(CypherParser::PropertyKeyNameContext *ctx) override {
- return visitChildren(ctx);
- }
-
- virtual antlrcpp::Any visitIntegerLiteral(CypherParser::IntegerLiteralContext *ctx) override {
- return visitChildren(ctx);
- }
-
- virtual antlrcpp::Any visitDoubleLiteral(CypherParser::DoubleLiteralContext *ctx) override {
- return visitChildren(ctx);
- }
-
- virtual antlrcpp::Any visitSymbolicName(CypherParser::SymbolicNameContext *ctx) override {
- return visitChildren(ctx);
- }
-
- virtual antlrcpp::Any visitLeftArrowHead(CypherParser::LeftArrowHeadContext *ctx) override {
- return visitChildren(ctx);
- }
-
- virtual antlrcpp::Any visitRightArrowHead(CypherParser::RightArrowHeadContext *ctx) override {
- return visitChildren(ctx);
- }
-
- virtual antlrcpp::Any visitDash(CypherParser::DashContext *ctx) override {
- return visitChildren(ctx);
- }
-
-
-};
-
-} // namespace antlropencypher
diff --git a/src/query/frontend/opencypher/generated/CypherLexer.cpp b/src/query/frontend/opencypher/generated/CypherLexer.cpp
deleted file mode 100644
index aa6be5fb7..000000000
--- a/src/query/frontend/opencypher/generated/CypherLexer.cpp
+++ /dev/null
@@ -1,929 +0,0 @@
-
-// Generated from /home/mislav/code/memgraph/memgraph/src/query/frontend/opencypher/grammar/Cypher.g4 by ANTLR 4.6
-
-
-#include "CypherLexer.h"
-
-
-using namespace antlr4;
-
-using namespace antlropencypher;
-
-CypherLexer::CypherLexer(CharStream *input) : Lexer(input) {
- _interpreter = new atn::LexerATNSimulator(this, _atn, _decisionToDFA, _sharedContextCache);
-}
-
-CypherLexer::~CypherLexer() {
- delete _interpreter;
-}
-
-std::string CypherLexer::getGrammarFileName() const {
- return "Cypher.g4";
-}
-
-const std::vector<std::string>& CypherLexer::getRuleNames() const {
- return _ruleNames;
-}
-
-const std::vector<std::string>& CypherLexer::getModeNames() const {
- return _modeNames;
-}
-
-const std::vector<std::string>& CypherLexer::getTokenNames() const {
- return _tokenNames;
-}
-
-dfa::Vocabulary& CypherLexer::getVocabulary() const {
- return _vocabulary;
-}
-
-const std::vector<uint16_t> CypherLexer::getSerializedATN() const {
- return _serializedATN;
-}
-
-const atn::ATN& CypherLexer::getATN() const {
- return _atn;
-}
-
-
-
-
-// Static vars and initialization.
-std::vector<dfa::DFA> CypherLexer::_decisionToDFA;
-atn::PredictionContextCache CypherLexer::_sharedContextCache;
-
-// We own the ATN which in turn owns the ATN states.
-atn::ATN CypherLexer::_atn;
-std::vector<uint16_t> CypherLexer::_serializedATN;
-
-std::vector<std::string> CypherLexer::_ruleNames = {
- "T__0", "T__1", "T__2", "T__3", "T__4", "T__5", "T__6", "T__7", "T__8",
- "T__9", "T__10", "T__11", "T__12", "T__13", "T__14", "T__15", "T__16",
- "T__17", "T__18", "T__19", "T__20", "T__21", "T__22", "T__23", "T__24",
- "T__25", "T__26", "T__27", "T__28", "T__29", "T__30", "T__31", "T__32",
- "T__33", "T__34", "T__35", "T__36", "T__37", "T__38", "T__39", "T__40",
- "T__41", "T__42", "T__43", "T__44", "T__45", "T__46", "StringLiteral",
- "EscapedChar", "HexInteger", "DecimalInteger", "OctalInteger", "HexLetter",
- "HexDigit", "Digit", "NonZeroDigit", "NonZeroOctDigit", "OctDigit", "ZeroDigit",
- "ExponentDecimalReal", "RegularDecimalReal", "UNION", "ALL", "OPTIONAL",
- "MATCH", "UNWIND", "AS", "MERGE", "ON", "CREATE", "SET", "DETACH", "DELETE",
- "REMOVE", "WITH", "DISTINCT", "RETURN", "ORDER", "BY", "L_SKIP", "LIMIT",
- "ASCENDING", "ASC", "DESCENDING", "DESC", "WHERE", "OR", "XOR", "AND",
- "NOT", "IN", "STARTS", "ENDS", "CONTAINS", "IS", "CYPHERNULL", "COUNT",
- "FILTER", "EXTRACT", "ANY", "NONE", "SINGLE", "TRUE", "FALSE", "UnescapedSymbolicName",
- "IdentifierStart", "IdentifierPart", "EscapedSymbolicName", "SP", "WHITESPACE",
- "Comment", "FF", "EscapedSymbolicName_0", "RS", "ID_Continue", "Comment_1",
- "StringLiteral_1", "Comment_3", "Comment_2", "GS", "FS", "CR", "Sc", "SPACE",
- "TAB", "StringLiteral_0", "LF", "VT", "US", "ID_Start"
-};
-
-std::vector<std::string> CypherLexer::_modeNames = {
- "DEFAULT_MODE"
-};
-
-std::vector<std::string> CypherLexer::_literalNames = {
- "", "';'", "','", "'='", "'+='", "'*'", "'('", "')'", "'['", "']'", "':'",
- "'|'", "'..'", "'+'", "'-'", "'/'", "'%'", "'^'", "'=~'", "'<>'", "'!='",
- "'<'", "'>'", "'<='", "'>='", "'.'", "'{'", "'}'", "'$'", "'⟨'", "'〈'",
- "'﹤'", "'＜'", "'⟩'", "'〉'", "'﹥'", "'＞'", "''", "'‐'", "'‑'", "'‒'",
- "'–'", "'—'", "'―'", "'−'", "'﹘'", "'﹣'", "'－'", "", "", "", "", "", "",
- "", "", "", "", "", "'0'"
-};
-
-std::vector<std::string> CypherLexer::_symbolicNames = {
- "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
- "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
- "", "", "", "", "", "", "", "", "", "", "", "", "StringLiteral", "EscapedChar",
- "HexInteger", "DecimalInteger", "OctalInteger", "HexLetter", "HexDigit",
- "Digit", "NonZeroDigit", "NonZeroOctDigit", "OctDigit", "ZeroDigit", "ExponentDecimalReal",
- "RegularDecimalReal", "UNION", "ALL", "OPTIONAL", "MATCH", "UNWIND", "AS",
- "MERGE", "ON", "CREATE", "SET", "DETACH", "DELETE", "REMOVE", "WITH",
- "DISTINCT", "RETURN", "ORDER", "BY", "L_SKIP", "LIMIT", "ASCENDING", "ASC",
- "DESCENDING", "DESC", "WHERE", "OR", "XOR", "AND", "NOT", "IN", "STARTS",
- "ENDS", "CONTAINS", "IS", "CYPHERNULL", "COUNT", "FILTER", "EXTRACT",
- "ANY", "NONE", "SINGLE", "TRUE", "FALSE", "UnescapedSymbolicName", "IdentifierStart",
- "IdentifierPart", "EscapedSymbolicName", "SP", "WHITESPACE", "Comment"
-};
-
-dfa::Vocabulary CypherLexer::_vocabulary(_literalNames, _symbolicNames);
-
-std::vector<std::string> CypherLexer::_tokenNames;
-
-CypherLexer::Initializer::Initializer() {
- // This code could be in a static initializer lambda, but VS doesn't allow access to private class members from there.
- for (size_t i = 0; i < _symbolicNames.size(); ++i) {
- std::string name = _vocabulary.getLiteralName(i);
- if (name.empty()) {
- name = _vocabulary.getSymbolicName(i);
- }
-
- if (name.empty()) {
- _tokenNames.push_back("<INVALID>");
- } else {
- _tokenNames.push_back(name);
- }
- }
-
- _serializedATN = {
- 0x3, 0x430, 0xd6d1, 0x8206, 0xad2d, 0x4417, 0xaef1, 0x8d80, 0xaadd,
- 0x2, 0x71, 0x35d, 0x8, 0x1, 0x4, 0x2, 0x9, 0x2, 0x4, 0x3, 0x9, 0x3,
- 0x4, 0x4, 0x9, 0x4, 0x4, 0x5, 0x9, 0x5, 0x4, 0x6, 0x9, 0x6, 0x4, 0x7,
- 0x9, 0x7, 0x4, 0x8, 0x9, 0x8, 0x4, 0x9, 0x9, 0x9, 0x4, 0xa, 0x9, 0xa,
- 0x4, 0xb, 0x9, 0xb, 0x4, 0xc, 0x9, 0xc, 0x4, 0xd, 0x9, 0xd, 0x4, 0xe,
- 0x9, 0xe, 0x4, 0xf, 0x9, 0xf, 0x4, 0x10, 0x9, 0x10, 0x4, 0x11, 0x9,
- 0x11, 0x4, 0x12, 0x9, 0x12, 0x4, 0x13, 0x9, 0x13, 0x4, 0x14, 0x9, 0x14,
- 0x4, 0x15, 0x9, 0x15, 0x4, 0x16, 0x9, 0x16, 0x4, 0x17, 0x9, 0x17, 0x4,
- 0x18, 0x9, 0x18, 0x4, 0x19, 0x9, 0x19, 0x4, 0x1a, 0x9, 0x1a, 0x4, 0x1b,
- 0x9, 0x1b, 0x4, 0x1c, 0x9, 0x1c, 0x4, 0x1d, 0x9, 0x1d, 0x4, 0x1e, 0x9,
- 0x1e, 0x4, 0x1f, 0x9, 0x1f, 0x4, 0x20, 0x9, 0x20, 0x4, 0x21, 0x9, 0x21,
- 0x4, 0x22, 0x9, 0x22, 0x4, 0x23, 0x9, 0x23, 0x4, 0x24, 0x9, 0x24, 0x4,
- 0x25, 0x9, 0x25, 0x4, 0x26, 0x9, 0x26, 0x4, 0x27, 0x9, 0x27, 0x4, 0x28,
- 0x9, 0x28, 0x4, 0x29, 0x9, 0x29, 0x4, 0x2a, 0x9, 0x2a, 0x4, 0x2b, 0x9,
- 0x2b, 0x4, 0x2c, 0x9, 0x2c, 0x4, 0x2d, 0x9, 0x2d, 0x4, 0x2e, 0x9, 0x2e,
- 0x4, 0x2f, 0x9, 0x2f, 0x4, 0x30, 0x9, 0x30, 0x4, 0x31, 0x9, 0x31, 0x4,
- 0x32, 0x9, 0x32, 0x4, 0x33, 0x9, 0x33, 0x4, 0x34, 0x9, 0x34, 0x4, 0x35,
- 0x9, 0x35, 0x4, 0x36, 0x9, 0x36, 0x4, 0x37, 0x9, 0x37, 0x4, 0x38, 0x9,
- 0x38, 0x4, 0x39, 0x9, 0x39, 0x4, 0x3a, 0x9, 0x3a, 0x4, 0x3b, 0x9, 0x3b,
- 0x4, 0x3c, 0x9, 0x3c, 0x4, 0x3d, 0x9, 0x3d, 0x4, 0x3e, 0x9, 0x3e, 0x4,
- 0x3f, 0x9, 0x3f, 0x4, 0x40, 0x9, 0x40, 0x4, 0x41, 0x9, 0x41, 0x4, 0x42,
- 0x9, 0x42, 0x4, 0x43, 0x9, 0x43, 0x4, 0x44, 0x9, 0x44, 0x4, 0x45, 0x9,
- 0x45, 0x4, 0x46, 0x9, 0x46, 0x4, 0x47, 0x9, 0x47, 0x4, 0x48, 0x9, 0x48,
- 0x4, 0x49, 0x9, 0x49, 0x4, 0x4a, 0x9, 0x4a, 0x4, 0x4b, 0x9, 0x4b, 0x4,
- 0x4c, 0x9, 0x4c, 0x4, 0x4d, 0x9, 0x4d, 0x4, 0x4e, 0x9, 0x4e, 0x4, 0x4f,
- 0x9, 0x4f, 0x4, 0x50, 0x9, 0x50, 0x4, 0x51, 0x9, 0x51, 0x4, 0x52, 0x9,
- 0x52, 0x4, 0x53, 0x9, 0x53, 0x4, 0x54, 0x9, 0x54, 0x4, 0x55, 0x9, 0x55,
- 0x4, 0x56, 0x9, 0x56, 0x4, 0x57, 0x9, 0x57, 0x4, 0x58, 0x9, 0x58, 0x4,
- 0x59, 0x9, 0x59, 0x4, 0x5a, 0x9, 0x5a, 0x4, 0x5b, 0x9, 0x5b, 0x4, 0x5c,
- 0x9, 0x5c, 0x4, 0x5d, 0x9, 0x5d, 0x4, 0x5e, 0x9, 0x5e, 0x4, 0x5f, 0x9,
- 0x5f, 0x4, 0x60, 0x9, 0x60, 0x4, 0x61, 0x9, 0x61, 0x4, 0x62, 0x9, 0x62,
- 0x4, 0x63, 0x9, 0x63, 0x4, 0x64, 0x9, 0x64, 0x4, 0x65, 0x9, 0x65, 0x4,
- 0x66, 0x9, 0x66, 0x4, 0x67, 0x9, 0x67, 0x4, 0x68, 0x9, 0x68, 0x4, 0x69,
- 0x9, 0x69, 0x4, 0x6a, 0x9, 0x6a, 0x4, 0x6b, 0x9, 0x6b, 0x4, 0x6c, 0x9,
- 0x6c, 0x4, 0x6d, 0x9, 0x6d, 0x4, 0x6e, 0x9, 0x6e, 0x4, 0x6f, 0x9, 0x6f,
- 0x4, 0x70, 0x9, 0x70, 0x4, 0x71, 0x9, 0x71, 0x4, 0x72, 0x9, 0x72, 0x4,
- 0x73, 0x9, 0x73, 0x4, 0x74, 0x9, 0x74, 0x4, 0x75, 0x9, 0x75, 0x4, 0x76,
- 0x9, 0x76, 0x4, 0x77, 0x9, 0x77, 0x4, 0x78, 0x9, 0x78, 0x4, 0x79, 0x9,
- 0x79, 0x4, 0x7a, 0x9, 0x7a, 0x4, 0x7b, 0x9, 0x7b, 0x4, 0x7c, 0x9, 0x7c,
- 0x4, 0x7d, 0x9, 0x7d, 0x4, 0x7e, 0x9, 0x7e, 0x4, 0x7f, 0x9, 0x7f, 0x4,
- 0x80, 0x9, 0x80, 0x4, 0x81, 0x9, 0x81, 0x4, 0x82, 0x9, 0x82, 0x4, 0x83,
- 0x9, 0x83, 0x3, 0x2, 0x3, 0x2, 0x3, 0x3, 0x3, 0x3, 0x3, 0x4, 0x3, 0x4,
- 0x3, 0x5, 0x3, 0x5, 0x3, 0x5, 0x3, 0x6, 0x3, 0x6, 0x3, 0x7, 0x3, 0x7,
- 0x3, 0x8, 0x3, 0x8, 0x3, 0x9, 0x3, 0x9, 0x3, 0xa, 0x3, 0xa, 0x3, 0xb,
- 0x3, 0xb, 0x3, 0xc, 0x3, 0xc, 0x3, 0xd, 0x3, 0xd, 0x3, 0xd, 0x3, 0xe,
- 0x3, 0xe, 0x3, 0xf, 0x3, 0xf, 0x3, 0x10, 0x3, 0x10, 0x3, 0x11, 0x3,
- 0x11, 0x3, 0x12, 0x3, 0x12, 0x3, 0x13, 0x3, 0x13, 0x3, 0x13, 0x3, 0x14,
- 0x3, 0x14, 0x3, 0x14, 0x3, 0x15, 0x3, 0x15, 0x3, 0x15, 0x3, 0x16, 0x3,
- 0x16, 0x3, 0x17, 0x3, 0x17, 0x3, 0x18, 0x3, 0x18, 0x3, 0x18, 0x3, 0x19,
- 0x3, 0x19, 0x3, 0x19, 0x3, 0x1a, 0x3, 0x1a, 0x3, 0x1b, 0x3, 0x1b, 0x3,
- 0x1c, 0x3, 0x1c, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1e, 0x3, 0x1e, 0x3, 0x1f,
- 0x3, 0x1f, 0x3, 0x20, 0x3, 0x20, 0x3, 0x21, 0x3, 0x21, 0x3, 0x22, 0x3,
- 0x22, 0x3, 0x23, 0x3, 0x23, 0x3, 0x24, 0x3, 0x24, 0x3, 0x25, 0x3, 0x25,
- 0x3, 0x26, 0x3, 0x26, 0x3, 0x27, 0x3, 0x27, 0x3, 0x28, 0x3, 0x28, 0x3,
- 0x29, 0x3, 0x29, 0x3, 0x2a, 0x3, 0x2a, 0x3, 0x2b, 0x3, 0x2b, 0x3, 0x2c,
- 0x3, 0x2c, 0x3, 0x2d, 0x3, 0x2d, 0x3, 0x2e, 0x3, 0x2e, 0x3, 0x2f, 0x3,
- 0x2f, 0x3, 0x30, 0x3, 0x30, 0x3, 0x31, 0x3, 0x31, 0x3, 0x31, 0x7, 0x31,
- 0x170, 0xa, 0x31, 0xc, 0x31, 0xe, 0x31, 0x173, 0xb, 0x31, 0x3, 0x31,
- 0x3, 0x31, 0x3, 0x31, 0x3, 0x31, 0x7, 0x31, 0x179, 0xa, 0x31, 0xc, 0x31,
- 0xe, 0x31, 0x17c, 0xb, 0x31, 0x3, 0x31, 0x5, 0x31, 0x17f, 0xa, 0x31,
- 0x3, 0x32, 0x3, 0x32, 0x3, 0x32, 0x3, 0x32, 0x3, 0x32, 0x3, 0x32, 0x3,
- 0x32, 0x3, 0x32, 0x3, 0x32, 0x3, 0x32, 0x3, 0x32, 0x3, 0x32, 0x3, 0x32,
- 0x3, 0x32, 0x3, 0x32, 0x3, 0x32, 0x3, 0x32, 0x3, 0x32, 0x5, 0x32, 0x193,
- 0xa, 0x32, 0x3, 0x33, 0x3, 0x33, 0x3, 0x33, 0x3, 0x33, 0x6, 0x33, 0x199,
- 0xa, 0x33, 0xd, 0x33, 0xe, 0x33, 0x19a, 0x3, 0x34, 0x3, 0x34, 0x3, 0x34,
- 0x7, 0x34, 0x1a0, 0xa, 0x34, 0xc, 0x34, 0xe, 0x34, 0x1a3, 0xb, 0x34,
- 0x5, 0x34, 0x1a5, 0xa, 0x34, 0x3, 0x35, 0x3, 0x35, 0x6, 0x35, 0x1a9,
- 0xa, 0x35, 0xd, 0x35, 0xe, 0x35, 0x1aa, 0x3, 0x36, 0x5, 0x36, 0x1ae,
- 0xa, 0x36, 0x3, 0x37, 0x3, 0x37, 0x5, 0x37, 0x1b2, 0xa, 0x37, 0x3, 0x38,
- 0x3, 0x38, 0x5, 0x38, 0x1b6, 0xa, 0x38, 0x3, 0x39, 0x3, 0x39, 0x5, 0x39,
- 0x1ba, 0xa, 0x39, 0x3, 0x3a, 0x3, 0x3a, 0x3, 0x3b, 0x3, 0x3b, 0x5, 0x3b,
- 0x1c0, 0xa, 0x3b, 0x3, 0x3c, 0x3, 0x3c, 0x3, 0x3d, 0x6, 0x3d, 0x1c5,
- 0xa, 0x3d, 0xd, 0x3d, 0xe, 0x3d, 0x1c6, 0x3, 0x3d, 0x6, 0x3d, 0x1ca,
- 0xa, 0x3d, 0xd, 0x3d, 0xe, 0x3d, 0x1cb, 0x3, 0x3d, 0x3, 0x3d, 0x6, 0x3d,
- 0x1d0, 0xa, 0x3d, 0xd, 0x3d, 0xe, 0x3d, 0x1d1, 0x3, 0x3d, 0x3, 0x3d,
- 0x6, 0x3d, 0x1d6, 0xa, 0x3d, 0xd, 0x3d, 0xe, 0x3d, 0x1d7, 0x5, 0x3d,
- 0x1da, 0xa, 0x3d, 0x3, 0x3d, 0x5, 0x3d, 0x1dd, 0xa, 0x3d, 0x3, 0x3d,
- 0x5, 0x3d, 0x1e0, 0xa, 0x3d, 0x3, 0x3d, 0x6, 0x3d, 0x1e3, 0xa, 0x3d,
- 0xd, 0x3d, 0xe, 0x3d, 0x1e4, 0x3, 0x3e, 0x7, 0x3e, 0x1e8, 0xa, 0x3e,
- 0xc, 0x3e, 0xe, 0x3e, 0x1eb, 0xb, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x6, 0x3e,
- 0x1ef, 0xa, 0x3e, 0xd, 0x3e, 0xe, 0x3e, 0x1f0, 0x3, 0x3f, 0x3, 0x3f,
- 0x3, 0x3f, 0x3, 0x3f, 0x3, 0x3f, 0x3, 0x3f, 0x3, 0x40, 0x3, 0x40, 0x3,
- 0x40, 0x3, 0x40, 0x3, 0x41, 0x3, 0x41, 0x3, 0x41, 0x3, 0x41, 0x3, 0x41,
- 0x3, 0x41, 0x3, 0x41, 0x3, 0x41, 0x3, 0x41, 0x3, 0x42, 0x3, 0x42, 0x3,
- 0x42, 0x3, 0x42, 0x3, 0x42, 0x3, 0x42, 0x3, 0x43, 0x3, 0x43, 0x3, 0x43,
- 0x3, 0x43, 0x3, 0x43, 0x3, 0x43, 0x3, 0x43, 0x3, 0x44, 0x3, 0x44, 0x3,
- 0x44, 0x3, 0x45, 0x3, 0x45, 0x3, 0x45, 0x3, 0x45, 0x3, 0x45, 0x3, 0x45,
- 0x3, 0x46, 0x3, 0x46, 0x3, 0x46, 0x3, 0x47, 0x3, 0x47, 0x3, 0x47, 0x3,
- 0x47, 0x3, 0x47, 0x3, 0x47, 0x3, 0x47, 0x3, 0x48, 0x3, 0x48, 0x3, 0x48,
- 0x3, 0x48, 0x3, 0x49, 0x3, 0x49, 0x3, 0x49, 0x3, 0x49, 0x3, 0x49, 0x3,
- 0x49, 0x3, 0x49, 0x3, 0x4a, 0x3, 0x4a, 0x3, 0x4a, 0x3, 0x4a, 0x3, 0x4a,
- 0x3, 0x4a, 0x3, 0x4a, 0x3, 0x4b, 0x3, 0x4b, 0x3, 0x4b, 0x3, 0x4b, 0x3,
- 0x4b, 0x3, 0x4b, 0x3, 0x4b, 0x3, 0x4c, 0x3, 0x4c, 0x3, 0x4c, 0x3, 0x4c,
- 0x3, 0x4c, 0x3, 0x4d, 0x3, 0x4d, 0x3, 0x4d, 0x3, 0x4d, 0x3, 0x4d, 0x3,
- 0x4d, 0x3, 0x4d, 0x3, 0x4d, 0x3, 0x4d, 0x3, 0x4e, 0x3, 0x4e, 0x3, 0x4e,
- 0x3, 0x4e, 0x3, 0x4e, 0x3, 0x4e, 0x3, 0x4e, 0x3, 0x4f, 0x3, 0x4f, 0x3,
- 0x4f, 0x3, 0x4f, 0x3, 0x4f, 0x3, 0x4f, 0x3, 0x50, 0x3, 0x50, 0x3, 0x50,
- 0x3, 0x51, 0x3, 0x51, 0x3, 0x51, 0x3, 0x51, 0x3, 0x51, 0x3, 0x52, 0x3,
- 0x52, 0x3, 0x52, 0x3, 0x52, 0x3, 0x52, 0x3, 0x52, 0x3, 0x53, 0x3, 0x53,
- 0x3, 0x53, 0x3, 0x53, 0x3, 0x53, 0x3, 0x53, 0x3, 0x53, 0x3, 0x53, 0x3,
- 0x53, 0x3, 0x53, 0x3, 0x54, 0x3, 0x54, 0x3, 0x54, 0x3, 0x54, 0x3, 0x55,
- 0x3, 0x55, 0x3, 0x55, 0x3, 0x55, 0x3, 0x55, 0x3, 0x55, 0x3, 0x55, 0x3,
- 0x55, 0x3, 0x55, 0x3, 0x55, 0x3, 0x55, 0x3, 0x56, 0x3, 0x56, 0x3, 0x56,
- 0x3, 0x56, 0x3, 0x56, 0x3, 0x57, 0x3, 0x57, 0x3, 0x57, 0x3, 0x57, 0x3,
- 0x57, 0x3, 0x57, 0x3, 0x58, 0x3, 0x58, 0x3, 0x58, 0x3, 0x59, 0x3, 0x59,
- 0x3, 0x59, 0x3, 0x59, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3,
- 0x5b, 0x3, 0x5b, 0x3, 0x5b, 0x3, 0x5b, 0x3, 0x5c, 0x3, 0x5c, 0x3, 0x5c,
- 0x3, 0x5d, 0x3, 0x5d, 0x3, 0x5d, 0x3, 0x5d, 0x3, 0x5d, 0x3, 0x5d, 0x3,
- 0x5d, 0x3, 0x5e, 0x3, 0x5e, 0x3, 0x5e, 0x3, 0x5e, 0x3, 0x5e, 0x3, 0x5f,
- 0x3, 0x5f, 0x3, 0x5f, 0x3, 0x5f, 0x3, 0x5f, 0x3, 0x5f, 0x3, 0x5f, 0x3,
- 0x5f, 0x3, 0x5f, 0x3, 0x60, 0x3, 0x60, 0x3, 0x60, 0x3, 0x61, 0x3, 0x61,
- 0x3, 0x61, 0x3, 0x61, 0x3, 0x61, 0x3, 0x62, 0x3, 0x62, 0x3, 0x62, 0x3,
- 0x62, 0x3, 0x62, 0x3, 0x62, 0x3, 0x63, 0x3, 0x63, 0x3, 0x63, 0x3, 0x63,
- 0x3, 0x63, 0x3, 0x63, 0x3, 0x63, 0x3, 0x64, 0x3, 0x64, 0x3, 0x64, 0x3,
- 0x64, 0x3, 0x64, 0x3, 0x64, 0x3, 0x64, 0x3, 0x64, 0x3, 0x65, 0x3, 0x65,
- 0x3, 0x65, 0x3, 0x65, 0x3, 0x66, 0x3, 0x66, 0x3, 0x66, 0x3, 0x66, 0x3,
- 0x66, 0x3, 0x67, 0x3, 0x67, 0x3, 0x67, 0x3, 0x67, 0x3, 0x67, 0x3, 0x67,
- 0x3, 0x67, 0x3, 0x68, 0x3, 0x68, 0x3, 0x68, 0x3, 0x68, 0x3, 0x68, 0x3,
- 0x69, 0x3, 0x69, 0x3, 0x69, 0x3, 0x69, 0x3, 0x69, 0x3, 0x69, 0x3, 0x6a,
- 0x3, 0x6a, 0x7, 0x6a, 0x2ed, 0xa, 0x6a, 0xc, 0x6a, 0xe, 0x6a, 0x2f0,
- 0xb, 0x6a, 0x3, 0x6b, 0x3, 0x6b, 0x5, 0x6b, 0x2f4, 0xa, 0x6b, 0x3, 0x6c,
- 0x3, 0x6c, 0x5, 0x6c, 0x2f8, 0xa, 0x6c, 0x3, 0x6d, 0x3, 0x6d, 0x7, 0x6d,
- 0x2fc, 0xa, 0x6d, 0xc, 0x6d, 0xe, 0x6d, 0x2ff, 0xb, 0x6d, 0x3, 0x6d,
- 0x6, 0x6d, 0x302, 0xa, 0x6d, 0xd, 0x6d, 0xe, 0x6d, 0x303, 0x3, 0x6e,
- 0x6, 0x6e, 0x307, 0xa, 0x6e, 0xd, 0x6e, 0xe, 0x6e, 0x308, 0x3, 0x6f,
- 0x3, 0x6f, 0x3, 0x6f, 0x3, 0x6f, 0x3, 0x6f, 0x3, 0x6f, 0x3, 0x6f, 0x3,
- 0x6f, 0x3, 0x6f, 0x3, 0x6f, 0x3, 0x6f, 0x3, 0x6f, 0x5, 0x6f, 0x317,
- 0xa, 0x6f, 0x3, 0x70, 0x3, 0x70, 0x3, 0x70, 0x3, 0x70, 0x3, 0x70, 0x3,
- 0x70, 0x7, 0x70, 0x31f, 0xa, 0x70, 0xc, 0x70, 0xe, 0x70, 0x322, 0xb,
- 0x70, 0x3, 0x70, 0x3, 0x70, 0x3, 0x70, 0x3, 0x70, 0x3, 0x70, 0x3, 0x70,
- 0x7, 0x70, 0x32a, 0xa, 0x70, 0xc, 0x70, 0xe, 0x70, 0x32d, 0xb, 0x70,
- 0x3, 0x70, 0x5, 0x70, 0x330, 0xa, 0x70, 0x3, 0x70, 0x3, 0x70, 0x5, 0x70,
- 0x334, 0xa, 0x70, 0x5, 0x70, 0x336, 0xa, 0x70, 0x3, 0x71, 0x3, 0x71,
- 0x3, 0x72, 0x3, 0x72, 0x3, 0x73, 0x3, 0x73, 0x3, 0x74, 0x3, 0x74, 0x3,
- 0x75, 0x3, 0x75, 0x3, 0x76, 0x3, 0x76, 0x3, 0x77, 0x3, 0x77, 0x3, 0x78,
- 0x3, 0x78, 0x3, 0x79, 0x3, 0x79, 0x3, 0x7a, 0x3, 0x7a, 0x3, 0x7b, 0x3,
- 0x7b, 0x3, 0x7c, 0x3, 0x7c, 0x3, 0x7d, 0x3, 0x7d, 0x3, 0x7e, 0x3, 0x7e,
- 0x3, 0x7f, 0x3, 0x7f, 0x3, 0x80, 0x3, 0x80, 0x3, 0x81, 0x3, 0x81, 0x3,
- 0x82, 0x3, 0x82, 0x3, 0x83, 0x3, 0x83, 0x2, 0x2, 0x84, 0x3, 0x3, 0x5,
- 0x4, 0x7, 0x5, 0x9, 0x6, 0xb, 0x7, 0xd, 0x8, 0xf, 0x9, 0x11, 0xa, 0x13,
- 0xb, 0x15, 0xc, 0x17, 0xd, 0x19, 0xe, 0x1b, 0xf, 0x1d, 0x10, 0x1f, 0x11,
- 0x21, 0x12, 0x23, 0x13, 0x25, 0x14, 0x27, 0x15, 0x29, 0x16, 0x2b, 0x17,
- 0x2d, 0x18, 0x2f, 0x19, 0x31, 0x1a, 0x33, 0x1b, 0x35, 0x1c, 0x37, 0x1d,
- 0x39, 0x1e, 0x3b, 0x1f, 0x3d, 0x20, 0x3f, 0x21, 0x41, 0x22, 0x43, 0x23,
- 0x45, 0x24, 0x47, 0x25, 0x49, 0x26, 0x4b, 0x27, 0x4d, 0x28, 0x4f, 0x29,
- 0x51, 0x2a, 0x53, 0x2b, 0x55, 0x2c, 0x57, 0x2d, 0x59, 0x2e, 0x5b, 0x2f,
- 0x5d, 0x30, 0x5f, 0x31, 0x61, 0x32, 0x63, 0x33, 0x65, 0x34, 0x67, 0x35,
- 0x69, 0x36, 0x6b, 0x37, 0x6d, 0x38, 0x6f, 0x39, 0x71, 0x3a, 0x73, 0x3b,
- 0x75, 0x3c, 0x77, 0x3d, 0x79, 0x3e, 0x7b, 0x3f, 0x7d, 0x40, 0x7f, 0x41,
- 0x81, 0x42, 0x83, 0x43, 0x85, 0x44, 0x87, 0x45, 0x89, 0x46, 0x8b, 0x47,
- 0x8d, 0x48, 0x8f, 0x49, 0x91, 0x4a, 0x93, 0x4b, 0x95, 0x4c, 0x97, 0x4d,
- 0x99, 0x4e, 0x9b, 0x4f, 0x9d, 0x50, 0x9f, 0x51, 0xa1, 0x52, 0xa3, 0x53,
- 0xa5, 0x54, 0xa7, 0x55, 0xa9, 0x56, 0xab, 0x57, 0xad, 0x58, 0xaf, 0x59,
- 0xb1, 0x5a, 0xb3, 0x5b, 0xb5, 0x5c, 0xb7, 0x5d, 0xb9, 0x5e, 0xbb, 0x5f,
- 0xbd, 0x60, 0xbf, 0x61, 0xc1, 0x62, 0xc3, 0x63, 0xc5, 0x64, 0xc7, 0x65,
- 0xc9, 0x66, 0xcb, 0x67, 0xcd, 0x68, 0xcf, 0x69, 0xd1, 0x6a, 0xd3, 0x6b,
- 0xd5, 0x6c, 0xd7, 0x6d, 0xd9, 0x6e, 0xdb, 0x6f, 0xdd, 0x70, 0xdf, 0x71,
- 0xe1, 0x2, 0xe3, 0x2, 0xe5, 0x2, 0xe7, 0x2, 0xe9, 0x2, 0xeb, 0x2, 0xed,
- 0x2, 0xef, 0x2, 0xf1, 0x2, 0xf3, 0x2, 0xf5, 0x2, 0xf7, 0x2, 0xf9, 0x2,
- 0xfb, 0x2, 0xfd, 0x2, 0xff, 0x2, 0x101, 0x2, 0x103, 0x2, 0x105, 0x2,
- 0x3, 0x2, 0x30, 0xf, 0x2, 0x24, 0x24, 0x29, 0x29, 0x44, 0x44, 0x48,
- 0x48, 0x50, 0x50, 0x54, 0x54, 0x56, 0x56, 0x5e, 0x5e, 0x64, 0x64, 0x68,
- 0x68, 0x70, 0x70, 0x74, 0x74, 0x76, 0x76, 0x4, 0x2, 0x57, 0x57, 0x77,
- 0x77, 0x4, 0x2, 0x43, 0x48, 0x63, 0x68, 0x4, 0x2, 0x47, 0x47, 0x67,
- 0x67, 0x4, 0x2, 0x50, 0x50, 0x70, 0x70, 0x4, 0x2, 0x4b, 0x4b, 0x6b,
- 0x6b, 0x4, 0x2, 0x51, 0x51, 0x71, 0x71, 0x4, 0x2, 0x43, 0x43, 0x63,
- 0x63, 0x4, 0x2, 0x4e, 0x4e, 0x6e, 0x6e, 0x4, 0x2, 0x52, 0x52, 0x72,
- 0x72, 0x4, 0x2, 0x56, 0x56, 0x76, 0x76, 0x4, 0x2, 0x4f, 0x4f, 0x6f,
- 0x6f, 0x4, 0x2, 0x45, 0x45, 0x65, 0x65, 0x4, 0x2, 0x4a, 0x4a, 0x6a,
- 0x6a, 0x4, 0x2, 0x59, 0x59, 0x79, 0x79, 0x4, 0x2, 0x46, 0x46, 0x66,
- 0x66, 0x4, 0x2, 0x55, 0x55, 0x75, 0x75, 0x4, 0x2, 0x54, 0x54, 0x74,
- 0x74, 0x4, 0x2, 0x49, 0x49, 0x69, 0x69, 0x4, 0x2, 0x58, 0x58, 0x78,
- 0x78, 0x4, 0x2, 0x44, 0x44, 0x64, 0x64, 0x4, 0x2, 0x5b, 0x5b, 0x7b,
- 0x7b, 0x4, 0x2, 0x4d, 0x4d, 0x6d, 0x6d, 0x4, 0x2, 0x5a, 0x5a, 0x7a,
- 0x7a, 0x4, 0x2, 0x48, 0x48, 0x68, 0x68, 0x8, 0x2, 0x61, 0x61, 0x2041,
- 0x2042, 0x2056, 0x2056, 0xfe35, 0xfe36, 0xfe4f, 0xfe51, 0xff41, 0xff41,
- 0xa, 0x2, 0xa2, 0xa2, 0x1682, 0x1682, 0x1810, 0x1810, 0x2002, 0x200c,
- 0x202a, 0x202b, 0x2031, 0x2031, 0x2061, 0x2061, 0x3002, 0x3002, 0x3,
- 0x2, 0xe, 0xe, 0x4, 0x2, 0x2, 0x61, 0x63, 0x1, 0x3, 0x2, 0x20, 0x20,
- 0x1af, 0x2, 0x32, 0x3b, 0x43, 0x5c, 0x61, 0x61, 0x63, 0x7c, 0xac, 0xac,
- 0xb7, 0xb7, 0xb9, 0xb9, 0xbc, 0xbc, 0xc2, 0xd8, 0xda, 0xf8, 0xfa, 0x2c3,
- 0x2c8, 0x2d3, 0x2e2, 0x2e6, 0x2ee, 0x2ee, 0x2f0, 0x2f0, 0x302, 0x376,
- 0x378, 0x379, 0x37c, 0x37f, 0x388, 0x38c, 0x38e, 0x38e, 0x390, 0x3a3,
- 0x3a5, 0x3f7, 0x3f9, 0x483, 0x485, 0x489, 0x48c, 0x529, 0x533, 0x558,
- 0x55b, 0x55b, 0x563, 0x589, 0x593, 0x5bf, 0x5c1, 0x5c1, 0x5c3, 0x5c4,
- 0x5c6, 0x5c7, 0x5c9, 0x5c9, 0x5d2, 0x5ec, 0x5f2, 0x5f4, 0x612, 0x61c,
- 0x622, 0x66b, 0x670, 0x6d5, 0x6d7, 0x6de, 0x6e1, 0x6ea, 0x6ec, 0x6fe,
- 0x701, 0x701, 0x712, 0x74c, 0x74f, 0x7b3, 0x7c2, 0x7f7, 0x7fc, 0x7fc,
- 0x802, 0x82f, 0x842, 0x85d, 0x8a2, 0x8a2, 0x8a4, 0x8ae, 0x8e6, 0x900,
- 0x902, 0x965, 0x968, 0x971, 0x973, 0x979, 0x97b, 0x981, 0x983, 0x985,
- 0x987, 0x98e, 0x991, 0x992, 0x995, 0x9aa, 0x9ac, 0x9b2, 0x9b4, 0x9b4,
- 0x9b8, 0x9bb, 0x9be, 0x9c6, 0x9c9, 0x9ca, 0x9cd, 0x9d0, 0x9d9, 0x9d9,
- 0x9de, 0x9df, 0x9e1, 0x9e5, 0x9e8, 0x9f3, 0xa03, 0xa05, 0xa07, 0xa0c,
- 0xa11, 0xa12, 0xa15, 0xa2a, 0xa2c, 0xa32, 0xa34, 0xa35, 0xa37, 0xa38,
- 0xa3a, 0xa3b, 0xa3e, 0xa3e, 0xa40, 0xa44, 0xa49, 0xa4a, 0xa4d, 0xa4f,
- 0xa53, 0xa53, 0xa5b, 0xa5e, 0xa60, 0xa60, 0xa68, 0xa77, 0xa83, 0xa85,
- 0xa87, 0xa8f, 0xa91, 0xa93, 0xa95, 0xaaa, 0xaac, 0xab2, 0xab4, 0xab5,
- 0xab7, 0xabb, 0xabe, 0xac7, 0xac9, 0xacb, 0xacd, 0xacf, 0xad2, 0xad2,
- 0xae2, 0xae5, 0xae8, 0xaf1, 0xb03, 0xb05, 0xb07, 0xb0e, 0xb11, 0xb12,
- 0xb15, 0xb2a, 0xb2c, 0xb32, 0xb34, 0xb35, 0xb37, 0xb3b, 0xb3e, 0xb46,
- 0xb49, 0xb4a, 0xb4d, 0xb4f, 0xb58, 0xb59, 0xb5e, 0xb5f, 0xb61, 0xb65,
- 0xb68, 0xb71, 0xb73, 0xb73, 0xb84, 0xb85, 0xb87, 0xb8c, 0xb90, 0xb92,
- 0xb94, 0xb97, 0xb9b, 0xb9c, 0xb9e, 0xb9e, 0xba0, 0xba1, 0xba5, 0xba6,
- 0xbaa, 0xbac, 0xbb0, 0xbbb, 0xbc0, 0xbc4, 0xbc8, 0xbca, 0xbcc, 0xbcf,
- 0xbd2, 0xbd2, 0xbd9, 0xbd9, 0xbe8, 0xbf1, 0xc03, 0xc05, 0xc07, 0xc0e,
- 0xc10, 0xc12, 0xc14, 0xc2a, 0xc2c, 0xc35, 0xc37, 0xc3b, 0xc3f, 0xc46,
- 0xc48, 0xc4a, 0xc4c, 0xc4f, 0xc57, 0xc58, 0xc5a, 0xc5b, 0xc62, 0xc65,
- 0xc68, 0xc71, 0xc84, 0xc85, 0xc87, 0xc8e, 0xc90, 0xc92, 0xc94, 0xcaa,
- 0xcac, 0xcb5, 0xcb7, 0xcbb, 0xcbe, 0xcc6, 0xcc8, 0xcca, 0xccc, 0xccf,
- 0xcd7, 0xcd8, 0xce0, 0xce0, 0xce2, 0xce5, 0xce8, 0xcf1, 0xcf3, 0xcf4,
- 0xd04, 0xd05, 0xd07, 0xd0e, 0xd10, 0xd12, 0xd14, 0xd3c, 0xd3f, 0xd46,
- 0xd48, 0xd4a, 0xd4c, 0xd50, 0xd59, 0xd59, 0xd62, 0xd65, 0xd68, 0xd71,
- 0xd7c, 0xd81, 0xd84, 0xd85, 0xd87, 0xd98, 0xd9c, 0xdb3, 0xdb5, 0xdbd,
- 0xdbf, 0xdbf, 0xdc2, 0xdc8, 0xdcc, 0xdcc, 0xdd1, 0xdd6, 0xdd8, 0xdd8,
- 0xdda, 0xde1, 0xdf4, 0xdf5, 0xe03, 0xe3c, 0xe42, 0xe50, 0xe52, 0xe5b,
- 0xe83, 0xe84, 0xe86, 0xe86, 0xe89, 0xe8a, 0xe8c, 0xe8c, 0xe8f, 0xe8f,
- 0xe96, 0xe99, 0xe9b, 0xea1, 0xea3, 0xea5, 0xea7, 0xea7, 0xea9, 0xea9,
- 0xeac, 0xead, 0xeaf, 0xebb, 0xebd, 0xebf, 0xec2, 0xec6, 0xec8, 0xec8,
- 0xeca, 0xecf, 0xed2, 0xedb, 0xede, 0xee1, 0xf02, 0xf02, 0xf1a, 0xf1b,
- 0xf22, 0xf2b, 0xf37, 0xf37, 0xf39, 0xf39, 0xf3b, 0xf3b, 0xf40, 0xf49,
- 0xf4b, 0xf6e, 0xf73, 0xf86, 0xf88, 0xf99, 0xf9b, 0xfbe, 0xfc8, 0xfc8,
- 0x1002, 0x104b, 0x1052, 0x109f, 0x10a2, 0x10c7, 0x10c9, 0x10c9, 0x10cf,
- 0x10cf, 0x10d2, 0x10fc, 0x10fe, 0x124a, 0x124c, 0x124f, 0x1252, 0x1258,
- 0x125a, 0x125a, 0x125c, 0x125f, 0x1262, 0x128a, 0x128c, 0x128f, 0x1292,
- 0x12b2, 0x12b4, 0x12b7, 0x12ba, 0x12c0, 0x12c2, 0x12c2, 0x12c4, 0x12c7,
- 0x12ca, 0x12d8, 0x12da, 0x1312, 0x1314, 0x1317, 0x131a, 0x135c, 0x135f,
- 0x1361, 0x136b, 0x1373, 0x1382, 0x1391, 0x13a2, 0x13f6, 0x1403, 0x166e,
- 0x1671, 0x1681, 0x1683, 0x169c, 0x16a2, 0x16ec, 0x16f0, 0x16f2, 0x1702,
- 0x170e, 0x1710, 0x1716, 0x1722, 0x1736, 0x1742, 0x1755, 0x1762, 0x176e,
- 0x1770, 0x1772, 0x1774, 0x1775, 0x1782, 0x17d5, 0x17d9, 0x17d9, 0x17de,
- 0x17df, 0x17e2, 0x17eb, 0x180d, 0x180f, 0x1812, 0x181b, 0x1822, 0x1879,
- 0x1882, 0x18ac, 0x18b2, 0x18f7, 0x1902, 0x191e, 0x1922, 0x192d, 0x1932,
- 0x193d, 0x1948, 0x196f, 0x1972, 0x1976, 0x1982, 0x19ad, 0x19b2, 0x19cb,
- 0x19d2, 0x19dc, 0x1a02, 0x1a1d, 0x1a22, 0x1a60, 0x1a62, 0x1a7e, 0x1a81,
- 0x1a8b, 0x1a92, 0x1a9b, 0x1aa9, 0x1aa9, 0x1b02, 0x1b4d, 0x1b52, 0x1b5b,
- 0x1b6d, 0x1b75, 0x1b82, 0x1bf5, 0x1c02, 0x1c39, 0x1c42, 0x1c4b, 0x1c4f,
- 0x1c7f, 0x1cd2, 0x1cd4, 0x1cd6, 0x1cf8, 0x1d02, 0x1de8, 0x1dfe, 0x1f17,
- 0x1f1a, 0x1f1f, 0x1f22, 0x1f47, 0x1f4a, 0x1f4f, 0x1f52, 0x1f59, 0x1f5b,
- 0x1f5b, 0x1f5d, 0x1f5d, 0x1f5f, 0x1f5f, 0x1f61, 0x1f7f, 0x1f82, 0x1fb6,
- 0x1fb8, 0x1fbe, 0x1fc0, 0x1fc0, 0x1fc4, 0x1fc6, 0x1fc8, 0x1fce, 0x1fd2,
- 0x1fd5, 0x1fd8, 0x1fdd, 0x1fe2, 0x1fee, 0x1ff4, 0x1ff6, 0x1ff8, 0x1ffe,
- 0x2041, 0x2042, 0x2056, 0x2056, 0x2073, 0x2073, 0x2081, 0x2081, 0x2092,
- 0x209e, 0x20d2, 0x20de, 0x20e3, 0x20e3, 0x20e7, 0x20f2, 0x2104, 0x2104,
- 0x2109, 0x2109, 0x210c, 0x2115, 0x2117, 0x2117, 0x211a, 0x211f, 0x2126,
- 0x2126, 0x2128, 0x2128, 0x212a, 0x212a, 0x212c, 0x213b, 0x213e, 0x2141,
- 0x2147, 0x214b, 0x2150, 0x2150, 0x2162, 0x218a, 0x2c02, 0x2c30, 0x2c32,
- 0x2c60, 0x2c62, 0x2ce6, 0x2ced, 0x2cf5, 0x2d02, 0x2d27, 0x2d29, 0x2d29,
- 0x2d2f, 0x2d2f, 0x2d32, 0x2d69, 0x2d71, 0x2d71, 0x2d81, 0x2d98, 0x2da2,
- 0x2da8, 0x2daa, 0x2db0, 0x2db2, 0x2db8, 0x2dba, 0x2dc0, 0x2dc2, 0x2dc8,
- 0x2dca, 0x2dd0, 0x2dd2, 0x2dd8, 0x2dda, 0x2de0, 0x2de2, 0x2e01, 0x3007,
- 0x3009, 0x3023, 0x3031, 0x3033, 0x3037, 0x303a, 0x303e, 0x3043, 0x3098,
- 0x309b, 0x30a1, 0x30a3, 0x30fc, 0x30fe, 0x3101, 0x3107, 0x312f, 0x3133,
- 0x3190, 0x31a2, 0x31bc, 0x31f2, 0x3201, 0x3402, 0x4db7, 0x4e02, 0x9fce,
- 0xa002, 0xa48e, 0xa4d2, 0xa4ff, 0xa502, 0xa60e, 0xa612, 0xa62d, 0xa642,
- 0xa671, 0xa676, 0xa67f, 0xa681, 0xa699, 0xa6a1, 0xa6f3, 0xa719, 0xa721,
- 0xa724, 0xa78a, 0xa78d, 0xa790, 0xa792, 0xa795, 0xa7a2, 0xa7ac, 0xa7fa,
- 0xa829, 0xa842, 0xa875, 0xa882, 0xa8c6, 0xa8d2, 0xa8db, 0xa8e2, 0xa8f9,
- 0xa8fd, 0xa8fd, 0xa902, 0xa92f, 0xa932, 0xa955, 0xa962, 0xa97e, 0xa982,
- 0xa9c2, 0xa9d1, 0xa9db, 0xaa02, 0xaa38, 0xaa42, 0xaa4f, 0xaa52, 0xaa5b,
- 0xaa62, 0xaa78, 0xaa7c, 0xaa7d, 0xaa82, 0xaac4, 0xaadd, 0xaadf, 0xaae2,
- 0xaaf1, 0xaaf4, 0xaaf8, 0xab03, 0xab08, 0xab0b, 0xab10, 0xab13, 0xab18,
- 0xab22, 0xab28, 0xab2a, 0xab30, 0xabc2, 0xabec, 0xabee, 0xabef, 0xabf2,
- 0xabfb, 0xac02, 0xd7a5, 0xd7b2, 0xd7c8, 0xd7cd, 0xd7fd, 0xf902, 0xfa6f,
- 0xfa72, 0xfadb, 0xfb02, 0xfb08, 0xfb15, 0xfb19, 0xfb1f, 0xfb2a, 0xfb2c,
- 0xfb38, 0xfb3a, 0xfb3e, 0xfb40, 0xfb40, 0xfb42, 0xfb43, 0xfb45, 0xfb46,
- 0xfb48, 0xfbb3, 0xfbd5, 0xfd3f, 0xfd52, 0xfd91, 0xfd94, 0xfdc9, 0xfdf2,
- 0xfdfd, 0xfe02, 0xfe11, 0xfe22, 0xfe28, 0xfe35, 0xfe36, 0xfe4f, 0xfe51,
- 0xfe72, 0xfe76, 0xfe78, 0xfefe, 0xff12, 0xff1b, 0xff23, 0xff3c, 0xff41,
- 0xff41, 0xff43, 0xff5c, 0xff68, 0xffc0, 0xffc4, 0xffc9, 0xffcc, 0xffd1,
- 0xffd4, 0xffd9, 0xffdc, 0xffde, 0x4, 0x2, 0x2, 0x2b, 0x2d, 0x1, 0x5,
- 0x2, 0x2, 0x28, 0x2a, 0x5d, 0x5f, 0x1, 0x5, 0x2, 0x2, 0xb, 0xd, 0xe,
- 0x10, 0x1, 0x4, 0x2, 0x2, 0x30, 0x32, 0x1, 0x3, 0x2, 0x1f, 0x1f, 0x3,
- 0x2, 0x1e, 0x1e, 0x3, 0x2, 0xf, 0xf, 0x13, 0x2, 0x26, 0x26, 0xa4, 0xa7,
- 0x591, 0x591, 0x60d, 0x60d, 0x9f4, 0x9f5, 0x9fd, 0x9fd, 0xaf3, 0xaf3,
- 0xbfb, 0xbfb, 0xe41, 0xe41, 0x17dd, 0x17dd, 0x20a2, 0x20bc, 0xa83a,
- 0xa83a, 0xfdfe, 0xfdfe, 0xfe6b, 0xfe6b, 0xff06, 0xff06, 0xffe2, 0xffe3,
- 0xffe7, 0xffe8, 0x3, 0x2, 0x22, 0x22, 0x3, 0x2, 0xb, 0xb, 0x5, 0x2,
- 0x2, 0x23, 0x25, 0x5d, 0x5f, 0x1, 0x3, 0x2, 0xc, 0xc, 0x3, 0x2, 0xd,
- 0xd, 0x3, 0x2, 0x21, 0x21, 0x174, 0x2, 0x43, 0x5c, 0x63, 0x7c, 0xac,
- 0xac, 0xb7, 0xb7, 0xbc, 0xbc, 0xc2, 0xd8, 0xda, 0xf8, 0xfa, 0x2c3, 0x2c8,
- 0x2d3, 0x2e2, 0x2e6, 0x2ee, 0x2ee, 0x2f0, 0x2f0, 0x372, 0x376, 0x378,
- 0x379, 0x37c, 0x37f, 0x388, 0x388, 0x38a, 0x38c, 0x38e, 0x38e, 0x390,
- 0x3a3, 0x3a5, 0x3f7, 0x3f9, 0x483, 0x48c, 0x529, 0x533, 0x558, 0x55b,
- 0x55b, 0x563, 0x589, 0x5d2, 0x5ec, 0x5f2, 0x5f4, 0x622, 0x64c, 0x670,
- 0x671, 0x673, 0x6d5, 0x6d7, 0x6d7, 0x6e7, 0x6e8, 0x6f0, 0x6f1, 0x6fc,
- 0x6fe, 0x701, 0x701, 0x712, 0x712, 0x714, 0x731, 0x74f, 0x7a7, 0x7b3,
- 0x7b3, 0x7cc, 0x7ec, 0x7f6, 0x7f7, 0x7fc, 0x7fc, 0x802, 0x817, 0x81c,
- 0x81c, 0x826, 0x826, 0x82a, 0x82a, 0x842, 0x85a, 0x8a2, 0x8a2, 0x8a4,
- 0x8ae, 0x906, 0x93b, 0x93f, 0x93f, 0x952, 0x952, 0x95a, 0x963, 0x973,
- 0x979, 0x97b, 0x981, 0x987, 0x98e, 0x991, 0x992, 0x995, 0x9aa, 0x9ac,
- 0x9b2, 0x9b4, 0x9b4, 0x9b8, 0x9bb, 0x9bf, 0x9bf, 0x9d0, 0x9d0, 0x9de,
- 0x9df, 0x9e1, 0x9e3, 0x9f2, 0x9f3, 0xa07, 0xa0c, 0xa11, 0xa12, 0xa15,
- 0xa2a, 0xa2c, 0xa32, 0xa34, 0xa35, 0xa37, 0xa38, 0xa3a, 0xa3b, 0xa5b,
- 0xa5e, 0xa60, 0xa60, 0xa74, 0xa76, 0xa87, 0xa8f, 0xa91, 0xa93, 0xa95,
- 0xaaa, 0xaac, 0xab2, 0xab4, 0xab5, 0xab7, 0xabb, 0xabf, 0xabf, 0xad2,
- 0xad2, 0xae2, 0xae3, 0xb07, 0xb0e, 0xb11, 0xb12, 0xb15, 0xb2a, 0xb2c,
- 0xb32, 0xb34, 0xb35, 0xb37, 0xb3b, 0xb3f, 0xb3f, 0xb5e, 0xb5f, 0xb61,
- 0xb63, 0xb73, 0xb73, 0xb85, 0xb85, 0xb87, 0xb8c, 0xb90, 0xb92, 0xb94,
- 0xb97, 0xb9b, 0xb9c, 0xb9e, 0xb9e, 0xba0, 0xba1, 0xba5, 0xba6, 0xbaa,
- 0xbac, 0xbb0, 0xbbb, 0xbd2, 0xbd2, 0xc07, 0xc0e, 0xc10, 0xc12, 0xc14,
- 0xc2a, 0xc2c, 0xc35, 0xc37, 0xc3b, 0xc3f, 0xc3f, 0xc5a, 0xc5b, 0xc62,
- 0xc63, 0xc87, 0xc8e, 0xc90, 0xc92, 0xc94, 0xcaa, 0xcac, 0xcb5, 0xcb7,
- 0xcbb, 0xcbf, 0xcbf, 0xce0, 0xce0, 0xce2, 0xce3, 0xcf3, 0xcf4, 0xd07,
- 0xd0e, 0xd10, 0xd12, 0xd14, 0xd3c, 0xd3f, 0xd3f, 0xd50, 0xd50, 0xd62,
- 0xd63, 0xd7c, 0xd81, 0xd87, 0xd98, 0xd9c, 0xdb3, 0xdb5, 0xdbd, 0xdbf,
- 0xdbf, 0xdc2, 0xdc8, 0xe03, 0xe32, 0xe34, 0xe35, 0xe42, 0xe48, 0xe83,
- 0xe84, 0xe86, 0xe86, 0xe89, 0xe8a, 0xe8c, 0xe8c, 0xe8f, 0xe8f, 0xe96,
- 0xe99, 0xe9b, 0xea1, 0xea3, 0xea5, 0xea7, 0xea7, 0xea9, 0xea9, 0xeac,
- 0xead, 0xeaf, 0xeb2, 0xeb4, 0xeb5, 0xebf, 0xebf, 0xec2, 0xec6, 0xec8,
- 0xec8, 0xede, 0xee1, 0xf02, 0xf02, 0xf42, 0xf49, 0xf4b, 0xf6e, 0xf8a,
- 0xf8e, 0x1002, 0x102c, 0x1041, 0x1041, 0x1052, 0x1057, 0x105c, 0x105f,
- 0x1063, 0x1063, 0x1067, 0x1068, 0x1070, 0x1072, 0x1077, 0x1083, 0x1090,
- 0x1090, 0x10a2, 0x10c7, 0x10c9, 0x10c9, 0x10cf, 0x10cf, 0x10d2, 0x10fc,
- 0x10fe, 0x124a, 0x124c, 0x124f, 0x1252, 0x1258, 0x125a, 0x125a, 0x125c,
- 0x125f, 0x1262, 0x128a, 0x128c, 0x128f, 0x1292, 0x12b2, 0x12b4, 0x12b7,
- 0x12ba, 0x12c0, 0x12c2, 0x12c2, 0x12c4, 0x12c7, 0x12ca, 0x12d8, 0x12da,
- 0x1312, 0x1314, 0x1317, 0x131a, 0x135c, 0x1382, 0x1391, 0x13a2, 0x13f6,
- 0x1403, 0x166e, 0x1671, 0x1681, 0x1683, 0x169c, 0x16a2, 0x16ec, 0x16f0,
- 0x16f2, 0x1702, 0x170e, 0x1710, 0x1713, 0x1722, 0x1733, 0x1742, 0x1753,
- 0x1762, 0x176e, 0x1770, 0x1772, 0x1782, 0x17b5, 0x17d9, 0x17d9, 0x17de,
- 0x17de, 0x1822, 0x1879, 0x1882, 0x18aa, 0x18ac, 0x18ac, 0x18b2, 0x18f7,
- 0x1902, 0x191e, 0x1952, 0x196f, 0x1972, 0x1976, 0x1982, 0x19ad, 0x19c3,
- 0x19c9, 0x1a02, 0x1a18, 0x1a22, 0x1a56, 0x1aa9, 0x1aa9, 0x1b07, 0x1b35,
- 0x1b47, 0x1b4d, 0x1b85, 0x1ba2, 0x1bb0, 0x1bb1, 0x1bbc, 0x1be7, 0x1c02,
- 0x1c25, 0x1c4f, 0x1c51, 0x1c5c, 0x1c7f, 0x1ceb, 0x1cee, 0x1cf0, 0x1cf3,
- 0x1cf7, 0x1cf8, 0x1d02, 0x1dc1, 0x1e02, 0x1f17, 0x1f1a, 0x1f1f, 0x1f22,
- 0x1f47, 0x1f4a, 0x1f4f, 0x1f52, 0x1f59, 0x1f5b, 0x1f5b, 0x1f5d, 0x1f5d,
- 0x1f5f, 0x1f5f, 0x1f61, 0x1f7f, 0x1f82, 0x1fb6, 0x1fb8, 0x1fbe, 0x1fc0,
- 0x1fc0, 0x1fc4, 0x1fc6, 0x1fc8, 0x1fce, 0x1fd2, 0x1fd5, 0x1fd8, 0x1fdd,
- 0x1fe2, 0x1fee, 0x1ff4, 0x1ff6, 0x1ff8, 0x1ffe, 0x2073, 0x2073, 0x2081,
- 0x2081, 0x2092, 0x209e, 0x2104, 0x2104, 0x2109, 0x2109, 0x210c, 0x2115,
- 0x2117, 0x2117, 0x211a, 0x211f, 0x2126, 0x2126, 0x2128, 0x2128, 0x212a,
- 0x212a, 0x212c, 0x213b, 0x213e, 0x2141, 0x2147, 0x214b, 0x2150, 0x2150,
- 0x2162, 0x218a, 0x2c02, 0x2c30, 0x2c32, 0x2c60, 0x2c62, 0x2ce6, 0x2ced,
- 0x2cf0, 0x2cf4, 0x2cf5, 0x2d02, 0x2d27, 0x2d29, 0x2d29, 0x2d2f, 0x2d2f,
- 0x2d32, 0x2d69, 0x2d71, 0x2d71, 0x2d82, 0x2d98, 0x2da2, 0x2da8, 0x2daa,
- 0x2db0, 0x2db2, 0x2db8, 0x2dba, 0x2dc0, 0x2dc2, 0x2dc8, 0x2dca, 0x2dd0,
- 0x2dd2, 0x2dd8, 0x2dda, 0x2de0, 0x3007, 0x3009, 0x3023, 0x302b, 0x3033,
- 0x3037, 0x303a, 0x303e, 0x3043, 0x3098, 0x309d, 0x30a1, 0x30a3, 0x30fc,
- 0x30fe, 0x3101, 0x3107, 0x312f, 0x3133, 0x3190, 0x31a2, 0x31bc, 0x31f2,
- 0x3201, 0x3402, 0x4db7, 0x4e02, 0x9fce, 0xa002, 0xa48e, 0xa4d2, 0xa4ff,
- 0xa502, 0xa60e, 0xa612, 0xa621, 0xa62c, 0xa62d, 0xa642, 0xa670, 0xa681,
- 0xa699, 0xa6a2, 0xa6f1, 0xa719, 0xa721, 0xa724, 0xa78a, 0xa78d, 0xa790,
- 0xa792, 0xa795, 0xa7a2, 0xa7ac, 0xa7fa, 0xa803, 0xa805, 0xa807, 0xa809,
- 0xa80c, 0xa80e, 0xa824, 0xa842, 0xa875, 0xa884, 0xa8b5, 0xa8f4, 0xa8f9,
- 0xa8fd, 0xa8fd, 0xa90c, 0xa927, 0xa932, 0xa948, 0xa962, 0xa97e, 0xa986,
- 0xa9b4, 0xa9d1, 0xa9d1, 0xaa02, 0xaa2a, 0xaa42, 0xaa44, 0xaa46, 0xaa4d,
- 0xaa62, 0xaa78, 0xaa7c, 0xaa7c, 0xaa82, 0xaab1, 0xaab3, 0xaab3, 0xaab7,
- 0xaab8, 0xaabb, 0xaabf, 0xaac2, 0xaac2, 0xaac4, 0xaac4, 0xaadd, 0xaadf,
- 0xaae2, 0xaaec, 0xaaf4, 0xaaf6, 0xab03, 0xab08, 0xab0b, 0xab10, 0xab13,
- 0xab18, 0xab22, 0xab28, 0xab2a, 0xab30, 0xabc2, 0xabe4, 0xac02, 0xd7a5,
- 0xd7b2, 0xd7c8, 0xd7cd, 0xd7fd, 0xf902, 0xfa6f, 0xfa72, 0xfadb, 0xfb02,
- 0xfb08, 0xfb15, 0xfb19, 0xfb1f, 0xfb1f, 0xfb21, 0xfb2a, 0xfb2c, 0xfb38,
- 0xfb3a, 0xfb3e, 0xfb40, 0xfb40, 0xfb42, 0xfb43, 0xfb45, 0xfb46, 0xfb48,
- 0xfbb3, 0xfbd5, 0xfd3f, 0xfd52, 0xfd91, 0xfd94, 0xfdc9, 0xfdf2, 0xfdfd,
- 0xfe72, 0xfe76, 0xfe78, 0xfefe, 0xff23, 0xff3c, 0xff43, 0xff5c, 0xff68,
- 0xffc0, 0xffc4, 0xffc9, 0xffcc, 0xffd1, 0xffd4, 0xffd9, 0xffdc, 0xffde,
- 0x379, 0x2, 0x3, 0x3, 0x2, 0x2, 0x2, 0x2, 0x5, 0x3, 0x2, 0x2, 0x2, 0x2,
- 0x7, 0x3, 0x2, 0x2, 0x2, 0x2, 0x9, 0x3, 0x2, 0x2, 0x2, 0x2, 0xb, 0x3,
- 0x2, 0x2, 0x2, 0x2, 0xd, 0x3, 0x2, 0x2, 0x2, 0x2, 0xf, 0x3, 0x2, 0x2,
- 0x2, 0x2, 0x11, 0x3, 0x2, 0x2, 0x2, 0x2, 0x13, 0x3, 0x2, 0x2, 0x2, 0x2,
- 0x15, 0x3, 0x2, 0x2, 0x2, 0x2, 0x17, 0x3, 0x2, 0x2, 0x2, 0x2, 0x19,
- 0x3, 0x2, 0x2, 0x2, 0x2, 0x1b, 0x3, 0x2, 0x2, 0x2, 0x2, 0x1d, 0x3, 0x2,
- 0x2, 0x2, 0x2, 0x1f, 0x3, 0x2, 0x2, 0x2, 0x2, 0x21, 0x3, 0x2, 0x2, 0x2,
- 0x2, 0x23, 0x3, 0x2, 0x2, 0x2, 0x2, 0x25, 0x3, 0x2, 0x2, 0x2, 0x2, 0x27,
- 0x3, 0x2, 0x2, 0x2, 0x2, 0x29, 0x3, 0x2, 0x2, 0x2, 0x2, 0x2b, 0x3, 0x2,
- 0x2, 0x2, 0x2, 0x2d, 0x3, 0x2, 0x2, 0x2, 0x2, 0x2f, 0x3, 0x2, 0x2, 0x2,
- 0x2, 0x31, 0x3, 0x2, 0x2, 0x2, 0x2, 0x33, 0x3, 0x2, 0x2, 0x2, 0x2, 0x35,
- 0x3, 0x2, 0x2, 0x2, 0x2, 0x37, 0x3, 0x2, 0x2, 0x2, 0x2, 0x39, 0x3, 0x2,
- 0x2, 0x2, 0x2, 0x3b, 0x3, 0x2, 0x2, 0x2, 0x2, 0x3d, 0x3, 0x2, 0x2, 0x2,
- 0x2, 0x3f, 0x3, 0x2, 0x2, 0x2, 0x2, 0x41, 0x3, 0x2, 0x2, 0x2, 0x2, 0x43,
- 0x3, 0x2, 0x2, 0x2, 0x2, 0x45, 0x3, 0x2, 0x2, 0x2, 0x2, 0x47, 0x3, 0x2,
- 0x2, 0x2, 0x2, 0x49, 0x3, 0x2, 0x2, 0x2, 0x2, 0x4b, 0x3, 0x2, 0x2, 0x2,
- 0x2, 0x4d, 0x3, 0x2, 0x2, 0x2, 0x2, 0x4f, 0x3, 0x2, 0x2, 0x2, 0x2, 0x51,
- 0x3, 0x2, 0x2, 0x2, 0x2, 0x53, 0x3, 0x2, 0x2, 0x2, 0x2, 0x55, 0x3, 0x2,
- 0x2, 0x2, 0x2, 0x57, 0x3, 0x2, 0x2, 0x2, 0x2, 0x59, 0x3, 0x2, 0x2, 0x2,
- 0x2, 0x5b, 0x3, 0x2, 0x2, 0x2, 0x2, 0x5d, 0x3, 0x2, 0x2, 0x2, 0x2, 0x5f,
- 0x3, 0x2, 0x2, 0x2, 0x2, 0x61, 0x3, 0x2, 0x2, 0x2, 0x2, 0x63, 0x3, 0x2,
- 0x2, 0x2, 0x2, 0x65, 0x3, 0x2, 0x2, 0x2, 0x2, 0x67, 0x3, 0x2, 0x2, 0x2,
- 0x2, 0x69, 0x3, 0x2, 0x2, 0x2, 0x2, 0x6b, 0x3, 0x2, 0x2, 0x2, 0x2, 0x6d,
- 0x3, 0x2, 0x2, 0x2, 0x2, 0x6f, 0x3, 0x2, 0x2, 0x2, 0x2, 0x71, 0x3, 0x2,
- 0x2, 0x2, 0x2, 0x73, 0x3, 0x2, 0x2, 0x2, 0x2, 0x75, 0x3, 0x2, 0x2, 0x2,
- 0x2, 0x77, 0x3, 0x2, 0x2, 0x2, 0x2, 0x79, 0x3, 0x2, 0x2, 0x2, 0x2, 0x7b,
- 0x3, 0x2, 0x2, 0x2, 0x2, 0x7d, 0x3, 0x2, 0x2, 0x2, 0x2, 0x7f, 0x3, 0x2,
- 0x2, 0x2, 0x2, 0x81, 0x3, 0x2, 0x2, 0x2, 0x2, 0x83, 0x3, 0x2, 0x2, 0x2,
- 0x2, 0x85, 0x3, 0x2, 0x2, 0x2, 0x2, 0x87, 0x3, 0x2, 0x2, 0x2, 0x2, 0x89,
- 0x3, 0x2, 0x2, 0x2, 0x2, 0x8b, 0x3, 0x2, 0x2, 0x2, 0x2, 0x8d, 0x3, 0x2,
- 0x2, 0x2, 0x2, 0x8f, 0x3, 0x2, 0x2, 0x2, 0x2, 0x91, 0x3, 0x2, 0x2, 0x2,
- 0x2, 0x93, 0x3, 0x2, 0x2, 0x2, 0x2, 0x95, 0x3, 0x2, 0x2, 0x2, 0x2, 0x97,
- 0x3, 0x2, 0x2, 0x2, 0x2, 0x99, 0x3, 0x2, 0x2, 0x2, 0x2, 0x9b, 0x3, 0x2,
- 0x2, 0x2, 0x2, 0x9d, 0x3, 0x2, 0x2, 0x2, 0x2, 0x9f, 0x3, 0x2, 0x2, 0x2,
- 0x2, 0xa1, 0x3, 0x2, 0x2, 0x2, 0x2, 0xa3, 0x3, 0x2, 0x2, 0x2, 0x2, 0xa5,
- 0x3, 0x2, 0x2, 0x2, 0x2, 0xa7, 0x3, 0x2, 0x2, 0x2, 0x2, 0xa9, 0x3, 0x2,
- 0x2, 0x2, 0x2, 0xab, 0x3, 0x2, 0x2, 0x2, 0x2, 0xad, 0x3, 0x2, 0x2, 0x2,
- 0x2, 0xaf, 0x3, 0x2, 0x2, 0x2, 0x2, 0xb1, 0x3, 0x2, 0x2, 0x2, 0x2, 0xb3,
- 0x3, 0x2, 0x2, 0x2, 0x2, 0xb5, 0x3, 0x2, 0x2, 0x2, 0x2, 0xb7, 0x3, 0x2,
- 0x2, 0x2, 0x2, 0xb9, 0x3, 0x2, 0x2, 0x2, 0x2, 0xbb, 0x3, 0x2, 0x2, 0x2,
- 0x2, 0xbd, 0x3, 0x2, 0x2, 0x2, 0x2, 0xbf, 0x3, 0x2, 0x2, 0x2, 0x2, 0xc1,
- 0x3, 0x2, 0x2, 0x2, 0x2, 0xc3, 0x3, 0x2, 0x2, 0x2, 0x2, 0xc5, 0x3, 0x2,
- 0x2, 0x2, 0x2, 0xc7, 0x3, 0x2, 0x2, 0x2, 0x2, 0xc9, 0x3, 0x2, 0x2, 0x2,
- 0x2, 0xcb, 0x3, 0x2, 0x2, 0x2, 0x2, 0xcd, 0x3, 0x2, 0x2, 0x2, 0x2, 0xcf,
- 0x3, 0x2, 0x2, 0x2, 0x2, 0xd1, 0x3, 0x2, 0x2, 0x2, 0x2, 0xd3, 0x3, 0x2,
- 0x2, 0x2, 0x2, 0xd5, 0x3, 0x2, 0x2, 0x2, 0x2, 0xd7, 0x3, 0x2, 0x2, 0x2,
- 0x2, 0xd9, 0x3, 0x2, 0x2, 0x2, 0x2, 0xdb, 0x3, 0x2, 0x2, 0x2, 0x2, 0xdd,
- 0x3, 0x2, 0x2, 0x2, 0x2, 0xdf, 0x3, 0x2, 0x2, 0x2, 0x3, 0x107, 0x3,
- 0x2, 0x2, 0x2, 0x5, 0x109, 0x3, 0x2, 0x2, 0x2, 0x7, 0x10b, 0x3, 0x2,
- 0x2, 0x2, 0x9, 0x10d, 0x3, 0x2, 0x2, 0x2, 0xb, 0x110, 0x3, 0x2, 0x2,
- 0x2, 0xd, 0x112, 0x3, 0x2, 0x2, 0x2, 0xf, 0x114, 0x3, 0x2, 0x2, 0x2,
- 0x11, 0x116, 0x3, 0x2, 0x2, 0x2, 0x13, 0x118, 0x3, 0x2, 0x2, 0x2, 0x15,
- 0x11a, 0x3, 0x2, 0x2, 0x2, 0x17, 0x11c, 0x3, 0x2, 0x2, 0x2, 0x19, 0x11e,
- 0x3, 0x2, 0x2, 0x2, 0x1b, 0x121, 0x3, 0x2, 0x2, 0x2, 0x1d, 0x123, 0x3,
- 0x2, 0x2, 0x2, 0x1f, 0x125, 0x3, 0x2, 0x2, 0x2, 0x21, 0x127, 0x3, 0x2,
- 0x2, 0x2, 0x23, 0x129, 0x3, 0x2, 0x2, 0x2, 0x25, 0x12b, 0x3, 0x2, 0x2,
- 0x2, 0x27, 0x12e, 0x3, 0x2, 0x2, 0x2, 0x29, 0x131, 0x3, 0x2, 0x2, 0x2,
- 0x2b, 0x134, 0x3, 0x2, 0x2, 0x2, 0x2d, 0x136, 0x3, 0x2, 0x2, 0x2, 0x2f,
- 0x138, 0x3, 0x2, 0x2, 0x2, 0x31, 0x13b, 0x3, 0x2, 0x2, 0x2, 0x33, 0x13e,
- 0x3, 0x2, 0x2, 0x2, 0x35, 0x140, 0x3, 0x2, 0x2, 0x2, 0x37, 0x142, 0x3,
- 0x2, 0x2, 0x2, 0x39, 0x144, 0x3, 0x2, 0x2, 0x2, 0x3b, 0x146, 0x3, 0x2,
- 0x2, 0x2, 0x3d, 0x148, 0x3, 0x2, 0x2, 0x2, 0x3f, 0x14a, 0x3, 0x2, 0x2,
- 0x2, 0x41, 0x14c, 0x3, 0x2, 0x2, 0x2, 0x43, 0x14e, 0x3, 0x2, 0x2, 0x2,
- 0x45, 0x150, 0x3, 0x2, 0x2, 0x2, 0x47, 0x152, 0x3, 0x2, 0x2, 0x2, 0x49,
- 0x154, 0x3, 0x2, 0x2, 0x2, 0x4b, 0x156, 0x3, 0x2, 0x2, 0x2, 0x4d, 0x158,
- 0x3, 0x2, 0x2, 0x2, 0x4f, 0x15a, 0x3, 0x2, 0x2, 0x2, 0x51, 0x15c, 0x3,
- 0x2, 0x2, 0x2, 0x53, 0x15e, 0x3, 0x2, 0x2, 0x2, 0x55, 0x160, 0x3, 0x2,
- 0x2, 0x2, 0x57, 0x162, 0x3, 0x2, 0x2, 0x2, 0x59, 0x164, 0x3, 0x2, 0x2,
- 0x2, 0x5b, 0x166, 0x3, 0x2, 0x2, 0x2, 0x5d, 0x168, 0x3, 0x2, 0x2, 0x2,
- 0x5f, 0x16a, 0x3, 0x2, 0x2, 0x2, 0x61, 0x17e, 0x3, 0x2, 0x2, 0x2, 0x63,
- 0x180, 0x3, 0x2, 0x2, 0x2, 0x65, 0x194, 0x3, 0x2, 0x2, 0x2, 0x67, 0x1a4,
- 0x3, 0x2, 0x2, 0x2, 0x69, 0x1a6, 0x3, 0x2, 0x2, 0x2, 0x6b, 0x1ad, 0x3,
- 0x2, 0x2, 0x2, 0x6d, 0x1b1, 0x3, 0x2, 0x2, 0x2, 0x6f, 0x1b5, 0x3, 0x2,
- 0x2, 0x2, 0x71, 0x1b9, 0x3, 0x2, 0x2, 0x2, 0x73, 0x1bb, 0x3, 0x2, 0x2,
- 0x2, 0x75, 0x1bf, 0x3, 0x2, 0x2, 0x2, 0x77, 0x1c1, 0x3, 0x2, 0x2, 0x2,
- 0x79, 0x1d9, 0x3, 0x2, 0x2, 0x2, 0x7b, 0x1e9, 0x3, 0x2, 0x2, 0x2, 0x7d,
- 0x1f2, 0x3, 0x2, 0x2, 0x2, 0x7f, 0x1f8, 0x3, 0x2, 0x2, 0x2, 0x81, 0x1fc,
- 0x3, 0x2, 0x2, 0x2, 0x83, 0x205, 0x3, 0x2, 0x2, 0x2, 0x85, 0x20b, 0x3,
- 0x2, 0x2, 0x2, 0x87, 0x212, 0x3, 0x2, 0x2, 0x2, 0x89, 0x215, 0x3, 0x2,
- 0x2, 0x2, 0x8b, 0x21b, 0x3, 0x2, 0x2, 0x2, 0x8d, 0x21e, 0x3, 0x2, 0x2,
- 0x2, 0x8f, 0x225, 0x3, 0x2, 0x2, 0x2, 0x91, 0x229, 0x3, 0x2, 0x2, 0x2,
- 0x93, 0x230, 0x3, 0x2, 0x2, 0x2, 0x95, 0x237, 0x3, 0x2, 0x2, 0x2, 0x97,
- 0x23e, 0x3, 0x2, 0x2, 0x2, 0x99, 0x243, 0x3, 0x2, 0x2, 0x2, 0x9b, 0x24c,
- 0x3, 0x2, 0x2, 0x2, 0x9d, 0x253, 0x3, 0x2, 0x2, 0x2, 0x9f, 0x259, 0x3,
- 0x2, 0x2, 0x2, 0xa1, 0x25c, 0x3, 0x2, 0x2, 0x2, 0xa3, 0x261, 0x3, 0x2,
- 0x2, 0x2, 0xa5, 0x267, 0x3, 0x2, 0x2, 0x2, 0xa7, 0x271, 0x3, 0x2, 0x2,
- 0x2, 0xa9, 0x275, 0x3, 0x2, 0x2, 0x2, 0xab, 0x280, 0x3, 0x2, 0x2, 0x2,
- 0xad, 0x285, 0x3, 0x2, 0x2, 0x2, 0xaf, 0x28b, 0x3, 0x2, 0x2, 0x2, 0xb1,
- 0x28e, 0x3, 0x2, 0x2, 0x2, 0xb3, 0x292, 0x3, 0x2, 0x2, 0x2, 0xb5, 0x296,
- 0x3, 0x2, 0x2, 0x2, 0xb7, 0x29a, 0x3, 0x2, 0x2, 0x2, 0xb9, 0x29d, 0x3,
- 0x2, 0x2, 0x2, 0xbb, 0x2a4, 0x3, 0x2, 0x2, 0x2, 0xbd, 0x2a9, 0x3, 0x2,
- 0x2, 0x2, 0xbf, 0x2b2, 0x3, 0x2, 0x2, 0x2, 0xc1, 0x2b5, 0x3, 0x2, 0x2,
- 0x2, 0xc3, 0x2ba, 0x3, 0x2, 0x2, 0x2, 0xc5, 0x2c0, 0x3, 0x2, 0x2, 0x2,
- 0xc7, 0x2c7, 0x3, 0x2, 0x2, 0x2, 0xc9, 0x2cf, 0x3, 0x2, 0x2, 0x2, 0xcb,
- 0x2d3, 0x3, 0x2, 0x2, 0x2, 0xcd, 0x2d8, 0x3, 0x2, 0x2, 0x2, 0xcf, 0x2df,
- 0x3, 0x2, 0x2, 0x2, 0xd1, 0x2e4, 0x3, 0x2, 0x2, 0x2, 0xd3, 0x2ea, 0x3,
- 0x2, 0x2, 0x2, 0xd5, 0x2f3, 0x3, 0x2, 0x2, 0x2, 0xd7, 0x2f7, 0x3, 0x2,
- 0x2, 0x2, 0xd9, 0x301, 0x3, 0x2, 0x2, 0x2, 0xdb, 0x306, 0x3, 0x2, 0x2,
- 0x2, 0xdd, 0x316, 0x3, 0x2, 0x2, 0x2, 0xdf, 0x335, 0x3, 0x2, 0x2, 0x2,
- 0xe1, 0x337, 0x3, 0x2, 0x2, 0x2, 0xe3, 0x339, 0x3, 0x2, 0x2, 0x2, 0xe5,
- 0x33b, 0x3, 0x2, 0x2, 0x2, 0xe7, 0x33d, 0x3, 0x2, 0x2, 0x2, 0xe9, 0x33f,
- 0x3, 0x2, 0x2, 0x2, 0xeb, 0x341, 0x3, 0x2, 0x2, 0x2, 0xed, 0x343, 0x3,
- 0x2, 0x2, 0x2, 0xef, 0x345, 0x3, 0x2, 0x2, 0x2, 0xf1, 0x347, 0x3, 0x2,
- 0x2, 0x2, 0xf3, 0x349, 0x3, 0x2, 0x2, 0x2, 0xf5, 0x34b, 0x3, 0x2, 0x2,
- 0x2, 0xf7, 0x34d, 0x3, 0x2, 0x2, 0x2, 0xf9, 0x34f, 0x3, 0x2, 0x2, 0x2,
- 0xfb, 0x351, 0x3, 0x2, 0x2, 0x2, 0xfd, 0x353, 0x3, 0x2, 0x2, 0x2, 0xff,
- 0x355, 0x3, 0x2, 0x2, 0x2, 0x101, 0x357, 0x3, 0x2, 0x2, 0x2, 0x103,
- 0x359, 0x3, 0x2, 0x2, 0x2, 0x105, 0x35b, 0x3, 0x2, 0x2, 0x2, 0x107,
- 0x108, 0x7, 0x3d, 0x2, 0x2, 0x108, 0x4, 0x3, 0x2, 0x2, 0x2, 0x109, 0x10a,
- 0x7, 0x2e, 0x2, 0x2, 0x10a, 0x6, 0x3, 0x2, 0x2, 0x2, 0x10b, 0x10c, 0x7,
- 0x3f, 0x2, 0x2, 0x10c, 0x8, 0x3, 0x2, 0x2, 0x2, 0x10d, 0x10e, 0x7, 0x2d,
- 0x2, 0x2, 0x10e, 0x10f, 0x7, 0x3f, 0x2, 0x2, 0x10f, 0xa, 0x3, 0x2, 0x2,
- 0x2, 0x110, 0x111, 0x7, 0x2c, 0x2, 0x2, 0x111, 0xc, 0x3, 0x2, 0x2, 0x2,
- 0x112, 0x113, 0x7, 0x2a, 0x2, 0x2, 0x113, 0xe, 0x3, 0x2, 0x2, 0x2, 0x114,
- 0x115, 0x7, 0x2b, 0x2, 0x2, 0x115, 0x10, 0x3, 0x2, 0x2, 0x2, 0x116,
- 0x117, 0x7, 0x5d, 0x2, 0x2, 0x117, 0x12, 0x3, 0x2, 0x2, 0x2, 0x118,
- 0x119, 0x7, 0x5f, 0x2, 0x2, 0x119, 0x14, 0x3, 0x2, 0x2, 0x2, 0x11a,
- 0x11b, 0x7, 0x3c, 0x2, 0x2, 0x11b, 0x16, 0x3, 0x2, 0x2, 0x2, 0x11c,
- 0x11d, 0x7, 0x7e, 0x2, 0x2, 0x11d, 0x18, 0x3, 0x2, 0x2, 0x2, 0x11e,
- 0x11f, 0x7, 0x30, 0x2, 0x2, 0x11f, 0x120, 0x7, 0x30, 0x2, 0x2, 0x120,
- 0x1a, 0x3, 0x2, 0x2, 0x2, 0x121, 0x122, 0x7, 0x2d, 0x2, 0x2, 0x122,
- 0x1c, 0x3, 0x2, 0x2, 0x2, 0x123, 0x124, 0x7, 0x2f, 0x2, 0x2, 0x124,
- 0x1e, 0x3, 0x2, 0x2, 0x2, 0x125, 0x126, 0x7, 0x31, 0x2, 0x2, 0x126,
- 0x20, 0x3, 0x2, 0x2, 0x2, 0x127, 0x128, 0x7, 0x27, 0x2, 0x2, 0x128,
- 0x22, 0x3, 0x2, 0x2, 0x2, 0x129, 0x12a, 0x7, 0x60, 0x2, 0x2, 0x12a,
- 0x24, 0x3, 0x2, 0x2, 0x2, 0x12b, 0x12c, 0x7, 0x3f, 0x2, 0x2, 0x12c,
- 0x12d, 0x7, 0x80, 0x2, 0x2, 0x12d, 0x26, 0x3, 0x2, 0x2, 0x2, 0x12e,
- 0x12f, 0x7, 0x3e, 0x2, 0x2, 0x12f, 0x130, 0x7, 0x40, 0x2, 0x2, 0x130,
- 0x28, 0x3, 0x2, 0x2, 0x2, 0x131, 0x132, 0x7, 0x23, 0x2, 0x2, 0x132,
- 0x133, 0x7, 0x3f, 0x2, 0x2, 0x133, 0x2a, 0x3, 0x2, 0x2, 0x2, 0x134,
- 0x135, 0x7, 0x3e, 0x2, 0x2, 0x135, 0x2c, 0x3, 0x2, 0x2, 0x2, 0x136,
- 0x137, 0x7, 0x40, 0x2, 0x2, 0x137, 0x2e, 0x3, 0x2, 0x2, 0x2, 0x138,
- 0x139, 0x7, 0x3e, 0x2, 0x2, 0x139, 0x13a, 0x7, 0x3f, 0x2, 0x2, 0x13a,
- 0x30, 0x3, 0x2, 0x2, 0x2, 0x13b, 0x13c, 0x7, 0x40, 0x2, 0x2, 0x13c,
- 0x13d, 0x7, 0x3f, 0x2, 0x2, 0x13d, 0x32, 0x3, 0x2, 0x2, 0x2, 0x13e,
- 0x13f, 0x7, 0x30, 0x2, 0x2, 0x13f, 0x34, 0x3, 0x2, 0x2, 0x2, 0x140,
- 0x141, 0x7, 0x7d, 0x2, 0x2, 0x141, 0x36, 0x3, 0x2, 0x2, 0x2, 0x142,
- 0x143, 0x7, 0x7f, 0x2, 0x2, 0x143, 0x38, 0x3, 0x2, 0x2, 0x2, 0x144,
- 0x145, 0x7, 0x26, 0x2, 0x2, 0x145, 0x3a, 0x3, 0x2, 0x2, 0x2, 0x146,
- 0x147, 0x7, 0x27ea, 0x2, 0x2, 0x147, 0x3c, 0x3, 0x2, 0x2, 0x2, 0x148,
- 0x149, 0x7, 0x300a, 0x2, 0x2, 0x149, 0x3e, 0x3, 0x2, 0x2, 0x2, 0x14a,
- 0x14b, 0x7, 0xfe66, 0x2, 0x2, 0x14b, 0x40, 0x3, 0x2, 0x2, 0x2, 0x14c,
- 0x14d, 0x7, 0xff1e, 0x2, 0x2, 0x14d, 0x42, 0x3, 0x2, 0x2, 0x2, 0x14e,
- 0x14f, 0x7, 0x27eb, 0x2, 0x2, 0x14f, 0x44, 0x3, 0x2, 0x2, 0x2, 0x150,
- 0x151, 0x7, 0x300b, 0x2, 0x2, 0x151, 0x46, 0x3, 0x2, 0x2, 0x2, 0x152,
- 0x153, 0x7, 0xfe67, 0x2, 0x2, 0x153, 0x48, 0x3, 0x2, 0x2, 0x2, 0x154,
- 0x155, 0x7, 0xff20, 0x2, 0x2, 0x155, 0x4a, 0x3, 0x2, 0x2, 0x2, 0x156,
- 0x157, 0x7, 0xaf, 0x2, 0x2, 0x157, 0x4c, 0x3, 0x2, 0x2, 0x2, 0x158,
- 0x159, 0x7, 0x2012, 0x2, 0x2, 0x159, 0x4e, 0x3, 0x2, 0x2, 0x2, 0x15a,
- 0x15b, 0x7, 0x2013, 0x2, 0x2, 0x15b, 0x50, 0x3, 0x2, 0x2, 0x2, 0x15c,
- 0x15d, 0x7, 0x2014, 0x2, 0x2, 0x15d, 0x52, 0x3, 0x2, 0x2, 0x2, 0x15e,
- 0x15f, 0x7, 0x2015, 0x2, 0x2, 0x15f, 0x54, 0x3, 0x2, 0x2, 0x2, 0x160,
- 0x161, 0x7, 0x2016, 0x2, 0x2, 0x161, 0x56, 0x3, 0x2, 0x2, 0x2, 0x162,
- 0x163, 0x7, 0x2017, 0x2, 0x2, 0x163, 0x58, 0x3, 0x2, 0x2, 0x2, 0x164,
- 0x165, 0x7, 0x2214, 0x2, 0x2, 0x165, 0x5a, 0x3, 0x2, 0x2, 0x2, 0x166,
- 0x167, 0x7, 0xfe5a, 0x2, 0x2, 0x167, 0x5c, 0x3, 0x2, 0x2, 0x2, 0x168,
- 0x169, 0x7, 0xfe65, 0x2, 0x2, 0x169, 0x5e, 0x3, 0x2, 0x2, 0x2, 0x16a,
- 0x16b, 0x7, 0xff0f, 0x2, 0x2, 0x16b, 0x60, 0x3, 0x2, 0x2, 0x2, 0x16c,
- 0x171, 0x7, 0x24, 0x2, 0x2, 0x16d, 0x170, 0x5, 0xfd, 0x7f, 0x2, 0x16e,
- 0x170, 0x5, 0x63, 0x32, 0x2, 0x16f, 0x16d, 0x3, 0x2, 0x2, 0x2, 0x16f,
- 0x16e, 0x3, 0x2, 0x2, 0x2, 0x170, 0x173, 0x3, 0x2, 0x2, 0x2, 0x171,
- 0x16f, 0x3, 0x2, 0x2, 0x2, 0x171, 0x172, 0x3, 0x2, 0x2, 0x2, 0x172,
- 0x174, 0x3, 0x2, 0x2, 0x2, 0x173, 0x171, 0x3, 0x2, 0x2, 0x2, 0x174,
- 0x17f, 0x7, 0x24, 0x2, 0x2, 0x175, 0x17a, 0x7, 0x29, 0x2, 0x2, 0x176,
- 0x179, 0x5, 0xeb, 0x76, 0x2, 0x177, 0x179, 0x5, 0x63, 0x32, 0x2, 0x178,
- 0x176, 0x3, 0x2, 0x2, 0x2, 0x178, 0x177, 0x3, 0x2, 0x2, 0x2, 0x179,
- 0x17c, 0x3, 0x2, 0x2, 0x2, 0x17a, 0x178, 0x3, 0x2, 0x2, 0x2, 0x17a,
- 0x17b, 0x3, 0x2, 0x2, 0x2, 0x17b, 0x17d, 0x3, 0x2, 0x2, 0x2, 0x17c,
- 0x17a, 0x3, 0x2, 0x2, 0x2, 0x17d, 0x17f, 0x7, 0x29, 0x2, 0x2, 0x17e,
- 0x16c, 0x3, 0x2, 0x2, 0x2, 0x17e, 0x175, 0x3, 0x2, 0x2, 0x2, 0x17f,
- 0x62, 0x3, 0x2, 0x2, 0x2, 0x180, 0x192, 0x7, 0x5e, 0x2, 0x2, 0x181,
- 0x193, 0x9, 0x2, 0x2, 0x2, 0x182, 0x183, 0x9, 0x3, 0x2, 0x2, 0x183,
- 0x184, 0x5, 0x6d, 0x37, 0x2, 0x184, 0x185, 0x5, 0x6d, 0x37, 0x2, 0x185,
- 0x186, 0x5, 0x6d, 0x37, 0x2, 0x186, 0x187, 0x5, 0x6d, 0x37, 0x2, 0x187,
- 0x193, 0x3, 0x2, 0x2, 0x2, 0x188, 0x189, 0x9, 0x3, 0x2, 0x2, 0x189,
- 0x18a, 0x5, 0x6d, 0x37, 0x2, 0x18a, 0x18b, 0x5, 0x6d, 0x37, 0x2, 0x18b,
- 0x18c, 0x5, 0x6d, 0x37, 0x2, 0x18c, 0x18d, 0x5, 0x6d, 0x37, 0x2, 0x18d,
- 0x18e, 0x5, 0x6d, 0x37, 0x2, 0x18e, 0x18f, 0x5, 0x6d, 0x37, 0x2, 0x18f,
- 0x190, 0x5, 0x6d, 0x37, 0x2, 0x190, 0x191, 0x5, 0x6d, 0x37, 0x2, 0x191,
- 0x193, 0x3, 0x2, 0x2, 0x2, 0x192, 0x181, 0x3, 0x2, 0x2, 0x2, 0x192,
- 0x182, 0x3, 0x2, 0x2, 0x2, 0x192, 0x188, 0x3, 0x2, 0x2, 0x2, 0x193,
- 0x64, 0x3, 0x2, 0x2, 0x2, 0x194, 0x195, 0x7, 0x32, 0x2, 0x2, 0x195,
- 0x196, 0x7, 0x7a, 0x2, 0x2, 0x196, 0x198, 0x3, 0x2, 0x2, 0x2, 0x197,
- 0x199, 0x5, 0x6d, 0x37, 0x2, 0x198, 0x197, 0x3, 0x2, 0x2, 0x2, 0x199,
- 0x19a, 0x3, 0x2, 0x2, 0x2, 0x19a, 0x198, 0x3, 0x2, 0x2, 0x2, 0x19a,
- 0x19b, 0x3, 0x2, 0x2, 0x2, 0x19b, 0x66, 0x3, 0x2, 0x2, 0x2, 0x19c, 0x1a5,
- 0x5, 0x77, 0x3c, 0x2, 0x19d, 0x1a1, 0x5, 0x71, 0x39, 0x2, 0x19e, 0x1a0,
- 0x5, 0x6f, 0x38, 0x2, 0x19f, 0x19e, 0x3, 0x2, 0x2, 0x2, 0x1a0, 0x1a3,
- 0x3, 0x2, 0x2, 0x2, 0x1a1, 0x19f, 0x3, 0x2, 0x2, 0x2, 0x1a1, 0x1a2,
- 0x3, 0x2, 0x2, 0x2, 0x1a2, 0x1a5, 0x3, 0x2, 0x2, 0x2, 0x1a3, 0x1a1,
- 0x3, 0x2, 0x2, 0x2, 0x1a4, 0x19c, 0x3, 0x2, 0x2, 0x2, 0x1a4, 0x19d,
- 0x3, 0x2, 0x2, 0x2, 0x1a5, 0x68, 0x3, 0x2, 0x2, 0x2, 0x1a6, 0x1a8, 0x5,
- 0x77, 0x3c, 0x2, 0x1a7, 0x1a9, 0x5, 0x75, 0x3b, 0x2, 0x1a8, 0x1a7, 0x3,
- 0x2, 0x2, 0x2, 0x1a9, 0x1aa, 0x3, 0x2, 0x2, 0x2, 0x1aa, 0x1a8, 0x3,
- 0x2, 0x2, 0x2, 0x1aa, 0x1ab, 0x3, 0x2, 0x2, 0x2, 0x1ab, 0x6a, 0x3, 0x2,
- 0x2, 0x2, 0x1ac, 0x1ae, 0x9, 0x4, 0x2, 0x2, 0x1ad, 0x1ac, 0x3, 0x2,
- 0x2, 0x2, 0x1ae, 0x6c, 0x3, 0x2, 0x2, 0x2, 0x1af, 0x1b2, 0x5, 0x6f,
- 0x38, 0x2, 0x1b0, 0x1b2, 0x5, 0x6b, 0x36, 0x2, 0x1b1, 0x1af, 0x3, 0x2,
- 0x2, 0x2, 0x1b1, 0x1b0, 0x3, 0x2, 0x2, 0x2, 0x1b2, 0x6e, 0x3, 0x2, 0x2,
- 0x2, 0x1b3, 0x1b6, 0x5, 0x77, 0x3c, 0x2, 0x1b4, 0x1b6, 0x5, 0x71, 0x39,
- 0x2, 0x1b5, 0x1b3, 0x3, 0x2, 0x2, 0x2, 0x1b5, 0x1b4, 0x3, 0x2, 0x2,
- 0x2, 0x1b6, 0x70, 0x3, 0x2, 0x2, 0x2, 0x1b7, 0x1ba, 0x5, 0x73, 0x3a,
- 0x2, 0x1b8, 0x1ba, 0x4, 0x3a, 0x3b, 0x2, 0x1b9, 0x1b7, 0x3, 0x2, 0x2,
- 0x2, 0x1b9, 0x1b8, 0x3, 0x2, 0x2, 0x2, 0x1ba, 0x72, 0x3, 0x2, 0x2, 0x2,
- 0x1bb, 0x1bc, 0x4, 0x33, 0x39, 0x2, 0x1bc, 0x74, 0x3, 0x2, 0x2, 0x2,
- 0x1bd, 0x1c0, 0x5, 0x77, 0x3c, 0x2, 0x1be, 0x1c0, 0x5, 0x73, 0x3a, 0x2,
- 0x1bf, 0x1bd, 0x3, 0x2, 0x2, 0x2, 0x1bf, 0x1be, 0x3, 0x2, 0x2, 0x2,
- 0x1c0, 0x76, 0x3, 0x2, 0x2, 0x2, 0x1c1, 0x1c2, 0x7, 0x32, 0x2, 0x2,
- 0x1c2, 0x78, 0x3, 0x2, 0x2, 0x2, 0x1c3, 0x1c5, 0x5, 0x6f, 0x38, 0x2,
- 0x1c4, 0x1c3, 0x3, 0x2, 0x2, 0x2, 0x1c5, 0x1c6, 0x3, 0x2, 0x2, 0x2,
- 0x1c6, 0x1c4, 0x3, 0x2, 0x2, 0x2, 0x1c6, 0x1c7, 0x3, 0x2, 0x2, 0x2,
- 0x1c7, 0x1da, 0x3, 0x2, 0x2, 0x2, 0x1c8, 0x1ca, 0x5, 0x6f, 0x38, 0x2,
- 0x1c9, 0x1c8, 0x3, 0x2, 0x2, 0x2, 0x1ca, 0x1cb, 0x3, 0x2, 0x2, 0x2,
- 0x1cb, 0x1c9, 0x3, 0x2, 0x2, 0x2, 0x1cb, 0x1cc, 0x3, 0x2, 0x2, 0x2,
- 0x1cc, 0x1cd, 0x3, 0x2, 0x2, 0x2, 0x1cd, 0x1cf, 0x7, 0x30, 0x2, 0x2,
- 0x1ce, 0x1d0, 0x5, 0x6f, 0x38, 0x2, 0x1cf, 0x1ce, 0x3, 0x2, 0x2, 0x2,
- 0x1d0, 0x1d1, 0x3, 0x2, 0x2, 0x2, 0x1d1, 0x1cf, 0x3, 0x2, 0x2, 0x2,
- 0x1d1, 0x1d2, 0x3, 0x2, 0x2, 0x2, 0x1d2, 0x1da, 0x3, 0x2, 0x2, 0x2,
- 0x1d3, 0x1d5, 0x7, 0x30, 0x2, 0x2, 0x1d4, 0x1d6, 0x5, 0x6f, 0x38, 0x2,
- 0x1d5, 0x1d4, 0x3, 0x2, 0x2, 0x2, 0x1d6, 0x1d7, 0x3, 0x2, 0x2, 0x2,
- 0x1d7, 0x1d5, 0x3, 0x2, 0x2, 0x2, 0x1d7, 0x1d8, 0x3, 0x2, 0x2, 0x2,
- 0x1d8, 0x1da, 0x3, 0x2, 0x2, 0x2, 0x1d9, 0x1c4, 0x3, 0x2, 0x2, 0x2,
- 0x1d9, 0x1c9, 0x3, 0x2, 0x2, 0x2, 0x1d9, 0x1d3, 0x3, 0x2, 0x2, 0x2,
- 0x1da, 0x1dc, 0x3, 0x2, 0x2, 0x2, 0x1db, 0x1dd, 0x9, 0x5, 0x2, 0x2,
- 0x1dc, 0x1db, 0x3, 0x2, 0x2, 0x2, 0x1dd, 0x1df, 0x3, 0x2, 0x2, 0x2,
- 0x1de, 0x1e0, 0x7, 0x2f, 0x2, 0x2, 0x1df, 0x1de, 0x3, 0x2, 0x2, 0x2,
- 0x1df, 0x1e0, 0x3, 0x2, 0x2, 0x2, 0x1e0, 0x1e2, 0x3, 0x2, 0x2, 0x2,
- 0x1e1, 0x1e3, 0x5, 0x6f, 0x38, 0x2, 0x1e2, 0x1e1, 0x3, 0x2, 0x2, 0x2,
- 0x1e3, 0x1e4, 0x3, 0x2, 0x2, 0x2, 0x1e4, 0x1e2, 0x3, 0x2, 0x2, 0x2,
- 0x1e4, 0x1e5, 0x3, 0x2, 0x2, 0x2, 0x1e5, 0x7a, 0x3, 0x2, 0x2, 0x2, 0x1e6,
- 0x1e8, 0x5, 0x6f, 0x38, 0x2, 0x1e7, 0x1e6, 0x3, 0x2, 0x2, 0x2, 0x1e8,
- 0x1eb, 0x3, 0x2, 0x2, 0x2, 0x1e9, 0x1e7, 0x3, 0x2, 0x2, 0x2, 0x1e9,
- 0x1ea, 0x3, 0x2, 0x2, 0x2, 0x1ea, 0x1ec, 0x3, 0x2, 0x2, 0x2, 0x1eb,
- 0x1e9, 0x3, 0x2, 0x2, 0x2, 0x1ec, 0x1ee, 0x7, 0x30, 0x2, 0x2, 0x1ed,
- 0x1ef, 0x5, 0x6f, 0x38, 0x2, 0x1ee, 0x1ed, 0x3, 0x2, 0x2, 0x2, 0x1ef,
- 0x1f0, 0x3, 0x2, 0x2, 0x2, 0x1f0, 0x1ee, 0x3, 0x2, 0x2, 0x2, 0x1f0,
- 0x1f1, 0x3, 0x2, 0x2, 0x2, 0x1f1, 0x7c, 0x3, 0x2, 0x2, 0x2, 0x1f2, 0x1f3,
- 0x9, 0x3, 0x2, 0x2, 0x1f3, 0x1f4, 0x9, 0x6, 0x2, 0x2, 0x1f4, 0x1f5,
- 0x9, 0x7, 0x2, 0x2, 0x1f5, 0x1f6, 0x9, 0x8, 0x2, 0x2, 0x1f6, 0x1f7,
- 0x9, 0x6, 0x2, 0x2, 0x1f7, 0x7e, 0x3, 0x2, 0x2, 0x2, 0x1f8, 0x1f9, 0x9,
- 0x9, 0x2, 0x2, 0x1f9, 0x1fa, 0x9, 0xa, 0x2, 0x2, 0x1fa, 0x1fb, 0x9,
- 0xa, 0x2, 0x2, 0x1fb, 0x80, 0x3, 0x2, 0x2, 0x2, 0x1fc, 0x1fd, 0x9, 0x8,
- 0x2, 0x2, 0x1fd, 0x1fe, 0x9, 0xb, 0x2, 0x2, 0x1fe, 0x1ff, 0x9, 0xc,
- 0x2, 0x2, 0x1ff, 0x200, 0x9, 0x7, 0x2, 0x2, 0x200, 0x201, 0x9, 0x8,
- 0x2, 0x2, 0x201, 0x202, 0x9, 0x6, 0x2, 0x2, 0x202, 0x203, 0x9, 0x9,
- 0x2, 0x2, 0x203, 0x204, 0x9, 0xa, 0x2, 0x2, 0x204, 0x82, 0x3, 0x2, 0x2,
- 0x2, 0x205, 0x206, 0x9, 0xd, 0x2, 0x2, 0x206, 0x207, 0x9, 0x9, 0x2,
- 0x2, 0x207, 0x208, 0x9, 0xc, 0x2, 0x2, 0x208, 0x209, 0x9, 0xe, 0x2,
- 0x2, 0x209, 0x20a, 0x9, 0xf, 0x2, 0x2, 0x20a, 0x84, 0x3, 0x2, 0x2, 0x2,
- 0x20b, 0x20c, 0x9, 0x3, 0x2, 0x2, 0x20c, 0x20d, 0x9, 0x6, 0x2, 0x2,
- 0x20d, 0x20e, 0x9, 0x10, 0x2, 0x2, 0x20e, 0x20f, 0x9, 0x7, 0x2, 0x2,
- 0x20f, 0x210, 0x9, 0x6, 0x2, 0x2, 0x210, 0x211, 0x9, 0x11, 0x2, 0x2,
- 0x211, 0x86, 0x3, 0x2, 0x2, 0x2, 0x212, 0x213, 0x9, 0x9, 0x2, 0x2, 0x213,
- 0x214, 0x9, 0x12, 0x2, 0x2, 0x214, 0x88, 0x3, 0x2, 0x2, 0x2, 0x215,
- 0x216, 0x9, 0xd, 0x2, 0x2, 0x216, 0x217, 0x9, 0x5, 0x2, 0x2, 0x217,
- 0x218, 0x9, 0x13, 0x2, 0x2, 0x218, 0x219, 0x9, 0x14, 0x2, 0x2, 0x219,
- 0x21a, 0x9, 0x5, 0x2, 0x2, 0x21a, 0x8a, 0x3, 0x2, 0x2, 0x2, 0x21b, 0x21c,
- 0x9, 0x8, 0x2, 0x2, 0x21c, 0x21d, 0x9, 0x6, 0x2, 0x2, 0x21d, 0x8c, 0x3,
- 0x2, 0x2, 0x2, 0x21e, 0x21f, 0x9, 0xe, 0x2, 0x2, 0x21f, 0x220, 0x9,
- 0x13, 0x2, 0x2, 0x220, 0x221, 0x9, 0x5, 0x2, 0x2, 0x221, 0x222, 0x9,
- 0x9, 0x2, 0x2, 0x222, 0x223, 0x9, 0xc, 0x2, 0x2, 0x223, 0x224, 0x9,
- 0x5, 0x2, 0x2, 0x224, 0x8e, 0x3, 0x2, 0x2, 0x2, 0x225, 0x226, 0x9, 0x12,
- 0x2, 0x2, 0x226, 0x227, 0x9, 0x5, 0x2, 0x2, 0x227, 0x228, 0x9, 0xc,
- 0x2, 0x2, 0x228, 0x90, 0x3, 0x2, 0x2, 0x2, 0x229, 0x22a, 0x9, 0x11,
- 0x2, 0x2, 0x22a, 0x22b, 0x9, 0x5, 0x2, 0x2, 0x22b, 0x22c, 0x9, 0xc,
- 0x2, 0x2, 0x22c, 0x22d, 0x9, 0x9, 0x2, 0x2, 0x22d, 0x22e, 0x9, 0xe,
- 0x2, 0x2, 0x22e, 0x22f, 0x9, 0xf, 0x2, 0x2, 0x22f, 0x92, 0x3, 0x2, 0x2,
- 0x2, 0x230, 0x231, 0x9, 0x11, 0x2, 0x2, 0x231, 0x232, 0x9, 0x5, 0x2,
- 0x2, 0x232, 0x233, 0x9, 0xa, 0x2, 0x2, 0x233, 0x234, 0x9, 0x5, 0x2,
- 0x2, 0x234, 0x235, 0x9, 0xc, 0x2, 0x2, 0x235, 0x236, 0x9, 0x5, 0x2,
- 0x2, 0x236, 0x94, 0x3, 0x2, 0x2, 0x2, 0x237, 0x238, 0x9, 0x13, 0x2,
- 0x2, 0x238, 0x239, 0x9, 0x5, 0x2, 0x2, 0x239, 0x23a, 0x9, 0xd, 0x2,
- 0x2, 0x23a, 0x23b, 0x9, 0x8, 0x2, 0x2, 0x23b, 0x23c, 0x9, 0x15, 0x2,
- 0x2, 0x23c, 0x23d, 0x9, 0x5, 0x2, 0x2, 0x23d, 0x96, 0x3, 0x2, 0x2, 0x2,
- 0x23e, 0x23f, 0x9, 0x10, 0x2, 0x2, 0x23f, 0x240, 0x9, 0x7, 0x2, 0x2,
- 0x240, 0x241, 0x9, 0xc, 0x2, 0x2, 0x241, 0x242, 0x9, 0xf, 0x2, 0x2,
- 0x242, 0x98, 0x3, 0x2, 0x2, 0x2, 0x243, 0x244, 0x9, 0x11, 0x2, 0x2,
- 0x244, 0x245, 0x9, 0x7, 0x2, 0x2, 0x245, 0x246, 0x9, 0x12, 0x2, 0x2,
- 0x246, 0x247, 0x9, 0xc, 0x2, 0x2, 0x247, 0x248, 0x9, 0x7, 0x2, 0x2,
- 0x248, 0x249, 0x9, 0x6, 0x2, 0x2, 0x249, 0x24a, 0x9, 0xe, 0x2, 0x2,
- 0x24a, 0x24b, 0x9, 0xc, 0x2, 0x2, 0x24b, 0x9a, 0x3, 0x2, 0x2, 0x2, 0x24c,
- 0x24d, 0x9, 0x13, 0x2, 0x2, 0x24d, 0x24e, 0x9, 0x5, 0x2, 0x2, 0x24e,
- 0x24f, 0x9, 0xc, 0x2, 0x2, 0x24f, 0x250, 0x9, 0x3, 0x2, 0x2, 0x250,
- 0x251, 0x9, 0x13, 0x2, 0x2, 0x251, 0x252, 0x9, 0x6, 0x2, 0x2, 0x252,
- 0x9c, 0x3, 0x2, 0x2, 0x2, 0x253, 0x254, 0x9, 0x8, 0x2, 0x2, 0x254, 0x255,
- 0x9, 0x13, 0x2, 0x2, 0x255, 0x256, 0x9, 0x11, 0x2, 0x2, 0x256, 0x257,
- 0x9, 0x5, 0x2, 0x2, 0x257, 0x258, 0x9, 0x13, 0x2, 0x2, 0x258, 0x9e,
- 0x3, 0x2, 0x2, 0x2, 0x259, 0x25a, 0x9, 0x16, 0x2, 0x2, 0x25a, 0x25b,
- 0x9, 0x17, 0x2, 0x2, 0x25b, 0xa0, 0x3, 0x2, 0x2, 0x2, 0x25c, 0x25d,
- 0x9, 0x12, 0x2, 0x2, 0x25d, 0x25e, 0x9, 0x18, 0x2, 0x2, 0x25e, 0x25f,
- 0x9, 0x7, 0x2, 0x2, 0x25f, 0x260, 0x9, 0xb, 0x2, 0x2, 0x260, 0xa2, 0x3,
- 0x2, 0x2, 0x2, 0x261, 0x262, 0x9, 0xa, 0x2, 0x2, 0x262, 0x263, 0x9,
- 0x7, 0x2, 0x2, 0x263, 0x264, 0x9, 0xd, 0x2, 0x2, 0x264, 0x265, 0x9,
- 0x7, 0x2, 0x2, 0x265, 0x266, 0x9, 0xc, 0x2, 0x2, 0x266, 0xa4, 0x3, 0x2,
- 0x2, 0x2, 0x267, 0x268, 0x9, 0x9, 0x2, 0x2, 0x268, 0x269, 0x9, 0x12,
- 0x2, 0x2, 0x269, 0x26a, 0x9, 0xe, 0x2, 0x2, 0x26a, 0x26b, 0x9, 0x5,
- 0x2, 0x2, 0x26b, 0x26c, 0x9, 0x6, 0x2, 0x2, 0x26c, 0x26d, 0x9, 0x11,
- 0x2, 0x2, 0x26d, 0x26e, 0x9, 0x7, 0x2, 0x2, 0x26e, 0x26f, 0x9, 0x6,
- 0x2, 0x2, 0x26f, 0x270, 0x9, 0x14, 0x2, 0x2, 0x270, 0xa6, 0x3, 0x2,
- 0x2, 0x2, 0x271, 0x272, 0x9, 0x9, 0x2, 0x2, 0x272, 0x273, 0x9, 0x12,
- 0x2, 0x2, 0x273, 0x274, 0x9, 0xe, 0x2, 0x2, 0x274, 0xa8, 0x3, 0x2, 0x2,
- 0x2, 0x275, 0x276, 0x9, 0x11, 0x2, 0x2, 0x276, 0x277, 0x9, 0x5, 0x2,
- 0x2, 0x277, 0x278, 0x9, 0x12, 0x2, 0x2, 0x278, 0x279, 0x9, 0xe, 0x2,
- 0x2, 0x279, 0x27a, 0x9, 0x5, 0x2, 0x2, 0x27a, 0x27b, 0x9, 0x6, 0x2,
- 0x2, 0x27b, 0x27c, 0x9, 0x11, 0x2, 0x2, 0x27c, 0x27d, 0x9, 0x7, 0x2,
- 0x2, 0x27d, 0x27e, 0x9, 0x6, 0x2, 0x2, 0x27e, 0x27f, 0x9, 0x14, 0x2,
- 0x2, 0x27f, 0xaa, 0x3, 0x2, 0x2, 0x2, 0x280, 0x281, 0x9, 0x11, 0x2,
- 0x2, 0x281, 0x282, 0x9, 0x5, 0x2, 0x2, 0x282, 0x283, 0x9, 0x12, 0x2,
- 0x2, 0x283, 0x284, 0x9, 0xe, 0x2, 0x2, 0x284, 0xac, 0x3, 0x2, 0x2, 0x2,
- 0x285, 0x286, 0x9, 0x10, 0x2, 0x2, 0x286, 0x287, 0x9, 0xf, 0x2, 0x2,
- 0x287, 0x288, 0x9, 0x5, 0x2, 0x2, 0x288, 0x289, 0x9, 0x13, 0x2, 0x2,
- 0x289, 0x28a, 0x9, 0x5, 0x2, 0x2, 0x28a, 0xae, 0x3, 0x2, 0x2, 0x2, 0x28b,
- 0x28c, 0x9, 0x8, 0x2, 0x2, 0x28c, 0x28d, 0x9, 0x13, 0x2, 0x2, 0x28d,
- 0xb0, 0x3, 0x2, 0x2, 0x2, 0x28e, 0x28f, 0x9, 0x19, 0x2, 0x2, 0x28f,
- 0x290, 0x9, 0x8, 0x2, 0x2, 0x290, 0x291, 0x9, 0x13, 0x2, 0x2, 0x291,
- 0xb2, 0x3, 0x2, 0x2, 0x2, 0x292, 0x293, 0x9, 0x9, 0x2, 0x2, 0x293, 0x294,
- 0x9, 0x6, 0x2, 0x2, 0x294, 0x295, 0x9, 0x11, 0x2, 0x2, 0x295, 0xb4,
- 0x3, 0x2, 0x2, 0x2, 0x296, 0x297, 0x9, 0x6, 0x2, 0x2, 0x297, 0x298,
- 0x9, 0x8, 0x2, 0x2, 0x298, 0x299, 0x9, 0xc, 0x2, 0x2, 0x299, 0xb6, 0x3,
- 0x2, 0x2, 0x2, 0x29a, 0x29b, 0x9, 0x7, 0x2, 0x2, 0x29b, 0x29c, 0x9,
- 0x6, 0x2, 0x2, 0x29c, 0xb8, 0x3, 0x2, 0x2, 0x2, 0x29d, 0x29e, 0x9, 0x12,
- 0x2, 0x2, 0x29e, 0x29f, 0x9, 0xc, 0x2, 0x2, 0x29f, 0x2a0, 0x9, 0x9,
- 0x2, 0x2, 0x2a0, 0x2a1, 0x9, 0x13, 0x2, 0x2, 0x2a1, 0x2a2, 0x9, 0xc,
- 0x2, 0x2, 0x2a2, 0x2a3, 0x9, 0x12, 0x2, 0x2, 0x2a3, 0xba, 0x3, 0x2,
- 0x2, 0x2, 0x2a4, 0x2a5, 0x9, 0x5, 0x2, 0x2, 0x2a5, 0x2a6, 0x9, 0x6,
- 0x2, 0x2, 0x2a6, 0x2a7, 0x9, 0x11, 0x2, 0x2, 0x2a7, 0x2a8, 0x9, 0x12,
- 0x2, 0x2, 0x2a8, 0xbc, 0x3, 0x2, 0x2, 0x2, 0x2a9, 0x2aa, 0x9, 0xe, 0x2,
- 0x2, 0x2aa, 0x2ab, 0x9, 0x8, 0x2, 0x2, 0x2ab, 0x2ac, 0x9, 0x6, 0x2,
- 0x2, 0x2ac, 0x2ad, 0x9, 0xc, 0x2, 0x2, 0x2ad, 0x2ae, 0x9, 0x9, 0x2,
- 0x2, 0x2ae, 0x2af, 0x9, 0x7, 0x2, 0x2, 0x2af, 0x2b0, 0x9, 0x6, 0x2,
- 0x2, 0x2b0, 0x2b1, 0x9, 0x12, 0x2, 0x2, 0x2b1, 0xbe, 0x3, 0x2, 0x2,
- 0x2, 0x2b2, 0x2b3, 0x9, 0x7, 0x2, 0x2, 0x2b3, 0x2b4, 0x9, 0x12, 0x2,
- 0x2, 0x2b4, 0xc0, 0x3, 0x2, 0x2, 0x2, 0x2b5, 0x2b6, 0x9, 0x6, 0x2, 0x2,
- 0x2b6, 0x2b7, 0x9, 0x3, 0x2, 0x2, 0x2b7, 0x2b8, 0x9, 0xa, 0x2, 0x2,
- 0x2b8, 0x2b9, 0x9, 0xa, 0x2, 0x2, 0x2b9, 0xc2, 0x3, 0x2, 0x2, 0x2, 0x2ba,
- 0x2bb, 0x9, 0xe, 0x2, 0x2, 0x2bb, 0x2bc, 0x9, 0x8, 0x2, 0x2, 0x2bc,
- 0x2bd, 0x9, 0x3, 0x2, 0x2, 0x2bd, 0x2be, 0x9, 0x6, 0x2, 0x2, 0x2be,
- 0x2bf, 0x9, 0xc, 0x2, 0x2, 0x2bf, 0xc4, 0x3, 0x2, 0x2, 0x2, 0x2c0, 0x2c1,
- 0x9, 0x1a, 0x2, 0x2, 0x2c1, 0x2c2, 0x9, 0x7, 0x2, 0x2, 0x2c2, 0x2c3,
- 0x9, 0xa, 0x2, 0x2, 0x2c3, 0x2c4, 0x9, 0xc, 0x2, 0x2, 0x2c4, 0x2c5,
- 0x9, 0x5, 0x2, 0x2, 0x2c5, 0x2c6, 0x9, 0x13, 0x2, 0x2, 0x2c6, 0xc6,
- 0x3, 0x2, 0x2, 0x2, 0x2c7, 0x2c8, 0x9, 0x5, 0x2, 0x2, 0x2c8, 0x2c9,
- 0x9, 0x19, 0x2, 0x2, 0x2c9, 0x2ca, 0x9, 0xc, 0x2, 0x2, 0x2ca, 0x2cb,
- 0x9, 0x13, 0x2, 0x2, 0x2cb, 0x2cc, 0x9, 0x9, 0x2, 0x2, 0x2cc, 0x2cd,
- 0x9, 0xe, 0x2, 0x2, 0x2cd, 0x2ce, 0x9, 0xc, 0x2, 0x2, 0x2ce, 0xc8, 0x3,
- 0x2, 0x2, 0x2, 0x2cf, 0x2d0, 0x9, 0x9, 0x2, 0x2, 0x2d0, 0x2d1, 0x9,
- 0x6, 0x2, 0x2, 0x2d1, 0x2d2, 0x9, 0x17, 0x2, 0x2, 0x2d2, 0xca, 0x3,
- 0x2, 0x2, 0x2, 0x2d3, 0x2d4, 0x9, 0x6, 0x2, 0x2, 0x2d4, 0x2d5, 0x9,
- 0x8, 0x2, 0x2, 0x2d5, 0x2d6, 0x9, 0x6, 0x2, 0x2, 0x2d6, 0x2d7, 0x9,
- 0x5, 0x2, 0x2, 0x2d7, 0xcc, 0x3, 0x2, 0x2, 0x2, 0x2d8, 0x2d9, 0x9, 0x12,
- 0x2, 0x2, 0x2d9, 0x2da, 0x9, 0x7, 0x2, 0x2, 0x2da, 0x2db, 0x9, 0x6,
- 0x2, 0x2, 0x2db, 0x2dc, 0x9, 0x14, 0x2, 0x2, 0x2dc, 0x2dd, 0x9, 0xa,
- 0x2, 0x2, 0x2dd, 0x2de, 0x9, 0x5, 0x2, 0x2, 0x2de, 0xce, 0x3, 0x2, 0x2,
- 0x2, 0x2df, 0x2e0, 0x9, 0xc, 0x2, 0x2, 0x2e0, 0x2e1, 0x9, 0x13, 0x2,
- 0x2, 0x2e1, 0x2e2, 0x9, 0x3, 0x2, 0x2, 0x2e2, 0x2e3, 0x9, 0x5, 0x2,
- 0x2, 0x2e3, 0xd0, 0x3, 0x2, 0x2, 0x2, 0x2e4, 0x2e5, 0x9, 0x1a, 0x2,
- 0x2, 0x2e5, 0x2e6, 0x9, 0x9, 0x2, 0x2, 0x2e6, 0x2e7, 0x9, 0xa, 0x2,
- 0x2, 0x2e7, 0x2e8, 0x9, 0x12, 0x2, 0x2, 0x2e8, 0x2e9, 0x9, 0x5, 0x2,
- 0x2, 0x2e9, 0xd2, 0x3, 0x2, 0x2, 0x2, 0x2ea, 0x2ee, 0x5, 0xd5, 0x6b,
- 0x2, 0x2eb, 0x2ed, 0x5, 0xd7, 0x6c, 0x2, 0x2ec, 0x2eb, 0x3, 0x2, 0x2,
- 0x2, 0x2ed, 0x2f0, 0x3, 0x2, 0x2, 0x2, 0x2ee, 0x2ec, 0x3, 0x2, 0x2,
- 0x2, 0x2ee, 0x2ef, 0x3, 0x2, 0x2, 0x2, 0x2ef, 0xd4, 0x3, 0x2, 0x2, 0x2,
- 0x2f0, 0x2ee, 0x3, 0x2, 0x2, 0x2, 0x2f1, 0x2f4, 0x5, 0x105, 0x83, 0x2,
- 0x2f2, 0x2f4, 0x9, 0x1b, 0x2, 0x2, 0x2f3, 0x2f1, 0x3, 0x2, 0x2, 0x2,
- 0x2f3, 0x2f2, 0x3, 0x2, 0x2, 0x2, 0x2f4, 0xd6, 0x3, 0x2, 0x2, 0x2, 0x2f5,
- 0x2f8, 0x5, 0xe7, 0x74, 0x2, 0x2f6, 0x2f8, 0x5, 0xf7, 0x7c, 0x2, 0x2f7,
- 0x2f5, 0x3, 0x2, 0x2, 0x2, 0x2f7, 0x2f6, 0x3, 0x2, 0x2, 0x2, 0x2f8,
- 0xd8, 0x3, 0x2, 0x2, 0x2, 0x2f9, 0x2fd, 0x7, 0x62, 0x2, 0x2, 0x2fa,
- 0x2fc, 0x5, 0xe3, 0x72, 0x2, 0x2fb, 0x2fa, 0x3, 0x2, 0x2, 0x2, 0x2fc,
- 0x2ff, 0x3, 0x2, 0x2, 0x2, 0x2fd, 0x2fb, 0x3, 0x2, 0x2, 0x2, 0x2fd,
- 0x2fe, 0x3, 0x2, 0x2, 0x2, 0x2fe, 0x300, 0x3, 0x2, 0x2, 0x2, 0x2ff,
- 0x2fd, 0x3, 0x2, 0x2, 0x2, 0x300, 0x302, 0x7, 0x62, 0x2, 0x2, 0x301,
- 0x2f9, 0x3, 0x2, 0x2, 0x2, 0x302, 0x303, 0x3, 0x2, 0x2, 0x2, 0x303,
- 0x301, 0x3, 0x2, 0x2, 0x2, 0x303, 0x304, 0x3, 0x2, 0x2, 0x2, 0x304,
- 0xda, 0x3, 0x2, 0x2, 0x2, 0x305, 0x307, 0x5, 0xdd, 0x6f, 0x2, 0x306,
- 0x305, 0x3, 0x2, 0x2, 0x2, 0x307, 0x308, 0x3, 0x2, 0x2, 0x2, 0x308,
- 0x306, 0x3, 0x2, 0x2, 0x2, 0x308, 0x309, 0x3, 0x2, 0x2, 0x2, 0x309,
- 0xdc, 0x3, 0x2, 0x2, 0x2, 0x30a, 0x317, 0x5, 0xf9, 0x7d, 0x2, 0x30b,
- 0x317, 0x5, 0xfb, 0x7e, 0x2, 0x30c, 0x317, 0x5, 0xff, 0x80, 0x2, 0x30d,
- 0x317, 0x5, 0x101, 0x81, 0x2, 0x30e, 0x317, 0x5, 0xe1, 0x71, 0x2, 0x30f,
- 0x317, 0x5, 0xf5, 0x7b, 0x2, 0x310, 0x317, 0x5, 0xf3, 0x7a, 0x2, 0x311,
- 0x317, 0x5, 0xf1, 0x79, 0x2, 0x312, 0x317, 0x5, 0xe5, 0x73, 0x2, 0x313,
- 0x317, 0x5, 0x103, 0x82, 0x2, 0x314, 0x317, 0x9, 0x1c, 0x2, 0x2, 0x315,
- 0x317, 0x5, 0xdf, 0x70, 0x2, 0x316, 0x30a, 0x3, 0x2, 0x2, 0x2, 0x316,
- 0x30b, 0x3, 0x2, 0x2, 0x2, 0x316, 0x30c, 0x3, 0x2, 0x2, 0x2, 0x316,
- 0x30d, 0x3, 0x2, 0x2, 0x2, 0x316, 0x30e, 0x3, 0x2, 0x2, 0x2, 0x316,
- 0x30f, 0x3, 0x2, 0x2, 0x2, 0x316, 0x310, 0x3, 0x2, 0x2, 0x2, 0x316,
- 0x311, 0x3, 0x2, 0x2, 0x2, 0x316, 0x312, 0x3, 0x2, 0x2, 0x2, 0x316,
- 0x313, 0x3, 0x2, 0x2, 0x2, 0x316, 0x314, 0x3, 0x2, 0x2, 0x2, 0x316,
- 0x315, 0x3, 0x2, 0x2, 0x2, 0x317, 0xde, 0x3, 0x2, 0x2, 0x2, 0x318, 0x319,
- 0x7, 0x31, 0x2, 0x2, 0x319, 0x31a, 0x7, 0x2c, 0x2, 0x2, 0x31a, 0x320,
- 0x3, 0x2, 0x2, 0x2, 0x31b, 0x31f, 0x5, 0xe9, 0x75, 0x2, 0x31c, 0x31d,
- 0x7, 0x2c, 0x2, 0x2, 0x31d, 0x31f, 0x5, 0xef, 0x78, 0x2, 0x31e, 0x31b,
- 0x3, 0x2, 0x2, 0x2, 0x31e, 0x31c, 0x3, 0x2, 0x2, 0x2, 0x31f, 0x322,
- 0x3, 0x2, 0x2, 0x2, 0x320, 0x31e, 0x3, 0x2, 0x2, 0x2, 0x320, 0x321,
- 0x3, 0x2, 0x2, 0x2, 0x321, 0x323, 0x3, 0x2, 0x2, 0x2, 0x322, 0x320,
- 0x3, 0x2, 0x2, 0x2, 0x323, 0x324, 0x7, 0x2c, 0x2, 0x2, 0x324, 0x336,
- 0x7, 0x31, 0x2, 0x2, 0x325, 0x326, 0x7, 0x31, 0x2, 0x2, 0x326, 0x327,
- 0x7, 0x31, 0x2, 0x2, 0x327, 0x32b, 0x3, 0x2, 0x2, 0x2, 0x328, 0x32a,
- 0x5, 0xed, 0x77, 0x2, 0x329, 0x328, 0x3, 0x2, 0x2, 0x2, 0x32a, 0x32d,
- 0x3, 0x2, 0x2, 0x2, 0x32b, 0x329, 0x3, 0x2, 0x2, 0x2, 0x32b, 0x32c,
- 0x3, 0x2, 0x2, 0x2, 0x32c, 0x32f, 0x3, 0x2, 0x2, 0x2, 0x32d, 0x32b,
- 0x3, 0x2, 0x2, 0x2, 0x32e, 0x330, 0x5, 0xf5, 0x7b, 0x2, 0x32f, 0x32e,
- 0x3, 0x2, 0x2, 0x2, 0x32f, 0x330, 0x3, 0x2, 0x2, 0x2, 0x330, 0x333,
- 0x3, 0x2, 0x2, 0x2, 0x331, 0x334, 0x5, 0xff, 0x80, 0x2, 0x332, 0x334,
- 0x7, 0x2, 0x2, 0x3, 0x333, 0x331, 0x3, 0x2, 0x2, 0x2, 0x333, 0x332,
- 0x3, 0x2, 0x2, 0x2, 0x334, 0x336, 0x3, 0x2, 0x2, 0x2, 0x335, 0x318,
- 0x3, 0x2, 0x2, 0x2, 0x335, 0x325, 0x3, 0x2, 0x2, 0x2, 0x336, 0xe0, 0x3,
- 0x2, 0x2, 0x2, 0x337, 0x338, 0x9, 0x1d, 0x2, 0x2, 0x338, 0xe2, 0x3,
- 0x2, 0x2, 0x2, 0x339, 0x33a, 0x9, 0x1e, 0x2, 0x2, 0x33a, 0xe4, 0x3,
- 0x2, 0x2, 0x2, 0x33b, 0x33c, 0x9, 0x1f, 0x2, 0x2, 0x33c, 0xe6, 0x3,
- 0x2, 0x2, 0x2, 0x33d, 0x33e, 0x9, 0x20, 0x2, 0x2, 0x33e, 0xe8, 0x3,
- 0x2, 0x2, 0x2, 0x33f, 0x340, 0x9, 0x21, 0x2, 0x2, 0x340, 0xea, 0x3,
- 0x2, 0x2, 0x2, 0x341, 0x342, 0x9, 0x22, 0x2, 0x2, 0x342, 0xec, 0x3,
- 0x2, 0x2, 0x2, 0x343, 0x344, 0x9, 0x23, 0x2, 0x2, 0x344, 0xee, 0x3,
- 0x2, 0x2, 0x2, 0x345, 0x346, 0x9, 0x24, 0x2, 0x2, 0x346, 0xf0, 0x3,
- 0x2, 0x2, 0x2, 0x347, 0x348, 0x9, 0x25, 0x2, 0x2, 0x348, 0xf2, 0x3,
- 0x2, 0x2, 0x2, 0x349, 0x34a, 0x9, 0x26, 0x2, 0x2, 0x34a, 0xf4, 0x3,
- 0x2, 0x2, 0x2, 0x34b, 0x34c, 0x9, 0x27, 0x2, 0x2, 0x34c, 0xf6, 0x3,
- 0x2, 0x2, 0x2, 0x34d, 0x34e, 0x9, 0x28, 0x2, 0x2, 0x34e, 0xf8, 0x3,
- 0x2, 0x2, 0x2, 0x34f, 0x350, 0x9, 0x29, 0x2, 0x2, 0x350, 0xfa, 0x3,
- 0x2, 0x2, 0x2, 0x351, 0x352, 0x9, 0x2a, 0x2, 0x2, 0x352, 0xfc, 0x3,
- 0x2, 0x2, 0x2, 0x353, 0x354, 0x9, 0x2b, 0x2, 0x2, 0x354, 0xfe, 0x3,
- 0x2, 0x2, 0x2, 0x355, 0x356, 0x9, 0x2c, 0x2, 0x2, 0x356, 0x100, 0x3,
- 0x2, 0x2, 0x2, 0x357, 0x358, 0x9, 0x2d, 0x2, 0x2, 0x358, 0x102, 0x3,
- 0x2, 0x2, 0x2, 0x359, 0x35a, 0x9, 0x2e, 0x2, 0x2, 0x35a, 0x104, 0x3,
- 0x2, 0x2, 0x2, 0x35b, 0x35c, 0x9, 0x2f, 0x2, 0x2, 0x35c, 0x106, 0x3,
- 0x2, 0x2, 0x2, 0x29, 0x2, 0x16f, 0x171, 0x178, 0x17a, 0x17e, 0x192,
- 0x19a, 0x1a1, 0x1a4, 0x1aa, 0x1ad, 0x1b1, 0x1b5, 0x1b9, 0x1bf, 0x1c6,
- 0x1cb, 0x1d1, 0x1d7, 0x1d9, 0x1dc, 0x1df, 0x1e4, 0x1e9, 0x1f0, 0x2ee,
- 0x2f3, 0x2f7, 0x2fd, 0x303, 0x308, 0x316, 0x31e, 0x320, 0x32b, 0x32f,
- 0x333, 0x335, 0x2,
- };
-
- atn::ATNDeserializer deserializer;
- _atn = deserializer.deserialize(_serializedATN);
-
- size_t count = _atn.getNumberOfDecisions();
- _decisionToDFA.reserve(count);
- for (size_t i = 0; i < count; i++) {
- _decisionToDFA.emplace_back(_atn.getDecisionState(i), i);
- }
-}
-
-CypherLexer::Initializer CypherLexer::_init;
diff --git a/src/query/frontend/opencypher/generated/CypherLexer.h b/src/query/frontend/opencypher/generated/CypherLexer.h
deleted file mode 100644
index d1dcb0516..000000000
--- a/src/query/frontend/opencypher/generated/CypherLexer.h
+++ /dev/null
@@ -1,75 +0,0 @@
-
-// Generated from /home/mislav/code/memgraph/memgraph/src/query/frontend/opencypher/grammar/Cypher.g4 by ANTLR 4.6
-
-#pragma once
-
-
-#include "antlr4-runtime.h"
-
-
-namespace antlropencypher {
-
-
-class CypherLexer : public antlr4::Lexer {
-public:
- enum {
- T__0 = 1, T__1 = 2, T__2 = 3, T__3 = 4, T__4 = 5, T__5 = 6, T__6 = 7,
- T__7 = 8, T__8 = 9, T__9 = 10, T__10 = 11, T__11 = 12, T__12 = 13, T__13 = 14,
- T__14 = 15, T__15 = 16, T__16 = 17, T__17 = 18, T__18 = 19, T__19 = 20,
- T__20 = 21, T__21 = 22, T__22 = 23, T__23 = 24, T__24 = 25, T__25 = 26,
- T__26 = 27, T__27 = 28, T__28 = 29, T__29 = 30, T__30 = 31, T__31 = 32,
- T__32 = 33, T__33 = 34, T__34 = 35, T__35 = 36, T__36 = 37, T__37 = 38,
- T__38 = 39, T__39 = 40, T__40 = 41, T__41 = 42, T__42 = 43, T__43 = 44,
- T__44 = 45, T__45 = 46, T__46 = 47, StringLiteral = 48, EscapedChar = 49,
- HexInteger = 50, DecimalInteger = 51, OctalInteger = 52, HexLetter = 53,
- HexDigit = 54, Digit = 55, NonZeroDigit = 56, NonZeroOctDigit = 57,
- OctDigit = 58, ZeroDigit = 59, ExponentDecimalReal = 60, RegularDecimalReal = 61,
- UNION = 62, ALL = 63, OPTIONAL = 64, MATCH = 65, UNWIND = 66, AS = 67,
- MERGE = 68, ON = 69, CREATE = 70, SET = 71, DETACH = 72, DELETE = 73,
- REMOVE = 74, WITH = 75, DISTINCT = 76, RETURN = 77, ORDER = 78, BY = 79,
- L_SKIP = 80, LIMIT = 81, ASCENDING = 82, ASC = 83, DESCENDING = 84,
- DESC = 85, WHERE = 86, OR = 87, XOR = 88, AND = 89, NOT = 90, IN = 91,
- STARTS = 92, ENDS = 93, CONTAINS = 94, IS = 95, CYPHERNULL = 96, COUNT = 97,
- FILTER = 98, EXTRACT = 99, ANY = 100, NONE = 101, SINGLE = 102, TRUE = 103,
- FALSE = 104, UnescapedSymbolicName = 105, IdentifierStart = 106, IdentifierPart = 107,
- EscapedSymbolicName = 108, SP = 109, WHITESPACE = 110, Comment = 111
- };
-
- CypherLexer(antlr4::CharStream *input);
- ~CypherLexer();
-
- virtual std::string getGrammarFileName() const override;
- virtual const std::vector<std::string>& getRuleNames() const override;
-
- virtual const std::vector<std::string>& getModeNames() const override;
- virtual const std::vector<std::string>& getTokenNames() const override; // deprecated, use vocabulary instead
- virtual antlr4::dfa::Vocabulary& getVocabulary() const override;
-
- virtual const std::vector<uint16_t> getSerializedATN() const override;
- virtual const antlr4::atn::ATN& getATN() const override;
-
-private:
- static std::vector<antlr4::dfa::DFA> _decisionToDFA;
- static antlr4::atn::PredictionContextCache _sharedContextCache;
- static std::vector<std::string> _ruleNames;
- static std::vector<std::string> _tokenNames;
- static std::vector<std::string> _modeNames;
-
- static std::vector<std::string> _literalNames;
- static std::vector<std::string> _symbolicNames;
- static antlr4::dfa::Vocabulary _vocabulary;
- static antlr4::atn::ATN _atn;
- static std::vector<uint16_t> _serializedATN;
-
-
- // Individual action functions triggered by action() above.
-
- // Individual semantic predicate functions triggered by sempred() above.
-
- struct Initializer {
- Initializer();
- };
- static Initializer _init;
-};
-
-} // namespace antlropencypher
diff --git a/src/query/frontend/opencypher/generated/CypherLexer.tokens b/src/query/frontend/opencypher/generated/CypherLexer.tokens
deleted file mode 100644
index cac3f8383..000000000
--- a/src/query/frontend/opencypher/generated/CypherLexer.tokens
+++ /dev/null
@@ -1,159 +0,0 @@
-T__0=1
-T__1=2
-T__2=3
-T__3=4
-T__4=5
-T__5=6
-T__6=7
-T__7=8
-T__8=9
-T__9=10
-T__10=11
-T__11=12
-T__12=13
-T__13=14
-T__14=15
-T__15=16
-T__16=17
-T__17=18
-T__18=19
-T__19=20
-T__20=21
-T__21=22
-T__22=23
-T__23=24
-T__24=25
-T__25=26
-T__26=27
-T__27=28
-T__28=29
-T__29=30
-T__30=31
-T__31=32
-T__32=33
-T__33=34
-T__34=35
-T__35=36
-T__36=37
-T__37=38
-T__38=39
-T__39=40
-T__40=41
-T__41=42
-T__42=43
-T__43=44
-T__44=45
-T__45=46
-T__46=47
-StringLiteral=48
-EscapedChar=49
-HexInteger=50
-DecimalInteger=51
-OctalInteger=52
-HexLetter=53
-HexDigit=54
-Digit=55
-NonZeroDigit=56
-NonZeroOctDigit=57
-OctDigit=58
-ZeroDigit=59
-ExponentDecimalReal=60
-RegularDecimalReal=61
-UNION=62
-ALL=63
-OPTIONAL=64
-MATCH=65
-UNWIND=66
-AS=67
-MERGE=68
-ON=69
-CREATE=70
-SET=71
-DETACH=72
-DELETE=73
-REMOVE=74
-WITH=75
-DISTINCT=76
-RETURN=77
-ORDER=78
-BY=79
-L_SKIP=80
-LIMIT=81
-ASCENDING=82
-ASC=83
-DESCENDING=84
-DESC=85
-WHERE=86
-OR=87
-XOR=88
-AND=89
-NOT=90
-IN=91
-STARTS=92
-ENDS=93
-CONTAINS=94
-IS=95
-CYPHERNULL=96
-COUNT=97
-FILTER=98
-EXTRACT=99
-ANY=100
-NONE=101
-SINGLE=102
-TRUE=103
-FALSE=104
-UnescapedSymbolicName=105
-IdentifierStart=106
-IdentifierPart=107
-EscapedSymbolicName=108
-SP=109
-WHITESPACE=110
-Comment=111
-';'=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
-'0'=59
diff --git a/src/query/frontend/opencypher/generated/CypherListener.cpp b/src/query/frontend/opencypher/generated/CypherListener.cpp
deleted file mode 100644
index 67176a5b5..000000000
--- a/src/query/frontend/opencypher/generated/CypherListener.cpp
+++ /dev/null
@@ -1,9 +0,0 @@
-
-// Generated from /home/mislav/code/memgraph/memgraph/src/query/frontend/opencypher/grammar/Cypher.g4 by ANTLR 4.6
-
-
-#include "CypherListener.h"
-
-
-using namespace antlropencypher;
-
diff --git a/src/query/frontend/opencypher/generated/CypherListener.h b/src/query/frontend/opencypher/generated/CypherListener.h
deleted file mode 100644
index 4a1128f83..000000000
--- a/src/query/frontend/opencypher/generated/CypherListener.h
+++ /dev/null
@@ -1,262 +0,0 @@
-
-// Generated from /home/mislav/code/memgraph/memgraph/src/query/frontend/opencypher/grammar/Cypher.g4 by ANTLR 4.6
-
-#pragma once
-
-
-#include "antlr4-runtime.h"
-#include "CypherParser.h"
-
-
-namespace antlropencypher {
-
-/**
- * This interface defines an abstract listener for a parse tree produced by CypherParser.
- */
-class CypherListener : public antlr4::tree::ParseTreeListener {
-public:
-
- virtual void enterCypher(CypherParser::CypherContext *ctx) = 0;
- virtual void exitCypher(CypherParser::CypherContext *ctx) = 0;
-
- virtual void enterStatement(CypherParser::StatementContext *ctx) = 0;
- virtual void exitStatement(CypherParser::StatementContext *ctx) = 0;
-
- virtual void enterQuery(CypherParser::QueryContext *ctx) = 0;
- virtual void exitQuery(CypherParser::QueryContext *ctx) = 0;
-
- virtual void enterRegularQuery(CypherParser::RegularQueryContext *ctx) = 0;
- virtual void exitRegularQuery(CypherParser::RegularQueryContext *ctx) = 0;
-
- virtual void enterSingleQuery(CypherParser::SingleQueryContext *ctx) = 0;
- virtual void exitSingleQuery(CypherParser::SingleQueryContext *ctx) = 0;
-
- virtual void enterCypherUnion(CypherParser::CypherUnionContext *ctx) = 0;
- virtual void exitCypherUnion(CypherParser::CypherUnionContext *ctx) = 0;
-
- virtual void enterClause(CypherParser::ClauseContext *ctx) = 0;
- virtual void exitClause(CypherParser::ClauseContext *ctx) = 0;
-
- virtual void enterCypherMatch(CypherParser::CypherMatchContext *ctx) = 0;
- virtual void exitCypherMatch(CypherParser::CypherMatchContext *ctx) = 0;
-
- virtual void enterUnwind(CypherParser::UnwindContext *ctx) = 0;
- virtual void exitUnwind(CypherParser::UnwindContext *ctx) = 0;
-
- virtual void enterMerge(CypherParser::MergeContext *ctx) = 0;
- virtual void exitMerge(CypherParser::MergeContext *ctx) = 0;
-
- virtual void enterMergeAction(CypherParser::MergeActionContext *ctx) = 0;
- virtual void exitMergeAction(CypherParser::MergeActionContext *ctx) = 0;
-
- virtual void enterCreate(CypherParser::CreateContext *ctx) = 0;
- virtual void exitCreate(CypherParser::CreateContext *ctx) = 0;
-
- virtual void enterSet(CypherParser::SetContext *ctx) = 0;
- virtual void exitSet(CypherParser::SetContext *ctx) = 0;
-
- virtual void enterSetItem(CypherParser::SetItemContext *ctx) = 0;
- virtual void exitSetItem(CypherParser::SetItemContext *ctx) = 0;
-
- virtual void enterCypherDelete(CypherParser::CypherDeleteContext *ctx) = 0;
- virtual void exitCypherDelete(CypherParser::CypherDeleteContext *ctx) = 0;
-
- virtual void enterRemove(CypherParser::RemoveContext *ctx) = 0;
- virtual void exitRemove(CypherParser::RemoveContext *ctx) = 0;
-
- virtual void enterRemoveItem(CypherParser::RemoveItemContext *ctx) = 0;
- virtual void exitRemoveItem(CypherParser::RemoveItemContext *ctx) = 0;
-
- virtual void enterWith(CypherParser::WithContext *ctx) = 0;
- virtual void exitWith(CypherParser::WithContext *ctx) = 0;
-
- virtual void enterCypherReturn(CypherParser::CypherReturnContext *ctx) = 0;
- virtual void exitCypherReturn(CypherParser::CypherReturnContext *ctx) = 0;
-
- virtual void enterReturnBody(CypherParser::ReturnBodyContext *ctx) = 0;
- virtual void exitReturnBody(CypherParser::ReturnBodyContext *ctx) = 0;
-
- virtual void enterReturnItems(CypherParser::ReturnItemsContext *ctx) = 0;
- virtual void exitReturnItems(CypherParser::ReturnItemsContext *ctx) = 0;
-
- virtual void enterReturnItem(CypherParser::ReturnItemContext *ctx) = 0;
- virtual void exitReturnItem(CypherParser::ReturnItemContext *ctx) = 0;
-
- virtual void enterOrder(CypherParser::OrderContext *ctx) = 0;
- virtual void exitOrder(CypherParser::OrderContext *ctx) = 0;
-
- virtual void enterSkip(CypherParser::SkipContext *ctx) = 0;
- virtual void exitSkip(CypherParser::SkipContext *ctx) = 0;
-
- virtual void enterLimit(CypherParser::LimitContext *ctx) = 0;
- virtual void exitLimit(CypherParser::LimitContext *ctx) = 0;
-
- virtual void enterSortItem(CypherParser::SortItemContext *ctx) = 0;
- virtual void exitSortItem(CypherParser::SortItemContext *ctx) = 0;
-
- virtual void enterWhere(CypherParser::WhereContext *ctx) = 0;
- virtual void exitWhere(CypherParser::WhereContext *ctx) = 0;
-
- virtual void enterPattern(CypherParser::PatternContext *ctx) = 0;
- virtual void exitPattern(CypherParser::PatternContext *ctx) = 0;
-
- virtual void enterPatternPart(CypherParser::PatternPartContext *ctx) = 0;
- virtual void exitPatternPart(CypherParser::PatternPartContext *ctx) = 0;
-
- virtual void enterAnonymousPatternPart(CypherParser::AnonymousPatternPartContext *ctx) = 0;
- virtual void exitAnonymousPatternPart(CypherParser::AnonymousPatternPartContext *ctx) = 0;
-
- virtual void enterPatternElement(CypherParser::PatternElementContext *ctx) = 0;
- virtual void exitPatternElement(CypherParser::PatternElementContext *ctx) = 0;
-
- virtual void enterNodePattern(CypherParser::NodePatternContext *ctx) = 0;
- virtual void exitNodePattern(CypherParser::NodePatternContext *ctx) = 0;
-
- virtual void enterPatternElementChain(CypherParser::PatternElementChainContext *ctx) = 0;
- virtual void exitPatternElementChain(CypherParser::PatternElementChainContext *ctx) = 0;
-
- virtual void enterRelationshipPattern(CypherParser::RelationshipPatternContext *ctx) = 0;
- virtual void exitRelationshipPattern(CypherParser::RelationshipPatternContext *ctx) = 0;
-
- virtual void enterRelationshipDetail(CypherParser::RelationshipDetailContext *ctx) = 0;
- virtual void exitRelationshipDetail(CypherParser::RelationshipDetailContext *ctx) = 0;
-
- virtual void enterProperties(CypherParser::PropertiesContext *ctx) = 0;
- virtual void exitProperties(CypherParser::PropertiesContext *ctx) = 0;
-
- virtual void enterRelationshipTypes(CypherParser::RelationshipTypesContext *ctx) = 0;
- virtual void exitRelationshipTypes(CypherParser::RelationshipTypesContext *ctx) = 0;
-
- virtual void enterNodeLabels(CypherParser::NodeLabelsContext *ctx) = 0;
- virtual void exitNodeLabels(CypherParser::NodeLabelsContext *ctx) = 0;
-
- virtual void enterNodeLabel(CypherParser::NodeLabelContext *ctx) = 0;
- virtual void exitNodeLabel(CypherParser::NodeLabelContext *ctx) = 0;
-
- virtual void enterRangeLiteral(CypherParser::RangeLiteralContext *ctx) = 0;
- virtual void exitRangeLiteral(CypherParser::RangeLiteralContext *ctx) = 0;
-
- virtual void enterLabelName(CypherParser::LabelNameContext *ctx) = 0;
- virtual void exitLabelName(CypherParser::LabelNameContext *ctx) = 0;
-
- virtual void enterRelTypeName(CypherParser::RelTypeNameContext *ctx) = 0;
- virtual void exitRelTypeName(CypherParser::RelTypeNameContext *ctx) = 0;
-
- virtual void enterExpression(CypherParser::ExpressionContext *ctx) = 0;
- virtual void exitExpression(CypherParser::ExpressionContext *ctx) = 0;
-
- virtual void enterExpression12(CypherParser::Expression12Context *ctx) = 0;
- virtual void exitExpression12(CypherParser::Expression12Context *ctx) = 0;
-
- virtual void enterExpression11(CypherParser::Expression11Context *ctx) = 0;
- virtual void exitExpression11(CypherParser::Expression11Context *ctx) = 0;
-
- virtual void enterExpression10(CypherParser::Expression10Context *ctx) = 0;
- virtual void exitExpression10(CypherParser::Expression10Context *ctx) = 0;
-
- virtual void enterExpression9(CypherParser::Expression9Context *ctx) = 0;
- virtual void exitExpression9(CypherParser::Expression9Context *ctx) = 0;
-
- virtual void enterExpression8(CypherParser::Expression8Context *ctx) = 0;
- virtual void exitExpression8(CypherParser::Expression8Context *ctx) = 0;
-
- virtual void enterExpression7(CypherParser::Expression7Context *ctx) = 0;
- virtual void exitExpression7(CypherParser::Expression7Context *ctx) = 0;
-
- virtual void enterExpression6(CypherParser::Expression6Context *ctx) = 0;
- virtual void exitExpression6(CypherParser::Expression6Context *ctx) = 0;
-
- virtual void enterExpression5(CypherParser::Expression5Context *ctx) = 0;
- virtual void exitExpression5(CypherParser::Expression5Context *ctx) = 0;
-
- virtual void enterExpression4(CypherParser::Expression4Context *ctx) = 0;
- virtual void exitExpression4(CypherParser::Expression4Context *ctx) = 0;
-
- virtual void enterExpression3(CypherParser::Expression3Context *ctx) = 0;
- virtual void exitExpression3(CypherParser::Expression3Context *ctx) = 0;
-
- virtual void enterExpression2(CypherParser::Expression2Context *ctx) = 0;
- virtual void exitExpression2(CypherParser::Expression2Context *ctx) = 0;
-
- virtual void enterAtom(CypherParser::AtomContext *ctx) = 0;
- virtual void exitAtom(CypherParser::AtomContext *ctx) = 0;
-
- virtual void enterLiteral(CypherParser::LiteralContext *ctx) = 0;
- virtual void exitLiteral(CypherParser::LiteralContext *ctx) = 0;
-
- virtual void enterBooleanLiteral(CypherParser::BooleanLiteralContext *ctx) = 0;
- virtual void exitBooleanLiteral(CypherParser::BooleanLiteralContext *ctx) = 0;
-
- virtual void enterListLiteral(CypherParser::ListLiteralContext *ctx) = 0;
- virtual void exitListLiteral(CypherParser::ListLiteralContext *ctx) = 0;
-
- virtual void enterPartialComparisonExpression(CypherParser::PartialComparisonExpressionContext *ctx) = 0;
- virtual void exitPartialComparisonExpression(CypherParser::PartialComparisonExpressionContext *ctx) = 0;
-
- virtual void enterParenthesizedExpression(CypherParser::ParenthesizedExpressionContext *ctx) = 0;
- virtual void exitParenthesizedExpression(CypherParser::ParenthesizedExpressionContext *ctx) = 0;
-
- virtual void enterRelationshipsPattern(CypherParser::RelationshipsPatternContext *ctx) = 0;
- virtual void exitRelationshipsPattern(CypherParser::RelationshipsPatternContext *ctx) = 0;
-
- virtual void enterFilterExpression(CypherParser::FilterExpressionContext *ctx) = 0;
- virtual void exitFilterExpression(CypherParser::FilterExpressionContext *ctx) = 0;
-
- virtual void enterIdInColl(CypherParser::IdInCollContext *ctx) = 0;
- virtual void exitIdInColl(CypherParser::IdInCollContext *ctx) = 0;
-
- virtual void enterFunctionInvocation(CypherParser::FunctionInvocationContext *ctx) = 0;
- virtual void exitFunctionInvocation(CypherParser::FunctionInvocationContext *ctx) = 0;
-
- virtual void enterFunctionName(CypherParser::FunctionNameContext *ctx) = 0;
- virtual void exitFunctionName(CypherParser::FunctionNameContext *ctx) = 0;
-
- virtual void enterListComprehension(CypherParser::ListComprehensionContext *ctx) = 0;
- virtual void exitListComprehension(CypherParser::ListComprehensionContext *ctx) = 0;
-
- virtual void enterPatternComprehension(CypherParser::PatternComprehensionContext *ctx) = 0;
- virtual void exitPatternComprehension(CypherParser::PatternComprehensionContext *ctx) = 0;
-
- virtual void enterPropertyLookup(CypherParser::PropertyLookupContext *ctx) = 0;
- virtual void exitPropertyLookup(CypherParser::PropertyLookupContext *ctx) = 0;
-
- virtual void enterVariable(CypherParser::VariableContext *ctx) = 0;
- virtual void exitVariable(CypherParser::VariableContext *ctx) = 0;
-
- virtual void enterNumberLiteral(CypherParser::NumberLiteralContext *ctx) = 0;
- virtual void exitNumberLiteral(CypherParser::NumberLiteralContext *ctx) = 0;
-
- virtual void enterMapLiteral(CypherParser::MapLiteralContext *ctx) = 0;
- virtual void exitMapLiteral(CypherParser::MapLiteralContext *ctx) = 0;
-
- virtual void enterParameter(CypherParser::ParameterContext *ctx) = 0;
- virtual void exitParameter(CypherParser::ParameterContext *ctx) = 0;
-
- virtual void enterPropertyExpression(CypherParser::PropertyExpressionContext *ctx) = 0;
- virtual void exitPropertyExpression(CypherParser::PropertyExpressionContext *ctx) = 0;
-
- virtual void enterPropertyKeyName(CypherParser::PropertyKeyNameContext *ctx) = 0;
- virtual void exitPropertyKeyName(CypherParser::PropertyKeyNameContext *ctx) = 0;
-
- virtual void enterIntegerLiteral(CypherParser::IntegerLiteralContext *ctx) = 0;
- virtual void exitIntegerLiteral(CypherParser::IntegerLiteralContext *ctx) = 0;
-
- virtual void enterDoubleLiteral(CypherParser::DoubleLiteralContext *ctx) = 0;
- virtual void exitDoubleLiteral(CypherParser::DoubleLiteralContext *ctx) = 0;
-
- virtual void enterSymbolicName(CypherParser::SymbolicNameContext *ctx) = 0;
- virtual void exitSymbolicName(CypherParser::SymbolicNameContext *ctx) = 0;
-
- virtual void enterLeftArrowHead(CypherParser::LeftArrowHeadContext *ctx) = 0;
- virtual void exitLeftArrowHead(CypherParser::LeftArrowHeadContext *ctx) = 0;
-
- virtual void enterRightArrowHead(CypherParser::RightArrowHeadContext *ctx) = 0;
- virtual void exitRightArrowHead(CypherParser::RightArrowHeadContext *ctx) = 0;
-
- virtual void enterDash(CypherParser::DashContext *ctx) = 0;
- virtual void exitDash(CypherParser::DashContext *ctx) = 0;
-
-
-};
-
-} // namespace antlropencypher
diff --git a/src/query/frontend/opencypher/generated/CypherParser.cpp b/src/query/frontend/opencypher/generated/CypherParser.cpp
deleted file mode 100644
index 0063fc0a1..000000000
--- a/src/query/frontend/opencypher/generated/CypherParser.cpp
+++ /dev/null
@@ -1,10627 +0,0 @@
-
-// Generated from /home/mislav/code/memgraph/memgraph/src/query/frontend/opencypher/grammar/Cypher.g4 by ANTLR 4.6
-
-
-#include "CypherListener.h"
-#include "CypherVisitor.h"
-
-#include "CypherParser.h"
-
-
-using namespace antlrcpp;
-using namespace antlropencypher;
-using namespace antlr4;
-
-CypherParser::CypherParser(TokenStream *input) : Parser(input) {
- _interpreter = new atn::ParserATNSimulator(this, _atn, _decisionToDFA, _sharedContextCache);
-}
-
-CypherParser::~CypherParser() {
- delete _interpreter;
-}
-
-std::string CypherParser::getGrammarFileName() const {
- return "Cypher.g4";
-}
-
-const std::vector<std::string>& CypherParser::getRuleNames() const {
- return _ruleNames;
-}
-
-dfa::Vocabulary& CypherParser::getVocabulary() const {
- return _vocabulary;
-}
-
-
-//----------------- CypherContext ------------------------------------------------------------------
-
-CypherParser::CypherContext::CypherContext(ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {
-}
-
-CypherParser::StatementContext* CypherParser::CypherContext::statement() {
- return getRuleContext<CypherParser::StatementContext>(0);
-}
-
-std::vector<tree::TerminalNode *> CypherParser::CypherContext::SP() {
- return getTokens(CypherParser::SP);
-}
-
-tree::TerminalNode* CypherParser::CypherContext::SP(size_t i) {
- return getToken(CypherParser::SP, i);
-}
-
-
-size_t CypherParser::CypherContext::getRuleIndex() const {
- return CypherParser::RuleCypher;
-}
-
-void CypherParser::CypherContext::enterRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->enterCypher(this);
-}
-
-void CypherParser::CypherContext::exitRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->exitCypher(this);
-}
-
-
-antlrcpp::Any CypherParser::CypherContext::accept(tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
- return parserVisitor->visitCypher(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::CypherContext* CypherParser::cypher() {
- CypherContext *_localctx = _tracker.createInstance<CypherContext>(_ctx, getState());
- enterRule(_localctx, 0, CypherParser::RuleCypher);
- size_t _la = 0;
-
- auto onExit = finally([=] {
- exitRule();
- });
- try {
- enterOuterAlt(_localctx, 1);
- setState(161);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(160);
- match(CypherParser::SP);
- }
- setState(163);
- statement();
- setState(168);
- _errHandler->sync(this);
-
- switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 2, _ctx)) {
- case 1: {
- setState(165);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(164);
- match(CypherParser::SP);
- }
- setState(167);
- match(CypherParser::T__0);
- break;
- }
-
- }
- setState(171);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(170);
- match(CypherParser::SP);
- }
-
- }
- catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- StatementContext ------------------------------------------------------------------
-
-CypherParser::StatementContext::StatementContext(ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {
-}
-
-CypherParser::QueryContext* CypherParser::StatementContext::query() {
- return getRuleContext<CypherParser::QueryContext>(0);
-}
-
-
-size_t CypherParser::StatementContext::getRuleIndex() const {
- return CypherParser::RuleStatement;
-}
-
-void CypherParser::StatementContext::enterRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->enterStatement(this);
-}
-
-void CypherParser::StatementContext::exitRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->exitStatement(this);
-}
-
-
-antlrcpp::Any CypherParser::StatementContext::accept(tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
- return parserVisitor->visitStatement(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::StatementContext* CypherParser::statement() {
- StatementContext *_localctx = _tracker.createInstance<StatementContext>(_ctx, getState());
- enterRule(_localctx, 2, CypherParser::RuleStatement);
-
- auto onExit = finally([=] {
- exitRule();
- });
- try {
- enterOuterAlt(_localctx, 1);
- setState(173);
- query();
-
- }
- catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- QueryContext ------------------------------------------------------------------
-
-CypherParser::QueryContext::QueryContext(ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {
-}
-
-CypherParser::RegularQueryContext* CypherParser::QueryContext::regularQuery() {
- return getRuleContext<CypherParser::RegularQueryContext>(0);
-}
-
-
-size_t CypherParser::QueryContext::getRuleIndex() const {
- return CypherParser::RuleQuery;
-}
-
-void CypherParser::QueryContext::enterRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->enterQuery(this);
-}
-
-void CypherParser::QueryContext::exitRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->exitQuery(this);
-}
-
-
-antlrcpp::Any CypherParser::QueryContext::accept(tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
- return parserVisitor->visitQuery(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::QueryContext* CypherParser::query() {
- QueryContext *_localctx = _tracker.createInstance<QueryContext>(_ctx, getState());
- enterRule(_localctx, 4, CypherParser::RuleQuery);
-
- auto onExit = finally([=] {
- exitRule();
- });
- try {
- enterOuterAlt(_localctx, 1);
- setState(175);
- regularQuery();
-
- }
- catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- RegularQueryContext ------------------------------------------------------------------
-
-CypherParser::RegularQueryContext::RegularQueryContext(ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {
-}
-
-CypherParser::SingleQueryContext* CypherParser::RegularQueryContext::singleQuery() {
- return getRuleContext<CypherParser::SingleQueryContext>(0);
-}
-
-std::vector<CypherParser::CypherUnionContext *> CypherParser::RegularQueryContext::cypherUnion() {
- return getRuleContexts<CypherParser::CypherUnionContext>();
-}
-
-CypherParser::CypherUnionContext* CypherParser::RegularQueryContext::cypherUnion(size_t i) {
- return getRuleContext<CypherParser::CypherUnionContext>(i);
-}
-
-std::vector<tree::TerminalNode *> CypherParser::RegularQueryContext::SP() {
- return getTokens(CypherParser::SP);
-}
-
-tree::TerminalNode* CypherParser::RegularQueryContext::SP(size_t i) {
- return getToken(CypherParser::SP, i);
-}
-
-
-size_t CypherParser::RegularQueryContext::getRuleIndex() const {
- return CypherParser::RuleRegularQuery;
-}
-
-void CypherParser::RegularQueryContext::enterRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->enterRegularQuery(this);
-}
-
-void CypherParser::RegularQueryContext::exitRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->exitRegularQuery(this);
-}
-
-
-antlrcpp::Any CypherParser::RegularQueryContext::accept(tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
- return parserVisitor->visitRegularQuery(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::RegularQueryContext* CypherParser::regularQuery() {
- RegularQueryContext *_localctx = _tracker.createInstance<RegularQueryContext>(_ctx, getState());
- enterRule(_localctx, 6, CypherParser::RuleRegularQuery);
- size_t _la = 0;
-
- auto onExit = finally([=] {
- exitRule();
- });
- try {
- size_t alt;
- enterOuterAlt(_localctx, 1);
- setState(177);
- singleQuery();
- setState(184);
- _errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 5, _ctx);
- while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
- if (alt == 1) {
- setState(179);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(178);
- match(CypherParser::SP);
- }
- setState(181);
- cypherUnion();
- }
- setState(186);
- _errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 5, _ctx);
- }
-
- }
- catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- SingleQueryContext ------------------------------------------------------------------
-
-CypherParser::SingleQueryContext::SingleQueryContext(ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {
-}
-
-std::vector<CypherParser::ClauseContext *> CypherParser::SingleQueryContext::clause() {
- return getRuleContexts<CypherParser::ClauseContext>();
-}
-
-CypherParser::ClauseContext* CypherParser::SingleQueryContext::clause(size_t i) {
- return getRuleContext<CypherParser::ClauseContext>(i);
-}
-
-std::vector<tree::TerminalNode *> CypherParser::SingleQueryContext::SP() {
- return getTokens(CypherParser::SP);
-}
-
-tree::TerminalNode* CypherParser::SingleQueryContext::SP(size_t i) {
- return getToken(CypherParser::SP, i);
-}
-
-
-size_t CypherParser::SingleQueryContext::getRuleIndex() const {
- return CypherParser::RuleSingleQuery;
-}
-
-void CypherParser::SingleQueryContext::enterRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->enterSingleQuery(this);
-}
-
-void CypherParser::SingleQueryContext::exitRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->exitSingleQuery(this);
-}
-
-
-antlrcpp::Any CypherParser::SingleQueryContext::accept(tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
- return parserVisitor->visitSingleQuery(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::SingleQueryContext* CypherParser::singleQuery() {
- SingleQueryContext *_localctx = _tracker.createInstance<SingleQueryContext>(_ctx, getState());
- enterRule(_localctx, 8, CypherParser::RuleSingleQuery);
- size_t _la = 0;
-
- auto onExit = finally([=] {
- exitRule();
- });
- try {
- size_t alt;
- enterOuterAlt(_localctx, 1);
- setState(187);
- clause();
- setState(194);
- _errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 7, _ctx);
- while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
- if (alt == 1) {
- setState(189);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(188);
- match(CypherParser::SP);
- }
- setState(191);
- clause();
- }
- setState(196);
- _errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 7, _ctx);
- }
-
- }
- catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- CypherUnionContext ------------------------------------------------------------------
-
-CypherParser::CypherUnionContext::CypherUnionContext(ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {
-}
-
-tree::TerminalNode* CypherParser::CypherUnionContext::UNION() {
- return getToken(CypherParser::UNION, 0);
-}
-
-std::vector<tree::TerminalNode *> CypherParser::CypherUnionContext::SP() {
- return getTokens(CypherParser::SP);
-}
-
-tree::TerminalNode* CypherParser::CypherUnionContext::SP(size_t i) {
- return getToken(CypherParser::SP, i);
-}
-
-tree::TerminalNode* CypherParser::CypherUnionContext::ALL() {
- return getToken(CypherParser::ALL, 0);
-}
-
-CypherParser::SingleQueryContext* CypherParser::CypherUnionContext::singleQuery() {
- return getRuleContext<CypherParser::SingleQueryContext>(0);
-}
-
-
-size_t CypherParser::CypherUnionContext::getRuleIndex() const {
- return CypherParser::RuleCypherUnion;
-}
-
-void CypherParser::CypherUnionContext::enterRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->enterCypherUnion(this);
-}
-
-void CypherParser::CypherUnionContext::exitRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->exitCypherUnion(this);
-}
-
-
-antlrcpp::Any CypherParser::CypherUnionContext::accept(tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
- return parserVisitor->visitCypherUnion(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::CypherUnionContext* CypherParser::cypherUnion() {
- CypherUnionContext *_localctx = _tracker.createInstance<CypherUnionContext>(_ctx, getState());
- enterRule(_localctx, 10, CypherParser::RuleCypherUnion);
- size_t _la = 0;
-
- auto onExit = finally([=] {
- exitRule();
- });
- try {
- setState(209);
- _errHandler->sync(this);
- switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 10, _ctx)) {
- case 1: {
- enterOuterAlt(_localctx, 1);
- setState(197);
- match(CypherParser::UNION);
- setState(198);
- match(CypherParser::SP);
- setState(199);
- match(CypherParser::ALL);
- setState(201);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(200);
- match(CypherParser::SP);
- }
- setState(203);
- singleQuery();
- break;
- }
-
- case 2: {
- enterOuterAlt(_localctx, 2);
- setState(204);
- match(CypherParser::UNION);
- setState(206);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(205);
- match(CypherParser::SP);
- }
- setState(208);
- singleQuery();
- break;
- }
-
- }
-
- }
- catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- ClauseContext ------------------------------------------------------------------
-
-CypherParser::ClauseContext::ClauseContext(ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {
-}
-
-CypherParser::CypherMatchContext* CypherParser::ClauseContext::cypherMatch() {
- return getRuleContext<CypherParser::CypherMatchContext>(0);
-}
-
-CypherParser::UnwindContext* CypherParser::ClauseContext::unwind() {
- return getRuleContext<CypherParser::UnwindContext>(0);
-}
-
-CypherParser::MergeContext* CypherParser::ClauseContext::merge() {
- return getRuleContext<CypherParser::MergeContext>(0);
-}
-
-CypherParser::CreateContext* CypherParser::ClauseContext::create() {
- return getRuleContext<CypherParser::CreateContext>(0);
-}
-
-CypherParser::SetContext* CypherParser::ClauseContext::set() {
- return getRuleContext<CypherParser::SetContext>(0);
-}
-
-CypherParser::CypherDeleteContext* CypherParser::ClauseContext::cypherDelete() {
- return getRuleContext<CypherParser::CypherDeleteContext>(0);
-}
-
-CypherParser::RemoveContext* CypherParser::ClauseContext::remove() {
- return getRuleContext<CypherParser::RemoveContext>(0);
-}
-
-CypherParser::WithContext* CypherParser::ClauseContext::with() {
- return getRuleContext<CypherParser::WithContext>(0);
-}
-
-CypherParser::CypherReturnContext* CypherParser::ClauseContext::cypherReturn() {
- return getRuleContext<CypherParser::CypherReturnContext>(0);
-}
-
-
-size_t CypherParser::ClauseContext::getRuleIndex() const {
- return CypherParser::RuleClause;
-}
-
-void CypherParser::ClauseContext::enterRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->enterClause(this);
-}
-
-void CypherParser::ClauseContext::exitRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->exitClause(this);
-}
-
-
-antlrcpp::Any CypherParser::ClauseContext::accept(tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
- return parserVisitor->visitClause(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::ClauseContext* CypherParser::clause() {
- ClauseContext *_localctx = _tracker.createInstance<ClauseContext>(_ctx, getState());
- enterRule(_localctx, 12, CypherParser::RuleClause);
-
- auto onExit = finally([=] {
- exitRule();
- });
- try {
- setState(220);
- _errHandler->sync(this);
- switch (_input->LA(1)) {
- case CypherParser::OPTIONAL:
- case CypherParser::MATCH: {
- enterOuterAlt(_localctx, 1);
- setState(211);
- cypherMatch();
- break;
- }
-
- case CypherParser::UNWIND: {
- enterOuterAlt(_localctx, 2);
- setState(212);
- unwind();
- break;
- }
-
- case CypherParser::MERGE: {
- enterOuterAlt(_localctx, 3);
- setState(213);
- merge();
- break;
- }
-
- case CypherParser::CREATE: {
- enterOuterAlt(_localctx, 4);
- setState(214);
- create();
- break;
- }
-
- case CypherParser::SET: {
- enterOuterAlt(_localctx, 5);
- setState(215);
- set();
- break;
- }
-
- case CypherParser::DETACH:
- case CypherParser::DELETE: {
- enterOuterAlt(_localctx, 6);
- setState(216);
- cypherDelete();
- break;
- }
-
- case CypherParser::REMOVE: {
- enterOuterAlt(_localctx, 7);
- setState(217);
- remove();
- break;
- }
-
- case CypherParser::WITH: {
- enterOuterAlt(_localctx, 8);
- setState(218);
- with();
- break;
- }
-
- case CypherParser::RETURN: {
- enterOuterAlt(_localctx, 9);
- setState(219);
- cypherReturn();
- break;
- }
-
- default:
- throw NoViableAltException(this);
- }
-
- }
- catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- CypherMatchContext ------------------------------------------------------------------
-
-CypherParser::CypherMatchContext::CypherMatchContext(ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {
-}
-
-tree::TerminalNode* CypherParser::CypherMatchContext::MATCH() {
- return getToken(CypherParser::MATCH, 0);
-}
-
-CypherParser::PatternContext* CypherParser::CypherMatchContext::pattern() {
- return getRuleContext<CypherParser::PatternContext>(0);
-}
-
-tree::TerminalNode* CypherParser::CypherMatchContext::OPTIONAL() {
- return getToken(CypherParser::OPTIONAL, 0);
-}
-
-std::vector<tree::TerminalNode *> CypherParser::CypherMatchContext::SP() {
- return getTokens(CypherParser::SP);
-}
-
-tree::TerminalNode* CypherParser::CypherMatchContext::SP(size_t i) {
- return getToken(CypherParser::SP, i);
-}
-
-CypherParser::WhereContext* CypherParser::CypherMatchContext::where() {
- return getRuleContext<CypherParser::WhereContext>(0);
-}
-
-
-size_t CypherParser::CypherMatchContext::getRuleIndex() const {
- return CypherParser::RuleCypherMatch;
-}
-
-void CypherParser::CypherMatchContext::enterRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->enterCypherMatch(this);
-}
-
-void CypherParser::CypherMatchContext::exitRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->exitCypherMatch(this);
-}
-
-
-antlrcpp::Any CypherParser::CypherMatchContext::accept(tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
- return parserVisitor->visitCypherMatch(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::CypherMatchContext* CypherParser::cypherMatch() {
- CypherMatchContext *_localctx = _tracker.createInstance<CypherMatchContext>(_ctx, getState());
- enterRule(_localctx, 14, CypherParser::RuleCypherMatch);
- size_t _la = 0;
-
- auto onExit = finally([=] {
- exitRule();
- });
- try {
- enterOuterAlt(_localctx, 1);
- setState(224);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::OPTIONAL) {
- setState(222);
- match(CypherParser::OPTIONAL);
- setState(223);
- match(CypherParser::SP);
- }
- setState(226);
- match(CypherParser::MATCH);
- setState(228);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(227);
- match(CypherParser::SP);
- }
- setState(230);
- pattern();
- setState(235);
- _errHandler->sync(this);
-
- switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 15, _ctx)) {
- case 1: {
- setState(232);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(231);
- match(CypherParser::SP);
- }
- setState(234);
- where();
- break;
- }
-
- }
-
- }
- catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- UnwindContext ------------------------------------------------------------------
-
-CypherParser::UnwindContext::UnwindContext(ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {
-}
-
-tree::TerminalNode* CypherParser::UnwindContext::UNWIND() {
- return getToken(CypherParser::UNWIND, 0);
-}
-
-CypherParser::ExpressionContext* CypherParser::UnwindContext::expression() {
- return getRuleContext<CypherParser::ExpressionContext>(0);
-}
-
-std::vector<tree::TerminalNode *> CypherParser::UnwindContext::SP() {
- return getTokens(CypherParser::SP);
-}
-
-tree::TerminalNode* CypherParser::UnwindContext::SP(size_t i) {
- return getToken(CypherParser::SP, i);
-}
-
-tree::TerminalNode* CypherParser::UnwindContext::AS() {
- return getToken(CypherParser::AS, 0);
-}
-
-CypherParser::VariableContext* CypherParser::UnwindContext::variable() {
- return getRuleContext<CypherParser::VariableContext>(0);
-}
-
-
-size_t CypherParser::UnwindContext::getRuleIndex() const {
- return CypherParser::RuleUnwind;
-}
-
-void CypherParser::UnwindContext::enterRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->enterUnwind(this);
-}
-
-void CypherParser::UnwindContext::exitRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->exitUnwind(this);
-}
-
-
-antlrcpp::Any CypherParser::UnwindContext::accept(tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
- return parserVisitor->visitUnwind(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::UnwindContext* CypherParser::unwind() {
- UnwindContext *_localctx = _tracker.createInstance<UnwindContext>(_ctx, getState());
- enterRule(_localctx, 16, CypherParser::RuleUnwind);
- size_t _la = 0;
-
- auto onExit = finally([=] {
- exitRule();
- });
- try {
- enterOuterAlt(_localctx, 1);
- setState(237);
- match(CypherParser::UNWIND);
- setState(239);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(238);
- match(CypherParser::SP);
- }
- setState(241);
- expression();
- setState(242);
- match(CypherParser::SP);
- setState(243);
- match(CypherParser::AS);
- setState(244);
- match(CypherParser::SP);
- setState(245);
- variable();
-
- }
- catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- MergeContext ------------------------------------------------------------------
-
-CypherParser::MergeContext::MergeContext(ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {
-}
-
-tree::TerminalNode* CypherParser::MergeContext::MERGE() {
- return getToken(CypherParser::MERGE, 0);
-}
-
-CypherParser::PatternPartContext* CypherParser::MergeContext::patternPart() {
- return getRuleContext<CypherParser::PatternPartContext>(0);
-}
-
-std::vector<tree::TerminalNode *> CypherParser::MergeContext::SP() {
- return getTokens(CypherParser::SP);
-}
-
-tree::TerminalNode* CypherParser::MergeContext::SP(size_t i) {
- return getToken(CypherParser::SP, i);
-}
-
-std::vector<CypherParser::MergeActionContext *> CypherParser::MergeContext::mergeAction() {
- return getRuleContexts<CypherParser::MergeActionContext>();
-}
-
-CypherParser::MergeActionContext* CypherParser::MergeContext::mergeAction(size_t i) {
- return getRuleContext<CypherParser::MergeActionContext>(i);
-}
-
-
-size_t CypherParser::MergeContext::getRuleIndex() const {
- return CypherParser::RuleMerge;
-}
-
-void CypherParser::MergeContext::enterRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->enterMerge(this);
-}
-
-void CypherParser::MergeContext::exitRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->exitMerge(this);
-}
-
-
-antlrcpp::Any CypherParser::MergeContext::accept(tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
- return parserVisitor->visitMerge(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::MergeContext* CypherParser::merge() {
- MergeContext *_localctx = _tracker.createInstance<MergeContext>(_ctx, getState());
- enterRule(_localctx, 18, CypherParser::RuleMerge);
- size_t _la = 0;
-
- auto onExit = finally([=] {
- exitRule();
- });
- try {
- size_t alt;
- enterOuterAlt(_localctx, 1);
- setState(247);
- match(CypherParser::MERGE);
- setState(249);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(248);
- match(CypherParser::SP);
- }
- setState(251);
- patternPart();
- setState(256);
- _errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 18, _ctx);
- while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
- if (alt == 1) {
- setState(252);
- match(CypherParser::SP);
- setState(253);
- mergeAction();
- }
- setState(258);
- _errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 18, _ctx);
- }
-
- }
- catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- MergeActionContext ------------------------------------------------------------------
-
-CypherParser::MergeActionContext::MergeActionContext(ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {
-}
-
-tree::TerminalNode* CypherParser::MergeActionContext::ON() {
- return getToken(CypherParser::ON, 0);
-}
-
-std::vector<tree::TerminalNode *> CypherParser::MergeActionContext::SP() {
- return getTokens(CypherParser::SP);
-}
-
-tree::TerminalNode* CypherParser::MergeActionContext::SP(size_t i) {
- return getToken(CypherParser::SP, i);
-}
-
-tree::TerminalNode* CypherParser::MergeActionContext::MATCH() {
- return getToken(CypherParser::MATCH, 0);
-}
-
-CypherParser::SetContext* CypherParser::MergeActionContext::set() {
- return getRuleContext<CypherParser::SetContext>(0);
-}
-
-tree::TerminalNode* CypherParser::MergeActionContext::CREATE() {
- return getToken(CypherParser::CREATE, 0);
-}
-
-
-size_t CypherParser::MergeActionContext::getRuleIndex() const {
- return CypherParser::RuleMergeAction;
-}
-
-void CypherParser::MergeActionContext::enterRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->enterMergeAction(this);
-}
-
-void CypherParser::MergeActionContext::exitRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->exitMergeAction(this);
-}
-
-
-antlrcpp::Any CypherParser::MergeActionContext::accept(tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
- return parserVisitor->visitMergeAction(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::MergeActionContext* CypherParser::mergeAction() {
- MergeActionContext *_localctx = _tracker.createInstance<MergeActionContext>(_ctx, getState());
- enterRule(_localctx, 20, CypherParser::RuleMergeAction);
-
- auto onExit = finally([=] {
- exitRule();
- });
- try {
- setState(269);
- _errHandler->sync(this);
- switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 19, _ctx)) {
- case 1: {
- enterOuterAlt(_localctx, 1);
- setState(259);
- match(CypherParser::ON);
- setState(260);
- match(CypherParser::SP);
- setState(261);
- match(CypherParser::MATCH);
- setState(262);
- match(CypherParser::SP);
- setState(263);
- set();
- break;
- }
-
- case 2: {
- enterOuterAlt(_localctx, 2);
- setState(264);
- match(CypherParser::ON);
- setState(265);
- match(CypherParser::SP);
- setState(266);
- match(CypherParser::CREATE);
- setState(267);
- match(CypherParser::SP);
- setState(268);
- set();
- break;
- }
-
- }
-
- }
- catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- CreateContext ------------------------------------------------------------------
-
-CypherParser::CreateContext::CreateContext(ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {
-}
-
-tree::TerminalNode* CypherParser::CreateContext::CREATE() {
- return getToken(CypherParser::CREATE, 0);
-}
-
-CypherParser::PatternContext* CypherParser::CreateContext::pattern() {
- return getRuleContext<CypherParser::PatternContext>(0);
-}
-
-tree::TerminalNode* CypherParser::CreateContext::SP() {
- return getToken(CypherParser::SP, 0);
-}
-
-
-size_t CypherParser::CreateContext::getRuleIndex() const {
- return CypherParser::RuleCreate;
-}
-
-void CypherParser::CreateContext::enterRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->enterCreate(this);
-}
-
-void CypherParser::CreateContext::exitRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->exitCreate(this);
-}
-
-
-antlrcpp::Any CypherParser::CreateContext::accept(tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
- return parserVisitor->visitCreate(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::CreateContext* CypherParser::create() {
- CreateContext *_localctx = _tracker.createInstance<CreateContext>(_ctx, getState());
- enterRule(_localctx, 22, CypherParser::RuleCreate);
- size_t _la = 0;
-
- auto onExit = finally([=] {
- exitRule();
- });
- try {
- enterOuterAlt(_localctx, 1);
- setState(271);
- match(CypherParser::CREATE);
- setState(273);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(272);
- match(CypherParser::SP);
- }
- setState(275);
- pattern();
-
- }
- catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- SetContext ------------------------------------------------------------------
-
-CypherParser::SetContext::SetContext(ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {
-}
-
-tree::TerminalNode* CypherParser::SetContext::SET() {
- return getToken(CypherParser::SET, 0);
-}
-
-std::vector<CypherParser::SetItemContext *> CypherParser::SetContext::setItem() {
- return getRuleContexts<CypherParser::SetItemContext>();
-}
-
-CypherParser::SetItemContext* CypherParser::SetContext::setItem(size_t i) {
- return getRuleContext<CypherParser::SetItemContext>(i);
-}
-
-tree::TerminalNode* CypherParser::SetContext::SP() {
- return getToken(CypherParser::SP, 0);
-}
-
-
-size_t CypherParser::SetContext::getRuleIndex() const {
- return CypherParser::RuleSet;
-}
-
-void CypherParser::SetContext::enterRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->enterSet(this);
-}
-
-void CypherParser::SetContext::exitRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->exitSet(this);
-}
-
-
-antlrcpp::Any CypherParser::SetContext::accept(tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
- return parserVisitor->visitSet(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::SetContext* CypherParser::set() {
- SetContext *_localctx = _tracker.createInstance<SetContext>(_ctx, getState());
- enterRule(_localctx, 24, CypherParser::RuleSet);
- size_t _la = 0;
-
- auto onExit = finally([=] {
- exitRule();
- });
- try {
- enterOuterAlt(_localctx, 1);
- setState(277);
- match(CypherParser::SET);
- setState(279);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(278);
- match(CypherParser::SP);
- }
- setState(281);
- setItem();
- setState(286);
- _errHandler->sync(this);
- _la = _input->LA(1);
- while (_la == CypherParser::T__1) {
- setState(282);
- match(CypherParser::T__1);
- setState(283);
- setItem();
- setState(288);
- _errHandler->sync(this);
- _la = _input->LA(1);
- }
-
- }
- catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- SetItemContext ------------------------------------------------------------------
-
-CypherParser::SetItemContext::SetItemContext(ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {
-}
-
-CypherParser::PropertyExpressionContext* CypherParser::SetItemContext::propertyExpression() {
- return getRuleContext<CypherParser::PropertyExpressionContext>(0);
-}
-
-CypherParser::ExpressionContext* CypherParser::SetItemContext::expression() {
- return getRuleContext<CypherParser::ExpressionContext>(0);
-}
-
-std::vector<tree::TerminalNode *> CypherParser::SetItemContext::SP() {
- return getTokens(CypherParser::SP);
-}
-
-tree::TerminalNode* CypherParser::SetItemContext::SP(size_t i) {
- return getToken(CypherParser::SP, i);
-}
-
-CypherParser::VariableContext* CypherParser::SetItemContext::variable() {
- return getRuleContext<CypherParser::VariableContext>(0);
-}
-
-CypherParser::NodeLabelsContext* CypherParser::SetItemContext::nodeLabels() {
- return getRuleContext<CypherParser::NodeLabelsContext>(0);
-}
-
-
-size_t CypherParser::SetItemContext::getRuleIndex() const {
- return CypherParser::RuleSetItem;
-}
-
-void CypherParser::SetItemContext::enterRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->enterSetItem(this);
-}
-
-void CypherParser::SetItemContext::exitRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->exitSetItem(this);
-}
-
-
-antlrcpp::Any CypherParser::SetItemContext::accept(tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
- return parserVisitor->visitSetItem(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::SetItemContext* CypherParser::setItem() {
- SetItemContext *_localctx = _tracker.createInstance<SetItemContext>(_ctx, getState());
- enterRule(_localctx, 26, CypherParser::RuleSetItem);
- size_t _la = 0;
-
- auto onExit = finally([=] {
- exitRule();
- });
- try {
- setState(325);
- _errHandler->sync(this);
- switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 30, _ctx)) {
- case 1: {
- enterOuterAlt(_localctx, 1);
- setState(289);
- propertyExpression();
- setState(291);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(290);
- match(CypherParser::SP);
- }
- setState(293);
- match(CypherParser::T__2);
- setState(295);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(294);
- match(CypherParser::SP);
- }
- setState(297);
- expression();
- break;
- }
-
- case 2: {
- enterOuterAlt(_localctx, 2);
- setState(299);
- variable();
- setState(301);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(300);
- match(CypherParser::SP);
- }
- setState(303);
- match(CypherParser::T__2);
- setState(305);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(304);
- match(CypherParser::SP);
- }
- setState(307);
- expression();
- break;
- }
-
- case 3: {
- enterOuterAlt(_localctx, 3);
- setState(309);
- variable();
- setState(311);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(310);
- match(CypherParser::SP);
- }
- setState(313);
- match(CypherParser::T__3);
- setState(315);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(314);
- match(CypherParser::SP);
- }
- setState(317);
- expression();
- break;
- }
-
- case 4: {
- enterOuterAlt(_localctx, 4);
- setState(319);
- variable();
- setState(321);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(320);
- match(CypherParser::SP);
- }
- setState(323);
- nodeLabels();
- break;
- }
-
- }
-
- }
- catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- CypherDeleteContext ------------------------------------------------------------------
-
-CypherParser::CypherDeleteContext::CypherDeleteContext(ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {
-}
-
-tree::TerminalNode* CypherParser::CypherDeleteContext::DELETE() {
- return getToken(CypherParser::DELETE, 0);
-}
-
-std::vector<CypherParser::ExpressionContext *> CypherParser::CypherDeleteContext::expression() {
- return getRuleContexts<CypherParser::ExpressionContext>();
-}
-
-CypherParser::ExpressionContext* CypherParser::CypherDeleteContext::expression(size_t i) {
- return getRuleContext<CypherParser::ExpressionContext>(i);
-}
-
-tree::TerminalNode* CypherParser::CypherDeleteContext::DETACH() {
- return getToken(CypherParser::DETACH, 0);
-}
-
-std::vector<tree::TerminalNode *> CypherParser::CypherDeleteContext::SP() {
- return getTokens(CypherParser::SP);
-}
-
-tree::TerminalNode* CypherParser::CypherDeleteContext::SP(size_t i) {
- return getToken(CypherParser::SP, i);
-}
-
-
-size_t CypherParser::CypherDeleteContext::getRuleIndex() const {
- return CypherParser::RuleCypherDelete;
-}
-
-void CypherParser::CypherDeleteContext::enterRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->enterCypherDelete(this);
-}
-
-void CypherParser::CypherDeleteContext::exitRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->exitCypherDelete(this);
-}
-
-
-antlrcpp::Any CypherParser::CypherDeleteContext::accept(tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
- return parserVisitor->visitCypherDelete(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::CypherDeleteContext* CypherParser::cypherDelete() {
- CypherDeleteContext *_localctx = _tracker.createInstance<CypherDeleteContext>(_ctx, getState());
- enterRule(_localctx, 28, CypherParser::RuleCypherDelete);
- size_t _la = 0;
-
- auto onExit = finally([=] {
- exitRule();
- });
- try {
- size_t alt;
- enterOuterAlt(_localctx, 1);
- setState(329);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::DETACH) {
- setState(327);
- match(CypherParser::DETACH);
- setState(328);
- match(CypherParser::SP);
- }
- setState(331);
- match(CypherParser::DELETE);
- setState(333);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(332);
- match(CypherParser::SP);
- }
- setState(335);
- expression();
- setState(346);
- _errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 35, _ctx);
- while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
- if (alt == 1) {
- setState(337);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(336);
- match(CypherParser::SP);
- }
- setState(339);
- match(CypherParser::T__1);
- setState(341);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(340);
- match(CypherParser::SP);
- }
- setState(343);
- expression();
- }
- setState(348);
- _errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 35, _ctx);
- }
-
- }
- catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- RemoveContext ------------------------------------------------------------------
-
-CypherParser::RemoveContext::RemoveContext(ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {
-}
-
-tree::TerminalNode* CypherParser::RemoveContext::REMOVE() {
- return getToken(CypherParser::REMOVE, 0);
-}
-
-std::vector<tree::TerminalNode *> CypherParser::RemoveContext::SP() {
- return getTokens(CypherParser::SP);
-}
-
-tree::TerminalNode* CypherParser::RemoveContext::SP(size_t i) {
- return getToken(CypherParser::SP, i);
-}
-
-std::vector<CypherParser::RemoveItemContext *> CypherParser::RemoveContext::removeItem() {
- return getRuleContexts<CypherParser::RemoveItemContext>();
-}
-
-CypherParser::RemoveItemContext* CypherParser::RemoveContext::removeItem(size_t i) {
- return getRuleContext<CypherParser::RemoveItemContext>(i);
-}
-
-
-size_t CypherParser::RemoveContext::getRuleIndex() const {
- return CypherParser::RuleRemove;
-}
-
-void CypherParser::RemoveContext::enterRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->enterRemove(this);
-}
-
-void CypherParser::RemoveContext::exitRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->exitRemove(this);
-}
-
-
-antlrcpp::Any CypherParser::RemoveContext::accept(tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
- return parserVisitor->visitRemove(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::RemoveContext* CypherParser::remove() {
- RemoveContext *_localctx = _tracker.createInstance<RemoveContext>(_ctx, getState());
- enterRule(_localctx, 30, CypherParser::RuleRemove);
- size_t _la = 0;
-
- auto onExit = finally([=] {
- exitRule();
- });
- try {
- size_t alt;
- enterOuterAlt(_localctx, 1);
- setState(349);
- match(CypherParser::REMOVE);
- setState(350);
- match(CypherParser::SP);
- setState(351);
- removeItem();
- setState(362);
- _errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 38, _ctx);
- while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
- if (alt == 1) {
- setState(353);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(352);
- match(CypherParser::SP);
- }
- setState(355);
- match(CypherParser::T__1);
- setState(357);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(356);
- match(CypherParser::SP);
- }
- setState(359);
- removeItem();
- }
- setState(364);
- _errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 38, _ctx);
- }
-
- }
- catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- RemoveItemContext ------------------------------------------------------------------
-
-CypherParser::RemoveItemContext::RemoveItemContext(ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {
-}
-
-CypherParser::VariableContext* CypherParser::RemoveItemContext::variable() {
- return getRuleContext<CypherParser::VariableContext>(0);
-}
-
-CypherParser::NodeLabelsContext* CypherParser::RemoveItemContext::nodeLabels() {
- return getRuleContext<CypherParser::NodeLabelsContext>(0);
-}
-
-CypherParser::PropertyExpressionContext* CypherParser::RemoveItemContext::propertyExpression() {
- return getRuleContext<CypherParser::PropertyExpressionContext>(0);
-}
-
-
-size_t CypherParser::RemoveItemContext::getRuleIndex() const {
- return CypherParser::RuleRemoveItem;
-}
-
-void CypherParser::RemoveItemContext::enterRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->enterRemoveItem(this);
-}
-
-void CypherParser::RemoveItemContext::exitRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->exitRemoveItem(this);
-}
-
-
-antlrcpp::Any CypherParser::RemoveItemContext::accept(tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
- return parserVisitor->visitRemoveItem(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::RemoveItemContext* CypherParser::removeItem() {
- RemoveItemContext *_localctx = _tracker.createInstance<RemoveItemContext>(_ctx, getState());
- enterRule(_localctx, 32, CypherParser::RuleRemoveItem);
-
- auto onExit = finally([=] {
- exitRule();
- });
- try {
- setState(369);
- _errHandler->sync(this);
- switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 39, _ctx)) {
- case 1: {
- enterOuterAlt(_localctx, 1);
- setState(365);
- variable();
- setState(366);
- nodeLabels();
- break;
- }
-
- case 2: {
- enterOuterAlt(_localctx, 2);
- setState(368);
- propertyExpression();
- break;
- }
-
- }
-
- }
- catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- WithContext ------------------------------------------------------------------
-
-CypherParser::WithContext::WithContext(ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {
-}
-
-tree::TerminalNode* CypherParser::WithContext::WITH() {
- return getToken(CypherParser::WITH, 0);
-}
-
-std::vector<tree::TerminalNode *> CypherParser::WithContext::SP() {
- return getTokens(CypherParser::SP);
-}
-
-tree::TerminalNode* CypherParser::WithContext::SP(size_t i) {
- return getToken(CypherParser::SP, i);
-}
-
-CypherParser::ReturnBodyContext* CypherParser::WithContext::returnBody() {
- return getRuleContext<CypherParser::ReturnBodyContext>(0);
-}
-
-tree::TerminalNode* CypherParser::WithContext::DISTINCT() {
- return getToken(CypherParser::DISTINCT, 0);
-}
-
-CypherParser::WhereContext* CypherParser::WithContext::where() {
- return getRuleContext<CypherParser::WhereContext>(0);
-}
-
-
-size_t CypherParser::WithContext::getRuleIndex() const {
- return CypherParser::RuleWith;
-}
-
-void CypherParser::WithContext::enterRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->enterWith(this);
-}
-
-void CypherParser::WithContext::exitRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->exitWith(this);
-}
-
-
-antlrcpp::Any CypherParser::WithContext::accept(tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
- return parserVisitor->visitWith(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::WithContext* CypherParser::with() {
- WithContext *_localctx = _tracker.createInstance<WithContext>(_ctx, getState());
- enterRule(_localctx, 34, CypherParser::RuleWith);
- size_t _la = 0;
-
- auto onExit = finally([=] {
- exitRule();
- });
- try {
- enterOuterAlt(_localctx, 1);
- setState(371);
- match(CypherParser::WITH);
- setState(376);
- _errHandler->sync(this);
-
- switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 41, _ctx)) {
- case 1: {
- setState(373);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(372);
- match(CypherParser::SP);
- }
- setState(375);
- match(CypherParser::DISTINCT);
- break;
- }
-
- }
- setState(378);
- match(CypherParser::SP);
- setState(379);
- returnBody();
- setState(384);
- _errHandler->sync(this);
-
- switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 43, _ctx)) {
- case 1: {
- setState(381);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(380);
- match(CypherParser::SP);
- }
- setState(383);
- where();
- break;
- }
-
- }
-
- }
- catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- CypherReturnContext ------------------------------------------------------------------
-
-CypherParser::CypherReturnContext::CypherReturnContext(ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {
-}
-
-tree::TerminalNode* CypherParser::CypherReturnContext::RETURN() {
- return getToken(CypherParser::RETURN, 0);
-}
-
-std::vector<tree::TerminalNode *> CypherParser::CypherReturnContext::SP() {
- return getTokens(CypherParser::SP);
-}
-
-tree::TerminalNode* CypherParser::CypherReturnContext::SP(size_t i) {
- return getToken(CypherParser::SP, i);
-}
-
-CypherParser::ReturnBodyContext* CypherParser::CypherReturnContext::returnBody() {
- return getRuleContext<CypherParser::ReturnBodyContext>(0);
-}
-
-tree::TerminalNode* CypherParser::CypherReturnContext::DISTINCT() {
- return getToken(CypherParser::DISTINCT, 0);
-}
-
-
-size_t CypherParser::CypherReturnContext::getRuleIndex() const {
- return CypherParser::RuleCypherReturn;
-}
-
-void CypherParser::CypherReturnContext::enterRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->enterCypherReturn(this);
-}
-
-void CypherParser::CypherReturnContext::exitRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->exitCypherReturn(this);
-}
-
-
-antlrcpp::Any CypherParser::CypherReturnContext::accept(tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
- return parserVisitor->visitCypherReturn(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::CypherReturnContext* CypherParser::cypherReturn() {
- CypherReturnContext *_localctx = _tracker.createInstance<CypherReturnContext>(_ctx, getState());
- enterRule(_localctx, 36, CypherParser::RuleCypherReturn);
- size_t _la = 0;
-
- auto onExit = finally([=] {
- exitRule();
- });
- try {
- enterOuterAlt(_localctx, 1);
- setState(386);
- match(CypherParser::RETURN);
- setState(391);
- _errHandler->sync(this);
-
- switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 45, _ctx)) {
- case 1: {
- setState(388);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(387);
- match(CypherParser::SP);
- }
- setState(390);
- match(CypherParser::DISTINCT);
- break;
- }
-
- }
- setState(393);
- match(CypherParser::SP);
- setState(394);
- returnBody();
-
- }
- catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- ReturnBodyContext ------------------------------------------------------------------
-
-CypherParser::ReturnBodyContext::ReturnBodyContext(ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {
-}
-
-CypherParser::ReturnItemsContext* CypherParser::ReturnBodyContext::returnItems() {
- return getRuleContext<CypherParser::ReturnItemsContext>(0);
-}
-
-std::vector<tree::TerminalNode *> CypherParser::ReturnBodyContext::SP() {
- return getTokens(CypherParser::SP);
-}
-
-tree::TerminalNode* CypherParser::ReturnBodyContext::SP(size_t i) {
- return getToken(CypherParser::SP, i);
-}
-
-CypherParser::OrderContext* CypherParser::ReturnBodyContext::order() {
- return getRuleContext<CypherParser::OrderContext>(0);
-}
-
-CypherParser::SkipContext* CypherParser::ReturnBodyContext::skip() {
- return getRuleContext<CypherParser::SkipContext>(0);
-}
-
-CypherParser::LimitContext* CypherParser::ReturnBodyContext::limit() {
- return getRuleContext<CypherParser::LimitContext>(0);
-}
-
-
-size_t CypherParser::ReturnBodyContext::getRuleIndex() const {
- return CypherParser::RuleReturnBody;
-}
-
-void CypherParser::ReturnBodyContext::enterRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->enterReturnBody(this);
-}
-
-void CypherParser::ReturnBodyContext::exitRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->exitReturnBody(this);
-}
-
-
-antlrcpp::Any CypherParser::ReturnBodyContext::accept(tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
- return parserVisitor->visitReturnBody(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::ReturnBodyContext* CypherParser::returnBody() {
- ReturnBodyContext *_localctx = _tracker.createInstance<ReturnBodyContext>(_ctx, getState());
- enterRule(_localctx, 38, CypherParser::RuleReturnBody);
-
- auto onExit = finally([=] {
- exitRule();
- });
- try {
- enterOuterAlt(_localctx, 1);
- setState(396);
- returnItems();
- setState(399);
- _errHandler->sync(this);
-
- switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 46, _ctx)) {
- case 1: {
- setState(397);
- match(CypherParser::SP);
- setState(398);
- order();
- break;
- }
-
- }
- setState(403);
- _errHandler->sync(this);
-
- switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 47, _ctx)) {
- case 1: {
- setState(401);
- match(CypherParser::SP);
- setState(402);
- skip();
- break;
- }
-
- }
- setState(407);
- _errHandler->sync(this);
-
- switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 48, _ctx)) {
- case 1: {
- setState(405);
- match(CypherParser::SP);
- setState(406);
- limit();
- break;
- }
-
- }
-
- }
- catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- ReturnItemsContext ------------------------------------------------------------------
-
-CypherParser::ReturnItemsContext::ReturnItemsContext(ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {
-}
-
-std::vector<CypherParser::ReturnItemContext *> CypherParser::ReturnItemsContext::returnItem() {
- return getRuleContexts<CypherParser::ReturnItemContext>();
-}
-
-CypherParser::ReturnItemContext* CypherParser::ReturnItemsContext::returnItem(size_t i) {
- return getRuleContext<CypherParser::ReturnItemContext>(i);
-}
-
-std::vector<tree::TerminalNode *> CypherParser::ReturnItemsContext::SP() {
- return getTokens(CypherParser::SP);
-}
-
-tree::TerminalNode* CypherParser::ReturnItemsContext::SP(size_t i) {
- return getToken(CypherParser::SP, i);
-}
-
-
-size_t CypherParser::ReturnItemsContext::getRuleIndex() const {
- return CypherParser::RuleReturnItems;
-}
-
-void CypherParser::ReturnItemsContext::enterRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->enterReturnItems(this);
-}
-
-void CypherParser::ReturnItemsContext::exitRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->exitReturnItems(this);
-}
-
-
-antlrcpp::Any CypherParser::ReturnItemsContext::accept(tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
- return parserVisitor->visitReturnItems(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::ReturnItemsContext* CypherParser::returnItems() {
- ReturnItemsContext *_localctx = _tracker.createInstance<ReturnItemsContext>(_ctx, getState());
- enterRule(_localctx, 40, CypherParser::RuleReturnItems);
- size_t _la = 0;
-
- auto onExit = finally([=] {
- exitRule();
- });
- try {
- size_t alt;
- setState(437);
- _errHandler->sync(this);
- switch (_input->LA(1)) {
- case CypherParser::T__4: {
- enterOuterAlt(_localctx, 1);
- setState(409);
- match(CypherParser::T__4);
- setState(420);
- _errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 51, _ctx);
- while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
- if (alt == 1) {
- setState(411);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(410);
- match(CypherParser::SP);
- }
- setState(413);
- match(CypherParser::T__1);
- setState(415);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(414);
- match(CypherParser::SP);
- }
- setState(417);
- returnItem();
- }
- setState(422);
- _errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 51, _ctx);
- }
- break;
- }
-
- case CypherParser::T__5:
- case CypherParser::T__7:
- case CypherParser::T__12:
- case CypherParser::T__13:
- case CypherParser::T__25:
- case CypherParser::T__27:
- case CypherParser::StringLiteral:
- case CypherParser::HexInteger:
- case CypherParser::DecimalInteger:
- case CypherParser::OctalInteger:
- case CypherParser::HexLetter:
- case CypherParser::ExponentDecimalReal:
- case CypherParser::RegularDecimalReal:
- case CypherParser::UNION:
- case CypherParser::ALL:
- case CypherParser::OPTIONAL:
- case CypherParser::MATCH:
- case CypherParser::UNWIND:
- case CypherParser::AS:
- case CypherParser::MERGE:
- case CypherParser::ON:
- case CypherParser::CREATE:
- case CypherParser::SET:
- case CypherParser::DETACH:
- case CypherParser::DELETE:
- case CypherParser::REMOVE:
- case CypherParser::WITH:
- case CypherParser::DISTINCT:
- case CypherParser::RETURN:
- case CypherParser::ORDER:
- case CypherParser::BY:
- case CypherParser::L_SKIP:
- case CypherParser::LIMIT:
- case CypherParser::ASCENDING:
- case CypherParser::ASC:
- case CypherParser::DESCENDING:
- case CypherParser::DESC:
- case CypherParser::WHERE:
- case CypherParser::OR:
- case CypherParser::XOR:
- case CypherParser::AND:
- case CypherParser::NOT:
- case CypherParser::IN:
- case CypherParser::STARTS:
- case CypherParser::ENDS:
- case CypherParser::CONTAINS:
- case CypherParser::IS:
- case CypherParser::CYPHERNULL:
- case CypherParser::COUNT:
- case CypherParser::FILTER:
- case CypherParser::EXTRACT:
- case CypherParser::ANY:
- case CypherParser::NONE:
- case CypherParser::SINGLE:
- case CypherParser::TRUE:
- case CypherParser::FALSE:
- case CypherParser::UnescapedSymbolicName:
- case CypherParser::EscapedSymbolicName: {
- enterOuterAlt(_localctx, 2);
- setState(423);
- returnItem();
- setState(434);
- _errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 54, _ctx);
- while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
- if (alt == 1) {
- setState(425);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(424);
- match(CypherParser::SP);
- }
- setState(427);
- match(CypherParser::T__1);
- setState(429);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(428);
- match(CypherParser::SP);
- }
- setState(431);
- returnItem();
- }
- setState(436);
- _errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 54, _ctx);
- }
- break;
- }
-
- default:
- throw NoViableAltException(this);
- }
-
- }
- catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- ReturnItemContext ------------------------------------------------------------------
-
-CypherParser::ReturnItemContext::ReturnItemContext(ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {
-}
-
-CypherParser::ExpressionContext* CypherParser::ReturnItemContext::expression() {
- return getRuleContext<CypherParser::ExpressionContext>(0);
-}
-
-std::vector<tree::TerminalNode *> CypherParser::ReturnItemContext::SP() {
- return getTokens(CypherParser::SP);
-}
-
-tree::TerminalNode* CypherParser::ReturnItemContext::SP(size_t i) {
- return getToken(CypherParser::SP, i);
-}
-
-tree::TerminalNode* CypherParser::ReturnItemContext::AS() {
- return getToken(CypherParser::AS, 0);
-}
-
-CypherParser::VariableContext* CypherParser::ReturnItemContext::variable() {
- return getRuleContext<CypherParser::VariableContext>(0);
-}
-
-
-size_t CypherParser::ReturnItemContext::getRuleIndex() const {
- return CypherParser::RuleReturnItem;
-}
-
-void CypherParser::ReturnItemContext::enterRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->enterReturnItem(this);
-}
-
-void CypherParser::ReturnItemContext::exitRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->exitReturnItem(this);
-}
-
-
-antlrcpp::Any CypherParser::ReturnItemContext::accept(tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
- return parserVisitor->visitReturnItem(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::ReturnItemContext* CypherParser::returnItem() {
- ReturnItemContext *_localctx = _tracker.createInstance<ReturnItemContext>(_ctx, getState());
- enterRule(_localctx, 42, CypherParser::RuleReturnItem);
-
- auto onExit = finally([=] {
- exitRule();
- });
- try {
- setState(446);
- _errHandler->sync(this);
- switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 56, _ctx)) {
- case 1: {
- enterOuterAlt(_localctx, 1);
- setState(439);
- expression();
- setState(440);
- match(CypherParser::SP);
- setState(441);
- match(CypherParser::AS);
- setState(442);
- match(CypherParser::SP);
- setState(443);
- variable();
- break;
- }
-
- case 2: {
- enterOuterAlt(_localctx, 2);
- setState(445);
- expression();
- break;
- }
-
- }
-
- }
- catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- OrderContext ------------------------------------------------------------------
-
-CypherParser::OrderContext::OrderContext(ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {
-}
-
-tree::TerminalNode* CypherParser::OrderContext::ORDER() {
- return getToken(CypherParser::ORDER, 0);
-}
-
-std::vector<tree::TerminalNode *> CypherParser::OrderContext::SP() {
- return getTokens(CypherParser::SP);
-}
-
-tree::TerminalNode* CypherParser::OrderContext::SP(size_t i) {
- return getToken(CypherParser::SP, i);
-}
-
-tree::TerminalNode* CypherParser::OrderContext::BY() {
- return getToken(CypherParser::BY, 0);
-}
-
-std::vector<CypherParser::SortItemContext *> CypherParser::OrderContext::sortItem() {
- return getRuleContexts<CypherParser::SortItemContext>();
-}
-
-CypherParser::SortItemContext* CypherParser::OrderContext::sortItem(size_t i) {
- return getRuleContext<CypherParser::SortItemContext>(i);
-}
-
-
-size_t CypherParser::OrderContext::getRuleIndex() const {
- return CypherParser::RuleOrder;
-}
-
-void CypherParser::OrderContext::enterRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->enterOrder(this);
-}
-
-void CypherParser::OrderContext::exitRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->exitOrder(this);
-}
-
-
-antlrcpp::Any CypherParser::OrderContext::accept(tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
- return parserVisitor->visitOrder(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::OrderContext* CypherParser::order() {
- OrderContext *_localctx = _tracker.createInstance<OrderContext>(_ctx, getState());
- enterRule(_localctx, 44, CypherParser::RuleOrder);
- size_t _la = 0;
-
- auto onExit = finally([=] {
- exitRule();
- });
- try {
- enterOuterAlt(_localctx, 1);
- setState(448);
- match(CypherParser::ORDER);
- setState(449);
- match(CypherParser::SP);
- setState(450);
- match(CypherParser::BY);
- setState(451);
- match(CypherParser::SP);
- setState(452);
- sortItem();
- setState(460);
- _errHandler->sync(this);
- _la = _input->LA(1);
- while (_la == CypherParser::T__1) {
- setState(453);
- match(CypherParser::T__1);
- setState(455);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(454);
- match(CypherParser::SP);
- }
- setState(457);
- sortItem();
- setState(462);
- _errHandler->sync(this);
- _la = _input->LA(1);
- }
-
- }
- catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- SkipContext ------------------------------------------------------------------
-
-CypherParser::SkipContext::SkipContext(ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {
-}
-
-tree::TerminalNode* CypherParser::SkipContext::L_SKIP() {
- return getToken(CypherParser::L_SKIP, 0);
-}
-
-tree::TerminalNode* CypherParser::SkipContext::SP() {
- return getToken(CypherParser::SP, 0);
-}
-
-CypherParser::ExpressionContext* CypherParser::SkipContext::expression() {
- return getRuleContext<CypherParser::ExpressionContext>(0);
-}
-
-
-size_t CypherParser::SkipContext::getRuleIndex() const {
- return CypherParser::RuleSkip;
-}
-
-void CypherParser::SkipContext::enterRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->enterSkip(this);
-}
-
-void CypherParser::SkipContext::exitRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->exitSkip(this);
-}
-
-
-antlrcpp::Any CypherParser::SkipContext::accept(tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
- return parserVisitor->visitSkip(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::SkipContext* CypherParser::skip() {
- SkipContext *_localctx = _tracker.createInstance<SkipContext>(_ctx, getState());
- enterRule(_localctx, 46, CypherParser::RuleSkip);
-
- auto onExit = finally([=] {
- exitRule();
- });
- try {
- enterOuterAlt(_localctx, 1);
- setState(463);
- match(CypherParser::L_SKIP);
- setState(464);
- match(CypherParser::SP);
- setState(465);
- expression();
-
- }
- catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- LimitContext ------------------------------------------------------------------
-
-CypherParser::LimitContext::LimitContext(ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {
-}
-
-tree::TerminalNode* CypherParser::LimitContext::LIMIT() {
- return getToken(CypherParser::LIMIT, 0);
-}
-
-tree::TerminalNode* CypherParser::LimitContext::SP() {
- return getToken(CypherParser::SP, 0);
-}
-
-CypherParser::ExpressionContext* CypherParser::LimitContext::expression() {
- return getRuleContext<CypherParser::ExpressionContext>(0);
-}
-
-
-size_t CypherParser::LimitContext::getRuleIndex() const {
- return CypherParser::RuleLimit;
-}
-
-void CypherParser::LimitContext::enterRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->enterLimit(this);
-}
-
-void CypherParser::LimitContext::exitRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->exitLimit(this);
-}
-
-
-antlrcpp::Any CypherParser::LimitContext::accept(tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
- return parserVisitor->visitLimit(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::LimitContext* CypherParser::limit() {
- LimitContext *_localctx = _tracker.createInstance<LimitContext>(_ctx, getState());
- enterRule(_localctx, 48, CypherParser::RuleLimit);
-
- auto onExit = finally([=] {
- exitRule();
- });
- try {
- enterOuterAlt(_localctx, 1);
- setState(467);
- match(CypherParser::LIMIT);
- setState(468);
- match(CypherParser::SP);
- setState(469);
- expression();
-
- }
- catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- SortItemContext ------------------------------------------------------------------
-
-CypherParser::SortItemContext::SortItemContext(ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {
-}
-
-CypherParser::ExpressionContext* CypherParser::SortItemContext::expression() {
- return getRuleContext<CypherParser::ExpressionContext>(0);
-}
-
-tree::TerminalNode* CypherParser::SortItemContext::ASCENDING() {
- return getToken(CypherParser::ASCENDING, 0);
-}
-
-tree::TerminalNode* CypherParser::SortItemContext::ASC() {
- return getToken(CypherParser::ASC, 0);
-}
-
-tree::TerminalNode* CypherParser::SortItemContext::DESCENDING() {
- return getToken(CypherParser::DESCENDING, 0);
-}
-
-tree::TerminalNode* CypherParser::SortItemContext::DESC() {
- return getToken(CypherParser::DESC, 0);
-}
-
-tree::TerminalNode* CypherParser::SortItemContext::SP() {
- return getToken(CypherParser::SP, 0);
-}
-
-
-size_t CypherParser::SortItemContext::getRuleIndex() const {
- return CypherParser::RuleSortItem;
-}
-
-void CypherParser::SortItemContext::enterRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->enterSortItem(this);
-}
-
-void CypherParser::SortItemContext::exitRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->exitSortItem(this);
-}
-
-
-antlrcpp::Any CypherParser::SortItemContext::accept(tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
- return parserVisitor->visitSortItem(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::SortItemContext* CypherParser::sortItem() {
- SortItemContext *_localctx = _tracker.createInstance<SortItemContext>(_ctx, getState());
- enterRule(_localctx, 50, CypherParser::RuleSortItem);
- size_t _la = 0;
-
- auto onExit = finally([=] {
- exitRule();
- });
- try {
- enterOuterAlt(_localctx, 1);
- setState(471);
- expression();
- setState(476);
- _errHandler->sync(this);
-
- switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 60, _ctx)) {
- case 1: {
- setState(473);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(472);
- match(CypherParser::SP);
- }
- setState(475);
- _la = _input->LA(1);
- if (!(((((_la - 82) & ~ 0x3fULL) == 0) &&
- ((1ULL << (_la - 82)) & ((1ULL << (CypherParser::ASCENDING - 82))
- | (1ULL << (CypherParser::ASC - 82))
- | (1ULL << (CypherParser::DESCENDING - 82))
- | (1ULL << (CypherParser::DESC - 82)))) != 0))) {
- _errHandler->recoverInline(this);
- }
- else {
- _errHandler->reportMatch(this);
- consume();
- }
- break;
- }
-
- }
-
- }
- catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- WhereContext ------------------------------------------------------------------
-
-CypherParser::WhereContext::WhereContext(ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {
-}
-
-tree::TerminalNode* CypherParser::WhereContext::WHERE() {
- return getToken(CypherParser::WHERE, 0);
-}
-
-tree::TerminalNode* CypherParser::WhereContext::SP() {
- return getToken(CypherParser::SP, 0);
-}
-
-CypherParser::ExpressionContext* CypherParser::WhereContext::expression() {
- return getRuleContext<CypherParser::ExpressionContext>(0);
-}
-
-
-size_t CypherParser::WhereContext::getRuleIndex() const {
- return CypherParser::RuleWhere;
-}
-
-void CypherParser::WhereContext::enterRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->enterWhere(this);
-}
-
-void CypherParser::WhereContext::exitRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->exitWhere(this);
-}
-
-
-antlrcpp::Any CypherParser::WhereContext::accept(tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
- return parserVisitor->visitWhere(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::WhereContext* CypherParser::where() {
- WhereContext *_localctx = _tracker.createInstance<WhereContext>(_ctx, getState());
- enterRule(_localctx, 52, CypherParser::RuleWhere);
-
- auto onExit = finally([=] {
- exitRule();
- });
- try {
- enterOuterAlt(_localctx, 1);
- setState(478);
- match(CypherParser::WHERE);
- setState(479);
- match(CypherParser::SP);
- setState(480);
- expression();
-
- }
- catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- PatternContext ------------------------------------------------------------------
-
-CypherParser::PatternContext::PatternContext(ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {
-}
-
-std::vector<CypherParser::PatternPartContext *> CypherParser::PatternContext::patternPart() {
- return getRuleContexts<CypherParser::PatternPartContext>();
-}
-
-CypherParser::PatternPartContext* CypherParser::PatternContext::patternPart(size_t i) {
- return getRuleContext<CypherParser::PatternPartContext>(i);
-}
-
-std::vector<tree::TerminalNode *> CypherParser::PatternContext::SP() {
- return getTokens(CypherParser::SP);
-}
-
-tree::TerminalNode* CypherParser::PatternContext::SP(size_t i) {
- return getToken(CypherParser::SP, i);
-}
-
-
-size_t CypherParser::PatternContext::getRuleIndex() const {
- return CypherParser::RulePattern;
-}
-
-void CypherParser::PatternContext::enterRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->enterPattern(this);
-}
-
-void CypherParser::PatternContext::exitRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->exitPattern(this);
-}
-
-
-antlrcpp::Any CypherParser::PatternContext::accept(tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
- return parserVisitor->visitPattern(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::PatternContext* CypherParser::pattern() {
- PatternContext *_localctx = _tracker.createInstance<PatternContext>(_ctx, getState());
- enterRule(_localctx, 54, CypherParser::RulePattern);
- size_t _la = 0;
-
- auto onExit = finally([=] {
- exitRule();
- });
- try {
- size_t alt;
- enterOuterAlt(_localctx, 1);
- setState(482);
- patternPart();
- setState(493);
- _errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 63, _ctx);
- while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
- if (alt == 1) {
- setState(484);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(483);
- match(CypherParser::SP);
- }
- setState(486);
- match(CypherParser::T__1);
- setState(488);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(487);
- match(CypherParser::SP);
- }
- setState(490);
- patternPart();
- }
- setState(495);
- _errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 63, _ctx);
- }
-
- }
- catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- PatternPartContext ------------------------------------------------------------------
-
-CypherParser::PatternPartContext::PatternPartContext(ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {
-}
-
-CypherParser::VariableContext* CypherParser::PatternPartContext::variable() {
- return getRuleContext<CypherParser::VariableContext>(0);
-}
-
-CypherParser::AnonymousPatternPartContext* CypherParser::PatternPartContext::anonymousPatternPart() {
- return getRuleContext<CypherParser::AnonymousPatternPartContext>(0);
-}
-
-std::vector<tree::TerminalNode *> CypherParser::PatternPartContext::SP() {
- return getTokens(CypherParser::SP);
-}
-
-tree::TerminalNode* CypherParser::PatternPartContext::SP(size_t i) {
- return getToken(CypherParser::SP, i);
-}
-
-
-size_t CypherParser::PatternPartContext::getRuleIndex() const {
- return CypherParser::RulePatternPart;
-}
-
-void CypherParser::PatternPartContext::enterRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->enterPatternPart(this);
-}
-
-void CypherParser::PatternPartContext::exitRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->exitPatternPart(this);
-}
-
-
-antlrcpp::Any CypherParser::PatternPartContext::accept(tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
- return parserVisitor->visitPatternPart(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::PatternPartContext* CypherParser::patternPart() {
- PatternPartContext *_localctx = _tracker.createInstance<PatternPartContext>(_ctx, getState());
- enterRule(_localctx, 56, CypherParser::RulePatternPart);
- size_t _la = 0;
-
- auto onExit = finally([=] {
- exitRule();
- });
- try {
- setState(507);
- _errHandler->sync(this);
- switch (_input->LA(1)) {
- case CypherParser::HexLetter:
- case CypherParser::UNION:
- case CypherParser::ALL:
- case CypherParser::OPTIONAL:
- case CypherParser::MATCH:
- case CypherParser::UNWIND:
- case CypherParser::AS:
- case CypherParser::MERGE:
- case CypherParser::ON:
- case CypherParser::CREATE:
- case CypherParser::SET:
- case CypherParser::DETACH:
- case CypherParser::DELETE:
- case CypherParser::REMOVE:
- case CypherParser::WITH:
- case CypherParser::DISTINCT:
- case CypherParser::RETURN:
- case CypherParser::ORDER:
- case CypherParser::BY:
- case CypherParser::L_SKIP:
- case CypherParser::LIMIT:
- case CypherParser::ASCENDING:
- case CypherParser::ASC:
- case CypherParser::DESCENDING:
- case CypherParser::DESC:
- case CypherParser::WHERE:
- case CypherParser::OR:
- case CypherParser::XOR:
- case CypherParser::AND:
- case CypherParser::NOT:
- case CypherParser::IN:
- case CypherParser::STARTS:
- case CypherParser::ENDS:
- case CypherParser::CONTAINS:
- case CypherParser::IS:
- case CypherParser::CYPHERNULL:
- case CypherParser::COUNT:
- case CypherParser::FILTER:
- case CypherParser::EXTRACT:
- case CypherParser::ANY:
- case CypherParser::NONE:
- case CypherParser::SINGLE:
- case CypherParser::TRUE:
- case CypherParser::FALSE:
- case CypherParser::UnescapedSymbolicName:
- case CypherParser::EscapedSymbolicName: {
- enterOuterAlt(_localctx, 1);
- setState(496);
- variable();
- setState(498);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(497);
- match(CypherParser::SP);
- }
- setState(500);
- match(CypherParser::T__2);
- setState(502);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(501);
- match(CypherParser::SP);
- }
- setState(504);
- anonymousPatternPart();
- break;
- }
-
- case CypherParser::T__5: {
- enterOuterAlt(_localctx, 2);
- setState(506);
- anonymousPatternPart();
- break;
- }
-
- default:
- throw NoViableAltException(this);
- }
-
- }
- catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- AnonymousPatternPartContext ------------------------------------------------------------------
-
-CypherParser::AnonymousPatternPartContext::AnonymousPatternPartContext(ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {
-}
-
-CypherParser::PatternElementContext* CypherParser::AnonymousPatternPartContext::patternElement() {
- return getRuleContext<CypherParser::PatternElementContext>(0);
-}
-
-
-size_t CypherParser::AnonymousPatternPartContext::getRuleIndex() const {
- return CypherParser::RuleAnonymousPatternPart;
-}
-
-void CypherParser::AnonymousPatternPartContext::enterRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->enterAnonymousPatternPart(this);
-}
-
-void CypherParser::AnonymousPatternPartContext::exitRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->exitAnonymousPatternPart(this);
-}
-
-
-antlrcpp::Any CypherParser::AnonymousPatternPartContext::accept(tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
- return parserVisitor->visitAnonymousPatternPart(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::AnonymousPatternPartContext* CypherParser::anonymousPatternPart() {
- AnonymousPatternPartContext *_localctx = _tracker.createInstance<AnonymousPatternPartContext>(_ctx, getState());
- enterRule(_localctx, 58, CypherParser::RuleAnonymousPatternPart);
-
- auto onExit = finally([=] {
- exitRule();
- });
- try {
- enterOuterAlt(_localctx, 1);
- setState(509);
- patternElement();
-
- }
- catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- PatternElementContext ------------------------------------------------------------------
-
-CypherParser::PatternElementContext::PatternElementContext(ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {
-}
-
-CypherParser::NodePatternContext* CypherParser::PatternElementContext::nodePattern() {
- return getRuleContext<CypherParser::NodePatternContext>(0);
-}
-
-std::vector<CypherParser::PatternElementChainContext *> CypherParser::PatternElementContext::patternElementChain() {
- return getRuleContexts<CypherParser::PatternElementChainContext>();
-}
-
-CypherParser::PatternElementChainContext* CypherParser::PatternElementContext::patternElementChain(size_t i) {
- return getRuleContext<CypherParser::PatternElementChainContext>(i);
-}
-
-std::vector<tree::TerminalNode *> CypherParser::PatternElementContext::SP() {
- return getTokens(CypherParser::SP);
-}
-
-tree::TerminalNode* CypherParser::PatternElementContext::SP(size_t i) {
- return getToken(CypherParser::SP, i);
-}
-
-CypherParser::PatternElementContext* CypherParser::PatternElementContext::patternElement() {
- return getRuleContext<CypherParser::PatternElementContext>(0);
-}
-
-
-size_t CypherParser::PatternElementContext::getRuleIndex() const {
- return CypherParser::RulePatternElement;
-}
-
-void CypherParser::PatternElementContext::enterRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->enterPatternElement(this);
-}
-
-void CypherParser::PatternElementContext::exitRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->exitPatternElement(this);
-}
-
-
-antlrcpp::Any CypherParser::PatternElementContext::accept(tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
- return parserVisitor->visitPatternElement(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::PatternElementContext* CypherParser::patternElement() {
- PatternElementContext *_localctx = _tracker.createInstance<PatternElementContext>(_ctx, getState());
- enterRule(_localctx, 60, CypherParser::RulePatternElement);
- size_t _la = 0;
-
- auto onExit = finally([=] {
- exitRule();
- });
- try {
- size_t alt;
- setState(525);
- _errHandler->sync(this);
- switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 69, _ctx)) {
- case 1: {
- enterOuterAlt(_localctx, 1);
- setState(511);
- nodePattern();
- setState(518);
- _errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 68, _ctx);
- while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
- if (alt == 1) {
- setState(513);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(512);
- match(CypherParser::SP);
- }
- setState(515);
- patternElementChain();
- }
- setState(520);
- _errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 68, _ctx);
- }
- break;
- }
-
- case 2: {
- enterOuterAlt(_localctx, 2);
- setState(521);
- match(CypherParser::T__5);
- setState(522);
- patternElement();
- setState(523);
- match(CypherParser::T__6);
- break;
- }
-
- }
-
- }
- catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- NodePatternContext ------------------------------------------------------------------
-
-CypherParser::NodePatternContext::NodePatternContext(ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {
-}
-
-std::vector<tree::TerminalNode *> CypherParser::NodePatternContext::SP() {
- return getTokens(CypherParser::SP);
-}
-
-tree::TerminalNode* CypherParser::NodePatternContext::SP(size_t i) {
- return getToken(CypherParser::SP, i);
-}
-
-CypherParser::VariableContext* CypherParser::NodePatternContext::variable() {
- return getRuleContext<CypherParser::VariableContext>(0);
-}
-
-CypherParser::NodeLabelsContext* CypherParser::NodePatternContext::nodeLabels() {
- return getRuleContext<CypherParser::NodeLabelsContext>(0);
-}
-
-CypherParser::PropertiesContext* CypherParser::NodePatternContext::properties() {
- return getRuleContext<CypherParser::PropertiesContext>(0);
-}
-
-
-size_t CypherParser::NodePatternContext::getRuleIndex() const {
- return CypherParser::RuleNodePattern;
-}
-
-void CypherParser::NodePatternContext::enterRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->enterNodePattern(this);
-}
-
-void CypherParser::NodePatternContext::exitRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->exitNodePattern(this);
-}
-
-
-antlrcpp::Any CypherParser::NodePatternContext::accept(tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
- return parserVisitor->visitNodePattern(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::NodePatternContext* CypherParser::nodePattern() {
- NodePatternContext *_localctx = _tracker.createInstance<NodePatternContext>(_ctx, getState());
- enterRule(_localctx, 62, CypherParser::RuleNodePattern);
- size_t _la = 0;
-
- auto onExit = finally([=] {
- exitRule();
- });
- try {
- enterOuterAlt(_localctx, 1);
- setState(527);
- match(CypherParser::T__5);
- setState(529);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(528);
- match(CypherParser::SP);
- }
- setState(535);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (((((_la - 53) & ~ 0x3fULL) == 0) &&
- ((1ULL << (_la - 53)) & ((1ULL << (CypherParser::HexLetter - 53))
- | (1ULL << (CypherParser::UNION - 53))
- | (1ULL << (CypherParser::ALL - 53))
- | (1ULL << (CypherParser::OPTIONAL - 53))
- | (1ULL << (CypherParser::MATCH - 53))
- | (1ULL << (CypherParser::UNWIND - 53))
- | (1ULL << (CypherParser::AS - 53))
- | (1ULL << (CypherParser::MERGE - 53))
- | (1ULL << (CypherParser::ON - 53))
- | (1ULL << (CypherParser::CREATE - 53))
- | (1ULL << (CypherParser::SET - 53))
- | (1ULL << (CypherParser::DETACH - 53))
- | (1ULL << (CypherParser::DELETE - 53))
- | (1ULL << (CypherParser::REMOVE - 53))
- | (1ULL << (CypherParser::WITH - 53))
- | (1ULL << (CypherParser::DISTINCT - 53))
- | (1ULL << (CypherParser::RETURN - 53))
- | (1ULL << (CypherParser::ORDER - 53))
- | (1ULL << (CypherParser::BY - 53))
- | (1ULL << (CypherParser::L_SKIP - 53))
- | (1ULL << (CypherParser::LIMIT - 53))
- | (1ULL << (CypherParser::ASCENDING - 53))
- | (1ULL << (CypherParser::ASC - 53))
- | (1ULL << (CypherParser::DESCENDING - 53))
- | (1ULL << (CypherParser::DESC - 53))
- | (1ULL << (CypherParser::WHERE - 53))
- | (1ULL << (CypherParser::OR - 53))
- | (1ULL << (CypherParser::XOR - 53))
- | (1ULL << (CypherParser::AND - 53))
- | (1ULL << (CypherParser::NOT - 53))
- | (1ULL << (CypherParser::IN - 53))
- | (1ULL << (CypherParser::STARTS - 53))
- | (1ULL << (CypherParser::ENDS - 53))
- | (1ULL << (CypherParser::CONTAINS - 53))
- | (1ULL << (CypherParser::IS - 53))
- | (1ULL << (CypherParser::CYPHERNULL - 53))
- | (1ULL << (CypherParser::COUNT - 53))
- | (1ULL << (CypherParser::FILTER - 53))
- | (1ULL << (CypherParser::EXTRACT - 53))
- | (1ULL << (CypherParser::ANY - 53))
- | (1ULL << (CypherParser::NONE - 53))
- | (1ULL << (CypherParser::SINGLE - 53))
- | (1ULL << (CypherParser::TRUE - 53))
- | (1ULL << (CypherParser::FALSE - 53))
- | (1ULL << (CypherParser::UnescapedSymbolicName - 53))
- | (1ULL << (CypherParser::EscapedSymbolicName - 53)))) != 0)) {
- setState(531);
- variable();
- setState(533);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(532);
- match(CypherParser::SP);
- }
- }
- setState(541);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::T__9) {
- setState(537);
- nodeLabels();
- setState(539);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(538);
- match(CypherParser::SP);
- }
- }
- setState(547);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::T__25
-
- || _la == CypherParser::T__27) {
- setState(543);
- properties();
- setState(545);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(544);
- match(CypherParser::SP);
- }
- }
- setState(549);
- match(CypherParser::T__6);
-
- }
- catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- PatternElementChainContext ------------------------------------------------------------------
-
-CypherParser::PatternElementChainContext::PatternElementChainContext(ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {
-}
-
-CypherParser::RelationshipPatternContext* CypherParser::PatternElementChainContext::relationshipPattern() {
- return getRuleContext<CypherParser::RelationshipPatternContext>(0);
-}
-
-CypherParser::NodePatternContext* CypherParser::PatternElementChainContext::nodePattern() {
- return getRuleContext<CypherParser::NodePatternContext>(0);
-}
-
-tree::TerminalNode* CypherParser::PatternElementChainContext::SP() {
- return getToken(CypherParser::SP, 0);
-}
-
-
-size_t CypherParser::PatternElementChainContext::getRuleIndex() const {
- return CypherParser::RulePatternElementChain;
-}
-
-void CypherParser::PatternElementChainContext::enterRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->enterPatternElementChain(this);
-}
-
-void CypherParser::PatternElementChainContext::exitRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->exitPatternElementChain(this);
-}
-
-
-antlrcpp::Any CypherParser::PatternElementChainContext::accept(tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
- return parserVisitor->visitPatternElementChain(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::PatternElementChainContext* CypherParser::patternElementChain() {
- PatternElementChainContext *_localctx = _tracker.createInstance<PatternElementChainContext>(_ctx, getState());
- enterRule(_localctx, 64, CypherParser::RulePatternElementChain);
- size_t _la = 0;
-
- auto onExit = finally([=] {
- exitRule();
- });
- try {
- enterOuterAlt(_localctx, 1);
- setState(551);
- relationshipPattern();
- setState(553);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(552);
- match(CypherParser::SP);
- }
- setState(555);
- nodePattern();
-
- }
- catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- RelationshipPatternContext ------------------------------------------------------------------
-
-CypherParser::RelationshipPatternContext::RelationshipPatternContext(ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {
-}
-
-CypherParser::LeftArrowHeadContext* CypherParser::RelationshipPatternContext::leftArrowHead() {
- return getRuleContext<CypherParser::LeftArrowHeadContext>(0);
-}
-
-std::vector<CypherParser::DashContext *> CypherParser::RelationshipPatternContext::dash() {
- return getRuleContexts<CypherParser::DashContext>();
-}
-
-CypherParser::DashContext* CypherParser::RelationshipPatternContext::dash(size_t i) {
- return getRuleContext<CypherParser::DashContext>(i);
-}
-
-CypherParser::RightArrowHeadContext* CypherParser::RelationshipPatternContext::rightArrowHead() {
- return getRuleContext<CypherParser::RightArrowHeadContext>(0);
-}
-
-std::vector<tree::TerminalNode *> CypherParser::RelationshipPatternContext::SP() {
- return getTokens(CypherParser::SP);
-}
-
-tree::TerminalNode* CypherParser::RelationshipPatternContext::SP(size_t i) {
- return getToken(CypherParser::SP, i);
-}
-
-CypherParser::RelationshipDetailContext* CypherParser::RelationshipPatternContext::relationshipDetail() {
- return getRuleContext<CypherParser::RelationshipDetailContext>(0);
-}
-
-
-size_t CypherParser::RelationshipPatternContext::getRuleIndex() const {
- return CypherParser::RuleRelationshipPattern;
-}
-
-void CypherParser::RelationshipPatternContext::enterRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->enterRelationshipPattern(this);
-}
-
-void CypherParser::RelationshipPatternContext::exitRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->exitRelationshipPattern(this);
-}
-
-
-antlrcpp::Any CypherParser::RelationshipPatternContext::accept(tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
- return parserVisitor->visitRelationshipPattern(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::RelationshipPatternContext* CypherParser::relationshipPattern() {
- RelationshipPatternContext *_localctx = _tracker.createInstance<RelationshipPatternContext>(_ctx, getState());
- enterRule(_localctx, 66, CypherParser::RuleRelationshipPattern);
- size_t _la = 0;
-
- auto onExit = finally([=] {
- exitRule();
- });
- try {
- setState(621);
- _errHandler->sync(this);
- switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 94, _ctx)) {
- case 1: {
- enterOuterAlt(_localctx, 1);
- setState(557);
- leftArrowHead();
- setState(559);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(558);
- match(CypherParser::SP);
- }
- setState(561);
- dash();
- setState(563);
- _errHandler->sync(this);
-
- switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 79, _ctx)) {
- case 1: {
- setState(562);
- match(CypherParser::SP);
- break;
- }
-
- }
- setState(566);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::T__7) {
- setState(565);
- relationshipDetail();
- }
- setState(569);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(568);
- match(CypherParser::SP);
- }
- setState(571);
- dash();
- setState(573);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(572);
- match(CypherParser::SP);
- }
- setState(575);
- rightArrowHead();
- break;
- }
-
- case 2: {
- enterOuterAlt(_localctx, 2);
- setState(577);
- leftArrowHead();
- setState(579);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(578);
- match(CypherParser::SP);
- }
- setState(581);
- dash();
- setState(583);
- _errHandler->sync(this);
-
- switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 84, _ctx)) {
- case 1: {
- setState(582);
- match(CypherParser::SP);
- break;
- }
-
- }
- setState(586);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::T__7) {
- setState(585);
- relationshipDetail();
- }
- setState(589);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(588);
- match(CypherParser::SP);
- }
- setState(591);
- dash();
- break;
- }
-
- case 3: {
- enterOuterAlt(_localctx, 3);
- setState(593);
- dash();
- setState(595);
- _errHandler->sync(this);
-
- switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 87, _ctx)) {
- case 1: {
- setState(594);
- match(CypherParser::SP);
- break;
- }
-
- }
- setState(598);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::T__7) {
- setState(597);
- relationshipDetail();
- }
- setState(601);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(600);
- match(CypherParser::SP);
- }
- setState(603);
- dash();
- setState(605);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(604);
- match(CypherParser::SP);
- }
- setState(607);
- rightArrowHead();
- break;
- }
-
- case 4: {
- enterOuterAlt(_localctx, 4);
- setState(609);
- dash();
- setState(611);
- _errHandler->sync(this);
-
- switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 91, _ctx)) {
- case 1: {
- setState(610);
- match(CypherParser::SP);
- break;
- }
-
- }
- setState(614);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::T__7) {
- setState(613);
- relationshipDetail();
- }
- setState(617);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(616);
- match(CypherParser::SP);
- }
- setState(619);
- dash();
- break;
- }
-
- }
-
- }
- catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- RelationshipDetailContext ------------------------------------------------------------------
-
-CypherParser::RelationshipDetailContext::RelationshipDetailContext(ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {
-}
-
-std::vector<tree::TerminalNode *> CypherParser::RelationshipDetailContext::SP() {
- return getTokens(CypherParser::SP);
-}
-
-tree::TerminalNode* CypherParser::RelationshipDetailContext::SP(size_t i) {
- return getToken(CypherParser::SP, i);
-}
-
-CypherParser::VariableContext* CypherParser::RelationshipDetailContext::variable() {
- return getRuleContext<CypherParser::VariableContext>(0);
-}
-
-CypherParser::RelationshipTypesContext* CypherParser::RelationshipDetailContext::relationshipTypes() {
- return getRuleContext<CypherParser::RelationshipTypesContext>(0);
-}
-
-CypherParser::RangeLiteralContext* CypherParser::RelationshipDetailContext::rangeLiteral() {
- return getRuleContext<CypherParser::RangeLiteralContext>(0);
-}
-
-CypherParser::PropertiesContext* CypherParser::RelationshipDetailContext::properties() {
- return getRuleContext<CypherParser::PropertiesContext>(0);
-}
-
-
-size_t CypherParser::RelationshipDetailContext::getRuleIndex() const {
- return CypherParser::RuleRelationshipDetail;
-}
-
-void CypherParser::RelationshipDetailContext::enterRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->enterRelationshipDetail(this);
-}
-
-void CypherParser::RelationshipDetailContext::exitRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->exitRelationshipDetail(this);
-}
-
-
-antlrcpp::Any CypherParser::RelationshipDetailContext::accept(tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
- return parserVisitor->visitRelationshipDetail(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::RelationshipDetailContext* CypherParser::relationshipDetail() {
- RelationshipDetailContext *_localctx = _tracker.createInstance<RelationshipDetailContext>(_ctx, getState());
- enterRule(_localctx, 68, CypherParser::RuleRelationshipDetail);
- size_t _la = 0;
-
- auto onExit = finally([=] {
- exitRule();
- });
- try {
- enterOuterAlt(_localctx, 1);
- setState(623);
- match(CypherParser::T__7);
- setState(625);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(624);
- match(CypherParser::SP);
- }
- setState(631);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (((((_la - 53) & ~ 0x3fULL) == 0) &&
- ((1ULL << (_la - 53)) & ((1ULL << (CypherParser::HexLetter - 53))
- | (1ULL << (CypherParser::UNION - 53))
- | (1ULL << (CypherParser::ALL - 53))
- | (1ULL << (CypherParser::OPTIONAL - 53))
- | (1ULL << (CypherParser::MATCH - 53))
- | (1ULL << (CypherParser::UNWIND - 53))
- | (1ULL << (CypherParser::AS - 53))
- | (1ULL << (CypherParser::MERGE - 53))
- | (1ULL << (CypherParser::ON - 53))
- | (1ULL << (CypherParser::CREATE - 53))
- | (1ULL << (CypherParser::SET - 53))
- | (1ULL << (CypherParser::DETACH - 53))
- | (1ULL << (CypherParser::DELETE - 53))
- | (1ULL << (CypherParser::REMOVE - 53))
- | (1ULL << (CypherParser::WITH - 53))
- | (1ULL << (CypherParser::DISTINCT - 53))
- | (1ULL << (CypherParser::RETURN - 53))
- | (1ULL << (CypherParser::ORDER - 53))
- | (1ULL << (CypherParser::BY - 53))
- | (1ULL << (CypherParser::L_SKIP - 53))
- | (1ULL << (CypherParser::LIMIT - 53))
- | (1ULL << (CypherParser::ASCENDING - 53))
- | (1ULL << (CypherParser::ASC - 53))
- | (1ULL << (CypherParser::DESCENDING - 53))
- | (1ULL << (CypherParser::DESC - 53))
- | (1ULL << (CypherParser::WHERE - 53))
- | (1ULL << (CypherParser::OR - 53))
- | (1ULL << (CypherParser::XOR - 53))
- | (1ULL << (CypherParser::AND - 53))
- | (1ULL << (CypherParser::NOT - 53))
- | (1ULL << (CypherParser::IN - 53))
- | (1ULL << (CypherParser::STARTS - 53))
- | (1ULL << (CypherParser::ENDS - 53))
- | (1ULL << (CypherParser::CONTAINS - 53))
- | (1ULL << (CypherParser::IS - 53))
- | (1ULL << (CypherParser::CYPHERNULL - 53))
- | (1ULL << (CypherParser::COUNT - 53))
- | (1ULL << (CypherParser::FILTER - 53))
- | (1ULL << (CypherParser::EXTRACT - 53))
- | (1ULL << (CypherParser::ANY - 53))
- | (1ULL << (CypherParser::NONE - 53))
- | (1ULL << (CypherParser::SINGLE - 53))
- | (1ULL << (CypherParser::TRUE - 53))
- | (1ULL << (CypherParser::FALSE - 53))
- | (1ULL << (CypherParser::UnescapedSymbolicName - 53))
- | (1ULL << (CypherParser::EscapedSymbolicName - 53)))) != 0)) {
- setState(627);
- variable();
- setState(629);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(628);
- match(CypherParser::SP);
- }
- }
- setState(637);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::T__9) {
- setState(633);
- relationshipTypes();
- setState(635);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(634);
- match(CypherParser::SP);
- }
- }
- setState(640);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::T__4) {
- setState(639);
- rangeLiteral();
- }
- setState(646);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::T__25
-
- || _la == CypherParser::T__27) {
- setState(642);
- properties();
- setState(644);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(643);
- match(CypherParser::SP);
- }
- }
- setState(648);
- match(CypherParser::T__8);
-
- }
- catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- PropertiesContext ------------------------------------------------------------------
-
-CypherParser::PropertiesContext::PropertiesContext(ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {
-}
-
-CypherParser::MapLiteralContext* CypherParser::PropertiesContext::mapLiteral() {
- return getRuleContext<CypherParser::MapLiteralContext>(0);
-}
-
-CypherParser::ParameterContext* CypherParser::PropertiesContext::parameter() {
- return getRuleContext<CypherParser::ParameterContext>(0);
-}
-
-
-size_t CypherParser::PropertiesContext::getRuleIndex() const {
- return CypherParser::RuleProperties;
-}
-
-void CypherParser::PropertiesContext::enterRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->enterProperties(this);
-}
-
-void CypherParser::PropertiesContext::exitRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->exitProperties(this);
-}
-
-
-antlrcpp::Any CypherParser::PropertiesContext::accept(tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
- return parserVisitor->visitProperties(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::PropertiesContext* CypherParser::properties() {
- PropertiesContext *_localctx = _tracker.createInstance<PropertiesContext>(_ctx, getState());
- enterRule(_localctx, 70, CypherParser::RuleProperties);
-
- auto onExit = finally([=] {
- exitRule();
- });
- try {
- setState(652);
- _errHandler->sync(this);
- switch (_input->LA(1)) {
- case CypherParser::T__25: {
- enterOuterAlt(_localctx, 1);
- setState(650);
- mapLiteral();
- break;
- }
-
- case CypherParser::T__27: {
- enterOuterAlt(_localctx, 2);
- setState(651);
- parameter();
- break;
- }
-
- default:
- throw NoViableAltException(this);
- }
-
- }
- catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- RelationshipTypesContext ------------------------------------------------------------------
-
-CypherParser::RelationshipTypesContext::RelationshipTypesContext(ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {
-}
-
-std::vector<CypherParser::RelTypeNameContext *> CypherParser::RelationshipTypesContext::relTypeName() {
- return getRuleContexts<CypherParser::RelTypeNameContext>();
-}
-
-CypherParser::RelTypeNameContext* CypherParser::RelationshipTypesContext::relTypeName(size_t i) {
- return getRuleContext<CypherParser::RelTypeNameContext>(i);
-}
-
-std::vector<tree::TerminalNode *> CypherParser::RelationshipTypesContext::SP() {
- return getTokens(CypherParser::SP);
-}
-
-tree::TerminalNode* CypherParser::RelationshipTypesContext::SP(size_t i) {
- return getToken(CypherParser::SP, i);
-}
-
-
-size_t CypherParser::RelationshipTypesContext::getRuleIndex() const {
- return CypherParser::RuleRelationshipTypes;
-}
-
-void CypherParser::RelationshipTypesContext::enterRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->enterRelationshipTypes(this);
-}
-
-void CypherParser::RelationshipTypesContext::exitRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->exitRelationshipTypes(this);
-}
-
-
-antlrcpp::Any CypherParser::RelationshipTypesContext::accept(tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
- return parserVisitor->visitRelationshipTypes(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::RelationshipTypesContext* CypherParser::relationshipTypes() {
- RelationshipTypesContext *_localctx = _tracker.createInstance<RelationshipTypesContext>(_ctx, getState());
- enterRule(_localctx, 72, CypherParser::RuleRelationshipTypes);
- size_t _la = 0;
-
- auto onExit = finally([=] {
- exitRule();
- });
- try {
- size_t alt;
- enterOuterAlt(_localctx, 1);
- setState(654);
- match(CypherParser::T__9);
- setState(656);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(655);
- match(CypherParser::SP);
- }
- setState(658);
- relTypeName();
- setState(672);
- _errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 108, _ctx);
- while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
- if (alt == 1) {
- setState(660);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(659);
- match(CypherParser::SP);
- }
- setState(662);
- match(CypherParser::T__10);
- setState(664);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::T__9) {
- setState(663);
- match(CypherParser::T__9);
- }
- setState(667);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(666);
- match(CypherParser::SP);
- }
- setState(669);
- relTypeName();
- }
- setState(674);
- _errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 108, _ctx);
- }
-
- }
- catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- NodeLabelsContext ------------------------------------------------------------------
-
-CypherParser::NodeLabelsContext::NodeLabelsContext(ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {
-}
-
-std::vector<CypherParser::NodeLabelContext *> CypherParser::NodeLabelsContext::nodeLabel() {
- return getRuleContexts<CypherParser::NodeLabelContext>();
-}
-
-CypherParser::NodeLabelContext* CypherParser::NodeLabelsContext::nodeLabel(size_t i) {
- return getRuleContext<CypherParser::NodeLabelContext>(i);
-}
-
-std::vector<tree::TerminalNode *> CypherParser::NodeLabelsContext::SP() {
- return getTokens(CypherParser::SP);
-}
-
-tree::TerminalNode* CypherParser::NodeLabelsContext::SP(size_t i) {
- return getToken(CypherParser::SP, i);
-}
-
-
-size_t CypherParser::NodeLabelsContext::getRuleIndex() const {
- return CypherParser::RuleNodeLabels;
-}
-
-void CypherParser::NodeLabelsContext::enterRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->enterNodeLabels(this);
-}
-
-void CypherParser::NodeLabelsContext::exitRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->exitNodeLabels(this);
-}
-
-
-antlrcpp::Any CypherParser::NodeLabelsContext::accept(tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
- return parserVisitor->visitNodeLabels(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::NodeLabelsContext* CypherParser::nodeLabels() {
- NodeLabelsContext *_localctx = _tracker.createInstance<NodeLabelsContext>(_ctx, getState());
- enterRule(_localctx, 74, CypherParser::RuleNodeLabels);
- size_t _la = 0;
-
- auto onExit = finally([=] {
- exitRule();
- });
- try {
- size_t alt;
- enterOuterAlt(_localctx, 1);
- setState(675);
- nodeLabel();
- setState(682);
- _errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 110, _ctx);
- while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
- if (alt == 1) {
- setState(677);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(676);
- match(CypherParser::SP);
- }
- setState(679);
- nodeLabel();
- }
- setState(684);
- _errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 110, _ctx);
- }
-
- }
- catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- NodeLabelContext ------------------------------------------------------------------
-
-CypherParser::NodeLabelContext::NodeLabelContext(ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {
-}
-
-CypherParser::LabelNameContext* CypherParser::NodeLabelContext::labelName() {
- return getRuleContext<CypherParser::LabelNameContext>(0);
-}
-
-tree::TerminalNode* CypherParser::NodeLabelContext::SP() {
- return getToken(CypherParser::SP, 0);
-}
-
-
-size_t CypherParser::NodeLabelContext::getRuleIndex() const {
- return CypherParser::RuleNodeLabel;
-}
-
-void CypherParser::NodeLabelContext::enterRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->enterNodeLabel(this);
-}
-
-void CypherParser::NodeLabelContext::exitRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->exitNodeLabel(this);
-}
-
-
-antlrcpp::Any CypherParser::NodeLabelContext::accept(tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
- return parserVisitor->visitNodeLabel(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::NodeLabelContext* CypherParser::nodeLabel() {
- NodeLabelContext *_localctx = _tracker.createInstance<NodeLabelContext>(_ctx, getState());
- enterRule(_localctx, 76, CypherParser::RuleNodeLabel);
- size_t _la = 0;
-
- auto onExit = finally([=] {
- exitRule();
- });
- try {
- enterOuterAlt(_localctx, 1);
- setState(685);
- match(CypherParser::T__9);
- setState(687);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(686);
- match(CypherParser::SP);
- }
- setState(689);
- labelName();
-
- }
- catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- RangeLiteralContext ------------------------------------------------------------------
-
-CypherParser::RangeLiteralContext::RangeLiteralContext(ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {
-}
-
-std::vector<tree::TerminalNode *> CypherParser::RangeLiteralContext::SP() {
- return getTokens(CypherParser::SP);
-}
-
-tree::TerminalNode* CypherParser::RangeLiteralContext::SP(size_t i) {
- return getToken(CypherParser::SP, i);
-}
-
-std::vector<CypherParser::IntegerLiteralContext *> CypherParser::RangeLiteralContext::integerLiteral() {
- return getRuleContexts<CypherParser::IntegerLiteralContext>();
-}
-
-CypherParser::IntegerLiteralContext* CypherParser::RangeLiteralContext::integerLiteral(size_t i) {
- return getRuleContext<CypherParser::IntegerLiteralContext>(i);
-}
-
-
-size_t CypherParser::RangeLiteralContext::getRuleIndex() const {
- return CypherParser::RuleRangeLiteral;
-}
-
-void CypherParser::RangeLiteralContext::enterRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->enterRangeLiteral(this);
-}
-
-void CypherParser::RangeLiteralContext::exitRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->exitRangeLiteral(this);
-}
-
-
-antlrcpp::Any CypherParser::RangeLiteralContext::accept(tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
- return parserVisitor->visitRangeLiteral(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::RangeLiteralContext* CypherParser::rangeLiteral() {
- RangeLiteralContext *_localctx = _tracker.createInstance<RangeLiteralContext>(_ctx, getState());
- enterRule(_localctx, 78, CypherParser::RuleRangeLiteral);
- size_t _la = 0;
-
- auto onExit = finally([=] {
- exitRule();
- });
- try {
- enterOuterAlt(_localctx, 1);
- setState(691);
- match(CypherParser::T__4);
- setState(693);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(692);
- match(CypherParser::SP);
- }
- setState(699);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if ((((_la & ~ 0x3fULL) == 0) &&
- ((1ULL << _la) & ((1ULL << CypherParser::HexInteger)
- | (1ULL << CypherParser::DecimalInteger)
- | (1ULL << CypherParser::OctalInteger))) != 0)) {
- setState(695);
- integerLiteral();
- setState(697);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(696);
- match(CypherParser::SP);
- }
- }
- setState(711);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::T__11) {
- setState(701);
- match(CypherParser::T__11);
- setState(703);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(702);
- match(CypherParser::SP);
- }
- setState(709);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if ((((_la & ~ 0x3fULL) == 0) &&
- ((1ULL << _la) & ((1ULL << CypherParser::HexInteger)
- | (1ULL << CypherParser::DecimalInteger)
- | (1ULL << CypherParser::OctalInteger))) != 0)) {
- setState(705);
- integerLiteral();
- setState(707);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(706);
- match(CypherParser::SP);
- }
- }
- }
-
- }
- catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- LabelNameContext ------------------------------------------------------------------
-
-CypherParser::LabelNameContext::LabelNameContext(ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {
-}
-
-CypherParser::SymbolicNameContext* CypherParser::LabelNameContext::symbolicName() {
- return getRuleContext<CypherParser::SymbolicNameContext>(0);
-}
-
-
-size_t CypherParser::LabelNameContext::getRuleIndex() const {
- return CypherParser::RuleLabelName;
-}
-
-void CypherParser::LabelNameContext::enterRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->enterLabelName(this);
-}
-
-void CypherParser::LabelNameContext::exitRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->exitLabelName(this);
-}
-
-
-antlrcpp::Any CypherParser::LabelNameContext::accept(tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
- return parserVisitor->visitLabelName(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::LabelNameContext* CypherParser::labelName() {
- LabelNameContext *_localctx = _tracker.createInstance<LabelNameContext>(_ctx, getState());
- enterRule(_localctx, 80, CypherParser::RuleLabelName);
-
- auto onExit = finally([=] {
- exitRule();
- });
- try {
- enterOuterAlt(_localctx, 1);
- setState(713);
- symbolicName();
-
- }
- catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- RelTypeNameContext ------------------------------------------------------------------
-
-CypherParser::RelTypeNameContext::RelTypeNameContext(ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {
-}
-
-CypherParser::SymbolicNameContext* CypherParser::RelTypeNameContext::symbolicName() {
- return getRuleContext<CypherParser::SymbolicNameContext>(0);
-}
-
-
-size_t CypherParser::RelTypeNameContext::getRuleIndex() const {
- return CypherParser::RuleRelTypeName;
-}
-
-void CypherParser::RelTypeNameContext::enterRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->enterRelTypeName(this);
-}
-
-void CypherParser::RelTypeNameContext::exitRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->exitRelTypeName(this);
-}
-
-
-antlrcpp::Any CypherParser::RelTypeNameContext::accept(tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
- return parserVisitor->visitRelTypeName(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::RelTypeNameContext* CypherParser::relTypeName() {
- RelTypeNameContext *_localctx = _tracker.createInstance<RelTypeNameContext>(_ctx, getState());
- enterRule(_localctx, 82, CypherParser::RuleRelTypeName);
-
- auto onExit = finally([=] {
- exitRule();
- });
- try {
- enterOuterAlt(_localctx, 1);
- setState(715);
- symbolicName();
-
- }
- catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- ExpressionContext ------------------------------------------------------------------
-
-CypherParser::ExpressionContext::ExpressionContext(ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {
-}
-
-CypherParser::Expression12Context* CypherParser::ExpressionContext::expression12() {
- return getRuleContext<CypherParser::Expression12Context>(0);
-}
-
-
-size_t CypherParser::ExpressionContext::getRuleIndex() const {
- return CypherParser::RuleExpression;
-}
-
-void CypherParser::ExpressionContext::enterRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->enterExpression(this);
-}
-
-void CypherParser::ExpressionContext::exitRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->exitExpression(this);
-}
-
-
-antlrcpp::Any CypherParser::ExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
- return parserVisitor->visitExpression(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::ExpressionContext* CypherParser::expression() {
- ExpressionContext *_localctx = _tracker.createInstance<ExpressionContext>(_ctx, getState());
- enterRule(_localctx, 84, CypherParser::RuleExpression);
-
- auto onExit = finally([=] {
- exitRule();
- });
- try {
- enterOuterAlt(_localctx, 1);
- setState(717);
- expression12();
-
- }
- catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- Expression12Context ------------------------------------------------------------------
-
-CypherParser::Expression12Context::Expression12Context(ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {
-}
-
-std::vector<CypherParser::Expression11Context *> CypherParser::Expression12Context::expression11() {
- return getRuleContexts<CypherParser::Expression11Context>();
-}
-
-CypherParser::Expression11Context* CypherParser::Expression12Context::expression11(size_t i) {
- return getRuleContext<CypherParser::Expression11Context>(i);
-}
-
-std::vector<tree::TerminalNode *> CypherParser::Expression12Context::SP() {
- return getTokens(CypherParser::SP);
-}
-
-tree::TerminalNode* CypherParser::Expression12Context::SP(size_t i) {
- return getToken(CypherParser::SP, i);
-}
-
-std::vector<tree::TerminalNode *> CypherParser::Expression12Context::OR() {
- return getTokens(CypherParser::OR);
-}
-
-tree::TerminalNode* CypherParser::Expression12Context::OR(size_t i) {
- return getToken(CypherParser::OR, i);
-}
-
-
-size_t CypherParser::Expression12Context::getRuleIndex() const {
- return CypherParser::RuleExpression12;
-}
-
-void CypherParser::Expression12Context::enterRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->enterExpression12(this);
-}
-
-void CypherParser::Expression12Context::exitRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->exitExpression12(this);
-}
-
-
-antlrcpp::Any CypherParser::Expression12Context::accept(tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
- return parserVisitor->visitExpression12(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::Expression12Context* CypherParser::expression12() {
- Expression12Context *_localctx = _tracker.createInstance<Expression12Context>(_ctx, getState());
- enterRule(_localctx, 86, CypherParser::RuleExpression12);
-
- auto onExit = finally([=] {
- exitRule();
- });
- try {
- size_t alt;
- enterOuterAlt(_localctx, 1);
- setState(719);
- expression11();
- setState(726);
- _errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 119, _ctx);
- while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
- if (alt == 1) {
- setState(720);
- match(CypherParser::SP);
- setState(721);
- match(CypherParser::OR);
- setState(722);
- match(CypherParser::SP);
- setState(723);
- expression11();
- }
- setState(728);
- _errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 119, _ctx);
- }
-
- }
- catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- Expression11Context ------------------------------------------------------------------
-
-CypherParser::Expression11Context::Expression11Context(ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {
-}
-
-std::vector<CypherParser::Expression10Context *> CypherParser::Expression11Context::expression10() {
- return getRuleContexts<CypherParser::Expression10Context>();
-}
-
-CypherParser::Expression10Context* CypherParser::Expression11Context::expression10(size_t i) {
- return getRuleContext<CypherParser::Expression10Context>(i);
-}
-
-std::vector<tree::TerminalNode *> CypherParser::Expression11Context::SP() {
- return getTokens(CypherParser::SP);
-}
-
-tree::TerminalNode* CypherParser::Expression11Context::SP(size_t i) {
- return getToken(CypherParser::SP, i);
-}
-
-std::vector<tree::TerminalNode *> CypherParser::Expression11Context::XOR() {
- return getTokens(CypherParser::XOR);
-}
-
-tree::TerminalNode* CypherParser::Expression11Context::XOR(size_t i) {
- return getToken(CypherParser::XOR, i);
-}
-
-
-size_t CypherParser::Expression11Context::getRuleIndex() const {
- return CypherParser::RuleExpression11;
-}
-
-void CypherParser::Expression11Context::enterRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->enterExpression11(this);
-}
-
-void CypherParser::Expression11Context::exitRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->exitExpression11(this);
-}
-
-
-antlrcpp::Any CypherParser::Expression11Context::accept(tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
- return parserVisitor->visitExpression11(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::Expression11Context* CypherParser::expression11() {
- Expression11Context *_localctx = _tracker.createInstance<Expression11Context>(_ctx, getState());
- enterRule(_localctx, 88, CypherParser::RuleExpression11);
-
- auto onExit = finally([=] {
- exitRule();
- });
- try {
- size_t alt;
- enterOuterAlt(_localctx, 1);
- setState(729);
- expression10();
- setState(736);
- _errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 120, _ctx);
- while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
- if (alt == 1) {
- setState(730);
- match(CypherParser::SP);
- setState(731);
- match(CypherParser::XOR);
- setState(732);
- match(CypherParser::SP);
- setState(733);
- expression10();
- }
- setState(738);
- _errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 120, _ctx);
- }
-
- }
- catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- Expression10Context ------------------------------------------------------------------
-
-CypherParser::Expression10Context::Expression10Context(ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {
-}
-
-std::vector<CypherParser::Expression9Context *> CypherParser::Expression10Context::expression9() {
- return getRuleContexts<CypherParser::Expression9Context>();
-}
-
-CypherParser::Expression9Context* CypherParser::Expression10Context::expression9(size_t i) {
- return getRuleContext<CypherParser::Expression9Context>(i);
-}
-
-std::vector<tree::TerminalNode *> CypherParser::Expression10Context::SP() {
- return getTokens(CypherParser::SP);
-}
-
-tree::TerminalNode* CypherParser::Expression10Context::SP(size_t i) {
- return getToken(CypherParser::SP, i);
-}
-
-std::vector<tree::TerminalNode *> CypherParser::Expression10Context::AND() {
- return getTokens(CypherParser::AND);
-}
-
-tree::TerminalNode* CypherParser::Expression10Context::AND(size_t i) {
- return getToken(CypherParser::AND, i);
-}
-
-
-size_t CypherParser::Expression10Context::getRuleIndex() const {
- return CypherParser::RuleExpression10;
-}
-
-void CypherParser::Expression10Context::enterRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->enterExpression10(this);
-}
-
-void CypherParser::Expression10Context::exitRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->exitExpression10(this);
-}
-
-
-antlrcpp::Any CypherParser::Expression10Context::accept(tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
- return parserVisitor->visitExpression10(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::Expression10Context* CypherParser::expression10() {
- Expression10Context *_localctx = _tracker.createInstance<Expression10Context>(_ctx, getState());
- enterRule(_localctx, 90, CypherParser::RuleExpression10);
-
- auto onExit = finally([=] {
- exitRule();
- });
- try {
- size_t alt;
- enterOuterAlt(_localctx, 1);
- setState(739);
- expression9();
- setState(746);
- _errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 121, _ctx);
- while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
- if (alt == 1) {
- setState(740);
- match(CypherParser::SP);
- setState(741);
- match(CypherParser::AND);
- setState(742);
- match(CypherParser::SP);
- setState(743);
- expression9();
- }
- setState(748);
- _errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 121, _ctx);
- }
-
- }
- catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- Expression9Context ------------------------------------------------------------------
-
-CypherParser::Expression9Context::Expression9Context(ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {
-}
-
-CypherParser::Expression8Context* CypherParser::Expression9Context::expression8() {
- return getRuleContext<CypherParser::Expression8Context>(0);
-}
-
-std::vector<tree::TerminalNode *> CypherParser::Expression9Context::NOT() {
- return getTokens(CypherParser::NOT);
-}
-
-tree::TerminalNode* CypherParser::Expression9Context::NOT(size_t i) {
- return getToken(CypherParser::NOT, i);
-}
-
-std::vector<tree::TerminalNode *> CypherParser::Expression9Context::SP() {
- return getTokens(CypherParser::SP);
-}
-
-tree::TerminalNode* CypherParser::Expression9Context::SP(size_t i) {
- return getToken(CypherParser::SP, i);
-}
-
-
-size_t CypherParser::Expression9Context::getRuleIndex() const {
- return CypherParser::RuleExpression9;
-}
-
-void CypherParser::Expression9Context::enterRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->enterExpression9(this);
-}
-
-void CypherParser::Expression9Context::exitRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->exitExpression9(this);
-}
-
-
-antlrcpp::Any CypherParser::Expression9Context::accept(tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
- return parserVisitor->visitExpression9(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::Expression9Context* CypherParser::expression9() {
- Expression9Context *_localctx = _tracker.createInstance<Expression9Context>(_ctx, getState());
- enterRule(_localctx, 92, CypherParser::RuleExpression9);
- size_t _la = 0;
-
- auto onExit = finally([=] {
- exitRule();
- });
- try {
- size_t alt;
- enterOuterAlt(_localctx, 1);
- setState(755);
- _errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 123, _ctx);
- while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
- if (alt == 1) {
- setState(749);
- match(CypherParser::NOT);
- setState(751);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(750);
- match(CypherParser::SP);
- }
- }
- setState(757);
- _errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 123, _ctx);
- }
- setState(758);
- expression8();
-
- }
- catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- Expression8Context ------------------------------------------------------------------
-
-CypherParser::Expression8Context::Expression8Context(ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {
-}
-
-CypherParser::Expression7Context* CypherParser::Expression8Context::expression7() {
- return getRuleContext<CypherParser::Expression7Context>(0);
-}
-
-std::vector<CypherParser::PartialComparisonExpressionContext *> CypherParser::Expression8Context::partialComparisonExpression() {
- return getRuleContexts<CypherParser::PartialComparisonExpressionContext>();
-}
-
-CypherParser::PartialComparisonExpressionContext* CypherParser::Expression8Context::partialComparisonExpression(size_t i) {
- return getRuleContext<CypherParser::PartialComparisonExpressionContext>(i);
-}
-
-std::vector<tree::TerminalNode *> CypherParser::Expression8Context::SP() {
- return getTokens(CypherParser::SP);
-}
-
-tree::TerminalNode* CypherParser::Expression8Context::SP(size_t i) {
- return getToken(CypherParser::SP, i);
-}
-
-
-size_t CypherParser::Expression8Context::getRuleIndex() const {
- return CypherParser::RuleExpression8;
-}
-
-void CypherParser::Expression8Context::enterRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->enterExpression8(this);
-}
-
-void CypherParser::Expression8Context::exitRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->exitExpression8(this);
-}
-
-
-antlrcpp::Any CypherParser::Expression8Context::accept(tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
- return parserVisitor->visitExpression8(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::Expression8Context* CypherParser::expression8() {
- Expression8Context *_localctx = _tracker.createInstance<Expression8Context>(_ctx, getState());
- enterRule(_localctx, 94, CypherParser::RuleExpression8);
- size_t _la = 0;
-
- auto onExit = finally([=] {
- exitRule();
- });
- try {
- size_t alt;
- enterOuterAlt(_localctx, 1);
- setState(760);
- expression7();
- setState(767);
- _errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 125, _ctx);
- while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
- if (alt == 1) {
- setState(762);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(761);
- match(CypherParser::SP);
- }
- setState(764);
- partialComparisonExpression();
- }
- setState(769);
- _errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 125, _ctx);
- }
-
- }
- catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- Expression7Context ------------------------------------------------------------------
-
-CypherParser::Expression7Context::Expression7Context(ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {
-}
-
-std::vector<CypherParser::Expression6Context *> CypherParser::Expression7Context::expression6() {
- return getRuleContexts<CypherParser::Expression6Context>();
-}
-
-CypherParser::Expression6Context* CypherParser::Expression7Context::expression6(size_t i) {
- return getRuleContext<CypherParser::Expression6Context>(i);
-}
-
-std::vector<tree::TerminalNode *> CypherParser::Expression7Context::SP() {
- return getTokens(CypherParser::SP);
-}
-
-tree::TerminalNode* CypherParser::Expression7Context::SP(size_t i) {
- return getToken(CypherParser::SP, i);
-}
-
-
-size_t CypherParser::Expression7Context::getRuleIndex() const {
- return CypherParser::RuleExpression7;
-}
-
-void CypherParser::Expression7Context::enterRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->enterExpression7(this);
-}
-
-void CypherParser::Expression7Context::exitRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->exitExpression7(this);
-}
-
-
-antlrcpp::Any CypherParser::Expression7Context::accept(tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
- return parserVisitor->visitExpression7(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::Expression7Context* CypherParser::expression7() {
- Expression7Context *_localctx = _tracker.createInstance<Expression7Context>(_ctx, getState());
- enterRule(_localctx, 96, CypherParser::RuleExpression7);
- size_t _la = 0;
-
- auto onExit = finally([=] {
- exitRule();
- });
- try {
- size_t alt;
- enterOuterAlt(_localctx, 1);
- setState(770);
- expression6();
- setState(789);
- _errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 131, _ctx);
- while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
- if (alt == 1) {
- setState(787);
- _errHandler->sync(this);
- switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 130, _ctx)) {
- case 1: {
- setState(772);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(771);
- match(CypherParser::SP);
- }
- setState(774);
- match(CypherParser::T__12);
- setState(776);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(775);
- match(CypherParser::SP);
- }
- setState(778);
- expression6();
- break;
- }
-
- case 2: {
- setState(780);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(779);
- match(CypherParser::SP);
- }
- setState(782);
- match(CypherParser::T__13);
- setState(784);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(783);
- match(CypherParser::SP);
- }
- setState(786);
- expression6();
- break;
- }
-
- }
- }
- setState(791);
- _errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 131, _ctx);
- }
-
- }
- catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- Expression6Context ------------------------------------------------------------------
-
-CypherParser::Expression6Context::Expression6Context(ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {
-}
-
-std::vector<CypherParser::Expression5Context *> CypherParser::Expression6Context::expression5() {
- return getRuleContexts<CypherParser::Expression5Context>();
-}
-
-CypherParser::Expression5Context* CypherParser::Expression6Context::expression5(size_t i) {
- return getRuleContext<CypherParser::Expression5Context>(i);
-}
-
-std::vector<tree::TerminalNode *> CypherParser::Expression6Context::SP() {
- return getTokens(CypherParser::SP);
-}
-
-tree::TerminalNode* CypherParser::Expression6Context::SP(size_t i) {
- return getToken(CypherParser::SP, i);
-}
-
-
-size_t CypherParser::Expression6Context::getRuleIndex() const {
- return CypherParser::RuleExpression6;
-}
-
-void CypherParser::Expression6Context::enterRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->enterExpression6(this);
-}
-
-void CypherParser::Expression6Context::exitRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->exitExpression6(this);
-}
-
-
-antlrcpp::Any CypherParser::Expression6Context::accept(tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
- return parserVisitor->visitExpression6(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::Expression6Context* CypherParser::expression6() {
- Expression6Context *_localctx = _tracker.createInstance<Expression6Context>(_ctx, getState());
- enterRule(_localctx, 98, CypherParser::RuleExpression6);
- size_t _la = 0;
-
- auto onExit = finally([=] {
- exitRule();
- });
- try {
- size_t alt;
- enterOuterAlt(_localctx, 1);
- setState(792);
- expression5();
- setState(819);
- _errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 139, _ctx);
- while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
- if (alt == 1) {
- setState(817);
- _errHandler->sync(this);
- switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 138, _ctx)) {
- case 1: {
- setState(794);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(793);
- match(CypherParser::SP);
- }
- setState(796);
- match(CypherParser::T__4);
- setState(798);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(797);
- match(CypherParser::SP);
- }
- setState(800);
- expression5();
- break;
- }
-
- case 2: {
- setState(802);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(801);
- match(CypherParser::SP);
- }
- setState(804);
- match(CypherParser::T__14);
- setState(806);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(805);
- match(CypherParser::SP);
- }
- setState(808);
- expression5();
- break;
- }
-
- case 3: {
- setState(810);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(809);
- match(CypherParser::SP);
- }
- setState(812);
- match(CypherParser::T__15);
- setState(814);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(813);
- match(CypherParser::SP);
- }
- setState(816);
- expression5();
- break;
- }
-
- }
- }
- setState(821);
- _errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 139, _ctx);
- }
-
- }
- catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- Expression5Context ------------------------------------------------------------------
-
-CypherParser::Expression5Context::Expression5Context(ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {
-}
-
-std::vector<CypherParser::Expression4Context *> CypherParser::Expression5Context::expression4() {
- return getRuleContexts<CypherParser::Expression4Context>();
-}
-
-CypherParser::Expression4Context* CypherParser::Expression5Context::expression4(size_t i) {
- return getRuleContext<CypherParser::Expression4Context>(i);
-}
-
-std::vector<tree::TerminalNode *> CypherParser::Expression5Context::SP() {
- return getTokens(CypherParser::SP);
-}
-
-tree::TerminalNode* CypherParser::Expression5Context::SP(size_t i) {
- return getToken(CypherParser::SP, i);
-}
-
-
-size_t CypherParser::Expression5Context::getRuleIndex() const {
- return CypherParser::RuleExpression5;
-}
-
-void CypherParser::Expression5Context::enterRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->enterExpression5(this);
-}
-
-void CypherParser::Expression5Context::exitRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->exitExpression5(this);
-}
-
-
-antlrcpp::Any CypherParser::Expression5Context::accept(tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
- return parserVisitor->visitExpression5(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::Expression5Context* CypherParser::expression5() {
- Expression5Context *_localctx = _tracker.createInstance<Expression5Context>(_ctx, getState());
- enterRule(_localctx, 100, CypherParser::RuleExpression5);
- size_t _la = 0;
-
- auto onExit = finally([=] {
- exitRule();
- });
- try {
- size_t alt;
- enterOuterAlt(_localctx, 1);
- setState(822);
- expression4();
- setState(833);
- _errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 142, _ctx);
- while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
- if (alt == 1) {
- setState(824);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(823);
- match(CypherParser::SP);
- }
- setState(826);
- match(CypherParser::T__16);
- setState(828);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(827);
- match(CypherParser::SP);
- }
- setState(830);
- expression4();
- }
- setState(835);
- _errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 142, _ctx);
- }
-
- }
- catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- Expression4Context ------------------------------------------------------------------
-
-CypherParser::Expression4Context::Expression4Context(ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {
-}
-
-CypherParser::Expression3Context* CypherParser::Expression4Context::expression3() {
- return getRuleContext<CypherParser::Expression3Context>(0);
-}
-
-std::vector<tree::TerminalNode *> CypherParser::Expression4Context::SP() {
- return getTokens(CypherParser::SP);
-}
-
-tree::TerminalNode* CypherParser::Expression4Context::SP(size_t i) {
- return getToken(CypherParser::SP, i);
-}
-
-
-size_t CypherParser::Expression4Context::getRuleIndex() const {
- return CypherParser::RuleExpression4;
-}
-
-void CypherParser::Expression4Context::enterRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->enterExpression4(this);
-}
-
-void CypherParser::Expression4Context::exitRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->exitExpression4(this);
-}
-
-
-antlrcpp::Any CypherParser::Expression4Context::accept(tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
- return parserVisitor->visitExpression4(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::Expression4Context* CypherParser::expression4() {
- Expression4Context *_localctx = _tracker.createInstance<Expression4Context>(_ctx, getState());
- enterRule(_localctx, 102, CypherParser::RuleExpression4);
- size_t _la = 0;
-
- auto onExit = finally([=] {
- exitRule();
- });
- try {
- enterOuterAlt(_localctx, 1);
- setState(842);
- _errHandler->sync(this);
- _la = _input->LA(1);
- while (_la == CypherParser::T__12
-
- || _la == CypherParser::T__13) {
- setState(836);
- _la = _input->LA(1);
- if (!(_la == CypherParser::T__12
-
- || _la == CypherParser::T__13)) {
- _errHandler->recoverInline(this);
- }
- else {
- _errHandler->reportMatch(this);
- consume();
- }
- setState(838);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(837);
- match(CypherParser::SP);
- }
- setState(844);
- _errHandler->sync(this);
- _la = _input->LA(1);
- }
- setState(845);
- expression3();
-
- }
- catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- Expression3Context ------------------------------------------------------------------
-
-CypherParser::Expression3Context::Expression3Context(ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {
-}
-
-std::vector<CypherParser::Expression2Context *> CypherParser::Expression3Context::expression2() {
- return getRuleContexts<CypherParser::Expression2Context>();
-}
-
-CypherParser::Expression2Context* CypherParser::Expression3Context::expression2(size_t i) {
- return getRuleContext<CypherParser::Expression2Context>(i);
-}
-
-std::vector<CypherParser::ExpressionContext *> CypherParser::Expression3Context::expression() {
- return getRuleContexts<CypherParser::ExpressionContext>();
-}
-
-CypherParser::ExpressionContext* CypherParser::Expression3Context::expression(size_t i) {
- return getRuleContext<CypherParser::ExpressionContext>(i);
-}
-
-std::vector<tree::TerminalNode *> CypherParser::Expression3Context::SP() {
- return getTokens(CypherParser::SP);
-}
-
-tree::TerminalNode* CypherParser::Expression3Context::SP(size_t i) {
- return getToken(CypherParser::SP, i);
-}
-
-std::vector<tree::TerminalNode *> CypherParser::Expression3Context::IS() {
- return getTokens(CypherParser::IS);
-}
-
-tree::TerminalNode* CypherParser::Expression3Context::IS(size_t i) {
- return getToken(CypherParser::IS, i);
-}
-
-std::vector<tree::TerminalNode *> CypherParser::Expression3Context::CYPHERNULL() {
- return getTokens(CypherParser::CYPHERNULL);
-}
-
-tree::TerminalNode* CypherParser::Expression3Context::CYPHERNULL(size_t i) {
- return getToken(CypherParser::CYPHERNULL, i);
-}
-
-std::vector<tree::TerminalNode *> CypherParser::Expression3Context::NOT() {
- return getTokens(CypherParser::NOT);
-}
-
-tree::TerminalNode* CypherParser::Expression3Context::NOT(size_t i) {
- return getToken(CypherParser::NOT, i);
-}
-
-std::vector<tree::TerminalNode *> CypherParser::Expression3Context::IN() {
- return getTokens(CypherParser::IN);
-}
-
-tree::TerminalNode* CypherParser::Expression3Context::IN(size_t i) {
- return getToken(CypherParser::IN, i);
-}
-
-std::vector<tree::TerminalNode *> CypherParser::Expression3Context::STARTS() {
- return getTokens(CypherParser::STARTS);
-}
-
-tree::TerminalNode* CypherParser::Expression3Context::STARTS(size_t i) {
- return getToken(CypherParser::STARTS, i);
-}
-
-std::vector<tree::TerminalNode *> CypherParser::Expression3Context::WITH() {
- return getTokens(CypherParser::WITH);
-}
-
-tree::TerminalNode* CypherParser::Expression3Context::WITH(size_t i) {
- return getToken(CypherParser::WITH, i);
-}
-
-std::vector<tree::TerminalNode *> CypherParser::Expression3Context::ENDS() {
- return getTokens(CypherParser::ENDS);
-}
-
-tree::TerminalNode* CypherParser::Expression3Context::ENDS(size_t i) {
- return getToken(CypherParser::ENDS, i);
-}
-
-std::vector<tree::TerminalNode *> CypherParser::Expression3Context::CONTAINS() {
- return getTokens(CypherParser::CONTAINS);
-}
-
-tree::TerminalNode* CypherParser::Expression3Context::CONTAINS(size_t i) {
- return getToken(CypherParser::CONTAINS, i);
-}
-
-
-size_t CypherParser::Expression3Context::getRuleIndex() const {
- return CypherParser::RuleExpression3;
-}
-
-void CypherParser::Expression3Context::enterRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->enterExpression3(this);
-}
-
-void CypherParser::Expression3Context::exitRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->exitExpression3(this);
-}
-
-
-antlrcpp::Any CypherParser::Expression3Context::accept(tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
- return parserVisitor->visitExpression3(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::Expression3Context* CypherParser::expression3() {
- Expression3Context *_localctx = _tracker.createInstance<Expression3Context>(_ctx, getState());
- enterRule(_localctx, 104, CypherParser::RuleExpression3);
- size_t _la = 0;
-
- auto onExit = finally([=] {
- exitRule();
- });
- try {
- size_t alt;
- enterOuterAlt(_localctx, 1);
- setState(847);
- expression2();
- setState(901);
- _errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 153, _ctx);
- while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
- if (alt == 1) {
- setState(899);
- _errHandler->sync(this);
- switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 152, _ctx)) {
- case 1: {
- setState(849);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(848);
- match(CypherParser::SP);
- }
- setState(851);
- match(CypherParser::T__7);
- setState(852);
- expression();
- setState(853);
- match(CypherParser::T__8);
- break;
- }
-
- case 2: {
- setState(856);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(855);
- match(CypherParser::SP);
- }
- setState(858);
- match(CypherParser::T__7);
- setState(860);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if ((((_la & ~ 0x3fULL) == 0) &&
- ((1ULL << _la) & ((1ULL << CypherParser::T__5)
- | (1ULL << CypherParser::T__7)
- | (1ULL << CypherParser::T__12)
- | (1ULL << CypherParser::T__13)
- | (1ULL << CypherParser::T__25)
- | (1ULL << CypherParser::T__27)
- | (1ULL << CypherParser::StringLiteral)
- | (1ULL << CypherParser::HexInteger)
- | (1ULL << CypherParser::DecimalInteger)
- | (1ULL << CypherParser::OctalInteger)
- | (1ULL << CypherParser::HexLetter)
- | (1ULL << CypherParser::ExponentDecimalReal)
- | (1ULL << CypherParser::RegularDecimalReal)
- | (1ULL << CypherParser::UNION)
- | (1ULL << CypherParser::ALL))) != 0) || ((((_la - 64) & ~ 0x3fULL) == 0) &&
- ((1ULL << (_la - 64)) & ((1ULL << (CypherParser::OPTIONAL - 64))
- | (1ULL << (CypherParser::MATCH - 64))
- | (1ULL << (CypherParser::UNWIND - 64))
- | (1ULL << (CypherParser::AS - 64))
- | (1ULL << (CypherParser::MERGE - 64))
- | (1ULL << (CypherParser::ON - 64))
- | (1ULL << (CypherParser::CREATE - 64))
- | (1ULL << (CypherParser::SET - 64))
- | (1ULL << (CypherParser::DETACH - 64))
- | (1ULL << (CypherParser::DELETE - 64))
- | (1ULL << (CypherParser::REMOVE - 64))
- | (1ULL << (CypherParser::WITH - 64))
- | (1ULL << (CypherParser::DISTINCT - 64))
- | (1ULL << (CypherParser::RETURN - 64))
- | (1ULL << (CypherParser::ORDER - 64))
- | (1ULL << (CypherParser::BY - 64))
- | (1ULL << (CypherParser::L_SKIP - 64))
- | (1ULL << (CypherParser::LIMIT - 64))
- | (1ULL << (CypherParser::ASCENDING - 64))
- | (1ULL << (CypherParser::ASC - 64))
- | (1ULL << (CypherParser::DESCENDING - 64))
- | (1ULL << (CypherParser::DESC - 64))
- | (1ULL << (CypherParser::WHERE - 64))
- | (1ULL << (CypherParser::OR - 64))
- | (1ULL << (CypherParser::XOR - 64))
- | (1ULL << (CypherParser::AND - 64))
- | (1ULL << (CypherParser::NOT - 64))
- | (1ULL << (CypherParser::IN - 64))
- | (1ULL << (CypherParser::STARTS - 64))
- | (1ULL << (CypherParser::ENDS - 64))
- | (1ULL << (CypherParser::CONTAINS - 64))
- | (1ULL << (CypherParser::IS - 64))
- | (1ULL << (CypherParser::CYPHERNULL - 64))
- | (1ULL << (CypherParser::COUNT - 64))
- | (1ULL << (CypherParser::FILTER - 64))
- | (1ULL << (CypherParser::EXTRACT - 64))
- | (1ULL << (CypherParser::ANY - 64))
- | (1ULL << (CypherParser::NONE - 64))
- | (1ULL << (CypherParser::SINGLE - 64))
- | (1ULL << (CypherParser::TRUE - 64))
- | (1ULL << (CypherParser::FALSE - 64))
- | (1ULL << (CypherParser::UnescapedSymbolicName - 64))
- | (1ULL << (CypherParser::EscapedSymbolicName - 64)))) != 0)) {
- setState(859);
- expression();
- }
- setState(862);
- match(CypherParser::T__11);
- setState(864);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if ((((_la & ~ 0x3fULL) == 0) &&
- ((1ULL << _la) & ((1ULL << CypherParser::T__5)
- | (1ULL << CypherParser::T__7)
- | (1ULL << CypherParser::T__12)
- | (1ULL << CypherParser::T__13)
- | (1ULL << CypherParser::T__25)
- | (1ULL << CypherParser::T__27)
- | (1ULL << CypherParser::StringLiteral)
- | (1ULL << CypherParser::HexInteger)
- | (1ULL << CypherParser::DecimalInteger)
- | (1ULL << CypherParser::OctalInteger)
- | (1ULL << CypherParser::HexLetter)
- | (1ULL << CypherParser::ExponentDecimalReal)
- | (1ULL << CypherParser::RegularDecimalReal)
- | (1ULL << CypherParser::UNION)
- | (1ULL << CypherParser::ALL))) != 0) || ((((_la - 64) & ~ 0x3fULL) == 0) &&
- ((1ULL << (_la - 64)) & ((1ULL << (CypherParser::OPTIONAL - 64))
- | (1ULL << (CypherParser::MATCH - 64))
- | (1ULL << (CypherParser::UNWIND - 64))
- | (1ULL << (CypherParser::AS - 64))
- | (1ULL << (CypherParser::MERGE - 64))
- | (1ULL << (CypherParser::ON - 64))
- | (1ULL << (CypherParser::CREATE - 64))
- | (1ULL << (CypherParser::SET - 64))
- | (1ULL << (CypherParser::DETACH - 64))
- | (1ULL << (CypherParser::DELETE - 64))
- | (1ULL << (CypherParser::REMOVE - 64))
- | (1ULL << (CypherParser::WITH - 64))
- | (1ULL << (CypherParser::DISTINCT - 64))
- | (1ULL << (CypherParser::RETURN - 64))
- | (1ULL << (CypherParser::ORDER - 64))
- | (1ULL << (CypherParser::BY - 64))
- | (1ULL << (CypherParser::L_SKIP - 64))
- | (1ULL << (CypherParser::LIMIT - 64))
- | (1ULL << (CypherParser::ASCENDING - 64))
- | (1ULL << (CypherParser::ASC - 64))
- | (1ULL << (CypherParser::DESCENDING - 64))
- | (1ULL << (CypherParser::DESC - 64))
- | (1ULL << (CypherParser::WHERE - 64))
- | (1ULL << (CypherParser::OR - 64))
- | (1ULL << (CypherParser::XOR - 64))
- | (1ULL << (CypherParser::AND - 64))
- | (1ULL << (CypherParser::NOT - 64))
- | (1ULL << (CypherParser::IN - 64))
- | (1ULL << (CypherParser::STARTS - 64))
- | (1ULL << (CypherParser::ENDS - 64))
- | (1ULL << (CypherParser::CONTAINS - 64))
- | (1ULL << (CypherParser::IS - 64))
- | (1ULL << (CypherParser::CYPHERNULL - 64))
- | (1ULL << (CypherParser::COUNT - 64))
- | (1ULL << (CypherParser::FILTER - 64))
- | (1ULL << (CypherParser::EXTRACT - 64))
- | (1ULL << (CypherParser::ANY - 64))
- | (1ULL << (CypherParser::NONE - 64))
- | (1ULL << (CypherParser::SINGLE - 64))
- | (1ULL << (CypherParser::TRUE - 64))
- | (1ULL << (CypherParser::FALSE - 64))
- | (1ULL << (CypherParser::UnescapedSymbolicName - 64))
- | (1ULL << (CypherParser::EscapedSymbolicName - 64)))) != 0)) {
- setState(863);
- expression();
- }
- setState(866);
- match(CypherParser::T__8);
- break;
- }
-
- case 3: {
- setState(883);
- _errHandler->sync(this);
- switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 150, _ctx)) {
- case 1: {
- setState(868);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(867);
- match(CypherParser::SP);
- }
- setState(870);
- match(CypherParser::T__17);
- break;
- }
-
- case 2: {
- setState(871);
- match(CypherParser::SP);
- setState(872);
- match(CypherParser::IN);
- break;
- }
-
- case 3: {
- setState(873);
- match(CypherParser::SP);
- setState(874);
- match(CypherParser::STARTS);
- setState(875);
- match(CypherParser::SP);
- setState(876);
- match(CypherParser::WITH);
- break;
- }
-
- case 4: {
- setState(877);
- match(CypherParser::SP);
- setState(878);
- match(CypherParser::ENDS);
- setState(879);
- match(CypherParser::SP);
- setState(880);
- match(CypherParser::WITH);
- break;
- }
-
- case 5: {
- setState(881);
- match(CypherParser::SP);
- setState(882);
- match(CypherParser::CONTAINS);
- break;
- }
-
- }
- setState(886);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(885);
- match(CypherParser::SP);
- }
- setState(888);
- expression2();
- break;
- }
-
- case 4: {
- setState(889);
- match(CypherParser::SP);
- setState(890);
- match(CypherParser::IS);
- setState(891);
- match(CypherParser::SP);
- setState(892);
- match(CypherParser::CYPHERNULL);
- break;
- }
-
- case 5: {
- setState(893);
- match(CypherParser::SP);
- setState(894);
- match(CypherParser::IS);
- setState(895);
- match(CypherParser::SP);
- setState(896);
- match(CypherParser::NOT);
- setState(897);
- match(CypherParser::SP);
- setState(898);
- match(CypherParser::CYPHERNULL);
- break;
- }
-
- }
- }
- setState(903);
- _errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 153, _ctx);
- }
-
- }
- catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- Expression2Context ------------------------------------------------------------------
-
-CypherParser::Expression2Context::Expression2Context(ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {
-}
-
-CypherParser::AtomContext* CypherParser::Expression2Context::atom() {
- return getRuleContext<CypherParser::AtomContext>(0);
-}
-
-std::vector<CypherParser::PropertyLookupContext *> CypherParser::Expression2Context::propertyLookup() {
- return getRuleContexts<CypherParser::PropertyLookupContext>();
-}
-
-CypherParser::PropertyLookupContext* CypherParser::Expression2Context::propertyLookup(size_t i) {
- return getRuleContext<CypherParser::PropertyLookupContext>(i);
-}
-
-std::vector<CypherParser::NodeLabelsContext *> CypherParser::Expression2Context::nodeLabels() {
- return getRuleContexts<CypherParser::NodeLabelsContext>();
-}
-
-CypherParser::NodeLabelsContext* CypherParser::Expression2Context::nodeLabels(size_t i) {
- return getRuleContext<CypherParser::NodeLabelsContext>(i);
-}
-
-std::vector<tree::TerminalNode *> CypherParser::Expression2Context::SP() {
- return getTokens(CypherParser::SP);
-}
-
-tree::TerminalNode* CypherParser::Expression2Context::SP(size_t i) {
- return getToken(CypherParser::SP, i);
-}
-
-
-size_t CypherParser::Expression2Context::getRuleIndex() const {
- return CypherParser::RuleExpression2;
-}
-
-void CypherParser::Expression2Context::enterRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->enterExpression2(this);
-}
-
-void CypherParser::Expression2Context::exitRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->exitExpression2(this);
-}
-
-
-antlrcpp::Any CypherParser::Expression2Context::accept(tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
- return parserVisitor->visitExpression2(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::Expression2Context* CypherParser::expression2() {
- Expression2Context *_localctx = _tracker.createInstance<Expression2Context>(_ctx, getState());
- enterRule(_localctx, 106, CypherParser::RuleExpression2);
- size_t _la = 0;
-
- auto onExit = finally([=] {
- exitRule();
- });
- try {
- size_t alt;
- enterOuterAlt(_localctx, 1);
- setState(904);
- atom();
- setState(914);
- _errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 156, _ctx);
- while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
- if (alt == 1) {
- setState(906);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(905);
- match(CypherParser::SP);
- }
- setState(910);
- _errHandler->sync(this);
- switch (_input->LA(1)) {
- case CypherParser::T__24: {
- setState(908);
- propertyLookup();
- break;
- }
-
- case CypherParser::T__9: {
- setState(909);
- nodeLabels();
- break;
- }
-
- default:
- throw NoViableAltException(this);
- }
- }
- setState(916);
- _errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 156, _ctx);
- }
-
- }
- catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- AtomContext ------------------------------------------------------------------
-
-CypherParser::AtomContext::AtomContext(ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {
-}
-
-CypherParser::LiteralContext* CypherParser::AtomContext::literal() {
- return getRuleContext<CypherParser::LiteralContext>(0);
-}
-
-CypherParser::ParameterContext* CypherParser::AtomContext::parameter() {
- return getRuleContext<CypherParser::ParameterContext>(0);
-}
-
-tree::TerminalNode* CypherParser::AtomContext::COUNT() {
- return getToken(CypherParser::COUNT, 0);
-}
-
-std::vector<tree::TerminalNode *> CypherParser::AtomContext::SP() {
- return getTokens(CypherParser::SP);
-}
-
-tree::TerminalNode* CypherParser::AtomContext::SP(size_t i) {
- return getToken(CypherParser::SP, i);
-}
-
-CypherParser::ListComprehensionContext* CypherParser::AtomContext::listComprehension() {
- return getRuleContext<CypherParser::ListComprehensionContext>(0);
-}
-
-CypherParser::PatternComprehensionContext* CypherParser::AtomContext::patternComprehension() {
- return getRuleContext<CypherParser::PatternComprehensionContext>(0);
-}
-
-tree::TerminalNode* CypherParser::AtomContext::FILTER() {
- return getToken(CypherParser::FILTER, 0);
-}
-
-CypherParser::FilterExpressionContext* CypherParser::AtomContext::filterExpression() {
- return getRuleContext<CypherParser::FilterExpressionContext>(0);
-}
-
-tree::TerminalNode* CypherParser::AtomContext::EXTRACT() {
- return getToken(CypherParser::EXTRACT, 0);
-}
-
-CypherParser::ExpressionContext* CypherParser::AtomContext::expression() {
- return getRuleContext<CypherParser::ExpressionContext>(0);
-}
-
-tree::TerminalNode* CypherParser::AtomContext::ALL() {
- return getToken(CypherParser::ALL, 0);
-}
-
-tree::TerminalNode* CypherParser::AtomContext::ANY() {
- return getToken(CypherParser::ANY, 0);
-}
-
-tree::TerminalNode* CypherParser::AtomContext::NONE() {
- return getToken(CypherParser::NONE, 0);
-}
-
-tree::TerminalNode* CypherParser::AtomContext::SINGLE() {
- return getToken(CypherParser::SINGLE, 0);
-}
-
-CypherParser::RelationshipsPatternContext* CypherParser::AtomContext::relationshipsPattern() {
- return getRuleContext<CypherParser::RelationshipsPatternContext>(0);
-}
-
-CypherParser::ParenthesizedExpressionContext* CypherParser::AtomContext::parenthesizedExpression() {
- return getRuleContext<CypherParser::ParenthesizedExpressionContext>(0);
-}
-
-CypherParser::FunctionInvocationContext* CypherParser::AtomContext::functionInvocation() {
- return getRuleContext<CypherParser::FunctionInvocationContext>(0);
-}
-
-CypherParser::VariableContext* CypherParser::AtomContext::variable() {
- return getRuleContext<CypherParser::VariableContext>(0);
-}
-
-
-size_t CypherParser::AtomContext::getRuleIndex() const {
- return CypherParser::RuleAtom;
-}
-
-void CypherParser::AtomContext::enterRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->enterAtom(this);
-}
-
-void CypherParser::AtomContext::exitRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->exitAtom(this);
-}
-
-
-antlrcpp::Any CypherParser::AtomContext::accept(tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
- return parserVisitor->visitAtom(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::AtomContext* CypherParser::atom() {
- AtomContext *_localctx = _tracker.createInstance<AtomContext>(_ctx, getState());
- enterRule(_localctx, 108, CypherParser::RuleAtom);
- size_t _la = 0;
-
- auto onExit = finally([=] {
- exitRule();
- });
- try {
- setState(1029);
- _errHandler->sync(this);
- switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 180, _ctx)) {
- case 1: {
- enterOuterAlt(_localctx, 1);
- setState(917);
- literal();
- break;
- }
-
- case 2: {
- enterOuterAlt(_localctx, 2);
- setState(918);
- parameter();
- break;
- }
-
- case 3: {
- enterOuterAlt(_localctx, 3);
- setState(919);
- match(CypherParser::COUNT);
- setState(921);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(920);
- match(CypherParser::SP);
- }
- setState(923);
- match(CypherParser::T__5);
- setState(925);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(924);
- match(CypherParser::SP);
- }
- setState(927);
- match(CypherParser::T__4);
- setState(929);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(928);
- match(CypherParser::SP);
- }
- setState(931);
- match(CypherParser::T__6);
- break;
- }
-
- case 4: {
- enterOuterAlt(_localctx, 4);
- setState(932);
- listComprehension();
- break;
- }
-
- case 5: {
- enterOuterAlt(_localctx, 5);
- setState(933);
- patternComprehension();
- break;
- }
-
- case 6: {
- enterOuterAlt(_localctx, 6);
- setState(934);
- match(CypherParser::FILTER);
- setState(936);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(935);
- match(CypherParser::SP);
- }
- setState(938);
- match(CypherParser::T__5);
- setState(940);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(939);
- match(CypherParser::SP);
- }
- setState(942);
- filterExpression();
- setState(944);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(943);
- match(CypherParser::SP);
- }
- setState(946);
- match(CypherParser::T__6);
- break;
- }
-
- case 7: {
- enterOuterAlt(_localctx, 7);
- setState(948);
- match(CypherParser::EXTRACT);
- setState(950);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(949);
- match(CypherParser::SP);
- }
- setState(952);
- match(CypherParser::T__5);
- setState(954);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(953);
- match(CypherParser::SP);
- }
- setState(956);
- filterExpression();
- setState(958);
- _errHandler->sync(this);
-
- switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 165, _ctx)) {
- case 1: {
- setState(957);
- match(CypherParser::SP);
- break;
- }
-
- }
- setState(965);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::T__10 || _la == CypherParser::SP) {
- setState(961);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(960);
- match(CypherParser::SP);
- }
- setState(963);
- match(CypherParser::T__10);
- setState(964);
- expression();
- }
- setState(967);
- match(CypherParser::T__6);
- break;
- }
-
- case 8: {
- enterOuterAlt(_localctx, 8);
- setState(969);
- match(CypherParser::ALL);
- setState(971);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(970);
- match(CypherParser::SP);
- }
- setState(973);
- match(CypherParser::T__5);
- setState(975);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(974);
- match(CypherParser::SP);
- }
- setState(977);
- filterExpression();
- setState(979);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(978);
- match(CypherParser::SP);
- }
- setState(981);
- match(CypherParser::T__6);
- break;
- }
-
- case 9: {
- enterOuterAlt(_localctx, 9);
- setState(983);
- match(CypherParser::ANY);
- setState(985);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(984);
- match(CypherParser::SP);
- }
- setState(987);
- match(CypherParser::T__5);
- setState(989);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(988);
- match(CypherParser::SP);
- }
- setState(991);
- filterExpression();
- setState(993);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(992);
- match(CypherParser::SP);
- }
- setState(995);
- match(CypherParser::T__6);
- break;
- }
-
- case 10: {
- enterOuterAlt(_localctx, 10);
- setState(997);
- match(CypherParser::NONE);
- setState(999);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(998);
- match(CypherParser::SP);
- }
- setState(1001);
- match(CypherParser::T__5);
- setState(1003);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(1002);
- match(CypherParser::SP);
- }
- setState(1005);
- filterExpression();
- setState(1007);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(1006);
- match(CypherParser::SP);
- }
- setState(1009);
- match(CypherParser::T__6);
- break;
- }
-
- case 11: {
- enterOuterAlt(_localctx, 11);
- setState(1011);
- match(CypherParser::SINGLE);
- setState(1013);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(1012);
- match(CypherParser::SP);
- }
- setState(1015);
- match(CypherParser::T__5);
- setState(1017);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(1016);
- match(CypherParser::SP);
- }
- setState(1019);
- filterExpression();
- setState(1021);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(1020);
- match(CypherParser::SP);
- }
- setState(1023);
- match(CypherParser::T__6);
- break;
- }
-
- case 12: {
- enterOuterAlt(_localctx, 12);
- setState(1025);
- relationshipsPattern();
- break;
- }
-
- case 13: {
- enterOuterAlt(_localctx, 13);
- setState(1026);
- parenthesizedExpression();
- break;
- }
-
- case 14: {
- enterOuterAlt(_localctx, 14);
- setState(1027);
- functionInvocation();
- break;
- }
-
- case 15: {
- enterOuterAlt(_localctx, 15);
- setState(1028);
- variable();
- break;
- }
-
- }
-
- }
- catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- LiteralContext ------------------------------------------------------------------
-
-CypherParser::LiteralContext::LiteralContext(ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {
-}
-
-CypherParser::NumberLiteralContext* CypherParser::LiteralContext::numberLiteral() {
- return getRuleContext<CypherParser::NumberLiteralContext>(0);
-}
-
-tree::TerminalNode* CypherParser::LiteralContext::StringLiteral() {
- return getToken(CypherParser::StringLiteral, 0);
-}
-
-CypherParser::BooleanLiteralContext* CypherParser::LiteralContext::booleanLiteral() {
- return getRuleContext<CypherParser::BooleanLiteralContext>(0);
-}
-
-tree::TerminalNode* CypherParser::LiteralContext::CYPHERNULL() {
- return getToken(CypherParser::CYPHERNULL, 0);
-}
-
-CypherParser::MapLiteralContext* CypherParser::LiteralContext::mapLiteral() {
- return getRuleContext<CypherParser::MapLiteralContext>(0);
-}
-
-CypherParser::ListLiteralContext* CypherParser::LiteralContext::listLiteral() {
- return getRuleContext<CypherParser::ListLiteralContext>(0);
-}
-
-
-size_t CypherParser::LiteralContext::getRuleIndex() const {
- return CypherParser::RuleLiteral;
-}
-
-void CypherParser::LiteralContext::enterRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->enterLiteral(this);
-}
-
-void CypherParser::LiteralContext::exitRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->exitLiteral(this);
-}
-
-
-antlrcpp::Any CypherParser::LiteralContext::accept(tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
- return parserVisitor->visitLiteral(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::LiteralContext* CypherParser::literal() {
- LiteralContext *_localctx = _tracker.createInstance<LiteralContext>(_ctx, getState());
- enterRule(_localctx, 110, CypherParser::RuleLiteral);
-
- auto onExit = finally([=] {
- exitRule();
- });
- try {
- setState(1037);
- _errHandler->sync(this);
- switch (_input->LA(1)) {
- case CypherParser::HexInteger:
- case CypherParser::DecimalInteger:
- case CypherParser::OctalInteger:
- case CypherParser::ExponentDecimalReal:
- case CypherParser::RegularDecimalReal: {
- enterOuterAlt(_localctx, 1);
- setState(1031);
- numberLiteral();
- break;
- }
-
- case CypherParser::StringLiteral: {
- enterOuterAlt(_localctx, 2);
- setState(1032);
- match(CypherParser::StringLiteral);
- break;
- }
-
- case CypherParser::TRUE:
- case CypherParser::FALSE: {
- enterOuterAlt(_localctx, 3);
- setState(1033);
- booleanLiteral();
- break;
- }
-
- case CypherParser::CYPHERNULL: {
- enterOuterAlt(_localctx, 4);
- setState(1034);
- match(CypherParser::CYPHERNULL);
- break;
- }
-
- case CypherParser::T__25: {
- enterOuterAlt(_localctx, 5);
- setState(1035);
- mapLiteral();
- break;
- }
-
- case CypherParser::T__7: {
- enterOuterAlt(_localctx, 6);
- setState(1036);
- listLiteral();
- break;
- }
-
- default:
- throw NoViableAltException(this);
- }
-
- }
- catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- BooleanLiteralContext ------------------------------------------------------------------
-
-CypherParser::BooleanLiteralContext::BooleanLiteralContext(ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {
-}
-
-tree::TerminalNode* CypherParser::BooleanLiteralContext::TRUE() {
- return getToken(CypherParser::TRUE, 0);
-}
-
-tree::TerminalNode* CypherParser::BooleanLiteralContext::FALSE() {
- return getToken(CypherParser::FALSE, 0);
-}
-
-
-size_t CypherParser::BooleanLiteralContext::getRuleIndex() const {
- return CypherParser::RuleBooleanLiteral;
-}
-
-void CypherParser::BooleanLiteralContext::enterRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->enterBooleanLiteral(this);
-}
-
-void CypherParser::BooleanLiteralContext::exitRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->exitBooleanLiteral(this);
-}
-
-
-antlrcpp::Any CypherParser::BooleanLiteralContext::accept(tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
- return parserVisitor->visitBooleanLiteral(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::BooleanLiteralContext* CypherParser::booleanLiteral() {
- BooleanLiteralContext *_localctx = _tracker.createInstance<BooleanLiteralContext>(_ctx, getState());
- enterRule(_localctx, 112, CypherParser::RuleBooleanLiteral);
- size_t _la = 0;
-
- auto onExit = finally([=] {
- exitRule();
- });
- try {
- enterOuterAlt(_localctx, 1);
- setState(1039);
- _la = _input->LA(1);
- if (!(_la == CypherParser::TRUE
-
- || _la == CypherParser::FALSE)) {
- _errHandler->recoverInline(this);
- }
- else {
- _errHandler->reportMatch(this);
- consume();
- }
-
- }
- catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- ListLiteralContext ------------------------------------------------------------------
-
-CypherParser::ListLiteralContext::ListLiteralContext(ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {
-}
-
-std::vector<tree::TerminalNode *> CypherParser::ListLiteralContext::SP() {
- return getTokens(CypherParser::SP);
-}
-
-tree::TerminalNode* CypherParser::ListLiteralContext::SP(size_t i) {
- return getToken(CypherParser::SP, i);
-}
-
-std::vector<CypherParser::ExpressionContext *> CypherParser::ListLiteralContext::expression() {
- return getRuleContexts<CypherParser::ExpressionContext>();
-}
-
-CypherParser::ExpressionContext* CypherParser::ListLiteralContext::expression(size_t i) {
- return getRuleContext<CypherParser::ExpressionContext>(i);
-}
-
-
-size_t CypherParser::ListLiteralContext::getRuleIndex() const {
- return CypherParser::RuleListLiteral;
-}
-
-void CypherParser::ListLiteralContext::enterRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->enterListLiteral(this);
-}
-
-void CypherParser::ListLiteralContext::exitRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->exitListLiteral(this);
-}
-
-
-antlrcpp::Any CypherParser::ListLiteralContext::accept(tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
- return parserVisitor->visitListLiteral(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::ListLiteralContext* CypherParser::listLiteral() {
- ListLiteralContext *_localctx = _tracker.createInstance<ListLiteralContext>(_ctx, getState());
- enterRule(_localctx, 114, CypherParser::RuleListLiteral);
- size_t _la = 0;
-
- auto onExit = finally([=] {
- exitRule();
- });
- try {
- enterOuterAlt(_localctx, 1);
- setState(1041);
- match(CypherParser::T__7);
- setState(1043);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(1042);
- match(CypherParser::SP);
- }
- setState(1062);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if ((((_la & ~ 0x3fULL) == 0) &&
- ((1ULL << _la) & ((1ULL << CypherParser::T__5)
- | (1ULL << CypherParser::T__7)
- | (1ULL << CypherParser::T__12)
- | (1ULL << CypherParser::T__13)
- | (1ULL << CypherParser::T__25)
- | (1ULL << CypherParser::T__27)
- | (1ULL << CypherParser::StringLiteral)
- | (1ULL << CypherParser::HexInteger)
- | (1ULL << CypherParser::DecimalInteger)
- | (1ULL << CypherParser::OctalInteger)
- | (1ULL << CypherParser::HexLetter)
- | (1ULL << CypherParser::ExponentDecimalReal)
- | (1ULL << CypherParser::RegularDecimalReal)
- | (1ULL << CypherParser::UNION)
- | (1ULL << CypherParser::ALL))) != 0) || ((((_la - 64) & ~ 0x3fULL) == 0) &&
- ((1ULL << (_la - 64)) & ((1ULL << (CypherParser::OPTIONAL - 64))
- | (1ULL << (CypherParser::MATCH - 64))
- | (1ULL << (CypherParser::UNWIND - 64))
- | (1ULL << (CypherParser::AS - 64))
- | (1ULL << (CypherParser::MERGE - 64))
- | (1ULL << (CypherParser::ON - 64))
- | (1ULL << (CypherParser::CREATE - 64))
- | (1ULL << (CypherParser::SET - 64))
- | (1ULL << (CypherParser::DETACH - 64))
- | (1ULL << (CypherParser::DELETE - 64))
- | (1ULL << (CypherParser::REMOVE - 64))
- | (1ULL << (CypherParser::WITH - 64))
- | (1ULL << (CypherParser::DISTINCT - 64))
- | (1ULL << (CypherParser::RETURN - 64))
- | (1ULL << (CypherParser::ORDER - 64))
- | (1ULL << (CypherParser::BY - 64))
- | (1ULL << (CypherParser::L_SKIP - 64))
- | (1ULL << (CypherParser::LIMIT - 64))
- | (1ULL << (CypherParser::ASCENDING - 64))
- | (1ULL << (CypherParser::ASC - 64))
- | (1ULL << (CypherParser::DESCENDING - 64))
- | (1ULL << (CypherParser::DESC - 64))
- | (1ULL << (CypherParser::WHERE - 64))
- | (1ULL << (CypherParser::OR - 64))
- | (1ULL << (CypherParser::XOR - 64))
- | (1ULL << (CypherParser::AND - 64))
- | (1ULL << (CypherParser::NOT - 64))
- | (1ULL << (CypherParser::IN - 64))
- | (1ULL << (CypherParser::STARTS - 64))
- | (1ULL << (CypherParser::ENDS - 64))
- | (1ULL << (CypherParser::CONTAINS - 64))
- | (1ULL << (CypherParser::IS - 64))
- | (1ULL << (CypherParser::CYPHERNULL - 64))
- | (1ULL << (CypherParser::COUNT - 64))
- | (1ULL << (CypherParser::FILTER - 64))
- | (1ULL << (CypherParser::EXTRACT - 64))
- | (1ULL << (CypherParser::ANY - 64))
- | (1ULL << (CypherParser::NONE - 64))
- | (1ULL << (CypherParser::SINGLE - 64))
- | (1ULL << (CypherParser::TRUE - 64))
- | (1ULL << (CypherParser::FALSE - 64))
- | (1ULL << (CypherParser::UnescapedSymbolicName - 64))
- | (1ULL << (CypherParser::EscapedSymbolicName - 64)))) != 0)) {
- setState(1045);
- expression();
- setState(1047);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(1046);
- match(CypherParser::SP);
- }
- setState(1059);
- _errHandler->sync(this);
- _la = _input->LA(1);
- while (_la == CypherParser::T__1) {
- setState(1049);
- match(CypherParser::T__1);
- setState(1051);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(1050);
- match(CypherParser::SP);
- }
- setState(1053);
- expression();
- setState(1055);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(1054);
- match(CypherParser::SP);
- }
- setState(1061);
- _errHandler->sync(this);
- _la = _input->LA(1);
- }
- }
- setState(1064);
- match(CypherParser::T__8);
-
- }
- catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- PartialComparisonExpressionContext ------------------------------------------------------------------
-
-CypherParser::PartialComparisonExpressionContext::PartialComparisonExpressionContext(ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {
-}
-
-CypherParser::Expression7Context* CypherParser::PartialComparisonExpressionContext::expression7() {
- return getRuleContext<CypherParser::Expression7Context>(0);
-}
-
-tree::TerminalNode* CypherParser::PartialComparisonExpressionContext::SP() {
- return getToken(CypherParser::SP, 0);
-}
-
-
-size_t CypherParser::PartialComparisonExpressionContext::getRuleIndex() const {
- return CypherParser::RulePartialComparisonExpression;
-}
-
-void CypherParser::PartialComparisonExpressionContext::enterRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->enterPartialComparisonExpression(this);
-}
-
-void CypherParser::PartialComparisonExpressionContext::exitRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->exitPartialComparisonExpression(this);
-}
-
-
-antlrcpp::Any CypherParser::PartialComparisonExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
- return parserVisitor->visitPartialComparisonExpression(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::PartialComparisonExpressionContext* CypherParser::partialComparisonExpression() {
- PartialComparisonExpressionContext *_localctx = _tracker.createInstance<PartialComparisonExpressionContext>(_ctx, getState());
- enterRule(_localctx, 116, CypherParser::RulePartialComparisonExpression);
- size_t _la = 0;
-
- auto onExit = finally([=] {
- exitRule();
- });
- try {
- setState(1101);
- _errHandler->sync(this);
- switch (_input->LA(1)) {
- case CypherParser::T__2: {
- enterOuterAlt(_localctx, 1);
- setState(1066);
- match(CypherParser::T__2);
- setState(1068);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(1067);
- match(CypherParser::SP);
- }
- setState(1070);
- expression7();
- break;
- }
-
- case CypherParser::T__18: {
- enterOuterAlt(_localctx, 2);
- setState(1071);
- match(CypherParser::T__18);
- setState(1073);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(1072);
- match(CypherParser::SP);
- }
- setState(1075);
- expression7();
- break;
- }
-
- case CypherParser::T__19: {
- enterOuterAlt(_localctx, 3);
- setState(1076);
- match(CypherParser::T__19);
- setState(1078);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(1077);
- match(CypherParser::SP);
- }
- setState(1080);
- expression7();
- break;
- }
-
- case CypherParser::T__20: {
- enterOuterAlt(_localctx, 4);
- setState(1081);
- match(CypherParser::T__20);
- setState(1083);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(1082);
- match(CypherParser::SP);
- }
- setState(1085);
- expression7();
- break;
- }
-
- case CypherParser::T__21: {
- enterOuterAlt(_localctx, 5);
- setState(1086);
- match(CypherParser::T__21);
- setState(1088);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(1087);
- match(CypherParser::SP);
- }
- setState(1090);
- expression7();
- break;
- }
-
- case CypherParser::T__22: {
- enterOuterAlt(_localctx, 6);
- setState(1091);
- match(CypherParser::T__22);
- setState(1093);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(1092);
- match(CypherParser::SP);
- }
- setState(1095);
- expression7();
- break;
- }
-
- case CypherParser::T__23: {
- enterOuterAlt(_localctx, 7);
- setState(1096);
- match(CypherParser::T__23);
- setState(1098);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(1097);
- match(CypherParser::SP);
- }
- setState(1100);
- expression7();
- break;
- }
-
- default:
- throw NoViableAltException(this);
- }
-
- }
- catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- ParenthesizedExpressionContext ------------------------------------------------------------------
-
-CypherParser::ParenthesizedExpressionContext::ParenthesizedExpressionContext(ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {
-}
-
-CypherParser::ExpressionContext* CypherParser::ParenthesizedExpressionContext::expression() {
- return getRuleContext<CypherParser::ExpressionContext>(0);
-}
-
-std::vector<tree::TerminalNode *> CypherParser::ParenthesizedExpressionContext::SP() {
- return getTokens(CypherParser::SP);
-}
-
-tree::TerminalNode* CypherParser::ParenthesizedExpressionContext::SP(size_t i) {
- return getToken(CypherParser::SP, i);
-}
-
-
-size_t CypherParser::ParenthesizedExpressionContext::getRuleIndex() const {
- return CypherParser::RuleParenthesizedExpression;
-}
-
-void CypherParser::ParenthesizedExpressionContext::enterRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->enterParenthesizedExpression(this);
-}
-
-void CypherParser::ParenthesizedExpressionContext::exitRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->exitParenthesizedExpression(this);
-}
-
-
-antlrcpp::Any CypherParser::ParenthesizedExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
- return parserVisitor->visitParenthesizedExpression(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::ParenthesizedExpressionContext* CypherParser::parenthesizedExpression() {
- ParenthesizedExpressionContext *_localctx = _tracker.createInstance<ParenthesizedExpressionContext>(_ctx, getState());
- enterRule(_localctx, 118, CypherParser::RuleParenthesizedExpression);
- size_t _la = 0;
-
- auto onExit = finally([=] {
- exitRule();
- });
- try {
- enterOuterAlt(_localctx, 1);
- setState(1103);
- match(CypherParser::T__5);
- setState(1105);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(1104);
- match(CypherParser::SP);
- }
- setState(1107);
- expression();
- setState(1109);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(1108);
- match(CypherParser::SP);
- }
- setState(1111);
- match(CypherParser::T__6);
-
- }
- catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- RelationshipsPatternContext ------------------------------------------------------------------
-
-CypherParser::RelationshipsPatternContext::RelationshipsPatternContext(ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {
-}
-
-CypherParser::NodePatternContext* CypherParser::RelationshipsPatternContext::nodePattern() {
- return getRuleContext<CypherParser::NodePatternContext>(0);
-}
-
-std::vector<CypherParser::PatternElementChainContext *> CypherParser::RelationshipsPatternContext::patternElementChain() {
- return getRuleContexts<CypherParser::PatternElementChainContext>();
-}
-
-CypherParser::PatternElementChainContext* CypherParser::RelationshipsPatternContext::patternElementChain(size_t i) {
- return getRuleContext<CypherParser::PatternElementChainContext>(i);
-}
-
-std::vector<tree::TerminalNode *> CypherParser::RelationshipsPatternContext::SP() {
- return getTokens(CypherParser::SP);
-}
-
-tree::TerminalNode* CypherParser::RelationshipsPatternContext::SP(size_t i) {
- return getToken(CypherParser::SP, i);
-}
-
-
-size_t CypherParser::RelationshipsPatternContext::getRuleIndex() const {
- return CypherParser::RuleRelationshipsPattern;
-}
-
-void CypherParser::RelationshipsPatternContext::enterRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->enterRelationshipsPattern(this);
-}
-
-void CypherParser::RelationshipsPatternContext::exitRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->exitRelationshipsPattern(this);
-}
-
-
-antlrcpp::Any CypherParser::RelationshipsPatternContext::accept(tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
- return parserVisitor->visitRelationshipsPattern(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::RelationshipsPatternContext* CypherParser::relationshipsPattern() {
- RelationshipsPatternContext *_localctx = _tracker.createInstance<RelationshipsPatternContext>(_ctx, getState());
- enterRule(_localctx, 120, CypherParser::RuleRelationshipsPattern);
- size_t _la = 0;
-
- auto onExit = finally([=] {
- exitRule();
- });
- try {
- size_t alt;
- enterOuterAlt(_localctx, 1);
- setState(1113);
- nodePattern();
- setState(1118);
- _errHandler->sync(this);
- alt = 1;
- do {
- switch (alt) {
- case 1: {
- setState(1115);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(1114);
- match(CypherParser::SP);
- }
- setState(1117);
- patternElementChain();
- break;
- }
-
- default:
- throw NoViableAltException(this);
- }
- setState(1120);
- _errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 199, _ctx);
- } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
-
- }
- catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- FilterExpressionContext ------------------------------------------------------------------
-
-CypherParser::FilterExpressionContext::FilterExpressionContext(ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {
-}
-
-CypherParser::IdInCollContext* CypherParser::FilterExpressionContext::idInColl() {
- return getRuleContext<CypherParser::IdInCollContext>(0);
-}
-
-CypherParser::WhereContext* CypherParser::FilterExpressionContext::where() {
- return getRuleContext<CypherParser::WhereContext>(0);
-}
-
-tree::TerminalNode* CypherParser::FilterExpressionContext::SP() {
- return getToken(CypherParser::SP, 0);
-}
-
-
-size_t CypherParser::FilterExpressionContext::getRuleIndex() const {
- return CypherParser::RuleFilterExpression;
-}
-
-void CypherParser::FilterExpressionContext::enterRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->enterFilterExpression(this);
-}
-
-void CypherParser::FilterExpressionContext::exitRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->exitFilterExpression(this);
-}
-
-
-antlrcpp::Any CypherParser::FilterExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
- return parserVisitor->visitFilterExpression(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::FilterExpressionContext* CypherParser::filterExpression() {
- FilterExpressionContext *_localctx = _tracker.createInstance<FilterExpressionContext>(_ctx, getState());
- enterRule(_localctx, 122, CypherParser::RuleFilterExpression);
- size_t _la = 0;
-
- auto onExit = finally([=] {
- exitRule();
- });
- try {
- enterOuterAlt(_localctx, 1);
- setState(1122);
- idInColl();
- setState(1127);
- _errHandler->sync(this);
-
- switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 201, _ctx)) {
- case 1: {
- setState(1124);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(1123);
- match(CypherParser::SP);
- }
- setState(1126);
- where();
- break;
- }
-
- }
-
- }
- catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- IdInCollContext ------------------------------------------------------------------
-
-CypherParser::IdInCollContext::IdInCollContext(ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {
-}
-
-CypherParser::VariableContext* CypherParser::IdInCollContext::variable() {
- return getRuleContext<CypherParser::VariableContext>(0);
-}
-
-std::vector<tree::TerminalNode *> CypherParser::IdInCollContext::SP() {
- return getTokens(CypherParser::SP);
-}
-
-tree::TerminalNode* CypherParser::IdInCollContext::SP(size_t i) {
- return getToken(CypherParser::SP, i);
-}
-
-tree::TerminalNode* CypherParser::IdInCollContext::IN() {
- return getToken(CypherParser::IN, 0);
-}
-
-CypherParser::ExpressionContext* CypherParser::IdInCollContext::expression() {
- return getRuleContext<CypherParser::ExpressionContext>(0);
-}
-
-
-size_t CypherParser::IdInCollContext::getRuleIndex() const {
- return CypherParser::RuleIdInColl;
-}
-
-void CypherParser::IdInCollContext::enterRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->enterIdInColl(this);
-}
-
-void CypherParser::IdInCollContext::exitRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->exitIdInColl(this);
-}
-
-
-antlrcpp::Any CypherParser::IdInCollContext::accept(tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
- return parserVisitor->visitIdInColl(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::IdInCollContext* CypherParser::idInColl() {
- IdInCollContext *_localctx = _tracker.createInstance<IdInCollContext>(_ctx, getState());
- enterRule(_localctx, 124, CypherParser::RuleIdInColl);
-
- auto onExit = finally([=] {
- exitRule();
- });
- try {
- enterOuterAlt(_localctx, 1);
- setState(1129);
- variable();
- setState(1130);
- match(CypherParser::SP);
- setState(1131);
- match(CypherParser::IN);
- setState(1132);
- match(CypherParser::SP);
- setState(1133);
- expression();
-
- }
- catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- FunctionInvocationContext ------------------------------------------------------------------
-
-CypherParser::FunctionInvocationContext::FunctionInvocationContext(ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {
-}
-
-CypherParser::FunctionNameContext* CypherParser::FunctionInvocationContext::functionName() {
- return getRuleContext<CypherParser::FunctionNameContext>(0);
-}
-
-std::vector<tree::TerminalNode *> CypherParser::FunctionInvocationContext::SP() {
- return getTokens(CypherParser::SP);
-}
-
-tree::TerminalNode* CypherParser::FunctionInvocationContext::SP(size_t i) {
- return getToken(CypherParser::SP, i);
-}
-
-tree::TerminalNode* CypherParser::FunctionInvocationContext::DISTINCT() {
- return getToken(CypherParser::DISTINCT, 0);
-}
-
-std::vector<CypherParser::ExpressionContext *> CypherParser::FunctionInvocationContext::expression() {
- return getRuleContexts<CypherParser::ExpressionContext>();
-}
-
-CypherParser::ExpressionContext* CypherParser::FunctionInvocationContext::expression(size_t i) {
- return getRuleContext<CypherParser::ExpressionContext>(i);
-}
-
-
-size_t CypherParser::FunctionInvocationContext::getRuleIndex() const {
- return CypherParser::RuleFunctionInvocation;
-}
-
-void CypherParser::FunctionInvocationContext::enterRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->enterFunctionInvocation(this);
-}
-
-void CypherParser::FunctionInvocationContext::exitRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->exitFunctionInvocation(this);
-}
-
-
-antlrcpp::Any CypherParser::FunctionInvocationContext::accept(tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
- return parserVisitor->visitFunctionInvocation(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::FunctionInvocationContext* CypherParser::functionInvocation() {
- FunctionInvocationContext *_localctx = _tracker.createInstance<FunctionInvocationContext>(_ctx, getState());
- enterRule(_localctx, 126, CypherParser::RuleFunctionInvocation);
- size_t _la = 0;
-
- auto onExit = finally([=] {
- exitRule();
- });
- try {
- enterOuterAlt(_localctx, 1);
- setState(1135);
- functionName();
- setState(1137);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(1136);
- match(CypherParser::SP);
- }
- setState(1139);
- match(CypherParser::T__5);
- setState(1141);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(1140);
- match(CypherParser::SP);
- }
- setState(1147);
- _errHandler->sync(this);
-
- switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 205, _ctx)) {
- case 1: {
- setState(1143);
- match(CypherParser::DISTINCT);
- setState(1145);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(1144);
- match(CypherParser::SP);
- }
- break;
- }
-
- }
- setState(1166);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if ((((_la & ~ 0x3fULL) == 0) &&
- ((1ULL << _la) & ((1ULL << CypherParser::T__5)
- | (1ULL << CypherParser::T__7)
- | (1ULL << CypherParser::T__12)
- | (1ULL << CypherParser::T__13)
- | (1ULL << CypherParser::T__25)
- | (1ULL << CypherParser::T__27)
- | (1ULL << CypherParser::StringLiteral)
- | (1ULL << CypherParser::HexInteger)
- | (1ULL << CypherParser::DecimalInteger)
- | (1ULL << CypherParser::OctalInteger)
- | (1ULL << CypherParser::HexLetter)
- | (1ULL << CypherParser::ExponentDecimalReal)
- | (1ULL << CypherParser::RegularDecimalReal)
- | (1ULL << CypherParser::UNION)
- | (1ULL << CypherParser::ALL))) != 0) || ((((_la - 64) & ~ 0x3fULL) == 0) &&
- ((1ULL << (_la - 64)) & ((1ULL << (CypherParser::OPTIONAL - 64))
- | (1ULL << (CypherParser::MATCH - 64))
- | (1ULL << (CypherParser::UNWIND - 64))
- | (1ULL << (CypherParser::AS - 64))
- | (1ULL << (CypherParser::MERGE - 64))
- | (1ULL << (CypherParser::ON - 64))
- | (1ULL << (CypherParser::CREATE - 64))
- | (1ULL << (CypherParser::SET - 64))
- | (1ULL << (CypherParser::DETACH - 64))
- | (1ULL << (CypherParser::DELETE - 64))
- | (1ULL << (CypherParser::REMOVE - 64))
- | (1ULL << (CypherParser::WITH - 64))
- | (1ULL << (CypherParser::DISTINCT - 64))
- | (1ULL << (CypherParser::RETURN - 64))
- | (1ULL << (CypherParser::ORDER - 64))
- | (1ULL << (CypherParser::BY - 64))
- | (1ULL << (CypherParser::L_SKIP - 64))
- | (1ULL << (CypherParser::LIMIT - 64))
- | (1ULL << (CypherParser::ASCENDING - 64))
- | (1ULL << (CypherParser::ASC - 64))
- | (1ULL << (CypherParser::DESCENDING - 64))
- | (1ULL << (CypherParser::DESC - 64))
- | (1ULL << (CypherParser::WHERE - 64))
- | (1ULL << (CypherParser::OR - 64))
- | (1ULL << (CypherParser::XOR - 64))
- | (1ULL << (CypherParser::AND - 64))
- | (1ULL << (CypherParser::NOT - 64))
- | (1ULL << (CypherParser::IN - 64))
- | (1ULL << (CypherParser::STARTS - 64))
- | (1ULL << (CypherParser::ENDS - 64))
- | (1ULL << (CypherParser::CONTAINS - 64))
- | (1ULL << (CypherParser::IS - 64))
- | (1ULL << (CypherParser::CYPHERNULL - 64))
- | (1ULL << (CypherParser::COUNT - 64))
- | (1ULL << (CypherParser::FILTER - 64))
- | (1ULL << (CypherParser::EXTRACT - 64))
- | (1ULL << (CypherParser::ANY - 64))
- | (1ULL << (CypherParser::NONE - 64))
- | (1ULL << (CypherParser::SINGLE - 64))
- | (1ULL << (CypherParser::TRUE - 64))
- | (1ULL << (CypherParser::FALSE - 64))
- | (1ULL << (CypherParser::UnescapedSymbolicName - 64))
- | (1ULL << (CypherParser::EscapedSymbolicName - 64)))) != 0)) {
- setState(1149);
- expression();
- setState(1151);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(1150);
- match(CypherParser::SP);
- }
- setState(1163);
- _errHandler->sync(this);
- _la = _input->LA(1);
- while (_la == CypherParser::T__1) {
- setState(1153);
- match(CypherParser::T__1);
- setState(1155);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(1154);
- match(CypherParser::SP);
- }
- setState(1157);
- expression();
- setState(1159);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(1158);
- match(CypherParser::SP);
- }
- setState(1165);
- _errHandler->sync(this);
- _la = _input->LA(1);
- }
- }
- setState(1168);
- match(CypherParser::T__6);
-
- }
- catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- FunctionNameContext ------------------------------------------------------------------
-
-CypherParser::FunctionNameContext::FunctionNameContext(ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {
-}
-
-tree::TerminalNode* CypherParser::FunctionNameContext::UnescapedSymbolicName() {
- return getToken(CypherParser::UnescapedSymbolicName, 0);
-}
-
-tree::TerminalNode* CypherParser::FunctionNameContext::EscapedSymbolicName() {
- return getToken(CypherParser::EscapedSymbolicName, 0);
-}
-
-tree::TerminalNode* CypherParser::FunctionNameContext::COUNT() {
- return getToken(CypherParser::COUNT, 0);
-}
-
-
-size_t CypherParser::FunctionNameContext::getRuleIndex() const {
- return CypherParser::RuleFunctionName;
-}
-
-void CypherParser::FunctionNameContext::enterRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->enterFunctionName(this);
-}
-
-void CypherParser::FunctionNameContext::exitRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->exitFunctionName(this);
-}
-
-
-antlrcpp::Any CypherParser::FunctionNameContext::accept(tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
- return parserVisitor->visitFunctionName(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::FunctionNameContext* CypherParser::functionName() {
- FunctionNameContext *_localctx = _tracker.createInstance<FunctionNameContext>(_ctx, getState());
- enterRule(_localctx, 128, CypherParser::RuleFunctionName);
- size_t _la = 0;
-
- auto onExit = finally([=] {
- exitRule();
- });
- try {
- enterOuterAlt(_localctx, 1);
- setState(1170);
- _la = _input->LA(1);
- if (!(((((_la - 97) & ~ 0x3fULL) == 0) &&
- ((1ULL << (_la - 97)) & ((1ULL << (CypherParser::COUNT - 97))
- | (1ULL << (CypherParser::UnescapedSymbolicName - 97))
- | (1ULL << (CypherParser::EscapedSymbolicName - 97)))) != 0))) {
- _errHandler->recoverInline(this);
- }
- else {
- _errHandler->reportMatch(this);
- consume();
- }
-
- }
- catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- ListComprehensionContext ------------------------------------------------------------------
-
-CypherParser::ListComprehensionContext::ListComprehensionContext(ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {
-}
-
-CypherParser::FilterExpressionContext* CypherParser::ListComprehensionContext::filterExpression() {
- return getRuleContext<CypherParser::FilterExpressionContext>(0);
-}
-
-std::vector<tree::TerminalNode *> CypherParser::ListComprehensionContext::SP() {
- return getTokens(CypherParser::SP);
-}
-
-tree::TerminalNode* CypherParser::ListComprehensionContext::SP(size_t i) {
- return getToken(CypherParser::SP, i);
-}
-
-CypherParser::ExpressionContext* CypherParser::ListComprehensionContext::expression() {
- return getRuleContext<CypherParser::ExpressionContext>(0);
-}
-
-
-size_t CypherParser::ListComprehensionContext::getRuleIndex() const {
- return CypherParser::RuleListComprehension;
-}
-
-void CypherParser::ListComprehensionContext::enterRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->enterListComprehension(this);
-}
-
-void CypherParser::ListComprehensionContext::exitRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->exitListComprehension(this);
-}
-
-
-antlrcpp::Any CypherParser::ListComprehensionContext::accept(tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
- return parserVisitor->visitListComprehension(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::ListComprehensionContext* CypherParser::listComprehension() {
- ListComprehensionContext *_localctx = _tracker.createInstance<ListComprehensionContext>(_ctx, getState());
- enterRule(_localctx, 130, CypherParser::RuleListComprehension);
- size_t _la = 0;
-
- auto onExit = finally([=] {
- exitRule();
- });
- try {
- enterOuterAlt(_localctx, 1);
- setState(1172);
- match(CypherParser::T__7);
- setState(1174);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(1173);
- match(CypherParser::SP);
- }
- setState(1176);
- filterExpression();
- setState(1185);
- _errHandler->sync(this);
-
- switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 214, _ctx)) {
- case 1: {
- setState(1178);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(1177);
- match(CypherParser::SP);
- }
- setState(1180);
- match(CypherParser::T__10);
- setState(1182);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(1181);
- match(CypherParser::SP);
- }
- setState(1184);
- expression();
- break;
- }
-
- }
- setState(1188);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(1187);
- match(CypherParser::SP);
- }
- setState(1190);
- match(CypherParser::T__8);
-
- }
- catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- PatternComprehensionContext ------------------------------------------------------------------
-
-CypherParser::PatternComprehensionContext::PatternComprehensionContext(ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {
-}
-
-CypherParser::RelationshipsPatternContext* CypherParser::PatternComprehensionContext::relationshipsPattern() {
- return getRuleContext<CypherParser::RelationshipsPatternContext>(0);
-}
-
-std::vector<CypherParser::ExpressionContext *> CypherParser::PatternComprehensionContext::expression() {
- return getRuleContexts<CypherParser::ExpressionContext>();
-}
-
-CypherParser::ExpressionContext* CypherParser::PatternComprehensionContext::expression(size_t i) {
- return getRuleContext<CypherParser::ExpressionContext>(i);
-}
-
-std::vector<tree::TerminalNode *> CypherParser::PatternComprehensionContext::SP() {
- return getTokens(CypherParser::SP);
-}
-
-tree::TerminalNode* CypherParser::PatternComprehensionContext::SP(size_t i) {
- return getToken(CypherParser::SP, i);
-}
-
-CypherParser::VariableContext* CypherParser::PatternComprehensionContext::variable() {
- return getRuleContext<CypherParser::VariableContext>(0);
-}
-
-tree::TerminalNode* CypherParser::PatternComprehensionContext::WHERE() {
- return getToken(CypherParser::WHERE, 0);
-}
-
-
-size_t CypherParser::PatternComprehensionContext::getRuleIndex() const {
- return CypherParser::RulePatternComprehension;
-}
-
-void CypherParser::PatternComprehensionContext::enterRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->enterPatternComprehension(this);
-}
-
-void CypherParser::PatternComprehensionContext::exitRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->exitPatternComprehension(this);
-}
-
-
-antlrcpp::Any CypherParser::PatternComprehensionContext::accept(tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
- return parserVisitor->visitPatternComprehension(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::PatternComprehensionContext* CypherParser::patternComprehension() {
- PatternComprehensionContext *_localctx = _tracker.createInstance<PatternComprehensionContext>(_ctx, getState());
- enterRule(_localctx, 132, CypherParser::RulePatternComprehension);
- size_t _la = 0;
-
- auto onExit = finally([=] {
- exitRule();
- });
- try {
- enterOuterAlt(_localctx, 1);
- setState(1192);
- match(CypherParser::T__7);
- setState(1194);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(1193);
- match(CypherParser::SP);
- }
- setState(1204);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (((((_la - 53) & ~ 0x3fULL) == 0) &&
- ((1ULL << (_la - 53)) & ((1ULL << (CypherParser::HexLetter - 53))
- | (1ULL << (CypherParser::UNION - 53))
- | (1ULL << (CypherParser::ALL - 53))
- | (1ULL << (CypherParser::OPTIONAL - 53))
- | (1ULL << (CypherParser::MATCH - 53))
- | (1ULL << (CypherParser::UNWIND - 53))
- | (1ULL << (CypherParser::AS - 53))
- | (1ULL << (CypherParser::MERGE - 53))
- | (1ULL << (CypherParser::ON - 53))
- | (1ULL << (CypherParser::CREATE - 53))
- | (1ULL << (CypherParser::SET - 53))
- | (1ULL << (CypherParser::DETACH - 53))
- | (1ULL << (CypherParser::DELETE - 53))
- | (1ULL << (CypherParser::REMOVE - 53))
- | (1ULL << (CypherParser::WITH - 53))
- | (1ULL << (CypherParser::DISTINCT - 53))
- | (1ULL << (CypherParser::RETURN - 53))
- | (1ULL << (CypherParser::ORDER - 53))
- | (1ULL << (CypherParser::BY - 53))
- | (1ULL << (CypherParser::L_SKIP - 53))
- | (1ULL << (CypherParser::LIMIT - 53))
- | (1ULL << (CypherParser::ASCENDING - 53))
- | (1ULL << (CypherParser::ASC - 53))
- | (1ULL << (CypherParser::DESCENDING - 53))
- | (1ULL << (CypherParser::DESC - 53))
- | (1ULL << (CypherParser::WHERE - 53))
- | (1ULL << (CypherParser::OR - 53))
- | (1ULL << (CypherParser::XOR - 53))
- | (1ULL << (CypherParser::AND - 53))
- | (1ULL << (CypherParser::NOT - 53))
- | (1ULL << (CypherParser::IN - 53))
- | (1ULL << (CypherParser::STARTS - 53))
- | (1ULL << (CypherParser::ENDS - 53))
- | (1ULL << (CypherParser::CONTAINS - 53))
- | (1ULL << (CypherParser::IS - 53))
- | (1ULL << (CypherParser::CYPHERNULL - 53))
- | (1ULL << (CypherParser::COUNT - 53))
- | (1ULL << (CypherParser::FILTER - 53))
- | (1ULL << (CypherParser::EXTRACT - 53))
- | (1ULL << (CypherParser::ANY - 53))
- | (1ULL << (CypherParser::NONE - 53))
- | (1ULL << (CypherParser::SINGLE - 53))
- | (1ULL << (CypherParser::TRUE - 53))
- | (1ULL << (CypherParser::FALSE - 53))
- | (1ULL << (CypherParser::UnescapedSymbolicName - 53))
- | (1ULL << (CypherParser::EscapedSymbolicName - 53)))) != 0)) {
- setState(1196);
- variable();
- setState(1198);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(1197);
- match(CypherParser::SP);
- }
- setState(1200);
- match(CypherParser::T__2);
- setState(1202);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(1201);
- match(CypherParser::SP);
- }
- }
- setState(1206);
- relationshipsPattern();
- setState(1208);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(1207);
- match(CypherParser::SP);
- }
- setState(1218);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::WHERE) {
- setState(1210);
- match(CypherParser::WHERE);
- setState(1212);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(1211);
- match(CypherParser::SP);
- }
- setState(1214);
- expression();
- setState(1216);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(1215);
- match(CypherParser::SP);
- }
- }
- setState(1220);
- match(CypherParser::T__10);
- setState(1222);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(1221);
- match(CypherParser::SP);
- }
- setState(1224);
- expression();
- setState(1226);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(1225);
- match(CypherParser::SP);
- }
- setState(1228);
- match(CypherParser::T__8);
-
- }
- catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- PropertyLookupContext ------------------------------------------------------------------
-
-CypherParser::PropertyLookupContext::PropertyLookupContext(ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {
-}
-
-CypherParser::PropertyKeyNameContext* CypherParser::PropertyLookupContext::propertyKeyName() {
- return getRuleContext<CypherParser::PropertyKeyNameContext>(0);
-}
-
-tree::TerminalNode* CypherParser::PropertyLookupContext::SP() {
- return getToken(CypherParser::SP, 0);
-}
-
-
-size_t CypherParser::PropertyLookupContext::getRuleIndex() const {
- return CypherParser::RulePropertyLookup;
-}
-
-void CypherParser::PropertyLookupContext::enterRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->enterPropertyLookup(this);
-}
-
-void CypherParser::PropertyLookupContext::exitRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->exitPropertyLookup(this);
-}
-
-
-antlrcpp::Any CypherParser::PropertyLookupContext::accept(tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
- return parserVisitor->visitPropertyLookup(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::PropertyLookupContext* CypherParser::propertyLookup() {
- PropertyLookupContext *_localctx = _tracker.createInstance<PropertyLookupContext>(_ctx, getState());
- enterRule(_localctx, 134, CypherParser::RulePropertyLookup);
- size_t _la = 0;
-
- auto onExit = finally([=] {
- exitRule();
- });
- try {
- enterOuterAlt(_localctx, 1);
- setState(1230);
- match(CypherParser::T__24);
- setState(1232);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(1231);
- match(CypherParser::SP);
- }
-
- setState(1234);
- propertyKeyName();
-
- }
- catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- VariableContext ------------------------------------------------------------------
-
-CypherParser::VariableContext::VariableContext(ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {
-}
-
-CypherParser::SymbolicNameContext* CypherParser::VariableContext::symbolicName() {
- return getRuleContext<CypherParser::SymbolicNameContext>(0);
-}
-
-
-size_t CypherParser::VariableContext::getRuleIndex() const {
- return CypherParser::RuleVariable;
-}
-
-void CypherParser::VariableContext::enterRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->enterVariable(this);
-}
-
-void CypherParser::VariableContext::exitRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->exitVariable(this);
-}
-
-
-antlrcpp::Any CypherParser::VariableContext::accept(tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
- return parserVisitor->visitVariable(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::VariableContext* CypherParser::variable() {
- VariableContext *_localctx = _tracker.createInstance<VariableContext>(_ctx, getState());
- enterRule(_localctx, 136, CypherParser::RuleVariable);
-
- auto onExit = finally([=] {
- exitRule();
- });
- try {
- enterOuterAlt(_localctx, 1);
- setState(1236);
- symbolicName();
-
- }
- catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- NumberLiteralContext ------------------------------------------------------------------
-
-CypherParser::NumberLiteralContext::NumberLiteralContext(ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {
-}
-
-CypherParser::DoubleLiteralContext* CypherParser::NumberLiteralContext::doubleLiteral() {
- return getRuleContext<CypherParser::DoubleLiteralContext>(0);
-}
-
-CypherParser::IntegerLiteralContext* CypherParser::NumberLiteralContext::integerLiteral() {
- return getRuleContext<CypherParser::IntegerLiteralContext>(0);
-}
-
-
-size_t CypherParser::NumberLiteralContext::getRuleIndex() const {
- return CypherParser::RuleNumberLiteral;
-}
-
-void CypherParser::NumberLiteralContext::enterRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->enterNumberLiteral(this);
-}
-
-void CypherParser::NumberLiteralContext::exitRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->exitNumberLiteral(this);
-}
-
-
-antlrcpp::Any CypherParser::NumberLiteralContext::accept(tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
- return parserVisitor->visitNumberLiteral(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::NumberLiteralContext* CypherParser::numberLiteral() {
- NumberLiteralContext *_localctx = _tracker.createInstance<NumberLiteralContext>(_ctx, getState());
- enterRule(_localctx, 138, CypherParser::RuleNumberLiteral);
-
- auto onExit = finally([=] {
- exitRule();
- });
- try {
- setState(1240);
- _errHandler->sync(this);
- switch (_input->LA(1)) {
- case CypherParser::ExponentDecimalReal:
- case CypherParser::RegularDecimalReal: {
- enterOuterAlt(_localctx, 1);
- setState(1238);
- doubleLiteral();
- break;
- }
-
- case CypherParser::HexInteger:
- case CypherParser::DecimalInteger:
- case CypherParser::OctalInteger: {
- enterOuterAlt(_localctx, 2);
- setState(1239);
- integerLiteral();
- break;
- }
-
- default:
- throw NoViableAltException(this);
- }
-
- }
- catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- MapLiteralContext ------------------------------------------------------------------
-
-CypherParser::MapLiteralContext::MapLiteralContext(ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {
-}
-
-std::vector<tree::TerminalNode *> CypherParser::MapLiteralContext::SP() {
- return getTokens(CypherParser::SP);
-}
-
-tree::TerminalNode* CypherParser::MapLiteralContext::SP(size_t i) {
- return getToken(CypherParser::SP, i);
-}
-
-std::vector<CypherParser::PropertyKeyNameContext *> CypherParser::MapLiteralContext::propertyKeyName() {
- return getRuleContexts<CypherParser::PropertyKeyNameContext>();
-}
-
-CypherParser::PropertyKeyNameContext* CypherParser::MapLiteralContext::propertyKeyName(size_t i) {
- return getRuleContext<CypherParser::PropertyKeyNameContext>(i);
-}
-
-std::vector<CypherParser::ExpressionContext *> CypherParser::MapLiteralContext::expression() {
- return getRuleContexts<CypherParser::ExpressionContext>();
-}
-
-CypherParser::ExpressionContext* CypherParser::MapLiteralContext::expression(size_t i) {
- return getRuleContext<CypherParser::ExpressionContext>(i);
-}
-
-
-size_t CypherParser::MapLiteralContext::getRuleIndex() const {
- return CypherParser::RuleMapLiteral;
-}
-
-void CypherParser::MapLiteralContext::enterRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->enterMapLiteral(this);
-}
-
-void CypherParser::MapLiteralContext::exitRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->exitMapLiteral(this);
-}
-
-
-antlrcpp::Any CypherParser::MapLiteralContext::accept(tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
- return parserVisitor->visitMapLiteral(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::MapLiteralContext* CypherParser::mapLiteral() {
- MapLiteralContext *_localctx = _tracker.createInstance<MapLiteralContext>(_ctx, getState());
- enterRule(_localctx, 140, CypherParser::RuleMapLiteral);
- size_t _la = 0;
-
- auto onExit = finally([=] {
- exitRule();
- });
- try {
- enterOuterAlt(_localctx, 1);
- setState(1242);
- match(CypherParser::T__25);
- setState(1244);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(1243);
- match(CypherParser::SP);
- }
- setState(1279);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (((((_la - 53) & ~ 0x3fULL) == 0) &&
- ((1ULL << (_la - 53)) & ((1ULL << (CypherParser::HexLetter - 53))
- | (1ULL << (CypherParser::UNION - 53))
- | (1ULL << (CypherParser::ALL - 53))
- | (1ULL << (CypherParser::OPTIONAL - 53))
- | (1ULL << (CypherParser::MATCH - 53))
- | (1ULL << (CypherParser::UNWIND - 53))
- | (1ULL << (CypherParser::AS - 53))
- | (1ULL << (CypherParser::MERGE - 53))
- | (1ULL << (CypherParser::ON - 53))
- | (1ULL << (CypherParser::CREATE - 53))
- | (1ULL << (CypherParser::SET - 53))
- | (1ULL << (CypherParser::DETACH - 53))
- | (1ULL << (CypherParser::DELETE - 53))
- | (1ULL << (CypherParser::REMOVE - 53))
- | (1ULL << (CypherParser::WITH - 53))
- | (1ULL << (CypherParser::DISTINCT - 53))
- | (1ULL << (CypherParser::RETURN - 53))
- | (1ULL << (CypherParser::ORDER - 53))
- | (1ULL << (CypherParser::BY - 53))
- | (1ULL << (CypherParser::L_SKIP - 53))
- | (1ULL << (CypherParser::LIMIT - 53))
- | (1ULL << (CypherParser::ASCENDING - 53))
- | (1ULL << (CypherParser::ASC - 53))
- | (1ULL << (CypherParser::DESCENDING - 53))
- | (1ULL << (CypherParser::DESC - 53))
- | (1ULL << (CypherParser::WHERE - 53))
- | (1ULL << (CypherParser::OR - 53))
- | (1ULL << (CypherParser::XOR - 53))
- | (1ULL << (CypherParser::AND - 53))
- | (1ULL << (CypherParser::NOT - 53))
- | (1ULL << (CypherParser::IN - 53))
- | (1ULL << (CypherParser::STARTS - 53))
- | (1ULL << (CypherParser::ENDS - 53))
- | (1ULL << (CypherParser::CONTAINS - 53))
- | (1ULL << (CypherParser::IS - 53))
- | (1ULL << (CypherParser::CYPHERNULL - 53))
- | (1ULL << (CypherParser::COUNT - 53))
- | (1ULL << (CypherParser::FILTER - 53))
- | (1ULL << (CypherParser::EXTRACT - 53))
- | (1ULL << (CypherParser::ANY - 53))
- | (1ULL << (CypherParser::NONE - 53))
- | (1ULL << (CypherParser::SINGLE - 53))
- | (1ULL << (CypherParser::TRUE - 53))
- | (1ULL << (CypherParser::FALSE - 53))
- | (1ULL << (CypherParser::UnescapedSymbolicName - 53))
- | (1ULL << (CypherParser::EscapedSymbolicName - 53)))) != 0)) {
- setState(1246);
- propertyKeyName();
- setState(1248);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(1247);
- match(CypherParser::SP);
- }
- setState(1250);
- match(CypherParser::T__9);
- setState(1252);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(1251);
- match(CypherParser::SP);
- }
- setState(1254);
- expression();
- setState(1256);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(1255);
- match(CypherParser::SP);
- }
- setState(1276);
- _errHandler->sync(this);
- _la = _input->LA(1);
- while (_la == CypherParser::T__1) {
- setState(1258);
- match(CypherParser::T__1);
- setState(1260);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(1259);
- match(CypherParser::SP);
- }
- setState(1262);
- propertyKeyName();
- setState(1264);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(1263);
- match(CypherParser::SP);
- }
- setState(1266);
- match(CypherParser::T__9);
- setState(1268);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(1267);
- match(CypherParser::SP);
- }
- setState(1270);
- expression();
- setState(1272);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(1271);
- match(CypherParser::SP);
- }
- setState(1278);
- _errHandler->sync(this);
- _la = _input->LA(1);
- }
- }
- setState(1281);
- match(CypherParser::T__26);
-
- }
- catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- ParameterContext ------------------------------------------------------------------
-
-CypherParser::ParameterContext::ParameterContext(ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {
-}
-
-CypherParser::SymbolicNameContext* CypherParser::ParameterContext::symbolicName() {
- return getRuleContext<CypherParser::SymbolicNameContext>(0);
-}
-
-tree::TerminalNode* CypherParser::ParameterContext::DecimalInteger() {
- return getToken(CypherParser::DecimalInteger, 0);
-}
-
-
-size_t CypherParser::ParameterContext::getRuleIndex() const {
- return CypherParser::RuleParameter;
-}
-
-void CypherParser::ParameterContext::enterRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->enterParameter(this);
-}
-
-void CypherParser::ParameterContext::exitRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->exitParameter(this);
-}
-
-
-antlrcpp::Any CypherParser::ParameterContext::accept(tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
- return parserVisitor->visitParameter(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::ParameterContext* CypherParser::parameter() {
- ParameterContext *_localctx = _tracker.createInstance<ParameterContext>(_ctx, getState());
- enterRule(_localctx, 142, CypherParser::RuleParameter);
-
- auto onExit = finally([=] {
- exitRule();
- });
- try {
- enterOuterAlt(_localctx, 1);
- setState(1283);
- match(CypherParser::T__27);
- setState(1286);
- _errHandler->sync(this);
- switch (_input->LA(1)) {
- case CypherParser::HexLetter:
- case CypherParser::UNION:
- case CypherParser::ALL:
- case CypherParser::OPTIONAL:
- case CypherParser::MATCH:
- case CypherParser::UNWIND:
- case CypherParser::AS:
- case CypherParser::MERGE:
- case CypherParser::ON:
- case CypherParser::CREATE:
- case CypherParser::SET:
- case CypherParser::DETACH:
- case CypherParser::DELETE:
- case CypherParser::REMOVE:
- case CypherParser::WITH:
- case CypherParser::DISTINCT:
- case CypherParser::RETURN:
- case CypherParser::ORDER:
- case CypherParser::BY:
- case CypherParser::L_SKIP:
- case CypherParser::LIMIT:
- case CypherParser::ASCENDING:
- case CypherParser::ASC:
- case CypherParser::DESCENDING:
- case CypherParser::DESC:
- case CypherParser::WHERE:
- case CypherParser::OR:
- case CypherParser::XOR:
- case CypherParser::AND:
- case CypherParser::NOT:
- case CypherParser::IN:
- case CypherParser::STARTS:
- case CypherParser::ENDS:
- case CypherParser::CONTAINS:
- case CypherParser::IS:
- case CypherParser::CYPHERNULL:
- case CypherParser::COUNT:
- case CypherParser::FILTER:
- case CypherParser::EXTRACT:
- case CypherParser::ANY:
- case CypherParser::NONE:
- case CypherParser::SINGLE:
- case CypherParser::TRUE:
- case CypherParser::FALSE:
- case CypherParser::UnescapedSymbolicName:
- case CypherParser::EscapedSymbolicName: {
- setState(1284);
- symbolicName();
- break;
- }
-
- case CypherParser::DecimalInteger: {
- setState(1285);
- match(CypherParser::DecimalInteger);
- break;
- }
-
- default:
- throw NoViableAltException(this);
- }
-
- }
- catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- PropertyExpressionContext ------------------------------------------------------------------
-
-CypherParser::PropertyExpressionContext::PropertyExpressionContext(ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {
-}
-
-CypherParser::AtomContext* CypherParser::PropertyExpressionContext::atom() {
- return getRuleContext<CypherParser::AtomContext>(0);
-}
-
-std::vector<CypherParser::PropertyLookupContext *> CypherParser::PropertyExpressionContext::propertyLookup() {
- return getRuleContexts<CypherParser::PropertyLookupContext>();
-}
-
-CypherParser::PropertyLookupContext* CypherParser::PropertyExpressionContext::propertyLookup(size_t i) {
- return getRuleContext<CypherParser::PropertyLookupContext>(i);
-}
-
-std::vector<tree::TerminalNode *> CypherParser::PropertyExpressionContext::SP() {
- return getTokens(CypherParser::SP);
-}
-
-tree::TerminalNode* CypherParser::PropertyExpressionContext::SP(size_t i) {
- return getToken(CypherParser::SP, i);
-}
-
-
-size_t CypherParser::PropertyExpressionContext::getRuleIndex() const {
- return CypherParser::RulePropertyExpression;
-}
-
-void CypherParser::PropertyExpressionContext::enterRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->enterPropertyExpression(this);
-}
-
-void CypherParser::PropertyExpressionContext::exitRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->exitPropertyExpression(this);
-}
-
-
-antlrcpp::Any CypherParser::PropertyExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
- return parserVisitor->visitPropertyExpression(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::PropertyExpressionContext* CypherParser::propertyExpression() {
- PropertyExpressionContext *_localctx = _tracker.createInstance<PropertyExpressionContext>(_ctx, getState());
- enterRule(_localctx, 144, CypherParser::RulePropertyExpression);
- size_t _la = 0;
-
- auto onExit = finally([=] {
- exitRule();
- });
- try {
- size_t alt;
- enterOuterAlt(_localctx, 1);
- setState(1288);
- atom();
- setState(1293);
- _errHandler->sync(this);
- alt = 1;
- do {
- switch (alt) {
- case 1: {
- setState(1290);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(1289);
- match(CypherParser::SP);
- }
- setState(1292);
- propertyLookup();
- break;
- }
-
- default:
- throw NoViableAltException(this);
- }
- setState(1295);
- _errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 240, _ctx);
- } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
-
- }
- catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- PropertyKeyNameContext ------------------------------------------------------------------
-
-CypherParser::PropertyKeyNameContext::PropertyKeyNameContext(ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {
-}
-
-CypherParser::SymbolicNameContext* CypherParser::PropertyKeyNameContext::symbolicName() {
- return getRuleContext<CypherParser::SymbolicNameContext>(0);
-}
-
-
-size_t CypherParser::PropertyKeyNameContext::getRuleIndex() const {
- return CypherParser::RulePropertyKeyName;
-}
-
-void CypherParser::PropertyKeyNameContext::enterRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->enterPropertyKeyName(this);
-}
-
-void CypherParser::PropertyKeyNameContext::exitRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->exitPropertyKeyName(this);
-}
-
-
-antlrcpp::Any CypherParser::PropertyKeyNameContext::accept(tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
- return parserVisitor->visitPropertyKeyName(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::PropertyKeyNameContext* CypherParser::propertyKeyName() {
- PropertyKeyNameContext *_localctx = _tracker.createInstance<PropertyKeyNameContext>(_ctx, getState());
- enterRule(_localctx, 146, CypherParser::RulePropertyKeyName);
-
- auto onExit = finally([=] {
- exitRule();
- });
- try {
- enterOuterAlt(_localctx, 1);
- setState(1297);
- symbolicName();
-
- }
- catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- IntegerLiteralContext ------------------------------------------------------------------
-
-CypherParser::IntegerLiteralContext::IntegerLiteralContext(ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {
-}
-
-tree::TerminalNode* CypherParser::IntegerLiteralContext::HexInteger() {
- return getToken(CypherParser::HexInteger, 0);
-}
-
-tree::TerminalNode* CypherParser::IntegerLiteralContext::OctalInteger() {
- return getToken(CypherParser::OctalInteger, 0);
-}
-
-tree::TerminalNode* CypherParser::IntegerLiteralContext::DecimalInteger() {
- return getToken(CypherParser::DecimalInteger, 0);
-}
-
-
-size_t CypherParser::IntegerLiteralContext::getRuleIndex() const {
- return CypherParser::RuleIntegerLiteral;
-}
-
-void CypherParser::IntegerLiteralContext::enterRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->enterIntegerLiteral(this);
-}
-
-void CypherParser::IntegerLiteralContext::exitRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->exitIntegerLiteral(this);
-}
-
-
-antlrcpp::Any CypherParser::IntegerLiteralContext::accept(tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
- return parserVisitor->visitIntegerLiteral(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::IntegerLiteralContext* CypherParser::integerLiteral() {
- IntegerLiteralContext *_localctx = _tracker.createInstance<IntegerLiteralContext>(_ctx, getState());
- enterRule(_localctx, 148, CypherParser::RuleIntegerLiteral);
- size_t _la = 0;
-
- auto onExit = finally([=] {
- exitRule();
- });
- try {
- enterOuterAlt(_localctx, 1);
- setState(1299);
- _la = _input->LA(1);
- if (!((((_la & ~ 0x3fULL) == 0) &&
- ((1ULL << _la) & ((1ULL << CypherParser::HexInteger)
- | (1ULL << CypherParser::DecimalInteger)
- | (1ULL << CypherParser::OctalInteger))) != 0))) {
- _errHandler->recoverInline(this);
- }
- else {
- _errHandler->reportMatch(this);
- consume();
- }
-
- }
- catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- DoubleLiteralContext ------------------------------------------------------------------
-
-CypherParser::DoubleLiteralContext::DoubleLiteralContext(ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {
-}
-
-tree::TerminalNode* CypherParser::DoubleLiteralContext::ExponentDecimalReal() {
- return getToken(CypherParser::ExponentDecimalReal, 0);
-}
-
-tree::TerminalNode* CypherParser::DoubleLiteralContext::RegularDecimalReal() {
- return getToken(CypherParser::RegularDecimalReal, 0);
-}
-
-
-size_t CypherParser::DoubleLiteralContext::getRuleIndex() const {
- return CypherParser::RuleDoubleLiteral;
-}
-
-void CypherParser::DoubleLiteralContext::enterRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->enterDoubleLiteral(this);
-}
-
-void CypherParser::DoubleLiteralContext::exitRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->exitDoubleLiteral(this);
-}
-
-
-antlrcpp::Any CypherParser::DoubleLiteralContext::accept(tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
- return parserVisitor->visitDoubleLiteral(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::DoubleLiteralContext* CypherParser::doubleLiteral() {
- DoubleLiteralContext *_localctx = _tracker.createInstance<DoubleLiteralContext>(_ctx, getState());
- enterRule(_localctx, 150, CypherParser::RuleDoubleLiteral);
- size_t _la = 0;
-
- auto onExit = finally([=] {
- exitRule();
- });
- try {
- enterOuterAlt(_localctx, 1);
- setState(1301);
- _la = _input->LA(1);
- if (!(_la == CypherParser::ExponentDecimalReal
-
- || _la == CypherParser::RegularDecimalReal)) {
- _errHandler->recoverInline(this);
- }
- else {
- _errHandler->reportMatch(this);
- consume();
- }
-
- }
- catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- SymbolicNameContext ------------------------------------------------------------------
-
-CypherParser::SymbolicNameContext::SymbolicNameContext(ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {
-}
-
-tree::TerminalNode* CypherParser::SymbolicNameContext::UnescapedSymbolicName() {
- return getToken(CypherParser::UnescapedSymbolicName, 0);
-}
-
-tree::TerminalNode* CypherParser::SymbolicNameContext::EscapedSymbolicName() {
- return getToken(CypherParser::EscapedSymbolicName, 0);
-}
-
-tree::TerminalNode* CypherParser::SymbolicNameContext::UNION() {
- return getToken(CypherParser::UNION, 0);
-}
-
-tree::TerminalNode* CypherParser::SymbolicNameContext::ALL() {
- return getToken(CypherParser::ALL, 0);
-}
-
-tree::TerminalNode* CypherParser::SymbolicNameContext::OPTIONAL() {
- return getToken(CypherParser::OPTIONAL, 0);
-}
-
-tree::TerminalNode* CypherParser::SymbolicNameContext::MATCH() {
- return getToken(CypherParser::MATCH, 0);
-}
-
-tree::TerminalNode* CypherParser::SymbolicNameContext::UNWIND() {
- return getToken(CypherParser::UNWIND, 0);
-}
-
-tree::TerminalNode* CypherParser::SymbolicNameContext::AS() {
- return getToken(CypherParser::AS, 0);
-}
-
-tree::TerminalNode* CypherParser::SymbolicNameContext::MERGE() {
- return getToken(CypherParser::MERGE, 0);
-}
-
-tree::TerminalNode* CypherParser::SymbolicNameContext::ON() {
- return getToken(CypherParser::ON, 0);
-}
-
-tree::TerminalNode* CypherParser::SymbolicNameContext::CREATE() {
- return getToken(CypherParser::CREATE, 0);
-}
-
-tree::TerminalNode* CypherParser::SymbolicNameContext::SET() {
- return getToken(CypherParser::SET, 0);
-}
-
-tree::TerminalNode* CypherParser::SymbolicNameContext::DETACH() {
- return getToken(CypherParser::DETACH, 0);
-}
-
-tree::TerminalNode* CypherParser::SymbolicNameContext::DELETE() {
- return getToken(CypherParser::DELETE, 0);
-}
-
-tree::TerminalNode* CypherParser::SymbolicNameContext::REMOVE() {
- return getToken(CypherParser::REMOVE, 0);
-}
-
-tree::TerminalNode* CypherParser::SymbolicNameContext::WITH() {
- return getToken(CypherParser::WITH, 0);
-}
-
-tree::TerminalNode* CypherParser::SymbolicNameContext::DISTINCT() {
- return getToken(CypherParser::DISTINCT, 0);
-}
-
-tree::TerminalNode* CypherParser::SymbolicNameContext::RETURN() {
- return getToken(CypherParser::RETURN, 0);
-}
-
-tree::TerminalNode* CypherParser::SymbolicNameContext::ORDER() {
- return getToken(CypherParser::ORDER, 0);
-}
-
-tree::TerminalNode* CypherParser::SymbolicNameContext::BY() {
- return getToken(CypherParser::BY, 0);
-}
-
-tree::TerminalNode* CypherParser::SymbolicNameContext::L_SKIP() {
- return getToken(CypherParser::L_SKIP, 0);
-}
-
-tree::TerminalNode* CypherParser::SymbolicNameContext::LIMIT() {
- return getToken(CypherParser::LIMIT, 0);
-}
-
-tree::TerminalNode* CypherParser::SymbolicNameContext::ASCENDING() {
- return getToken(CypherParser::ASCENDING, 0);
-}
-
-tree::TerminalNode* CypherParser::SymbolicNameContext::ASC() {
- return getToken(CypherParser::ASC, 0);
-}
-
-tree::TerminalNode* CypherParser::SymbolicNameContext::DESCENDING() {
- return getToken(CypherParser::DESCENDING, 0);
-}
-
-tree::TerminalNode* CypherParser::SymbolicNameContext::DESC() {
- return getToken(CypherParser::DESC, 0);
-}
-
-tree::TerminalNode* CypherParser::SymbolicNameContext::WHERE() {
- return getToken(CypherParser::WHERE, 0);
-}
-
-tree::TerminalNode* CypherParser::SymbolicNameContext::OR() {
- return getToken(CypherParser::OR, 0);
-}
-
-tree::TerminalNode* CypherParser::SymbolicNameContext::XOR() {
- return getToken(CypherParser::XOR, 0);
-}
-
-tree::TerminalNode* CypherParser::SymbolicNameContext::AND() {
- return getToken(CypherParser::AND, 0);
-}
-
-tree::TerminalNode* CypherParser::SymbolicNameContext::NOT() {
- return getToken(CypherParser::NOT, 0);
-}
-
-tree::TerminalNode* CypherParser::SymbolicNameContext::IN() {
- return getToken(CypherParser::IN, 0);
-}
-
-tree::TerminalNode* CypherParser::SymbolicNameContext::STARTS() {
- return getToken(CypherParser::STARTS, 0);
-}
-
-tree::TerminalNode* CypherParser::SymbolicNameContext::ENDS() {
- return getToken(CypherParser::ENDS, 0);
-}
-
-tree::TerminalNode* CypherParser::SymbolicNameContext::CONTAINS() {
- return getToken(CypherParser::CONTAINS, 0);
-}
-
-tree::TerminalNode* CypherParser::SymbolicNameContext::IS() {
- return getToken(CypherParser::IS, 0);
-}
-
-tree::TerminalNode* CypherParser::SymbolicNameContext::CYPHERNULL() {
- return getToken(CypherParser::CYPHERNULL, 0);
-}
-
-tree::TerminalNode* CypherParser::SymbolicNameContext::COUNT() {
- return getToken(CypherParser::COUNT, 0);
-}
-
-tree::TerminalNode* CypherParser::SymbolicNameContext::FILTER() {
- return getToken(CypherParser::FILTER, 0);
-}
-
-tree::TerminalNode* CypherParser::SymbolicNameContext::EXTRACT() {
- return getToken(CypherParser::EXTRACT, 0);
-}
-
-tree::TerminalNode* CypherParser::SymbolicNameContext::ANY() {
- return getToken(CypherParser::ANY, 0);
-}
-
-tree::TerminalNode* CypherParser::SymbolicNameContext::NONE() {
- return getToken(CypherParser::NONE, 0);
-}
-
-tree::TerminalNode* CypherParser::SymbolicNameContext::SINGLE() {
- return getToken(CypherParser::SINGLE, 0);
-}
-
-tree::TerminalNode* CypherParser::SymbolicNameContext::TRUE() {
- return getToken(CypherParser::TRUE, 0);
-}
-
-tree::TerminalNode* CypherParser::SymbolicNameContext::FALSE() {
- return getToken(CypherParser::FALSE, 0);
-}
-
-tree::TerminalNode* CypherParser::SymbolicNameContext::HexLetter() {
- return getToken(CypherParser::HexLetter, 0);
-}
-
-
-size_t CypherParser::SymbolicNameContext::getRuleIndex() const {
- return CypherParser::RuleSymbolicName;
-}
-
-void CypherParser::SymbolicNameContext::enterRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->enterSymbolicName(this);
-}
-
-void CypherParser::SymbolicNameContext::exitRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->exitSymbolicName(this);
-}
-
-
-antlrcpp::Any CypherParser::SymbolicNameContext::accept(tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
- return parserVisitor->visitSymbolicName(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::SymbolicNameContext* CypherParser::symbolicName() {
- SymbolicNameContext *_localctx = _tracker.createInstance<SymbolicNameContext>(_ctx, getState());
- enterRule(_localctx, 152, CypherParser::RuleSymbolicName);
- size_t _la = 0;
-
- auto onExit = finally([=] {
- exitRule();
- });
- try {
- enterOuterAlt(_localctx, 1);
- setState(1303);
- _la = _input->LA(1);
- if (!(((((_la - 53) & ~ 0x3fULL) == 0) &&
- ((1ULL << (_la - 53)) & ((1ULL << (CypherParser::HexLetter - 53))
- | (1ULL << (CypherParser::UNION - 53))
- | (1ULL << (CypherParser::ALL - 53))
- | (1ULL << (CypherParser::OPTIONAL - 53))
- | (1ULL << (CypherParser::MATCH - 53))
- | (1ULL << (CypherParser::UNWIND - 53))
- | (1ULL << (CypherParser::AS - 53))
- | (1ULL << (CypherParser::MERGE - 53))
- | (1ULL << (CypherParser::ON - 53))
- | (1ULL << (CypherParser::CREATE - 53))
- | (1ULL << (CypherParser::SET - 53))
- | (1ULL << (CypherParser::DETACH - 53))
- | (1ULL << (CypherParser::DELETE - 53))
- | (1ULL << (CypherParser::REMOVE - 53))
- | (1ULL << (CypherParser::WITH - 53))
- | (1ULL << (CypherParser::DISTINCT - 53))
- | (1ULL << (CypherParser::RETURN - 53))
- | (1ULL << (CypherParser::ORDER - 53))
- | (1ULL << (CypherParser::BY - 53))
- | (1ULL << (CypherParser::L_SKIP - 53))
- | (1ULL << (CypherParser::LIMIT - 53))
- | (1ULL << (CypherParser::ASCENDING - 53))
- | (1ULL << (CypherParser::ASC - 53))
- | (1ULL << (CypherParser::DESCENDING - 53))
- | (1ULL << (CypherParser::DESC - 53))
- | (1ULL << (CypherParser::WHERE - 53))
- | (1ULL << (CypherParser::OR - 53))
- | (1ULL << (CypherParser::XOR - 53))
- | (1ULL << (CypherParser::AND - 53))
- | (1ULL << (CypherParser::NOT - 53))
- | (1ULL << (CypherParser::IN - 53))
- | (1ULL << (CypherParser::STARTS - 53))
- | (1ULL << (CypherParser::ENDS - 53))
- | (1ULL << (CypherParser::CONTAINS - 53))
- | (1ULL << (CypherParser::IS - 53))
- | (1ULL << (CypherParser::CYPHERNULL - 53))
- | (1ULL << (CypherParser::COUNT - 53))
- | (1ULL << (CypherParser::FILTER - 53))
- | (1ULL << (CypherParser::EXTRACT - 53))
- | (1ULL << (CypherParser::ANY - 53))
- | (1ULL << (CypherParser::NONE - 53))
- | (1ULL << (CypherParser::SINGLE - 53))
- | (1ULL << (CypherParser::TRUE - 53))
- | (1ULL << (CypherParser::FALSE - 53))
- | (1ULL << (CypherParser::UnescapedSymbolicName - 53))
- | (1ULL << (CypherParser::EscapedSymbolicName - 53)))) != 0))) {
- _errHandler->recoverInline(this);
- }
- else {
- _errHandler->reportMatch(this);
- consume();
- }
-
- }
- catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- LeftArrowHeadContext ------------------------------------------------------------------
-
-CypherParser::LeftArrowHeadContext::LeftArrowHeadContext(ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {
-}
-
-
-size_t CypherParser::LeftArrowHeadContext::getRuleIndex() const {
- return CypherParser::RuleLeftArrowHead;
-}
-
-void CypherParser::LeftArrowHeadContext::enterRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->enterLeftArrowHead(this);
-}
-
-void CypherParser::LeftArrowHeadContext::exitRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->exitLeftArrowHead(this);
-}
-
-
-antlrcpp::Any CypherParser::LeftArrowHeadContext::accept(tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
- return parserVisitor->visitLeftArrowHead(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::LeftArrowHeadContext* CypherParser::leftArrowHead() {
- LeftArrowHeadContext *_localctx = _tracker.createInstance<LeftArrowHeadContext>(_ctx, getState());
- enterRule(_localctx, 154, CypherParser::RuleLeftArrowHead);
- size_t _la = 0;
-
- auto onExit = finally([=] {
- exitRule();
- });
- try {
- enterOuterAlt(_localctx, 1);
- setState(1305);
- _la = _input->LA(1);
- if (!((((_la & ~ 0x3fULL) == 0) &&
- ((1ULL << _la) & ((1ULL << CypherParser::T__20)
- | (1ULL << CypherParser::T__28)
- | (1ULL << CypherParser::T__29)
- | (1ULL << CypherParser::T__30)
- | (1ULL << CypherParser::T__31))) != 0))) {
- _errHandler->recoverInline(this);
- }
- else {
- _errHandler->reportMatch(this);
- consume();
- }
-
- }
- catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- RightArrowHeadContext ------------------------------------------------------------------
-
-CypherParser::RightArrowHeadContext::RightArrowHeadContext(ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {
-}
-
-
-size_t CypherParser::RightArrowHeadContext::getRuleIndex() const {
- return CypherParser::RuleRightArrowHead;
-}
-
-void CypherParser::RightArrowHeadContext::enterRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->enterRightArrowHead(this);
-}
-
-void CypherParser::RightArrowHeadContext::exitRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->exitRightArrowHead(this);
-}
-
-
-antlrcpp::Any CypherParser::RightArrowHeadContext::accept(tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
- return parserVisitor->visitRightArrowHead(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::RightArrowHeadContext* CypherParser::rightArrowHead() {
- RightArrowHeadContext *_localctx = _tracker.createInstance<RightArrowHeadContext>(_ctx, getState());
- enterRule(_localctx, 156, CypherParser::RuleRightArrowHead);
- size_t _la = 0;
-
- auto onExit = finally([=] {
- exitRule();
- });
- try {
- enterOuterAlt(_localctx, 1);
- setState(1307);
- _la = _input->LA(1);
- if (!((((_la & ~ 0x3fULL) == 0) &&
- ((1ULL << _la) & ((1ULL << CypherParser::T__21)
- | (1ULL << CypherParser::T__32)
- | (1ULL << CypherParser::T__33)
- | (1ULL << CypherParser::T__34)
- | (1ULL << CypherParser::T__35))) != 0))) {
- _errHandler->recoverInline(this);
- }
- else {
- _errHandler->reportMatch(this);
- consume();
- }
-
- }
- catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- DashContext ------------------------------------------------------------------
-
-CypherParser::DashContext::DashContext(ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {
-}
-
-
-size_t CypherParser::DashContext::getRuleIndex() const {
- return CypherParser::RuleDash;
-}
-
-void CypherParser::DashContext::enterRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->enterDash(this);
-}
-
-void CypherParser::DashContext::exitRule(tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->exitDash(this);
-}
-
-
-antlrcpp::Any CypherParser::DashContext::accept(tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
- return parserVisitor->visitDash(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::DashContext* CypherParser::dash() {
- DashContext *_localctx = _tracker.createInstance<DashContext>(_ctx, getState());
- enterRule(_localctx, 158, CypherParser::RuleDash);
- size_t _la = 0;
-
- auto onExit = finally([=] {
- exitRule();
- });
- try {
- enterOuterAlt(_localctx, 1);
- setState(1309);
- _la = _input->LA(1);
- if (!((((_la & ~ 0x3fULL) == 0) &&
- ((1ULL << _la) & ((1ULL << CypherParser::T__13)
- | (1ULL << CypherParser::T__36)
- | (1ULL << CypherParser::T__37)
- | (1ULL << CypherParser::T__38)
- | (1ULL << CypherParser::T__39)
- | (1ULL << CypherParser::T__40)
- | (1ULL << CypherParser::T__41)
- | (1ULL << CypherParser::T__42)
- | (1ULL << CypherParser::T__43)
- | (1ULL << CypherParser::T__44)
- | (1ULL << CypherParser::T__45)
- | (1ULL << CypherParser::T__46))) != 0))) {
- _errHandler->recoverInline(this);
- }
- else {
- _errHandler->reportMatch(this);
- consume();
- }
-
- }
- catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-// Static vars and initialization.
-std::vector<dfa::DFA> CypherParser::_decisionToDFA;
-atn::PredictionContextCache CypherParser::_sharedContextCache;
-
-// We own the ATN which in turn owns the ATN states.
-atn::ATN CypherParser::_atn;
-std::vector<uint16_t> CypherParser::_serializedATN;
-
-std::vector<std::string> CypherParser::_ruleNames = {
- "cypher", "statement", "query", "regularQuery", "singleQuery", "cypherUnion",
- "clause", "cypherMatch", "unwind", "merge", "mergeAction", "create", "set",
- "setItem", "cypherDelete", "remove", "removeItem", "with", "cypherReturn",
- "returnBody", "returnItems", "returnItem", "order", "skip", "limit", "sortItem",
- "where", "pattern", "patternPart", "anonymousPatternPart", "patternElement",
- "nodePattern", "patternElementChain", "relationshipPattern", "relationshipDetail",
- "properties", "relationshipTypes", "nodeLabels", "nodeLabel", "rangeLiteral",
- "labelName", "relTypeName", "expression", "expression12", "expression11",
- "expression10", "expression9", "expression8", "expression7", "expression6",
- "expression5", "expression4", "expression3", "expression2", "atom", "literal",
- "booleanLiteral", "listLiteral", "partialComparisonExpression", "parenthesizedExpression",
- "relationshipsPattern", "filterExpression", "idInColl", "functionInvocation",
- "functionName", "listComprehension", "patternComprehension", "propertyLookup",
- "variable", "numberLiteral", "mapLiteral", "parameter", "propertyExpression",
- "propertyKeyName", "integerLiteral", "doubleLiteral", "symbolicName",
- "leftArrowHead", "rightArrowHead", "dash"
-};
-
-std::vector<std::string> CypherParser::_literalNames = {
- "", "';'", "','", "'='", "'+='", "'*'", "'('", "')'", "'['", "']'", "':'",
- "'|'", "'..'", "'+'", "'-'", "'/'", "'%'", "'^'", "'=~'", "'<>'", "'!='",
- "'<'", "'>'", "'<='", "'>='", "'.'", "'{'", "'}'", "'$'", "'⟨'", "'〈'",
- "'﹤'", "'＜'", "'⟩'", "'〉'", "'﹥'", "'＞'", "''", "'‐'", "'‑'", "'‒'",
- "'–'", "'—'", "'―'", "'−'", "'﹘'", "'﹣'", "'－'", "", "", "", "", "", "",
- "", "", "", "", "", "'0'"
-};
-
-std::vector<std::string> CypherParser::_symbolicNames = {
- "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
- "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
- "", "", "", "", "", "", "", "", "", "", "", "", "StringLiteral", "EscapedChar",
- "HexInteger", "DecimalInteger", "OctalInteger", "HexLetter", "HexDigit",
- "Digit", "NonZeroDigit", "NonZeroOctDigit", "OctDigit", "ZeroDigit", "ExponentDecimalReal",
- "RegularDecimalReal", "UNION", "ALL", "OPTIONAL", "MATCH", "UNWIND", "AS",
- "MERGE", "ON", "CREATE", "SET", "DETACH", "DELETE", "REMOVE", "WITH",
- "DISTINCT", "RETURN", "ORDER", "BY", "L_SKIP", "LIMIT", "ASCENDING", "ASC",
- "DESCENDING", "DESC", "WHERE", "OR", "XOR", "AND", "NOT", "IN", "STARTS",
- "ENDS", "CONTAINS", "IS", "CYPHERNULL", "COUNT", "FILTER", "EXTRACT",
- "ANY", "NONE", "SINGLE", "TRUE", "FALSE", "UnescapedSymbolicName", "IdentifierStart",
- "IdentifierPart", "EscapedSymbolicName", "SP", "WHITESPACE", "Comment"
-};
-
-dfa::Vocabulary CypherParser::_vocabulary(_literalNames, _symbolicNames);
-
-std::vector<std::string> CypherParser::_tokenNames;
-
-CypherParser::Initializer::Initializer() {
- for (size_t i = 0; i < _symbolicNames.size(); ++i) {
- std::string name = _vocabulary.getLiteralName(i);
- if (name.empty()) {
- name = _vocabulary.getSymbolicName(i);
- }
-
- if (name.empty()) {
- _tokenNames.push_back("<INVALID>");
- } else {
- _tokenNames.push_back(name);
- }
- }
-
- _serializedATN = {
- 0x3, 0x430, 0xd6d1, 0x8206, 0xad2d, 0x4417, 0xaef1, 0x8d80, 0xaadd,
- 0x3, 0x71, 0x522, 0x4, 0x2, 0x9, 0x2, 0x4, 0x3, 0x9, 0x3, 0x4, 0x4,
- 0x9, 0x4, 0x4, 0x5, 0x9, 0x5, 0x4, 0x6, 0x9, 0x6, 0x4, 0x7, 0x9, 0x7,
- 0x4, 0x8, 0x9, 0x8, 0x4, 0x9, 0x9, 0x9, 0x4, 0xa, 0x9, 0xa, 0x4, 0xb,
- 0x9, 0xb, 0x4, 0xc, 0x9, 0xc, 0x4, 0xd, 0x9, 0xd, 0x4, 0xe, 0x9, 0xe,
- 0x4, 0xf, 0x9, 0xf, 0x4, 0x10, 0x9, 0x10, 0x4, 0x11, 0x9, 0x11, 0x4,
- 0x12, 0x9, 0x12, 0x4, 0x13, 0x9, 0x13, 0x4, 0x14, 0x9, 0x14, 0x4, 0x15,
- 0x9, 0x15, 0x4, 0x16, 0x9, 0x16, 0x4, 0x17, 0x9, 0x17, 0x4, 0x18, 0x9,
- 0x18, 0x4, 0x19, 0x9, 0x19, 0x4, 0x1a, 0x9, 0x1a, 0x4, 0x1b, 0x9, 0x1b,
- 0x4, 0x1c, 0x9, 0x1c, 0x4, 0x1d, 0x9, 0x1d, 0x4, 0x1e, 0x9, 0x1e, 0x4,
- 0x1f, 0x9, 0x1f, 0x4, 0x20, 0x9, 0x20, 0x4, 0x21, 0x9, 0x21, 0x4, 0x22,
- 0x9, 0x22, 0x4, 0x23, 0x9, 0x23, 0x4, 0x24, 0x9, 0x24, 0x4, 0x25, 0x9,
- 0x25, 0x4, 0x26, 0x9, 0x26, 0x4, 0x27, 0x9, 0x27, 0x4, 0x28, 0x9, 0x28,
- 0x4, 0x29, 0x9, 0x29, 0x4, 0x2a, 0x9, 0x2a, 0x4, 0x2b, 0x9, 0x2b, 0x4,
- 0x2c, 0x9, 0x2c, 0x4, 0x2d, 0x9, 0x2d, 0x4, 0x2e, 0x9, 0x2e, 0x4, 0x2f,
- 0x9, 0x2f, 0x4, 0x30, 0x9, 0x30, 0x4, 0x31, 0x9, 0x31, 0x4, 0x32, 0x9,
- 0x32, 0x4, 0x33, 0x9, 0x33, 0x4, 0x34, 0x9, 0x34, 0x4, 0x35, 0x9, 0x35,
- 0x4, 0x36, 0x9, 0x36, 0x4, 0x37, 0x9, 0x37, 0x4, 0x38, 0x9, 0x38, 0x4,
- 0x39, 0x9, 0x39, 0x4, 0x3a, 0x9, 0x3a, 0x4, 0x3b, 0x9, 0x3b, 0x4, 0x3c,
- 0x9, 0x3c, 0x4, 0x3d, 0x9, 0x3d, 0x4, 0x3e, 0x9, 0x3e, 0x4, 0x3f, 0x9,
- 0x3f, 0x4, 0x40, 0x9, 0x40, 0x4, 0x41, 0x9, 0x41, 0x4, 0x42, 0x9, 0x42,
- 0x4, 0x43, 0x9, 0x43, 0x4, 0x44, 0x9, 0x44, 0x4, 0x45, 0x9, 0x45, 0x4,
- 0x46, 0x9, 0x46, 0x4, 0x47, 0x9, 0x47, 0x4, 0x48, 0x9, 0x48, 0x4, 0x49,
- 0x9, 0x49, 0x4, 0x4a, 0x9, 0x4a, 0x4, 0x4b, 0x9, 0x4b, 0x4, 0x4c, 0x9,
- 0x4c, 0x4, 0x4d, 0x9, 0x4d, 0x4, 0x4e, 0x9, 0x4e, 0x4, 0x4f, 0x9, 0x4f,
- 0x4, 0x50, 0x9, 0x50, 0x4, 0x51, 0x9, 0x51, 0x3, 0x2, 0x5, 0x2, 0xa4,
- 0xa, 0x2, 0x3, 0x2, 0x3, 0x2, 0x5, 0x2, 0xa8, 0xa, 0x2, 0x3, 0x2, 0x5,
- 0x2, 0xab, 0xa, 0x2, 0x3, 0x2, 0x5, 0x2, 0xae, 0xa, 0x2, 0x3, 0x3, 0x3,
- 0x3, 0x3, 0x4, 0x3, 0x4, 0x3, 0x5, 0x3, 0x5, 0x5, 0x5, 0xb6, 0xa, 0x5,
- 0x3, 0x5, 0x7, 0x5, 0xb9, 0xa, 0x5, 0xc, 0x5, 0xe, 0x5, 0xbc, 0xb, 0x5,
- 0x3, 0x6, 0x3, 0x6, 0x5, 0x6, 0xc0, 0xa, 0x6, 0x3, 0x6, 0x7, 0x6, 0xc3,
- 0xa, 0x6, 0xc, 0x6, 0xe, 0x6, 0xc6, 0xb, 0x6, 0x3, 0x7, 0x3, 0x7, 0x3,
- 0x7, 0x3, 0x7, 0x5, 0x7, 0xcc, 0xa, 0x7, 0x3, 0x7, 0x3, 0x7, 0x3, 0x7,
- 0x5, 0x7, 0xd1, 0xa, 0x7, 0x3, 0x7, 0x5, 0x7, 0xd4, 0xa, 0x7, 0x3, 0x8,
- 0x3, 0x8, 0x3, 0x8, 0x3, 0x8, 0x3, 0x8, 0x3, 0x8, 0x3, 0x8, 0x3, 0x8,
- 0x3, 0x8, 0x5, 0x8, 0xdf, 0xa, 0x8, 0x3, 0x9, 0x3, 0x9, 0x5, 0x9, 0xe3,
- 0xa, 0x9, 0x3, 0x9, 0x3, 0x9, 0x5, 0x9, 0xe7, 0xa, 0x9, 0x3, 0x9, 0x3,
- 0x9, 0x5, 0x9, 0xeb, 0xa, 0x9, 0x3, 0x9, 0x5, 0x9, 0xee, 0xa, 0x9, 0x3,
- 0xa, 0x3, 0xa, 0x5, 0xa, 0xf2, 0xa, 0xa, 0x3, 0xa, 0x3, 0xa, 0x3, 0xa,
- 0x3, 0xa, 0x3, 0xa, 0x3, 0xa, 0x3, 0xb, 0x3, 0xb, 0x5, 0xb, 0xfc, 0xa,
- 0xb, 0x3, 0xb, 0x3, 0xb, 0x3, 0xb, 0x7, 0xb, 0x101, 0xa, 0xb, 0xc, 0xb,
- 0xe, 0xb, 0x104, 0xb, 0xb, 0x3, 0xc, 0x3, 0xc, 0x3, 0xc, 0x3, 0xc, 0x3,
- 0xc, 0x3, 0xc, 0x3, 0xc, 0x3, 0xc, 0x3, 0xc, 0x3, 0xc, 0x5, 0xc, 0x110,
- 0xa, 0xc, 0x3, 0xd, 0x3, 0xd, 0x5, 0xd, 0x114, 0xa, 0xd, 0x3, 0xd, 0x3,
- 0xd, 0x3, 0xe, 0x3, 0xe, 0x5, 0xe, 0x11a, 0xa, 0xe, 0x3, 0xe, 0x3, 0xe,
- 0x3, 0xe, 0x7, 0xe, 0x11f, 0xa, 0xe, 0xc, 0xe, 0xe, 0xe, 0x122, 0xb,
- 0xe, 0x3, 0xf, 0x3, 0xf, 0x5, 0xf, 0x126, 0xa, 0xf, 0x3, 0xf, 0x3, 0xf,
- 0x5, 0xf, 0x12a, 0xa, 0xf, 0x3, 0xf, 0x3, 0xf, 0x3, 0xf, 0x3, 0xf, 0x5,
- 0xf, 0x130, 0xa, 0xf, 0x3, 0xf, 0x3, 0xf, 0x5, 0xf, 0x134, 0xa, 0xf,
- 0x3, 0xf, 0x3, 0xf, 0x3, 0xf, 0x3, 0xf, 0x5, 0xf, 0x13a, 0xa, 0xf, 0x3,
- 0xf, 0x3, 0xf, 0x5, 0xf, 0x13e, 0xa, 0xf, 0x3, 0xf, 0x3, 0xf, 0x3, 0xf,
- 0x3, 0xf, 0x5, 0xf, 0x144, 0xa, 0xf, 0x3, 0xf, 0x3, 0xf, 0x5, 0xf, 0x148,
- 0xa, 0xf, 0x3, 0x10, 0x3, 0x10, 0x5, 0x10, 0x14c, 0xa, 0x10, 0x3, 0x10,
- 0x3, 0x10, 0x5, 0x10, 0x150, 0xa, 0x10, 0x3, 0x10, 0x3, 0x10, 0x5, 0x10,
- 0x154, 0xa, 0x10, 0x3, 0x10, 0x3, 0x10, 0x5, 0x10, 0x158, 0xa, 0x10,
- 0x3, 0x10, 0x7, 0x10, 0x15b, 0xa, 0x10, 0xc, 0x10, 0xe, 0x10, 0x15e,
- 0xb, 0x10, 0x3, 0x11, 0x3, 0x11, 0x3, 0x11, 0x3, 0x11, 0x5, 0x11, 0x164,
- 0xa, 0x11, 0x3, 0x11, 0x3, 0x11, 0x5, 0x11, 0x168, 0xa, 0x11, 0x3, 0x11,
- 0x7, 0x11, 0x16b, 0xa, 0x11, 0xc, 0x11, 0xe, 0x11, 0x16e, 0xb, 0x11,
- 0x3, 0x12, 0x3, 0x12, 0x3, 0x12, 0x3, 0x12, 0x5, 0x12, 0x174, 0xa, 0x12,
- 0x3, 0x13, 0x3, 0x13, 0x5, 0x13, 0x178, 0xa, 0x13, 0x3, 0x13, 0x5, 0x13,
- 0x17b, 0xa, 0x13, 0x3, 0x13, 0x3, 0x13, 0x3, 0x13, 0x5, 0x13, 0x180,
- 0xa, 0x13, 0x3, 0x13, 0x5, 0x13, 0x183, 0xa, 0x13, 0x3, 0x14, 0x3, 0x14,
- 0x5, 0x14, 0x187, 0xa, 0x14, 0x3, 0x14, 0x5, 0x14, 0x18a, 0xa, 0x14,
- 0x3, 0x14, 0x3, 0x14, 0x3, 0x14, 0x3, 0x15, 0x3, 0x15, 0x3, 0x15, 0x5,
- 0x15, 0x192, 0xa, 0x15, 0x3, 0x15, 0x3, 0x15, 0x5, 0x15, 0x196, 0xa,
- 0x15, 0x3, 0x15, 0x3, 0x15, 0x5, 0x15, 0x19a, 0xa, 0x15, 0x3, 0x16,
- 0x3, 0x16, 0x5, 0x16, 0x19e, 0xa, 0x16, 0x3, 0x16, 0x3, 0x16, 0x5, 0x16,
- 0x1a2, 0xa, 0x16, 0x3, 0x16, 0x7, 0x16, 0x1a5, 0xa, 0x16, 0xc, 0x16,
- 0xe, 0x16, 0x1a8, 0xb, 0x16, 0x3, 0x16, 0x3, 0x16, 0x5, 0x16, 0x1ac,
- 0xa, 0x16, 0x3, 0x16, 0x3, 0x16, 0x5, 0x16, 0x1b0, 0xa, 0x16, 0x3, 0x16,
- 0x7, 0x16, 0x1b3, 0xa, 0x16, 0xc, 0x16, 0xe, 0x16, 0x1b6, 0xb, 0x16,
- 0x5, 0x16, 0x1b8, 0xa, 0x16, 0x3, 0x17, 0x3, 0x17, 0x3, 0x17, 0x3, 0x17,
- 0x3, 0x17, 0x3, 0x17, 0x3, 0x17, 0x5, 0x17, 0x1c1, 0xa, 0x17, 0x3, 0x18,
- 0x3, 0x18, 0x3, 0x18, 0x3, 0x18, 0x3, 0x18, 0x3, 0x18, 0x3, 0x18, 0x5,
- 0x18, 0x1ca, 0xa, 0x18, 0x3, 0x18, 0x7, 0x18, 0x1cd, 0xa, 0x18, 0xc,
- 0x18, 0xe, 0x18, 0x1d0, 0xb, 0x18, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19,
- 0x3, 0x19, 0x3, 0x1a, 0x3, 0x1a, 0x3, 0x1a, 0x3, 0x1a, 0x3, 0x1b, 0x3,
- 0x1b, 0x5, 0x1b, 0x1dc, 0xa, 0x1b, 0x3, 0x1b, 0x5, 0x1b, 0x1df, 0xa,
- 0x1b, 0x3, 0x1c, 0x3, 0x1c, 0x3, 0x1c, 0x3, 0x1c, 0x3, 0x1d, 0x3, 0x1d,
- 0x5, 0x1d, 0x1e7, 0xa, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x5, 0x1d, 0x1eb,
- 0xa, 0x1d, 0x3, 0x1d, 0x7, 0x1d, 0x1ee, 0xa, 0x1d, 0xc, 0x1d, 0xe, 0x1d,
- 0x1f1, 0xb, 0x1d, 0x3, 0x1e, 0x3, 0x1e, 0x5, 0x1e, 0x1f5, 0xa, 0x1e,
- 0x3, 0x1e, 0x3, 0x1e, 0x5, 0x1e, 0x1f9, 0xa, 0x1e, 0x3, 0x1e, 0x3, 0x1e,
- 0x3, 0x1e, 0x5, 0x1e, 0x1fe, 0xa, 0x1e, 0x3, 0x1f, 0x3, 0x1f, 0x3, 0x20,
- 0x3, 0x20, 0x5, 0x20, 0x204, 0xa, 0x20, 0x3, 0x20, 0x7, 0x20, 0x207,
- 0xa, 0x20, 0xc, 0x20, 0xe, 0x20, 0x20a, 0xb, 0x20, 0x3, 0x20, 0x3, 0x20,
- 0x3, 0x20, 0x3, 0x20, 0x5, 0x20, 0x210, 0xa, 0x20, 0x3, 0x21, 0x3, 0x21,
- 0x5, 0x21, 0x214, 0xa, 0x21, 0x3, 0x21, 0x3, 0x21, 0x5, 0x21, 0x218,
- 0xa, 0x21, 0x5, 0x21, 0x21a, 0xa, 0x21, 0x3, 0x21, 0x3, 0x21, 0x5, 0x21,
- 0x21e, 0xa, 0x21, 0x5, 0x21, 0x220, 0xa, 0x21, 0x3, 0x21, 0x3, 0x21,
- 0x5, 0x21, 0x224, 0xa, 0x21, 0x5, 0x21, 0x226, 0xa, 0x21, 0x3, 0x21,
- 0x3, 0x21, 0x3, 0x22, 0x3, 0x22, 0x5, 0x22, 0x22c, 0xa, 0x22, 0x3, 0x22,
- 0x3, 0x22, 0x3, 0x23, 0x3, 0x23, 0x5, 0x23, 0x232, 0xa, 0x23, 0x3, 0x23,
- 0x3, 0x23, 0x5, 0x23, 0x236, 0xa, 0x23, 0x3, 0x23, 0x5, 0x23, 0x239,
- 0xa, 0x23, 0x3, 0x23, 0x5, 0x23, 0x23c, 0xa, 0x23, 0x3, 0x23, 0x3, 0x23,
- 0x5, 0x23, 0x240, 0xa, 0x23, 0x3, 0x23, 0x3, 0x23, 0x3, 0x23, 0x3, 0x23,
- 0x5, 0x23, 0x246, 0xa, 0x23, 0x3, 0x23, 0x3, 0x23, 0x5, 0x23, 0x24a,
- 0xa, 0x23, 0x3, 0x23, 0x5, 0x23, 0x24d, 0xa, 0x23, 0x3, 0x23, 0x5, 0x23,
- 0x250, 0xa, 0x23, 0x3, 0x23, 0x3, 0x23, 0x3, 0x23, 0x3, 0x23, 0x5, 0x23,
- 0x256, 0xa, 0x23, 0x3, 0x23, 0x5, 0x23, 0x259, 0xa, 0x23, 0x3, 0x23,
- 0x5, 0x23, 0x25c, 0xa, 0x23, 0x3, 0x23, 0x3, 0x23, 0x5, 0x23, 0x260,
- 0xa, 0x23, 0x3, 0x23, 0x3, 0x23, 0x3, 0x23, 0x3, 0x23, 0x5, 0x23, 0x266,
- 0xa, 0x23, 0x3, 0x23, 0x5, 0x23, 0x269, 0xa, 0x23, 0x3, 0x23, 0x5, 0x23,
- 0x26c, 0xa, 0x23, 0x3, 0x23, 0x3, 0x23, 0x5, 0x23, 0x270, 0xa, 0x23,
- 0x3, 0x24, 0x3, 0x24, 0x5, 0x24, 0x274, 0xa, 0x24, 0x3, 0x24, 0x3, 0x24,
- 0x5, 0x24, 0x278, 0xa, 0x24, 0x5, 0x24, 0x27a, 0xa, 0x24, 0x3, 0x24,
- 0x3, 0x24, 0x5, 0x24, 0x27e, 0xa, 0x24, 0x5, 0x24, 0x280, 0xa, 0x24,
- 0x3, 0x24, 0x5, 0x24, 0x283, 0xa, 0x24, 0x3, 0x24, 0x3, 0x24, 0x5, 0x24,
- 0x287, 0xa, 0x24, 0x5, 0x24, 0x289, 0xa, 0x24, 0x3, 0x24, 0x3, 0x24,
- 0x3, 0x25, 0x3, 0x25, 0x5, 0x25, 0x28f, 0xa, 0x25, 0x3, 0x26, 0x3, 0x26,
- 0x5, 0x26, 0x293, 0xa, 0x26, 0x3, 0x26, 0x3, 0x26, 0x5, 0x26, 0x297,
- 0xa, 0x26, 0x3, 0x26, 0x3, 0x26, 0x5, 0x26, 0x29b, 0xa, 0x26, 0x3, 0x26,
- 0x5, 0x26, 0x29e, 0xa, 0x26, 0x3, 0x26, 0x7, 0x26, 0x2a1, 0xa, 0x26,
- 0xc, 0x26, 0xe, 0x26, 0x2a4, 0xb, 0x26, 0x3, 0x27, 0x3, 0x27, 0x5, 0x27,
- 0x2a8, 0xa, 0x27, 0x3, 0x27, 0x7, 0x27, 0x2ab, 0xa, 0x27, 0xc, 0x27,
- 0xe, 0x27, 0x2ae, 0xb, 0x27, 0x3, 0x28, 0x3, 0x28, 0x5, 0x28, 0x2b2,
- 0xa, 0x28, 0x3, 0x28, 0x3, 0x28, 0x3, 0x29, 0x3, 0x29, 0x5, 0x29, 0x2b8,
- 0xa, 0x29, 0x3, 0x29, 0x3, 0x29, 0x5, 0x29, 0x2bc, 0xa, 0x29, 0x5, 0x29,
- 0x2be, 0xa, 0x29, 0x3, 0x29, 0x3, 0x29, 0x5, 0x29, 0x2c2, 0xa, 0x29,
- 0x3, 0x29, 0x3, 0x29, 0x5, 0x29, 0x2c6, 0xa, 0x29, 0x5, 0x29, 0x2c8,
- 0xa, 0x29, 0x5, 0x29, 0x2ca, 0xa, 0x29, 0x3, 0x2a, 0x3, 0x2a, 0x3, 0x2b,
- 0x3, 0x2b, 0x3, 0x2c, 0x3, 0x2c, 0x3, 0x2d, 0x3, 0x2d, 0x3, 0x2d, 0x3,
- 0x2d, 0x3, 0x2d, 0x7, 0x2d, 0x2d7, 0xa, 0x2d, 0xc, 0x2d, 0xe, 0x2d,
- 0x2da, 0xb, 0x2d, 0x3, 0x2e, 0x3, 0x2e, 0x3, 0x2e, 0x3, 0x2e, 0x3, 0x2e,
- 0x7, 0x2e, 0x2e1, 0xa, 0x2e, 0xc, 0x2e, 0xe, 0x2e, 0x2e4, 0xb, 0x2e,
- 0x3, 0x2f, 0x3, 0x2f, 0x3, 0x2f, 0x3, 0x2f, 0x3, 0x2f, 0x7, 0x2f, 0x2eb,
- 0xa, 0x2f, 0xc, 0x2f, 0xe, 0x2f, 0x2ee, 0xb, 0x2f, 0x3, 0x30, 0x3, 0x30,
- 0x5, 0x30, 0x2f2, 0xa, 0x30, 0x7, 0x30, 0x2f4, 0xa, 0x30, 0xc, 0x30,
- 0xe, 0x30, 0x2f7, 0xb, 0x30, 0x3, 0x30, 0x3, 0x30, 0x3, 0x31, 0x3, 0x31,
- 0x5, 0x31, 0x2fd, 0xa, 0x31, 0x3, 0x31, 0x7, 0x31, 0x300, 0xa, 0x31,
- 0xc, 0x31, 0xe, 0x31, 0x303, 0xb, 0x31, 0x3, 0x32, 0x3, 0x32, 0x5, 0x32,
- 0x307, 0xa, 0x32, 0x3, 0x32, 0x3, 0x32, 0x5, 0x32, 0x30b, 0xa, 0x32,
- 0x3, 0x32, 0x3, 0x32, 0x5, 0x32, 0x30f, 0xa, 0x32, 0x3, 0x32, 0x3, 0x32,
- 0x5, 0x32, 0x313, 0xa, 0x32, 0x3, 0x32, 0x7, 0x32, 0x316, 0xa, 0x32,
- 0xc, 0x32, 0xe, 0x32, 0x319, 0xb, 0x32, 0x3, 0x33, 0x3, 0x33, 0x5, 0x33,
- 0x31d, 0xa, 0x33, 0x3, 0x33, 0x3, 0x33, 0x5, 0x33, 0x321, 0xa, 0x33,
- 0x3, 0x33, 0x3, 0x33, 0x5, 0x33, 0x325, 0xa, 0x33, 0x3, 0x33, 0x3, 0x33,
- 0x5, 0x33, 0x329, 0xa, 0x33, 0x3, 0x33, 0x3, 0x33, 0x5, 0x33, 0x32d,
- 0xa, 0x33, 0x3, 0x33, 0x3, 0x33, 0x5, 0x33, 0x331, 0xa, 0x33, 0x3, 0x33,
- 0x7, 0x33, 0x334, 0xa, 0x33, 0xc, 0x33, 0xe, 0x33, 0x337, 0xb, 0x33,
- 0x3, 0x34, 0x3, 0x34, 0x5, 0x34, 0x33b, 0xa, 0x34, 0x3, 0x34, 0x3, 0x34,
- 0x5, 0x34, 0x33f, 0xa, 0x34, 0x3, 0x34, 0x7, 0x34, 0x342, 0xa, 0x34,
- 0xc, 0x34, 0xe, 0x34, 0x345, 0xb, 0x34, 0x3, 0x35, 0x3, 0x35, 0x5, 0x35,
- 0x349, 0xa, 0x35, 0x7, 0x35, 0x34b, 0xa, 0x35, 0xc, 0x35, 0xe, 0x35,
- 0x34e, 0xb, 0x35, 0x3, 0x35, 0x3, 0x35, 0x3, 0x36, 0x3, 0x36, 0x5, 0x36,
- 0x354, 0xa, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36,
- 0x5, 0x36, 0x35b, 0xa, 0x36, 0x3, 0x36, 0x3, 0x36, 0x5, 0x36, 0x35f,
- 0xa, 0x36, 0x3, 0x36, 0x3, 0x36, 0x5, 0x36, 0x363, 0xa, 0x36, 0x3, 0x36,
- 0x3, 0x36, 0x5, 0x36, 0x367, 0xa, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36,
- 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3,
- 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x5, 0x36, 0x376, 0xa, 0x36,
- 0x3, 0x36, 0x5, 0x36, 0x379, 0xa, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36,
- 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3,
- 0x36, 0x3, 0x36, 0x7, 0x36, 0x386, 0xa, 0x36, 0xc, 0x36, 0xe, 0x36,
- 0x389, 0xb, 0x36, 0x3, 0x37, 0x3, 0x37, 0x5, 0x37, 0x38d, 0xa, 0x37,
- 0x3, 0x37, 0x3, 0x37, 0x5, 0x37, 0x391, 0xa, 0x37, 0x7, 0x37, 0x393,
- 0xa, 0x37, 0xc, 0x37, 0xe, 0x37, 0x396, 0xb, 0x37, 0x3, 0x38, 0x3, 0x38,
- 0x3, 0x38, 0x3, 0x38, 0x5, 0x38, 0x39c, 0xa, 0x38, 0x3, 0x38, 0x3, 0x38,
- 0x5, 0x38, 0x3a0, 0xa, 0x38, 0x3, 0x38, 0x3, 0x38, 0x5, 0x38, 0x3a4,
- 0xa, 0x38, 0x3, 0x38, 0x3, 0x38, 0x3, 0x38, 0x3, 0x38, 0x3, 0x38, 0x5,
- 0x38, 0x3ab, 0xa, 0x38, 0x3, 0x38, 0x3, 0x38, 0x5, 0x38, 0x3af, 0xa,
- 0x38, 0x3, 0x38, 0x3, 0x38, 0x5, 0x38, 0x3b3, 0xa, 0x38, 0x3, 0x38,
- 0x3, 0x38, 0x3, 0x38, 0x3, 0x38, 0x5, 0x38, 0x3b9, 0xa, 0x38, 0x3, 0x38,
- 0x3, 0x38, 0x5, 0x38, 0x3bd, 0xa, 0x38, 0x3, 0x38, 0x3, 0x38, 0x5, 0x38,
- 0x3c1, 0xa, 0x38, 0x3, 0x38, 0x5, 0x38, 0x3c4, 0xa, 0x38, 0x3, 0x38,
- 0x3, 0x38, 0x5, 0x38, 0x3c8, 0xa, 0x38, 0x3, 0x38, 0x3, 0x38, 0x3, 0x38,
- 0x3, 0x38, 0x5, 0x38, 0x3ce, 0xa, 0x38, 0x3, 0x38, 0x3, 0x38, 0x5, 0x38,
- 0x3d2, 0xa, 0x38, 0x3, 0x38, 0x3, 0x38, 0x5, 0x38, 0x3d6, 0xa, 0x38,
- 0x3, 0x38, 0x3, 0x38, 0x3, 0x38, 0x3, 0x38, 0x5, 0x38, 0x3dc, 0xa, 0x38,
- 0x3, 0x38, 0x3, 0x38, 0x5, 0x38, 0x3e0, 0xa, 0x38, 0x3, 0x38, 0x3, 0x38,
- 0x5, 0x38, 0x3e4, 0xa, 0x38, 0x3, 0x38, 0x3, 0x38, 0x3, 0x38, 0x3, 0x38,
- 0x5, 0x38, 0x3ea, 0xa, 0x38, 0x3, 0x38, 0x3, 0x38, 0x5, 0x38, 0x3ee,
- 0xa, 0x38, 0x3, 0x38, 0x3, 0x38, 0x5, 0x38, 0x3f2, 0xa, 0x38, 0x3, 0x38,
- 0x3, 0x38, 0x3, 0x38, 0x3, 0x38, 0x5, 0x38, 0x3f8, 0xa, 0x38, 0x3, 0x38,
- 0x3, 0x38, 0x5, 0x38, 0x3fc, 0xa, 0x38, 0x3, 0x38, 0x3, 0x38, 0x5, 0x38,
- 0x400, 0xa, 0x38, 0x3, 0x38, 0x3, 0x38, 0x3, 0x38, 0x3, 0x38, 0x3, 0x38,
- 0x3, 0x38, 0x5, 0x38, 0x408, 0xa, 0x38, 0x3, 0x39, 0x3, 0x39, 0x3, 0x39,
- 0x3, 0x39, 0x3, 0x39, 0x3, 0x39, 0x5, 0x39, 0x410, 0xa, 0x39, 0x3, 0x3a,
- 0x3, 0x3a, 0x3, 0x3b, 0x3, 0x3b, 0x5, 0x3b, 0x416, 0xa, 0x3b, 0x3, 0x3b,
- 0x3, 0x3b, 0x5, 0x3b, 0x41a, 0xa, 0x3b, 0x3, 0x3b, 0x3, 0x3b, 0x5, 0x3b,
- 0x41e, 0xa, 0x3b, 0x3, 0x3b, 0x3, 0x3b, 0x5, 0x3b, 0x422, 0xa, 0x3b,
- 0x7, 0x3b, 0x424, 0xa, 0x3b, 0xc, 0x3b, 0xe, 0x3b, 0x427, 0xb, 0x3b,
- 0x5, 0x3b, 0x429, 0xa, 0x3b, 0x3, 0x3b, 0x3, 0x3b, 0x3, 0x3c, 0x3, 0x3c,
- 0x5, 0x3c, 0x42f, 0xa, 0x3c, 0x3, 0x3c, 0x3, 0x3c, 0x3, 0x3c, 0x5, 0x3c,
- 0x434, 0xa, 0x3c, 0x3, 0x3c, 0x3, 0x3c, 0x3, 0x3c, 0x5, 0x3c, 0x439,
- 0xa, 0x3c, 0x3, 0x3c, 0x3, 0x3c, 0x3, 0x3c, 0x5, 0x3c, 0x43e, 0xa, 0x3c,
- 0x3, 0x3c, 0x3, 0x3c, 0x3, 0x3c, 0x5, 0x3c, 0x443, 0xa, 0x3c, 0x3, 0x3c,
- 0x3, 0x3c, 0x3, 0x3c, 0x5, 0x3c, 0x448, 0xa, 0x3c, 0x3, 0x3c, 0x3, 0x3c,
- 0x3, 0x3c, 0x5, 0x3c, 0x44d, 0xa, 0x3c, 0x3, 0x3c, 0x5, 0x3c, 0x450,
- 0xa, 0x3c, 0x3, 0x3d, 0x3, 0x3d, 0x5, 0x3d, 0x454, 0xa, 0x3d, 0x3, 0x3d,
- 0x3, 0x3d, 0x5, 0x3d, 0x458, 0xa, 0x3d, 0x3, 0x3d, 0x3, 0x3d, 0x3, 0x3e,
- 0x3, 0x3e, 0x5, 0x3e, 0x45e, 0xa, 0x3e, 0x3, 0x3e, 0x6, 0x3e, 0x461,
- 0xa, 0x3e, 0xd, 0x3e, 0xe, 0x3e, 0x462, 0x3, 0x3f, 0x3, 0x3f, 0x5, 0x3f,
- 0x467, 0xa, 0x3f, 0x3, 0x3f, 0x5, 0x3f, 0x46a, 0xa, 0x3f, 0x3, 0x40,
- 0x3, 0x40, 0x3, 0x40, 0x3, 0x40, 0x3, 0x40, 0x3, 0x40, 0x3, 0x41, 0x3,
- 0x41, 0x5, 0x41, 0x474, 0xa, 0x41, 0x3, 0x41, 0x3, 0x41, 0x5, 0x41,
- 0x478, 0xa, 0x41, 0x3, 0x41, 0x3, 0x41, 0x5, 0x41, 0x47c, 0xa, 0x41,
- 0x5, 0x41, 0x47e, 0xa, 0x41, 0x3, 0x41, 0x3, 0x41, 0x5, 0x41, 0x482,
- 0xa, 0x41, 0x3, 0x41, 0x3, 0x41, 0x5, 0x41, 0x486, 0xa, 0x41, 0x3, 0x41,
- 0x3, 0x41, 0x5, 0x41, 0x48a, 0xa, 0x41, 0x7, 0x41, 0x48c, 0xa, 0x41,
- 0xc, 0x41, 0xe, 0x41, 0x48f, 0xb, 0x41, 0x5, 0x41, 0x491, 0xa, 0x41,
- 0x3, 0x41, 0x3, 0x41, 0x3, 0x42, 0x3, 0x42, 0x3, 0x43, 0x3, 0x43, 0x5,
- 0x43, 0x499, 0xa, 0x43, 0x3, 0x43, 0x3, 0x43, 0x5, 0x43, 0x49d, 0xa,
- 0x43, 0x3, 0x43, 0x3, 0x43, 0x5, 0x43, 0x4a1, 0xa, 0x43, 0x3, 0x43,
- 0x5, 0x43, 0x4a4, 0xa, 0x43, 0x3, 0x43, 0x5, 0x43, 0x4a7, 0xa, 0x43,
- 0x3, 0x43, 0x3, 0x43, 0x3, 0x44, 0x3, 0x44, 0x5, 0x44, 0x4ad, 0xa, 0x44,
- 0x3, 0x44, 0x3, 0x44, 0x5, 0x44, 0x4b1, 0xa, 0x44, 0x3, 0x44, 0x3, 0x44,
- 0x5, 0x44, 0x4b5, 0xa, 0x44, 0x5, 0x44, 0x4b7, 0xa, 0x44, 0x3, 0x44,
- 0x3, 0x44, 0x5, 0x44, 0x4bb, 0xa, 0x44, 0x3, 0x44, 0x3, 0x44, 0x5, 0x44,
- 0x4bf, 0xa, 0x44, 0x3, 0x44, 0x3, 0x44, 0x5, 0x44, 0x4c3, 0xa, 0x44,
- 0x5, 0x44, 0x4c5, 0xa, 0x44, 0x3, 0x44, 0x3, 0x44, 0x5, 0x44, 0x4c9,
- 0xa, 0x44, 0x3, 0x44, 0x3, 0x44, 0x5, 0x44, 0x4cd, 0xa, 0x44, 0x3, 0x44,
- 0x3, 0x44, 0x3, 0x45, 0x3, 0x45, 0x5, 0x45, 0x4d3, 0xa, 0x45, 0x3, 0x45,
- 0x3, 0x45, 0x3, 0x46, 0x3, 0x46, 0x3, 0x47, 0x3, 0x47, 0x5, 0x47, 0x4db,
- 0xa, 0x47, 0x3, 0x48, 0x3, 0x48, 0x5, 0x48, 0x4df, 0xa, 0x48, 0x3, 0x48,
- 0x3, 0x48, 0x5, 0x48, 0x4e3, 0xa, 0x48, 0x3, 0x48, 0x3, 0x48, 0x5, 0x48,
- 0x4e7, 0xa, 0x48, 0x3, 0x48, 0x3, 0x48, 0x5, 0x48, 0x4eb, 0xa, 0x48,
- 0x3, 0x48, 0x3, 0x48, 0x5, 0x48, 0x4ef, 0xa, 0x48, 0x3, 0x48, 0x3, 0x48,
- 0x5, 0x48, 0x4f3, 0xa, 0x48, 0x3, 0x48, 0x3, 0x48, 0x5, 0x48, 0x4f7,
- 0xa, 0x48, 0x3, 0x48, 0x3, 0x48, 0x5, 0x48, 0x4fb, 0xa, 0x48, 0x7, 0x48,
- 0x4fd, 0xa, 0x48, 0xc, 0x48, 0xe, 0x48, 0x500, 0xb, 0x48, 0x5, 0x48,
- 0x502, 0xa, 0x48, 0x3, 0x48, 0x3, 0x48, 0x3, 0x49, 0x3, 0x49, 0x3, 0x49,
- 0x5, 0x49, 0x509, 0xa, 0x49, 0x3, 0x4a, 0x3, 0x4a, 0x5, 0x4a, 0x50d,
- 0xa, 0x4a, 0x3, 0x4a, 0x6, 0x4a, 0x510, 0xa, 0x4a, 0xd, 0x4a, 0xe, 0x4a,
- 0x511, 0x3, 0x4b, 0x3, 0x4b, 0x3, 0x4c, 0x3, 0x4c, 0x3, 0x4d, 0x3, 0x4d,
- 0x3, 0x4e, 0x3, 0x4e, 0x3, 0x4f, 0x3, 0x4f, 0x3, 0x50, 0x3, 0x50, 0x3,
- 0x51, 0x3, 0x51, 0x3, 0x51, 0x2, 0x2, 0x52, 0x2, 0x4, 0x6, 0x8, 0xa,
- 0xc, 0xe, 0x10, 0x12, 0x14, 0x16, 0x18, 0x1a, 0x1c, 0x1e, 0x20, 0x22,
- 0x24, 0x26, 0x28, 0x2a, 0x2c, 0x2e, 0x30, 0x32, 0x34, 0x36, 0x38, 0x3a,
- 0x3c, 0x3e, 0x40, 0x42, 0x44, 0x46, 0x48, 0x4a, 0x4c, 0x4e, 0x50, 0x52,
- 0x54, 0x56, 0x58, 0x5a, 0x5c, 0x5e, 0x60, 0x62, 0x64, 0x66, 0x68, 0x6a,
- 0x6c, 0x6e, 0x70, 0x72, 0x74, 0x76, 0x78, 0x7a, 0x7c, 0x7e, 0x80, 0x82,
- 0x84, 0x86, 0x88, 0x8a, 0x8c, 0x8e, 0x90, 0x92, 0x94, 0x96, 0x98, 0x9a,
- 0x9c, 0x9e, 0xa0, 0x2, 0xc, 0x3, 0x2, 0x54, 0x57, 0x3, 0x2, 0xf, 0x10,
- 0x3, 0x2, 0x69, 0x6a, 0x5, 0x2, 0x63, 0x63, 0x6b, 0x6b, 0x6e, 0x6e,
- 0x3, 0x2, 0x34, 0x36, 0x3, 0x2, 0x3e, 0x3f, 0x5, 0x2, 0x37, 0x37, 0x40,
- 0x6b, 0x6e, 0x6e, 0x4, 0x2, 0x17, 0x17, 0x1f, 0x22, 0x4, 0x2, 0x18,
- 0x18, 0x23, 0x26, 0x4, 0x2, 0x10, 0x10, 0x27, 0x31, 0x5ea, 0x2, 0xa3,
- 0x3, 0x2, 0x2, 0x2, 0x4, 0xaf, 0x3, 0x2, 0x2, 0x2, 0x6, 0xb1, 0x3, 0x2,
- 0x2, 0x2, 0x8, 0xb3, 0x3, 0x2, 0x2, 0x2, 0xa, 0xbd, 0x3, 0x2, 0x2, 0x2,
- 0xc, 0xd3, 0x3, 0x2, 0x2, 0x2, 0xe, 0xde, 0x3, 0x2, 0x2, 0x2, 0x10,
- 0xe2, 0x3, 0x2, 0x2, 0x2, 0x12, 0xef, 0x3, 0x2, 0x2, 0x2, 0x14, 0xf9,
- 0x3, 0x2, 0x2, 0x2, 0x16, 0x10f, 0x3, 0x2, 0x2, 0x2, 0x18, 0x111, 0x3,
- 0x2, 0x2, 0x2, 0x1a, 0x117, 0x3, 0x2, 0x2, 0x2, 0x1c, 0x147, 0x3, 0x2,
- 0x2, 0x2, 0x1e, 0x14b, 0x3, 0x2, 0x2, 0x2, 0x20, 0x15f, 0x3, 0x2, 0x2,
- 0x2, 0x22, 0x173, 0x3, 0x2, 0x2, 0x2, 0x24, 0x175, 0x3, 0x2, 0x2, 0x2,
- 0x26, 0x184, 0x3, 0x2, 0x2, 0x2, 0x28, 0x18e, 0x3, 0x2, 0x2, 0x2, 0x2a,
- 0x1b7, 0x3, 0x2, 0x2, 0x2, 0x2c, 0x1c0, 0x3, 0x2, 0x2, 0x2, 0x2e, 0x1c2,
- 0x3, 0x2, 0x2, 0x2, 0x30, 0x1d1, 0x3, 0x2, 0x2, 0x2, 0x32, 0x1d5, 0x3,
- 0x2, 0x2, 0x2, 0x34, 0x1d9, 0x3, 0x2, 0x2, 0x2, 0x36, 0x1e0, 0x3, 0x2,
- 0x2, 0x2, 0x38, 0x1e4, 0x3, 0x2, 0x2, 0x2, 0x3a, 0x1fd, 0x3, 0x2, 0x2,
- 0x2, 0x3c, 0x1ff, 0x3, 0x2, 0x2, 0x2, 0x3e, 0x20f, 0x3, 0x2, 0x2, 0x2,
- 0x40, 0x211, 0x3, 0x2, 0x2, 0x2, 0x42, 0x229, 0x3, 0x2, 0x2, 0x2, 0x44,
- 0x26f, 0x3, 0x2, 0x2, 0x2, 0x46, 0x271, 0x3, 0x2, 0x2, 0x2, 0x48, 0x28e,
- 0x3, 0x2, 0x2, 0x2, 0x4a, 0x290, 0x3, 0x2, 0x2, 0x2, 0x4c, 0x2a5, 0x3,
- 0x2, 0x2, 0x2, 0x4e, 0x2af, 0x3, 0x2, 0x2, 0x2, 0x50, 0x2b5, 0x3, 0x2,
- 0x2, 0x2, 0x52, 0x2cb, 0x3, 0x2, 0x2, 0x2, 0x54, 0x2cd, 0x3, 0x2, 0x2,
- 0x2, 0x56, 0x2cf, 0x3, 0x2, 0x2, 0x2, 0x58, 0x2d1, 0x3, 0x2, 0x2, 0x2,
- 0x5a, 0x2db, 0x3, 0x2, 0x2, 0x2, 0x5c, 0x2e5, 0x3, 0x2, 0x2, 0x2, 0x5e,
- 0x2f5, 0x3, 0x2, 0x2, 0x2, 0x60, 0x2fa, 0x3, 0x2, 0x2, 0x2, 0x62, 0x304,
- 0x3, 0x2, 0x2, 0x2, 0x64, 0x31a, 0x3, 0x2, 0x2, 0x2, 0x66, 0x338, 0x3,
- 0x2, 0x2, 0x2, 0x68, 0x34c, 0x3, 0x2, 0x2, 0x2, 0x6a, 0x351, 0x3, 0x2,
- 0x2, 0x2, 0x6c, 0x38a, 0x3, 0x2, 0x2, 0x2, 0x6e, 0x407, 0x3, 0x2, 0x2,
- 0x2, 0x70, 0x40f, 0x3, 0x2, 0x2, 0x2, 0x72, 0x411, 0x3, 0x2, 0x2, 0x2,
- 0x74, 0x413, 0x3, 0x2, 0x2, 0x2, 0x76, 0x44f, 0x3, 0x2, 0x2, 0x2, 0x78,
- 0x451, 0x3, 0x2, 0x2, 0x2, 0x7a, 0x45b, 0x3, 0x2, 0x2, 0x2, 0x7c, 0x464,
- 0x3, 0x2, 0x2, 0x2, 0x7e, 0x46b, 0x3, 0x2, 0x2, 0x2, 0x80, 0x471, 0x3,
- 0x2, 0x2, 0x2, 0x82, 0x494, 0x3, 0x2, 0x2, 0x2, 0x84, 0x496, 0x3, 0x2,
- 0x2, 0x2, 0x86, 0x4aa, 0x3, 0x2, 0x2, 0x2, 0x88, 0x4d0, 0x3, 0x2, 0x2,
- 0x2, 0x8a, 0x4d6, 0x3, 0x2, 0x2, 0x2, 0x8c, 0x4da, 0x3, 0x2, 0x2, 0x2,
- 0x8e, 0x4dc, 0x3, 0x2, 0x2, 0x2, 0x90, 0x505, 0x3, 0x2, 0x2, 0x2, 0x92,
- 0x50a, 0x3, 0x2, 0x2, 0x2, 0x94, 0x513, 0x3, 0x2, 0x2, 0x2, 0x96, 0x515,
- 0x3, 0x2, 0x2, 0x2, 0x98, 0x517, 0x3, 0x2, 0x2, 0x2, 0x9a, 0x519, 0x3,
- 0x2, 0x2, 0x2, 0x9c, 0x51b, 0x3, 0x2, 0x2, 0x2, 0x9e, 0x51d, 0x3, 0x2,
- 0x2, 0x2, 0xa0, 0x51f, 0x3, 0x2, 0x2, 0x2, 0xa2, 0xa4, 0x7, 0x6f, 0x2,
- 0x2, 0xa3, 0xa2, 0x3, 0x2, 0x2, 0x2, 0xa3, 0xa4, 0x3, 0x2, 0x2, 0x2,
- 0xa4, 0xa5, 0x3, 0x2, 0x2, 0x2, 0xa5, 0xaa, 0x5, 0x4, 0x3, 0x2, 0xa6,
- 0xa8, 0x7, 0x6f, 0x2, 0x2, 0xa7, 0xa6, 0x3, 0x2, 0x2, 0x2, 0xa7, 0xa8,
- 0x3, 0x2, 0x2, 0x2, 0xa8, 0xa9, 0x3, 0x2, 0x2, 0x2, 0xa9, 0xab, 0x7,
- 0x3, 0x2, 0x2, 0xaa, 0xa7, 0x3, 0x2, 0x2, 0x2, 0xaa, 0xab, 0x3, 0x2,
- 0x2, 0x2, 0xab, 0xad, 0x3, 0x2, 0x2, 0x2, 0xac, 0xae, 0x7, 0x6f, 0x2,
- 0x2, 0xad, 0xac, 0x3, 0x2, 0x2, 0x2, 0xad, 0xae, 0x3, 0x2, 0x2, 0x2,
- 0xae, 0x3, 0x3, 0x2, 0x2, 0x2, 0xaf, 0xb0, 0x5, 0x6, 0x4, 0x2, 0xb0,
- 0x5, 0x3, 0x2, 0x2, 0x2, 0xb1, 0xb2, 0x5, 0x8, 0x5, 0x2, 0xb2, 0x7,
- 0x3, 0x2, 0x2, 0x2, 0xb3, 0xba, 0x5, 0xa, 0x6, 0x2, 0xb4, 0xb6, 0x7,
- 0x6f, 0x2, 0x2, 0xb5, 0xb4, 0x3, 0x2, 0x2, 0x2, 0xb5, 0xb6, 0x3, 0x2,
- 0x2, 0x2, 0xb6, 0xb7, 0x3, 0x2, 0x2, 0x2, 0xb7, 0xb9, 0x5, 0xc, 0x7,
- 0x2, 0xb8, 0xb5, 0x3, 0x2, 0x2, 0x2, 0xb9, 0xbc, 0x3, 0x2, 0x2, 0x2,
- 0xba, 0xb8, 0x3, 0x2, 0x2, 0x2, 0xba, 0xbb, 0x3, 0x2, 0x2, 0x2, 0xbb,
- 0x9, 0x3, 0x2, 0x2, 0x2, 0xbc, 0xba, 0x3, 0x2, 0x2, 0x2, 0xbd, 0xc4,
- 0x5, 0xe, 0x8, 0x2, 0xbe, 0xc0, 0x7, 0x6f, 0x2, 0x2, 0xbf, 0xbe, 0x3,
- 0x2, 0x2, 0x2, 0xbf, 0xc0, 0x3, 0x2, 0x2, 0x2, 0xc0, 0xc1, 0x3, 0x2,
- 0x2, 0x2, 0xc1, 0xc3, 0x5, 0xe, 0x8, 0x2, 0xc2, 0xbf, 0x3, 0x2, 0x2,
- 0x2, 0xc3, 0xc6, 0x3, 0x2, 0x2, 0x2, 0xc4, 0xc2, 0x3, 0x2, 0x2, 0x2,
- 0xc4, 0xc5, 0x3, 0x2, 0x2, 0x2, 0xc5, 0xb, 0x3, 0x2, 0x2, 0x2, 0xc6,
- 0xc4, 0x3, 0x2, 0x2, 0x2, 0xc7, 0xc8, 0x7, 0x40, 0x2, 0x2, 0xc8, 0xc9,
- 0x7, 0x6f, 0x2, 0x2, 0xc9, 0xcb, 0x7, 0x41, 0x2, 0x2, 0xca, 0xcc, 0x7,
- 0x6f, 0x2, 0x2, 0xcb, 0xca, 0x3, 0x2, 0x2, 0x2, 0xcb, 0xcc, 0x3, 0x2,
- 0x2, 0x2, 0xcc, 0xcd, 0x3, 0x2, 0x2, 0x2, 0xcd, 0xd4, 0x5, 0xa, 0x6,
- 0x2, 0xce, 0xd0, 0x7, 0x40, 0x2, 0x2, 0xcf, 0xd1, 0x7, 0x6f, 0x2, 0x2,
- 0xd0, 0xcf, 0x3, 0x2, 0x2, 0x2, 0xd0, 0xd1, 0x3, 0x2, 0x2, 0x2, 0xd1,
- 0xd2, 0x3, 0x2, 0x2, 0x2, 0xd2, 0xd4, 0x5, 0xa, 0x6, 0x2, 0xd3, 0xc7,
- 0x3, 0x2, 0x2, 0x2, 0xd3, 0xce, 0x3, 0x2, 0x2, 0x2, 0xd4, 0xd, 0x3,
- 0x2, 0x2, 0x2, 0xd5, 0xdf, 0x5, 0x10, 0x9, 0x2, 0xd6, 0xdf, 0x5, 0x12,
- 0xa, 0x2, 0xd7, 0xdf, 0x5, 0x14, 0xb, 0x2, 0xd8, 0xdf, 0x5, 0x18, 0xd,
- 0x2, 0xd9, 0xdf, 0x5, 0x1a, 0xe, 0x2, 0xda, 0xdf, 0x5, 0x1e, 0x10, 0x2,
- 0xdb, 0xdf, 0x5, 0x20, 0x11, 0x2, 0xdc, 0xdf, 0x5, 0x24, 0x13, 0x2,
- 0xdd, 0xdf, 0x5, 0x26, 0x14, 0x2, 0xde, 0xd5, 0x3, 0x2, 0x2, 0x2, 0xde,
- 0xd6, 0x3, 0x2, 0x2, 0x2, 0xde, 0xd7, 0x3, 0x2, 0x2, 0x2, 0xde, 0xd8,
- 0x3, 0x2, 0x2, 0x2, 0xde, 0xd9, 0x3, 0x2, 0x2, 0x2, 0xde, 0xda, 0x3,
- 0x2, 0x2, 0x2, 0xde, 0xdb, 0x3, 0x2, 0x2, 0x2, 0xde, 0xdc, 0x3, 0x2,
- 0x2, 0x2, 0xde, 0xdd, 0x3, 0x2, 0x2, 0x2, 0xdf, 0xf, 0x3, 0x2, 0x2,
- 0x2, 0xe0, 0xe1, 0x7, 0x42, 0x2, 0x2, 0xe1, 0xe3, 0x7, 0x6f, 0x2, 0x2,
- 0xe2, 0xe0, 0x3, 0x2, 0x2, 0x2, 0xe2, 0xe3, 0x3, 0x2, 0x2, 0x2, 0xe3,
- 0xe4, 0x3, 0x2, 0x2, 0x2, 0xe4, 0xe6, 0x7, 0x43, 0x2, 0x2, 0xe5, 0xe7,
- 0x7, 0x6f, 0x2, 0x2, 0xe6, 0xe5, 0x3, 0x2, 0x2, 0x2, 0xe6, 0xe7, 0x3,
- 0x2, 0x2, 0x2, 0xe7, 0xe8, 0x3, 0x2, 0x2, 0x2, 0xe8, 0xed, 0x5, 0x38,
- 0x1d, 0x2, 0xe9, 0xeb, 0x7, 0x6f, 0x2, 0x2, 0xea, 0xe9, 0x3, 0x2, 0x2,
- 0x2, 0xea, 0xeb, 0x3, 0x2, 0x2, 0x2, 0xeb, 0xec, 0x3, 0x2, 0x2, 0x2,
- 0xec, 0xee, 0x5, 0x36, 0x1c, 0x2, 0xed, 0xea, 0x3, 0x2, 0x2, 0x2, 0xed,
- 0xee, 0x3, 0x2, 0x2, 0x2, 0xee, 0x11, 0x3, 0x2, 0x2, 0x2, 0xef, 0xf1,
- 0x7, 0x44, 0x2, 0x2, 0xf0, 0xf2, 0x7, 0x6f, 0x2, 0x2, 0xf1, 0xf0, 0x3,
- 0x2, 0x2, 0x2, 0xf1, 0xf2, 0x3, 0x2, 0x2, 0x2, 0xf2, 0xf3, 0x3, 0x2,
- 0x2, 0x2, 0xf3, 0xf4, 0x5, 0x56, 0x2c, 0x2, 0xf4, 0xf5, 0x7, 0x6f, 0x2,
- 0x2, 0xf5, 0xf6, 0x7, 0x45, 0x2, 0x2, 0xf6, 0xf7, 0x7, 0x6f, 0x2, 0x2,
- 0xf7, 0xf8, 0x5, 0x8a, 0x46, 0x2, 0xf8, 0x13, 0x3, 0x2, 0x2, 0x2, 0xf9,
- 0xfb, 0x7, 0x46, 0x2, 0x2, 0xfa, 0xfc, 0x7, 0x6f, 0x2, 0x2, 0xfb, 0xfa,
- 0x3, 0x2, 0x2, 0x2, 0xfb, 0xfc, 0x3, 0x2, 0x2, 0x2, 0xfc, 0xfd, 0x3,
- 0x2, 0x2, 0x2, 0xfd, 0x102, 0x5, 0x3a, 0x1e, 0x2, 0xfe, 0xff, 0x7, 0x6f,
- 0x2, 0x2, 0xff, 0x101, 0x5, 0x16, 0xc, 0x2, 0x100, 0xfe, 0x3, 0x2, 0x2,
- 0x2, 0x101, 0x104, 0x3, 0x2, 0x2, 0x2, 0x102, 0x100, 0x3, 0x2, 0x2,
- 0x2, 0x102, 0x103, 0x3, 0x2, 0x2, 0x2, 0x103, 0x15, 0x3, 0x2, 0x2, 0x2,
- 0x104, 0x102, 0x3, 0x2, 0x2, 0x2, 0x105, 0x106, 0x7, 0x47, 0x2, 0x2,
- 0x106, 0x107, 0x7, 0x6f, 0x2, 0x2, 0x107, 0x108, 0x7, 0x43, 0x2, 0x2,
- 0x108, 0x109, 0x7, 0x6f, 0x2, 0x2, 0x109, 0x110, 0x5, 0x1a, 0xe, 0x2,
- 0x10a, 0x10b, 0x7, 0x47, 0x2, 0x2, 0x10b, 0x10c, 0x7, 0x6f, 0x2, 0x2,
- 0x10c, 0x10d, 0x7, 0x48, 0x2, 0x2, 0x10d, 0x10e, 0x7, 0x6f, 0x2, 0x2,
- 0x10e, 0x110, 0x5, 0x1a, 0xe, 0x2, 0x10f, 0x105, 0x3, 0x2, 0x2, 0x2,
- 0x10f, 0x10a, 0x3, 0x2, 0x2, 0x2, 0x110, 0x17, 0x3, 0x2, 0x2, 0x2, 0x111,
- 0x113, 0x7, 0x48, 0x2, 0x2, 0x112, 0x114, 0x7, 0x6f, 0x2, 0x2, 0x113,
- 0x112, 0x3, 0x2, 0x2, 0x2, 0x113, 0x114, 0x3, 0x2, 0x2, 0x2, 0x114,
- 0x115, 0x3, 0x2, 0x2, 0x2, 0x115, 0x116, 0x5, 0x38, 0x1d, 0x2, 0x116,
- 0x19, 0x3, 0x2, 0x2, 0x2, 0x117, 0x119, 0x7, 0x49, 0x2, 0x2, 0x118,
- 0x11a, 0x7, 0x6f, 0x2, 0x2, 0x119, 0x118, 0x3, 0x2, 0x2, 0x2, 0x119,
- 0x11a, 0x3, 0x2, 0x2, 0x2, 0x11a, 0x11b, 0x3, 0x2, 0x2, 0x2, 0x11b,
- 0x120, 0x5, 0x1c, 0xf, 0x2, 0x11c, 0x11d, 0x7, 0x4, 0x2, 0x2, 0x11d,
- 0x11f, 0x5, 0x1c, 0xf, 0x2, 0x11e, 0x11c, 0x3, 0x2, 0x2, 0x2, 0x11f,
- 0x122, 0x3, 0x2, 0x2, 0x2, 0x120, 0x11e, 0x3, 0x2, 0x2, 0x2, 0x120,
- 0x121, 0x3, 0x2, 0x2, 0x2, 0x121, 0x1b, 0x3, 0x2, 0x2, 0x2, 0x122, 0x120,
- 0x3, 0x2, 0x2, 0x2, 0x123, 0x125, 0x5, 0x92, 0x4a, 0x2, 0x124, 0x126,
- 0x7, 0x6f, 0x2, 0x2, 0x125, 0x124, 0x3, 0x2, 0x2, 0x2, 0x125, 0x126,
- 0x3, 0x2, 0x2, 0x2, 0x126, 0x127, 0x3, 0x2, 0x2, 0x2, 0x127, 0x129,
- 0x7, 0x5, 0x2, 0x2, 0x128, 0x12a, 0x7, 0x6f, 0x2, 0x2, 0x129, 0x128,
- 0x3, 0x2, 0x2, 0x2, 0x129, 0x12a, 0x3, 0x2, 0x2, 0x2, 0x12a, 0x12b,
- 0x3, 0x2, 0x2, 0x2, 0x12b, 0x12c, 0x5, 0x56, 0x2c, 0x2, 0x12c, 0x148,
- 0x3, 0x2, 0x2, 0x2, 0x12d, 0x12f, 0x5, 0x8a, 0x46, 0x2, 0x12e, 0x130,
- 0x7, 0x6f, 0x2, 0x2, 0x12f, 0x12e, 0x3, 0x2, 0x2, 0x2, 0x12f, 0x130,
- 0x3, 0x2, 0x2, 0x2, 0x130, 0x131, 0x3, 0x2, 0x2, 0x2, 0x131, 0x133,
- 0x7, 0x5, 0x2, 0x2, 0x132, 0x134, 0x7, 0x6f, 0x2, 0x2, 0x133, 0x132,
- 0x3, 0x2, 0x2, 0x2, 0x133, 0x134, 0x3, 0x2, 0x2, 0x2, 0x134, 0x135,
- 0x3, 0x2, 0x2, 0x2, 0x135, 0x136, 0x5, 0x56, 0x2c, 0x2, 0x136, 0x148,
- 0x3, 0x2, 0x2, 0x2, 0x137, 0x139, 0x5, 0x8a, 0x46, 0x2, 0x138, 0x13a,
- 0x7, 0x6f, 0x2, 0x2, 0x139, 0x138, 0x3, 0x2, 0x2, 0x2, 0x139, 0x13a,
- 0x3, 0x2, 0x2, 0x2, 0x13a, 0x13b, 0x3, 0x2, 0x2, 0x2, 0x13b, 0x13d,
- 0x7, 0x6, 0x2, 0x2, 0x13c, 0x13e, 0x7, 0x6f, 0x2, 0x2, 0x13d, 0x13c,
- 0x3, 0x2, 0x2, 0x2, 0x13d, 0x13e, 0x3, 0x2, 0x2, 0x2, 0x13e, 0x13f,
- 0x3, 0x2, 0x2, 0x2, 0x13f, 0x140, 0x5, 0x56, 0x2c, 0x2, 0x140, 0x148,
- 0x3, 0x2, 0x2, 0x2, 0x141, 0x143, 0x5, 0x8a, 0x46, 0x2, 0x142, 0x144,
- 0x7, 0x6f, 0x2, 0x2, 0x143, 0x142, 0x3, 0x2, 0x2, 0x2, 0x143, 0x144,
- 0x3, 0x2, 0x2, 0x2, 0x144, 0x145, 0x3, 0x2, 0x2, 0x2, 0x145, 0x146,
- 0x5, 0x4c, 0x27, 0x2, 0x146, 0x148, 0x3, 0x2, 0x2, 0x2, 0x147, 0x123,
- 0x3, 0x2, 0x2, 0x2, 0x147, 0x12d, 0x3, 0x2, 0x2, 0x2, 0x147, 0x137,
- 0x3, 0x2, 0x2, 0x2, 0x147, 0x141, 0x3, 0x2, 0x2, 0x2, 0x148, 0x1d, 0x3,
- 0x2, 0x2, 0x2, 0x149, 0x14a, 0x7, 0x4a, 0x2, 0x2, 0x14a, 0x14c, 0x7,
- 0x6f, 0x2, 0x2, 0x14b, 0x149, 0x3, 0x2, 0x2, 0x2, 0x14b, 0x14c, 0x3,
- 0x2, 0x2, 0x2, 0x14c, 0x14d, 0x3, 0x2, 0x2, 0x2, 0x14d, 0x14f, 0x7,
- 0x4b, 0x2, 0x2, 0x14e, 0x150, 0x7, 0x6f, 0x2, 0x2, 0x14f, 0x14e, 0x3,
- 0x2, 0x2, 0x2, 0x14f, 0x150, 0x3, 0x2, 0x2, 0x2, 0x150, 0x151, 0x3,
- 0x2, 0x2, 0x2, 0x151, 0x15c, 0x5, 0x56, 0x2c, 0x2, 0x152, 0x154, 0x7,
- 0x6f, 0x2, 0x2, 0x153, 0x152, 0x3, 0x2, 0x2, 0x2, 0x153, 0x154, 0x3,
- 0x2, 0x2, 0x2, 0x154, 0x155, 0x3, 0x2, 0x2, 0x2, 0x155, 0x157, 0x7,
- 0x4, 0x2, 0x2, 0x156, 0x158, 0x7, 0x6f, 0x2, 0x2, 0x157, 0x156, 0x3,
- 0x2, 0x2, 0x2, 0x157, 0x158, 0x3, 0x2, 0x2, 0x2, 0x158, 0x159, 0x3,
- 0x2, 0x2, 0x2, 0x159, 0x15b, 0x5, 0x56, 0x2c, 0x2, 0x15a, 0x153, 0x3,
- 0x2, 0x2, 0x2, 0x15b, 0x15e, 0x3, 0x2, 0x2, 0x2, 0x15c, 0x15a, 0x3,
- 0x2, 0x2, 0x2, 0x15c, 0x15d, 0x3, 0x2, 0x2, 0x2, 0x15d, 0x1f, 0x3, 0x2,
- 0x2, 0x2, 0x15e, 0x15c, 0x3, 0x2, 0x2, 0x2, 0x15f, 0x160, 0x7, 0x4c,
- 0x2, 0x2, 0x160, 0x161, 0x7, 0x6f, 0x2, 0x2, 0x161, 0x16c, 0x5, 0x22,
- 0x12, 0x2, 0x162, 0x164, 0x7, 0x6f, 0x2, 0x2, 0x163, 0x162, 0x3, 0x2,
- 0x2, 0x2, 0x163, 0x164, 0x3, 0x2, 0x2, 0x2, 0x164, 0x165, 0x3, 0x2,
- 0x2, 0x2, 0x165, 0x167, 0x7, 0x4, 0x2, 0x2, 0x166, 0x168, 0x7, 0x6f,
- 0x2, 0x2, 0x167, 0x166, 0x3, 0x2, 0x2, 0x2, 0x167, 0x168, 0x3, 0x2,
- 0x2, 0x2, 0x168, 0x169, 0x3, 0x2, 0x2, 0x2, 0x169, 0x16b, 0x5, 0x22,
- 0x12, 0x2, 0x16a, 0x163, 0x3, 0x2, 0x2, 0x2, 0x16b, 0x16e, 0x3, 0x2,
- 0x2, 0x2, 0x16c, 0x16a, 0x3, 0x2, 0x2, 0x2, 0x16c, 0x16d, 0x3, 0x2,
- 0x2, 0x2, 0x16d, 0x21, 0x3, 0x2, 0x2, 0x2, 0x16e, 0x16c, 0x3, 0x2, 0x2,
- 0x2, 0x16f, 0x170, 0x5, 0x8a, 0x46, 0x2, 0x170, 0x171, 0x5, 0x4c, 0x27,
- 0x2, 0x171, 0x174, 0x3, 0x2, 0x2, 0x2, 0x172, 0x174, 0x5, 0x92, 0x4a,
- 0x2, 0x173, 0x16f, 0x3, 0x2, 0x2, 0x2, 0x173, 0x172, 0x3, 0x2, 0x2,
- 0x2, 0x174, 0x23, 0x3, 0x2, 0x2, 0x2, 0x175, 0x17a, 0x7, 0x4d, 0x2,
- 0x2, 0x176, 0x178, 0x7, 0x6f, 0x2, 0x2, 0x177, 0x176, 0x3, 0x2, 0x2,
- 0x2, 0x177, 0x178, 0x3, 0x2, 0x2, 0x2, 0x178, 0x179, 0x3, 0x2, 0x2,
- 0x2, 0x179, 0x17b, 0x7, 0x4e, 0x2, 0x2, 0x17a, 0x177, 0x3, 0x2, 0x2,
- 0x2, 0x17a, 0x17b, 0x3, 0x2, 0x2, 0x2, 0x17b, 0x17c, 0x3, 0x2, 0x2,
- 0x2, 0x17c, 0x17d, 0x7, 0x6f, 0x2, 0x2, 0x17d, 0x182, 0x5, 0x28, 0x15,
- 0x2, 0x17e, 0x180, 0x7, 0x6f, 0x2, 0x2, 0x17f, 0x17e, 0x3, 0x2, 0x2,
- 0x2, 0x17f, 0x180, 0x3, 0x2, 0x2, 0x2, 0x180, 0x181, 0x3, 0x2, 0x2,
- 0x2, 0x181, 0x183, 0x5, 0x36, 0x1c, 0x2, 0x182, 0x17f, 0x3, 0x2, 0x2,
- 0x2, 0x182, 0x183, 0x3, 0x2, 0x2, 0x2, 0x183, 0x25, 0x3, 0x2, 0x2, 0x2,
- 0x184, 0x189, 0x7, 0x4f, 0x2, 0x2, 0x185, 0x187, 0x7, 0x6f, 0x2, 0x2,
- 0x186, 0x185, 0x3, 0x2, 0x2, 0x2, 0x186, 0x187, 0x3, 0x2, 0x2, 0x2,
- 0x187, 0x188, 0x3, 0x2, 0x2, 0x2, 0x188, 0x18a, 0x7, 0x4e, 0x2, 0x2,
- 0x189, 0x186, 0x3, 0x2, 0x2, 0x2, 0x189, 0x18a, 0x3, 0x2, 0x2, 0x2,
- 0x18a, 0x18b, 0x3, 0x2, 0x2, 0x2, 0x18b, 0x18c, 0x7, 0x6f, 0x2, 0x2,
- 0x18c, 0x18d, 0x5, 0x28, 0x15, 0x2, 0x18d, 0x27, 0x3, 0x2, 0x2, 0x2,
- 0x18e, 0x191, 0x5, 0x2a, 0x16, 0x2, 0x18f, 0x190, 0x7, 0x6f, 0x2, 0x2,
- 0x190, 0x192, 0x5, 0x2e, 0x18, 0x2, 0x191, 0x18f, 0x3, 0x2, 0x2, 0x2,
- 0x191, 0x192, 0x3, 0x2, 0x2, 0x2, 0x192, 0x195, 0x3, 0x2, 0x2, 0x2,
- 0x193, 0x194, 0x7, 0x6f, 0x2, 0x2, 0x194, 0x196, 0x5, 0x30, 0x19, 0x2,
- 0x195, 0x193, 0x3, 0x2, 0x2, 0x2, 0x195, 0x196, 0x3, 0x2, 0x2, 0x2,
- 0x196, 0x199, 0x3, 0x2, 0x2, 0x2, 0x197, 0x198, 0x7, 0x6f, 0x2, 0x2,
- 0x198, 0x19a, 0x5, 0x32, 0x1a, 0x2, 0x199, 0x197, 0x3, 0x2, 0x2, 0x2,
- 0x199, 0x19a, 0x3, 0x2, 0x2, 0x2, 0x19a, 0x29, 0x3, 0x2, 0x2, 0x2, 0x19b,
- 0x1a6, 0x7, 0x7, 0x2, 0x2, 0x19c, 0x19e, 0x7, 0x6f, 0x2, 0x2, 0x19d,
- 0x19c, 0x3, 0x2, 0x2, 0x2, 0x19d, 0x19e, 0x3, 0x2, 0x2, 0x2, 0x19e,
- 0x19f, 0x3, 0x2, 0x2, 0x2, 0x19f, 0x1a1, 0x7, 0x4, 0x2, 0x2, 0x1a0,
- 0x1a2, 0x7, 0x6f, 0x2, 0x2, 0x1a1, 0x1a0, 0x3, 0x2, 0x2, 0x2, 0x1a1,
- 0x1a2, 0x3, 0x2, 0x2, 0x2, 0x1a2, 0x1a3, 0x3, 0x2, 0x2, 0x2, 0x1a3,
- 0x1a5, 0x5, 0x2c, 0x17, 0x2, 0x1a4, 0x19d, 0x3, 0x2, 0x2, 0x2, 0x1a5,
- 0x1a8, 0x3, 0x2, 0x2, 0x2, 0x1a6, 0x1a4, 0x3, 0x2, 0x2, 0x2, 0x1a6,
- 0x1a7, 0x3, 0x2, 0x2, 0x2, 0x1a7, 0x1b8, 0x3, 0x2, 0x2, 0x2, 0x1a8,
- 0x1a6, 0x3, 0x2, 0x2, 0x2, 0x1a9, 0x1b4, 0x5, 0x2c, 0x17, 0x2, 0x1aa,
- 0x1ac, 0x7, 0x6f, 0x2, 0x2, 0x1ab, 0x1aa, 0x3, 0x2, 0x2, 0x2, 0x1ab,
- 0x1ac, 0x3, 0x2, 0x2, 0x2, 0x1ac, 0x1ad, 0x3, 0x2, 0x2, 0x2, 0x1ad,
- 0x1af, 0x7, 0x4, 0x2, 0x2, 0x1ae, 0x1b0, 0x7, 0x6f, 0x2, 0x2, 0x1af,
- 0x1ae, 0x3, 0x2, 0x2, 0x2, 0x1af, 0x1b0, 0x3, 0x2, 0x2, 0x2, 0x1b0,
- 0x1b1, 0x3, 0x2, 0x2, 0x2, 0x1b1, 0x1b3, 0x5, 0x2c, 0x17, 0x2, 0x1b2,
- 0x1ab, 0x3, 0x2, 0x2, 0x2, 0x1b3, 0x1b6, 0x3, 0x2, 0x2, 0x2, 0x1b4,
- 0x1b2, 0x3, 0x2, 0x2, 0x2, 0x1b4, 0x1b5, 0x3, 0x2, 0x2, 0x2, 0x1b5,
- 0x1b8, 0x3, 0x2, 0x2, 0x2, 0x1b6, 0x1b4, 0x3, 0x2, 0x2, 0x2, 0x1b7,
- 0x19b, 0x3, 0x2, 0x2, 0x2, 0x1b7, 0x1a9, 0x3, 0x2, 0x2, 0x2, 0x1b8,
- 0x2b, 0x3, 0x2, 0x2, 0x2, 0x1b9, 0x1ba, 0x5, 0x56, 0x2c, 0x2, 0x1ba,
- 0x1bb, 0x7, 0x6f, 0x2, 0x2, 0x1bb, 0x1bc, 0x7, 0x45, 0x2, 0x2, 0x1bc,
- 0x1bd, 0x7, 0x6f, 0x2, 0x2, 0x1bd, 0x1be, 0x5, 0x8a, 0x46, 0x2, 0x1be,
- 0x1c1, 0x3, 0x2, 0x2, 0x2, 0x1bf, 0x1c1, 0x5, 0x56, 0x2c, 0x2, 0x1c0,
- 0x1b9, 0x3, 0x2, 0x2, 0x2, 0x1c0, 0x1bf, 0x3, 0x2, 0x2, 0x2, 0x1c1,
- 0x2d, 0x3, 0x2, 0x2, 0x2, 0x1c2, 0x1c3, 0x7, 0x50, 0x2, 0x2, 0x1c3,
- 0x1c4, 0x7, 0x6f, 0x2, 0x2, 0x1c4, 0x1c5, 0x7, 0x51, 0x2, 0x2, 0x1c5,
- 0x1c6, 0x7, 0x6f, 0x2, 0x2, 0x1c6, 0x1ce, 0x5, 0x34, 0x1b, 0x2, 0x1c7,
- 0x1c9, 0x7, 0x4, 0x2, 0x2, 0x1c8, 0x1ca, 0x7, 0x6f, 0x2, 0x2, 0x1c9,
- 0x1c8, 0x3, 0x2, 0x2, 0x2, 0x1c9, 0x1ca, 0x3, 0x2, 0x2, 0x2, 0x1ca,
- 0x1cb, 0x3, 0x2, 0x2, 0x2, 0x1cb, 0x1cd, 0x5, 0x34, 0x1b, 0x2, 0x1cc,
- 0x1c7, 0x3, 0x2, 0x2, 0x2, 0x1cd, 0x1d0, 0x3, 0x2, 0x2, 0x2, 0x1ce,
- 0x1cc, 0x3, 0x2, 0x2, 0x2, 0x1ce, 0x1cf, 0x3, 0x2, 0x2, 0x2, 0x1cf,
- 0x2f, 0x3, 0x2, 0x2, 0x2, 0x1d0, 0x1ce, 0x3, 0x2, 0x2, 0x2, 0x1d1, 0x1d2,
- 0x7, 0x52, 0x2, 0x2, 0x1d2, 0x1d3, 0x7, 0x6f, 0x2, 0x2, 0x1d3, 0x1d4,
- 0x5, 0x56, 0x2c, 0x2, 0x1d4, 0x31, 0x3, 0x2, 0x2, 0x2, 0x1d5, 0x1d6,
- 0x7, 0x53, 0x2, 0x2, 0x1d6, 0x1d7, 0x7, 0x6f, 0x2, 0x2, 0x1d7, 0x1d8,
- 0x5, 0x56, 0x2c, 0x2, 0x1d8, 0x33, 0x3, 0x2, 0x2, 0x2, 0x1d9, 0x1de,
- 0x5, 0x56, 0x2c, 0x2, 0x1da, 0x1dc, 0x7, 0x6f, 0x2, 0x2, 0x1db, 0x1da,
- 0x3, 0x2, 0x2, 0x2, 0x1db, 0x1dc, 0x3, 0x2, 0x2, 0x2, 0x1dc, 0x1dd,
- 0x3, 0x2, 0x2, 0x2, 0x1dd, 0x1df, 0x9, 0x2, 0x2, 0x2, 0x1de, 0x1db,
- 0x3, 0x2, 0x2, 0x2, 0x1de, 0x1df, 0x3, 0x2, 0x2, 0x2, 0x1df, 0x35, 0x3,
- 0x2, 0x2, 0x2, 0x1e0, 0x1e1, 0x7, 0x58, 0x2, 0x2, 0x1e1, 0x1e2, 0x7,
- 0x6f, 0x2, 0x2, 0x1e2, 0x1e3, 0x5, 0x56, 0x2c, 0x2, 0x1e3, 0x37, 0x3,
- 0x2, 0x2, 0x2, 0x1e4, 0x1ef, 0x5, 0x3a, 0x1e, 0x2, 0x1e5, 0x1e7, 0x7,
- 0x6f, 0x2, 0x2, 0x1e6, 0x1e5, 0x3, 0x2, 0x2, 0x2, 0x1e6, 0x1e7, 0x3,
- 0x2, 0x2, 0x2, 0x1e7, 0x1e8, 0x3, 0x2, 0x2, 0x2, 0x1e8, 0x1ea, 0x7,
- 0x4, 0x2, 0x2, 0x1e9, 0x1eb, 0x7, 0x6f, 0x2, 0x2, 0x1ea, 0x1e9, 0x3,
- 0x2, 0x2, 0x2, 0x1ea, 0x1eb, 0x3, 0x2, 0x2, 0x2, 0x1eb, 0x1ec, 0x3,
- 0x2, 0x2, 0x2, 0x1ec, 0x1ee, 0x5, 0x3a, 0x1e, 0x2, 0x1ed, 0x1e6, 0x3,
- 0x2, 0x2, 0x2, 0x1ee, 0x1f1, 0x3, 0x2, 0x2, 0x2, 0x1ef, 0x1ed, 0x3,
- 0x2, 0x2, 0x2, 0x1ef, 0x1f0, 0x3, 0x2, 0x2, 0x2, 0x1f0, 0x39, 0x3, 0x2,
- 0x2, 0x2, 0x1f1, 0x1ef, 0x3, 0x2, 0x2, 0x2, 0x1f2, 0x1f4, 0x5, 0x8a,
- 0x46, 0x2, 0x1f3, 0x1f5, 0x7, 0x6f, 0x2, 0x2, 0x1f4, 0x1f3, 0x3, 0x2,
- 0x2, 0x2, 0x1f4, 0x1f5, 0x3, 0x2, 0x2, 0x2, 0x1f5, 0x1f6, 0x3, 0x2,
- 0x2, 0x2, 0x1f6, 0x1f8, 0x7, 0x5, 0x2, 0x2, 0x1f7, 0x1f9, 0x7, 0x6f,
- 0x2, 0x2, 0x1f8, 0x1f7, 0x3, 0x2, 0x2, 0x2, 0x1f8, 0x1f9, 0x3, 0x2,
- 0x2, 0x2, 0x1f9, 0x1fa, 0x3, 0x2, 0x2, 0x2, 0x1fa, 0x1fb, 0x5, 0x3c,
- 0x1f, 0x2, 0x1fb, 0x1fe, 0x3, 0x2, 0x2, 0x2, 0x1fc, 0x1fe, 0x5, 0x3c,
- 0x1f, 0x2, 0x1fd, 0x1f2, 0x3, 0x2, 0x2, 0x2, 0x1fd, 0x1fc, 0x3, 0x2,
- 0x2, 0x2, 0x1fe, 0x3b, 0x3, 0x2, 0x2, 0x2, 0x1ff, 0x200, 0x5, 0x3e,
- 0x20, 0x2, 0x200, 0x3d, 0x3, 0x2, 0x2, 0x2, 0x201, 0x208, 0x5, 0x40,
- 0x21, 0x2, 0x202, 0x204, 0x7, 0x6f, 0x2, 0x2, 0x203, 0x202, 0x3, 0x2,
- 0x2, 0x2, 0x203, 0x204, 0x3, 0x2, 0x2, 0x2, 0x204, 0x205, 0x3, 0x2,
- 0x2, 0x2, 0x205, 0x207, 0x5, 0x42, 0x22, 0x2, 0x206, 0x203, 0x3, 0x2,
- 0x2, 0x2, 0x207, 0x20a, 0x3, 0x2, 0x2, 0x2, 0x208, 0x206, 0x3, 0x2,
- 0x2, 0x2, 0x208, 0x209, 0x3, 0x2, 0x2, 0x2, 0x209, 0x210, 0x3, 0x2,
- 0x2, 0x2, 0x20a, 0x208, 0x3, 0x2, 0x2, 0x2, 0x20b, 0x20c, 0x7, 0x8,
- 0x2, 0x2, 0x20c, 0x20d, 0x5, 0x3e, 0x20, 0x2, 0x20d, 0x20e, 0x7, 0x9,
- 0x2, 0x2, 0x20e, 0x210, 0x3, 0x2, 0x2, 0x2, 0x20f, 0x201, 0x3, 0x2,
- 0x2, 0x2, 0x20f, 0x20b, 0x3, 0x2, 0x2, 0x2, 0x210, 0x3f, 0x3, 0x2, 0x2,
- 0x2, 0x211, 0x213, 0x7, 0x8, 0x2, 0x2, 0x212, 0x214, 0x7, 0x6f, 0x2,
- 0x2, 0x213, 0x212, 0x3, 0x2, 0x2, 0x2, 0x213, 0x214, 0x3, 0x2, 0x2,
- 0x2, 0x214, 0x219, 0x3, 0x2, 0x2, 0x2, 0x215, 0x217, 0x5, 0x8a, 0x46,
- 0x2, 0x216, 0x218, 0x7, 0x6f, 0x2, 0x2, 0x217, 0x216, 0x3, 0x2, 0x2,
- 0x2, 0x217, 0x218, 0x3, 0x2, 0x2, 0x2, 0x218, 0x21a, 0x3, 0x2, 0x2,
- 0x2, 0x219, 0x215, 0x3, 0x2, 0x2, 0x2, 0x219, 0x21a, 0x3, 0x2, 0x2,
- 0x2, 0x21a, 0x21f, 0x3, 0x2, 0x2, 0x2, 0x21b, 0x21d, 0x5, 0x4c, 0x27,
- 0x2, 0x21c, 0x21e, 0x7, 0x6f, 0x2, 0x2, 0x21d, 0x21c, 0x3, 0x2, 0x2,
- 0x2, 0x21d, 0x21e, 0x3, 0x2, 0x2, 0x2, 0x21e, 0x220, 0x3, 0x2, 0x2,
- 0x2, 0x21f, 0x21b, 0x3, 0x2, 0x2, 0x2, 0x21f, 0x220, 0x3, 0x2, 0x2,
- 0x2, 0x220, 0x225, 0x3, 0x2, 0x2, 0x2, 0x221, 0x223, 0x5, 0x48, 0x25,
- 0x2, 0x222, 0x224, 0x7, 0x6f, 0x2, 0x2, 0x223, 0x222, 0x3, 0x2, 0x2,
- 0x2, 0x223, 0x224, 0x3, 0x2, 0x2, 0x2, 0x224, 0x226, 0x3, 0x2, 0x2,
- 0x2, 0x225, 0x221, 0x3, 0x2, 0x2, 0x2, 0x225, 0x226, 0x3, 0x2, 0x2,
- 0x2, 0x226, 0x227, 0x3, 0x2, 0x2, 0x2, 0x227, 0x228, 0x7, 0x9, 0x2,
- 0x2, 0x228, 0x41, 0x3, 0x2, 0x2, 0x2, 0x229, 0x22b, 0x5, 0x44, 0x23,
- 0x2, 0x22a, 0x22c, 0x7, 0x6f, 0x2, 0x2, 0x22b, 0x22a, 0x3, 0x2, 0x2,
- 0x2, 0x22b, 0x22c, 0x3, 0x2, 0x2, 0x2, 0x22c, 0x22d, 0x3, 0x2, 0x2,
- 0x2, 0x22d, 0x22e, 0x5, 0x40, 0x21, 0x2, 0x22e, 0x43, 0x3, 0x2, 0x2,
- 0x2, 0x22f, 0x231, 0x5, 0x9c, 0x4f, 0x2, 0x230, 0x232, 0x7, 0x6f, 0x2,
- 0x2, 0x231, 0x230, 0x3, 0x2, 0x2, 0x2, 0x231, 0x232, 0x3, 0x2, 0x2,
- 0x2, 0x232, 0x233, 0x3, 0x2, 0x2, 0x2, 0x233, 0x235, 0x5, 0xa0, 0x51,
- 0x2, 0x234, 0x236, 0x7, 0x6f, 0x2, 0x2, 0x235, 0x234, 0x3, 0x2, 0x2,
- 0x2, 0x235, 0x236, 0x3, 0x2, 0x2, 0x2, 0x236, 0x238, 0x3, 0x2, 0x2,
- 0x2, 0x237, 0x239, 0x5, 0x46, 0x24, 0x2, 0x238, 0x237, 0x3, 0x2, 0x2,
- 0x2, 0x238, 0x239, 0x3, 0x2, 0x2, 0x2, 0x239, 0x23b, 0x3, 0x2, 0x2,
- 0x2, 0x23a, 0x23c, 0x7, 0x6f, 0x2, 0x2, 0x23b, 0x23a, 0x3, 0x2, 0x2,
- 0x2, 0x23b, 0x23c, 0x3, 0x2, 0x2, 0x2, 0x23c, 0x23d, 0x3, 0x2, 0x2,
- 0x2, 0x23d, 0x23f, 0x5, 0xa0, 0x51, 0x2, 0x23e, 0x240, 0x7, 0x6f, 0x2,
- 0x2, 0x23f, 0x23e, 0x3, 0x2, 0x2, 0x2, 0x23f, 0x240, 0x3, 0x2, 0x2,
- 0x2, 0x240, 0x241, 0x3, 0x2, 0x2, 0x2, 0x241, 0x242, 0x5, 0x9e, 0x50,
- 0x2, 0x242, 0x270, 0x3, 0x2, 0x2, 0x2, 0x243, 0x245, 0x5, 0x9c, 0x4f,
- 0x2, 0x244, 0x246, 0x7, 0x6f, 0x2, 0x2, 0x245, 0x244, 0x3, 0x2, 0x2,
- 0x2, 0x245, 0x246, 0x3, 0x2, 0x2, 0x2, 0x246, 0x247, 0x3, 0x2, 0x2,
- 0x2, 0x247, 0x249, 0x5, 0xa0, 0x51, 0x2, 0x248, 0x24a, 0x7, 0x6f, 0x2,
- 0x2, 0x249, 0x248, 0x3, 0x2, 0x2, 0x2, 0x249, 0x24a, 0x3, 0x2, 0x2,
- 0x2, 0x24a, 0x24c, 0x3, 0x2, 0x2, 0x2, 0x24b, 0x24d, 0x5, 0x46, 0x24,
- 0x2, 0x24c, 0x24b, 0x3, 0x2, 0x2, 0x2, 0x24c, 0x24d, 0x3, 0x2, 0x2,
- 0x2, 0x24d, 0x24f, 0x3, 0x2, 0x2, 0x2, 0x24e, 0x250, 0x7, 0x6f, 0x2,
- 0x2, 0x24f, 0x24e, 0x3, 0x2, 0x2, 0x2, 0x24f, 0x250, 0x3, 0x2, 0x2,
- 0x2, 0x250, 0x251, 0x3, 0x2, 0x2, 0x2, 0x251, 0x252, 0x5, 0xa0, 0x51,
- 0x2, 0x252, 0x270, 0x3, 0x2, 0x2, 0x2, 0x253, 0x255, 0x5, 0xa0, 0x51,
- 0x2, 0x254, 0x256, 0x7, 0x6f, 0x2, 0x2, 0x255, 0x254, 0x3, 0x2, 0x2,
- 0x2, 0x255, 0x256, 0x3, 0x2, 0x2, 0x2, 0x256, 0x258, 0x3, 0x2, 0x2,
- 0x2, 0x257, 0x259, 0x5, 0x46, 0x24, 0x2, 0x258, 0x257, 0x3, 0x2, 0x2,
- 0x2, 0x258, 0x259, 0x3, 0x2, 0x2, 0x2, 0x259, 0x25b, 0x3, 0x2, 0x2,
- 0x2, 0x25a, 0x25c, 0x7, 0x6f, 0x2, 0x2, 0x25b, 0x25a, 0x3, 0x2, 0x2,
- 0x2, 0x25b, 0x25c, 0x3, 0x2, 0x2, 0x2, 0x25c, 0x25d, 0x3, 0x2, 0x2,
- 0x2, 0x25d, 0x25f, 0x5, 0xa0, 0x51, 0x2, 0x25e, 0x260, 0x7, 0x6f, 0x2,
- 0x2, 0x25f, 0x25e, 0x3, 0x2, 0x2, 0x2, 0x25f, 0x260, 0x3, 0x2, 0x2,
- 0x2, 0x260, 0x261, 0x3, 0x2, 0x2, 0x2, 0x261, 0x262, 0x5, 0x9e, 0x50,
- 0x2, 0x262, 0x270, 0x3, 0x2, 0x2, 0x2, 0x263, 0x265, 0x5, 0xa0, 0x51,
- 0x2, 0x264, 0x266, 0x7, 0x6f, 0x2, 0x2, 0x265, 0x264, 0x3, 0x2, 0x2,
- 0x2, 0x265, 0x266, 0x3, 0x2, 0x2, 0x2, 0x266, 0x268, 0x3, 0x2, 0x2,
- 0x2, 0x267, 0x269, 0x5, 0x46, 0x24, 0x2, 0x268, 0x267, 0x3, 0x2, 0x2,
- 0x2, 0x268, 0x269, 0x3, 0x2, 0x2, 0x2, 0x269, 0x26b, 0x3, 0x2, 0x2,
- 0x2, 0x26a, 0x26c, 0x7, 0x6f, 0x2, 0x2, 0x26b, 0x26a, 0x3, 0x2, 0x2,
- 0x2, 0x26b, 0x26c, 0x3, 0x2, 0x2, 0x2, 0x26c, 0x26d, 0x3, 0x2, 0x2,
- 0x2, 0x26d, 0x26e, 0x5, 0xa0, 0x51, 0x2, 0x26e, 0x270, 0x3, 0x2, 0x2,
- 0x2, 0x26f, 0x22f, 0x3, 0x2, 0x2, 0x2, 0x26f, 0x243, 0x3, 0x2, 0x2,
- 0x2, 0x26f, 0x253, 0x3, 0x2, 0x2, 0x2, 0x26f, 0x263, 0x3, 0x2, 0x2,
- 0x2, 0x270, 0x45, 0x3, 0x2, 0x2, 0x2, 0x271, 0x273, 0x7, 0xa, 0x2, 0x2,
- 0x272, 0x274, 0x7, 0x6f, 0x2, 0x2, 0x273, 0x272, 0x3, 0x2, 0x2, 0x2,
- 0x273, 0x274, 0x3, 0x2, 0x2, 0x2, 0x274, 0x279, 0x3, 0x2, 0x2, 0x2,
- 0x275, 0x277, 0x5, 0x8a, 0x46, 0x2, 0x276, 0x278, 0x7, 0x6f, 0x2, 0x2,
- 0x277, 0x276, 0x3, 0x2, 0x2, 0x2, 0x277, 0x278, 0x3, 0x2, 0x2, 0x2,
- 0x278, 0x27a, 0x3, 0x2, 0x2, 0x2, 0x279, 0x275, 0x3, 0x2, 0x2, 0x2,
- 0x279, 0x27a, 0x3, 0x2, 0x2, 0x2, 0x27a, 0x27f, 0x3, 0x2, 0x2, 0x2,
- 0x27b, 0x27d, 0x5, 0x4a, 0x26, 0x2, 0x27c, 0x27e, 0x7, 0x6f, 0x2, 0x2,
- 0x27d, 0x27c, 0x3, 0x2, 0x2, 0x2, 0x27d, 0x27e, 0x3, 0x2, 0x2, 0x2,
- 0x27e, 0x280, 0x3, 0x2, 0x2, 0x2, 0x27f, 0x27b, 0x3, 0x2, 0x2, 0x2,
- 0x27f, 0x280, 0x3, 0x2, 0x2, 0x2, 0x280, 0x282, 0x3, 0x2, 0x2, 0x2,
- 0x281, 0x283, 0x5, 0x50, 0x29, 0x2, 0x282, 0x281, 0x3, 0x2, 0x2, 0x2,
- 0x282, 0x283, 0x3, 0x2, 0x2, 0x2, 0x283, 0x288, 0x3, 0x2, 0x2, 0x2,
- 0x284, 0x286, 0x5, 0x48, 0x25, 0x2, 0x285, 0x287, 0x7, 0x6f, 0x2, 0x2,
- 0x286, 0x285, 0x3, 0x2, 0x2, 0x2, 0x286, 0x287, 0x3, 0x2, 0x2, 0x2,
- 0x287, 0x289, 0x3, 0x2, 0x2, 0x2, 0x288, 0x284, 0x3, 0x2, 0x2, 0x2,
- 0x288, 0x289, 0x3, 0x2, 0x2, 0x2, 0x289, 0x28a, 0x3, 0x2, 0x2, 0x2,
- 0x28a, 0x28b, 0x7, 0xb, 0x2, 0x2, 0x28b, 0x47, 0x3, 0x2, 0x2, 0x2, 0x28c,
- 0x28f, 0x5, 0x8e, 0x48, 0x2, 0x28d, 0x28f, 0x5, 0x90, 0x49, 0x2, 0x28e,
- 0x28c, 0x3, 0x2, 0x2, 0x2, 0x28e, 0x28d, 0x3, 0x2, 0x2, 0x2, 0x28f,
- 0x49, 0x3, 0x2, 0x2, 0x2, 0x290, 0x292, 0x7, 0xc, 0x2, 0x2, 0x291, 0x293,
- 0x7, 0x6f, 0x2, 0x2, 0x292, 0x291, 0x3, 0x2, 0x2, 0x2, 0x292, 0x293,
- 0x3, 0x2, 0x2, 0x2, 0x293, 0x294, 0x3, 0x2, 0x2, 0x2, 0x294, 0x2a2,
- 0x5, 0x54, 0x2b, 0x2, 0x295, 0x297, 0x7, 0x6f, 0x2, 0x2, 0x296, 0x295,
- 0x3, 0x2, 0x2, 0x2, 0x296, 0x297, 0x3, 0x2, 0x2, 0x2, 0x297, 0x298,
- 0x3, 0x2, 0x2, 0x2, 0x298, 0x29a, 0x7, 0xd, 0x2, 0x2, 0x299, 0x29b,
- 0x7, 0xc, 0x2, 0x2, 0x29a, 0x299, 0x3, 0x2, 0x2, 0x2, 0x29a, 0x29b,
- 0x3, 0x2, 0x2, 0x2, 0x29b, 0x29d, 0x3, 0x2, 0x2, 0x2, 0x29c, 0x29e,
- 0x7, 0x6f, 0x2, 0x2, 0x29d, 0x29c, 0x3, 0x2, 0x2, 0x2, 0x29d, 0x29e,
- 0x3, 0x2, 0x2, 0x2, 0x29e, 0x29f, 0x3, 0x2, 0x2, 0x2, 0x29f, 0x2a1,
- 0x5, 0x54, 0x2b, 0x2, 0x2a0, 0x296, 0x3, 0x2, 0x2, 0x2, 0x2a1, 0x2a4,
- 0x3, 0x2, 0x2, 0x2, 0x2a2, 0x2a0, 0x3, 0x2, 0x2, 0x2, 0x2a2, 0x2a3,
- 0x3, 0x2, 0x2, 0x2, 0x2a3, 0x4b, 0x3, 0x2, 0x2, 0x2, 0x2a4, 0x2a2, 0x3,
- 0x2, 0x2, 0x2, 0x2a5, 0x2ac, 0x5, 0x4e, 0x28, 0x2, 0x2a6, 0x2a8, 0x7,
- 0x6f, 0x2, 0x2, 0x2a7, 0x2a6, 0x3, 0x2, 0x2, 0x2, 0x2a7, 0x2a8, 0x3,
- 0x2, 0x2, 0x2, 0x2a8, 0x2a9, 0x3, 0x2, 0x2, 0x2, 0x2a9, 0x2ab, 0x5,
- 0x4e, 0x28, 0x2, 0x2aa, 0x2a7, 0x3, 0x2, 0x2, 0x2, 0x2ab, 0x2ae, 0x3,
- 0x2, 0x2, 0x2, 0x2ac, 0x2aa, 0x3, 0x2, 0x2, 0x2, 0x2ac, 0x2ad, 0x3,
- 0x2, 0x2, 0x2, 0x2ad, 0x4d, 0x3, 0x2, 0x2, 0x2, 0x2ae, 0x2ac, 0x3, 0x2,
- 0x2, 0x2, 0x2af, 0x2b1, 0x7, 0xc, 0x2, 0x2, 0x2b0, 0x2b2, 0x7, 0x6f,
- 0x2, 0x2, 0x2b1, 0x2b0, 0x3, 0x2, 0x2, 0x2, 0x2b1, 0x2b2, 0x3, 0x2,
- 0x2, 0x2, 0x2b2, 0x2b3, 0x3, 0x2, 0x2, 0x2, 0x2b3, 0x2b4, 0x5, 0x52,
- 0x2a, 0x2, 0x2b4, 0x4f, 0x3, 0x2, 0x2, 0x2, 0x2b5, 0x2b7, 0x7, 0x7,
- 0x2, 0x2, 0x2b6, 0x2b8, 0x7, 0x6f, 0x2, 0x2, 0x2b7, 0x2b6, 0x3, 0x2,
- 0x2, 0x2, 0x2b7, 0x2b8, 0x3, 0x2, 0x2, 0x2, 0x2b8, 0x2bd, 0x3, 0x2,
- 0x2, 0x2, 0x2b9, 0x2bb, 0x5, 0x96, 0x4c, 0x2, 0x2ba, 0x2bc, 0x7, 0x6f,
- 0x2, 0x2, 0x2bb, 0x2ba, 0x3, 0x2, 0x2, 0x2, 0x2bb, 0x2bc, 0x3, 0x2,
- 0x2, 0x2, 0x2bc, 0x2be, 0x3, 0x2, 0x2, 0x2, 0x2bd, 0x2b9, 0x3, 0x2,
- 0x2, 0x2, 0x2bd, 0x2be, 0x3, 0x2, 0x2, 0x2, 0x2be, 0x2c9, 0x3, 0x2,
- 0x2, 0x2, 0x2bf, 0x2c1, 0x7, 0xe, 0x2, 0x2, 0x2c0, 0x2c2, 0x7, 0x6f,
- 0x2, 0x2, 0x2c1, 0x2c0, 0x3, 0x2, 0x2, 0x2, 0x2c1, 0x2c2, 0x3, 0x2,
- 0x2, 0x2, 0x2c2, 0x2c7, 0x3, 0x2, 0x2, 0x2, 0x2c3, 0x2c5, 0x5, 0x96,
- 0x4c, 0x2, 0x2c4, 0x2c6, 0x7, 0x6f, 0x2, 0x2, 0x2c5, 0x2c4, 0x3, 0x2,
- 0x2, 0x2, 0x2c5, 0x2c6, 0x3, 0x2, 0x2, 0x2, 0x2c6, 0x2c8, 0x3, 0x2,
- 0x2, 0x2, 0x2c7, 0x2c3, 0x3, 0x2, 0x2, 0x2, 0x2c7, 0x2c8, 0x3, 0x2,
- 0x2, 0x2, 0x2c8, 0x2ca, 0x3, 0x2, 0x2, 0x2, 0x2c9, 0x2bf, 0x3, 0x2,
- 0x2, 0x2, 0x2c9, 0x2ca, 0x3, 0x2, 0x2, 0x2, 0x2ca, 0x51, 0x3, 0x2, 0x2,
- 0x2, 0x2cb, 0x2cc, 0x5, 0x9a, 0x4e, 0x2, 0x2cc, 0x53, 0x3, 0x2, 0x2,
- 0x2, 0x2cd, 0x2ce, 0x5, 0x9a, 0x4e, 0x2, 0x2ce, 0x55, 0x3, 0x2, 0x2,
- 0x2, 0x2cf, 0x2d0, 0x5, 0x58, 0x2d, 0x2, 0x2d0, 0x57, 0x3, 0x2, 0x2,
- 0x2, 0x2d1, 0x2d8, 0x5, 0x5a, 0x2e, 0x2, 0x2d2, 0x2d3, 0x7, 0x6f, 0x2,
- 0x2, 0x2d3, 0x2d4, 0x7, 0x59, 0x2, 0x2, 0x2d4, 0x2d5, 0x7, 0x6f, 0x2,
- 0x2, 0x2d5, 0x2d7, 0x5, 0x5a, 0x2e, 0x2, 0x2d6, 0x2d2, 0x3, 0x2, 0x2,
- 0x2, 0x2d7, 0x2da, 0x3, 0x2, 0x2, 0x2, 0x2d8, 0x2d6, 0x3, 0x2, 0x2,
- 0x2, 0x2d8, 0x2d9, 0x3, 0x2, 0x2, 0x2, 0x2d9, 0x59, 0x3, 0x2, 0x2, 0x2,
- 0x2da, 0x2d8, 0x3, 0x2, 0x2, 0x2, 0x2db, 0x2e2, 0x5, 0x5c, 0x2f, 0x2,
- 0x2dc, 0x2dd, 0x7, 0x6f, 0x2, 0x2, 0x2dd, 0x2de, 0x7, 0x5a, 0x2, 0x2,
- 0x2de, 0x2df, 0x7, 0x6f, 0x2, 0x2, 0x2df, 0x2e1, 0x5, 0x5c, 0x2f, 0x2,
- 0x2e0, 0x2dc, 0x3, 0x2, 0x2, 0x2, 0x2e1, 0x2e4, 0x3, 0x2, 0x2, 0x2,
- 0x2e2, 0x2e0, 0x3, 0x2, 0x2, 0x2, 0x2e2, 0x2e3, 0x3, 0x2, 0x2, 0x2,
- 0x2e3, 0x5b, 0x3, 0x2, 0x2, 0x2, 0x2e4, 0x2e2, 0x3, 0x2, 0x2, 0x2, 0x2e5,
- 0x2ec, 0x5, 0x5e, 0x30, 0x2, 0x2e6, 0x2e7, 0x7, 0x6f, 0x2, 0x2, 0x2e7,
- 0x2e8, 0x7, 0x5b, 0x2, 0x2, 0x2e8, 0x2e9, 0x7, 0x6f, 0x2, 0x2, 0x2e9,
- 0x2eb, 0x5, 0x5e, 0x30, 0x2, 0x2ea, 0x2e6, 0x3, 0x2, 0x2, 0x2, 0x2eb,
- 0x2ee, 0x3, 0x2, 0x2, 0x2, 0x2ec, 0x2ea, 0x3, 0x2, 0x2, 0x2, 0x2ec,
- 0x2ed, 0x3, 0x2, 0x2, 0x2, 0x2ed, 0x5d, 0x3, 0x2, 0x2, 0x2, 0x2ee, 0x2ec,
- 0x3, 0x2, 0x2, 0x2, 0x2ef, 0x2f1, 0x7, 0x5c, 0x2, 0x2, 0x2f0, 0x2f2,
- 0x7, 0x6f, 0x2, 0x2, 0x2f1, 0x2f0, 0x3, 0x2, 0x2, 0x2, 0x2f1, 0x2f2,
- 0x3, 0x2, 0x2, 0x2, 0x2f2, 0x2f4, 0x3, 0x2, 0x2, 0x2, 0x2f3, 0x2ef,
- 0x3, 0x2, 0x2, 0x2, 0x2f4, 0x2f7, 0x3, 0x2, 0x2, 0x2, 0x2f5, 0x2f3,
- 0x3, 0x2, 0x2, 0x2, 0x2f5, 0x2f6, 0x3, 0x2, 0x2, 0x2, 0x2f6, 0x2f8,
- 0x3, 0x2, 0x2, 0x2, 0x2f7, 0x2f5, 0x3, 0x2, 0x2, 0x2, 0x2f8, 0x2f9,
- 0x5, 0x60, 0x31, 0x2, 0x2f9, 0x5f, 0x3, 0x2, 0x2, 0x2, 0x2fa, 0x301,
- 0x5, 0x62, 0x32, 0x2, 0x2fb, 0x2fd, 0x7, 0x6f, 0x2, 0x2, 0x2fc, 0x2fb,
- 0x3, 0x2, 0x2, 0x2, 0x2fc, 0x2fd, 0x3, 0x2, 0x2, 0x2, 0x2fd, 0x2fe,
- 0x3, 0x2, 0x2, 0x2, 0x2fe, 0x300, 0x5, 0x76, 0x3c, 0x2, 0x2ff, 0x2fc,
- 0x3, 0x2, 0x2, 0x2, 0x300, 0x303, 0x3, 0x2, 0x2, 0x2, 0x301, 0x2ff,
- 0x3, 0x2, 0x2, 0x2, 0x301, 0x302, 0x3, 0x2, 0x2, 0x2, 0x302, 0x61, 0x3,
- 0x2, 0x2, 0x2, 0x303, 0x301, 0x3, 0x2, 0x2, 0x2, 0x304, 0x317, 0x5,
- 0x64, 0x33, 0x2, 0x305, 0x307, 0x7, 0x6f, 0x2, 0x2, 0x306, 0x305, 0x3,
- 0x2, 0x2, 0x2, 0x306, 0x307, 0x3, 0x2, 0x2, 0x2, 0x307, 0x308, 0x3,
- 0x2, 0x2, 0x2, 0x308, 0x30a, 0x7, 0xf, 0x2, 0x2, 0x309, 0x30b, 0x7,
- 0x6f, 0x2, 0x2, 0x30a, 0x309, 0x3, 0x2, 0x2, 0x2, 0x30a, 0x30b, 0x3,
- 0x2, 0x2, 0x2, 0x30b, 0x30c, 0x3, 0x2, 0x2, 0x2, 0x30c, 0x316, 0x5,
- 0x64, 0x33, 0x2, 0x30d, 0x30f, 0x7, 0x6f, 0x2, 0x2, 0x30e, 0x30d, 0x3,
- 0x2, 0x2, 0x2, 0x30e, 0x30f, 0x3, 0x2, 0x2, 0x2, 0x30f, 0x310, 0x3,
- 0x2, 0x2, 0x2, 0x310, 0x312, 0x7, 0x10, 0x2, 0x2, 0x311, 0x313, 0x7,
- 0x6f, 0x2, 0x2, 0x312, 0x311, 0x3, 0x2, 0x2, 0x2, 0x312, 0x313, 0x3,
- 0x2, 0x2, 0x2, 0x313, 0x314, 0x3, 0x2, 0x2, 0x2, 0x314, 0x316, 0x5,
- 0x64, 0x33, 0x2, 0x315, 0x306, 0x3, 0x2, 0x2, 0x2, 0x315, 0x30e, 0x3,
- 0x2, 0x2, 0x2, 0x316, 0x319, 0x3, 0x2, 0x2, 0x2, 0x317, 0x315, 0x3,
- 0x2, 0x2, 0x2, 0x317, 0x318, 0x3, 0x2, 0x2, 0x2, 0x318, 0x63, 0x3, 0x2,
- 0x2, 0x2, 0x319, 0x317, 0x3, 0x2, 0x2, 0x2, 0x31a, 0x335, 0x5, 0x66,
- 0x34, 0x2, 0x31b, 0x31d, 0x7, 0x6f, 0x2, 0x2, 0x31c, 0x31b, 0x3, 0x2,
- 0x2, 0x2, 0x31c, 0x31d, 0x3, 0x2, 0x2, 0x2, 0x31d, 0x31e, 0x3, 0x2,
- 0x2, 0x2, 0x31e, 0x320, 0x7, 0x7, 0x2, 0x2, 0x31f, 0x321, 0x7, 0x6f,
- 0x2, 0x2, 0x320, 0x31f, 0x3, 0x2, 0x2, 0x2, 0x320, 0x321, 0x3, 0x2,
- 0x2, 0x2, 0x321, 0x322, 0x3, 0x2, 0x2, 0x2, 0x322, 0x334, 0x5, 0x66,
- 0x34, 0x2, 0x323, 0x325, 0x7, 0x6f, 0x2, 0x2, 0x324, 0x323, 0x3, 0x2,
- 0x2, 0x2, 0x324, 0x325, 0x3, 0x2, 0x2, 0x2, 0x325, 0x326, 0x3, 0x2,
- 0x2, 0x2, 0x326, 0x328, 0x7, 0x11, 0x2, 0x2, 0x327, 0x329, 0x7, 0x6f,
- 0x2, 0x2, 0x328, 0x327, 0x3, 0x2, 0x2, 0x2, 0x328, 0x329, 0x3, 0x2,
- 0x2, 0x2, 0x329, 0x32a, 0x3, 0x2, 0x2, 0x2, 0x32a, 0x334, 0x5, 0x66,
- 0x34, 0x2, 0x32b, 0x32d, 0x7, 0x6f, 0x2, 0x2, 0x32c, 0x32b, 0x3, 0x2,
- 0x2, 0x2, 0x32c, 0x32d, 0x3, 0x2, 0x2, 0x2, 0x32d, 0x32e, 0x3, 0x2,
- 0x2, 0x2, 0x32e, 0x330, 0x7, 0x12, 0x2, 0x2, 0x32f, 0x331, 0x7, 0x6f,
- 0x2, 0x2, 0x330, 0x32f, 0x3, 0x2, 0x2, 0x2, 0x330, 0x331, 0x3, 0x2,
- 0x2, 0x2, 0x331, 0x332, 0x3, 0x2, 0x2, 0x2, 0x332, 0x334, 0x5, 0x66,
- 0x34, 0x2, 0x333, 0x31c, 0x3, 0x2, 0x2, 0x2, 0x333, 0x324, 0x3, 0x2,
- 0x2, 0x2, 0x333, 0x32c, 0x3, 0x2, 0x2, 0x2, 0x334, 0x337, 0x3, 0x2,
- 0x2, 0x2, 0x335, 0x333, 0x3, 0x2, 0x2, 0x2, 0x335, 0x336, 0x3, 0x2,
- 0x2, 0x2, 0x336, 0x65, 0x3, 0x2, 0x2, 0x2, 0x337, 0x335, 0x3, 0x2, 0x2,
- 0x2, 0x338, 0x343, 0x5, 0x68, 0x35, 0x2, 0x339, 0x33b, 0x7, 0x6f, 0x2,
- 0x2, 0x33a, 0x339, 0x3, 0x2, 0x2, 0x2, 0x33a, 0x33b, 0x3, 0x2, 0x2,
- 0x2, 0x33b, 0x33c, 0x3, 0x2, 0x2, 0x2, 0x33c, 0x33e, 0x7, 0x13, 0x2,
- 0x2, 0x33d, 0x33f, 0x7, 0x6f, 0x2, 0x2, 0x33e, 0x33d, 0x3, 0x2, 0x2,
- 0x2, 0x33e, 0x33f, 0x3, 0x2, 0x2, 0x2, 0x33f, 0x340, 0x3, 0x2, 0x2,
- 0x2, 0x340, 0x342, 0x5, 0x68, 0x35, 0x2, 0x341, 0x33a, 0x3, 0x2, 0x2,
- 0x2, 0x342, 0x345, 0x3, 0x2, 0x2, 0x2, 0x343, 0x341, 0x3, 0x2, 0x2,
- 0x2, 0x343, 0x344, 0x3, 0x2, 0x2, 0x2, 0x344, 0x67, 0x3, 0x2, 0x2, 0x2,
- 0x345, 0x343, 0x3, 0x2, 0x2, 0x2, 0x346, 0x348, 0x9, 0x3, 0x2, 0x2,
- 0x347, 0x349, 0x7, 0x6f, 0x2, 0x2, 0x348, 0x347, 0x3, 0x2, 0x2, 0x2,
- 0x348, 0x349, 0x3, 0x2, 0x2, 0x2, 0x349, 0x34b, 0x3, 0x2, 0x2, 0x2,
- 0x34a, 0x346, 0x3, 0x2, 0x2, 0x2, 0x34b, 0x34e, 0x3, 0x2, 0x2, 0x2,
- 0x34c, 0x34a, 0x3, 0x2, 0x2, 0x2, 0x34c, 0x34d, 0x3, 0x2, 0x2, 0x2,
- 0x34d, 0x34f, 0x3, 0x2, 0x2, 0x2, 0x34e, 0x34c, 0x3, 0x2, 0x2, 0x2,
- 0x34f, 0x350, 0x5, 0x6a, 0x36, 0x2, 0x350, 0x69, 0x3, 0x2, 0x2, 0x2,
- 0x351, 0x387, 0x5, 0x6c, 0x37, 0x2, 0x352, 0x354, 0x7, 0x6f, 0x2, 0x2,
- 0x353, 0x352, 0x3, 0x2, 0x2, 0x2, 0x353, 0x354, 0x3, 0x2, 0x2, 0x2,
- 0x354, 0x355, 0x3, 0x2, 0x2, 0x2, 0x355, 0x356, 0x7, 0xa, 0x2, 0x2,
- 0x356, 0x357, 0x5, 0x56, 0x2c, 0x2, 0x357, 0x358, 0x7, 0xb, 0x2, 0x2,
- 0x358, 0x386, 0x3, 0x2, 0x2, 0x2, 0x359, 0x35b, 0x7, 0x6f, 0x2, 0x2,
- 0x35a, 0x359, 0x3, 0x2, 0x2, 0x2, 0x35a, 0x35b, 0x3, 0x2, 0x2, 0x2,
- 0x35b, 0x35c, 0x3, 0x2, 0x2, 0x2, 0x35c, 0x35e, 0x7, 0xa, 0x2, 0x2,
- 0x35d, 0x35f, 0x5, 0x56, 0x2c, 0x2, 0x35e, 0x35d, 0x3, 0x2, 0x2, 0x2,
- 0x35e, 0x35f, 0x3, 0x2, 0x2, 0x2, 0x35f, 0x360, 0x3, 0x2, 0x2, 0x2,
- 0x360, 0x362, 0x7, 0xe, 0x2, 0x2, 0x361, 0x363, 0x5, 0x56, 0x2c, 0x2,
- 0x362, 0x361, 0x3, 0x2, 0x2, 0x2, 0x362, 0x363, 0x3, 0x2, 0x2, 0x2,
- 0x363, 0x364, 0x3, 0x2, 0x2, 0x2, 0x364, 0x386, 0x7, 0xb, 0x2, 0x2,
- 0x365, 0x367, 0x7, 0x6f, 0x2, 0x2, 0x366, 0x365, 0x3, 0x2, 0x2, 0x2,
- 0x366, 0x367, 0x3, 0x2, 0x2, 0x2, 0x367, 0x368, 0x3, 0x2, 0x2, 0x2,
- 0x368, 0x376, 0x7, 0x14, 0x2, 0x2, 0x369, 0x36a, 0x7, 0x6f, 0x2, 0x2,
- 0x36a, 0x376, 0x7, 0x5d, 0x2, 0x2, 0x36b, 0x36c, 0x7, 0x6f, 0x2, 0x2,
- 0x36c, 0x36d, 0x7, 0x5e, 0x2, 0x2, 0x36d, 0x36e, 0x7, 0x6f, 0x2, 0x2,
- 0x36e, 0x376, 0x7, 0x4d, 0x2, 0x2, 0x36f, 0x370, 0x7, 0x6f, 0x2, 0x2,
- 0x370, 0x371, 0x7, 0x5f, 0x2, 0x2, 0x371, 0x372, 0x7, 0x6f, 0x2, 0x2,
- 0x372, 0x376, 0x7, 0x4d, 0x2, 0x2, 0x373, 0x374, 0x7, 0x6f, 0x2, 0x2,
- 0x374, 0x376, 0x7, 0x60, 0x2, 0x2, 0x375, 0x366, 0x3, 0x2, 0x2, 0x2,
- 0x375, 0x369, 0x3, 0x2, 0x2, 0x2, 0x375, 0x36b, 0x3, 0x2, 0x2, 0x2,
- 0x375, 0x36f, 0x3, 0x2, 0x2, 0x2, 0x375, 0x373, 0x3, 0x2, 0x2, 0x2,
- 0x376, 0x378, 0x3, 0x2, 0x2, 0x2, 0x377, 0x379, 0x7, 0x6f, 0x2, 0x2,
- 0x378, 0x377, 0x3, 0x2, 0x2, 0x2, 0x378, 0x379, 0x3, 0x2, 0x2, 0x2,
- 0x379, 0x37a, 0x3, 0x2, 0x2, 0x2, 0x37a, 0x386, 0x5, 0x6c, 0x37, 0x2,
- 0x37b, 0x37c, 0x7, 0x6f, 0x2, 0x2, 0x37c, 0x37d, 0x7, 0x61, 0x2, 0x2,
- 0x37d, 0x37e, 0x7, 0x6f, 0x2, 0x2, 0x37e, 0x386, 0x7, 0x62, 0x2, 0x2,
- 0x37f, 0x380, 0x7, 0x6f, 0x2, 0x2, 0x380, 0x381, 0x7, 0x61, 0x2, 0x2,
- 0x381, 0x382, 0x7, 0x6f, 0x2, 0x2, 0x382, 0x383, 0x7, 0x5c, 0x2, 0x2,
- 0x383, 0x384, 0x7, 0x6f, 0x2, 0x2, 0x384, 0x386, 0x7, 0x62, 0x2, 0x2,
- 0x385, 0x353, 0x3, 0x2, 0x2, 0x2, 0x385, 0x35a, 0x3, 0x2, 0x2, 0x2,
- 0x385, 0x375, 0x3, 0x2, 0x2, 0x2, 0x385, 0x37b, 0x3, 0x2, 0x2, 0x2,
- 0x385, 0x37f, 0x3, 0x2, 0x2, 0x2, 0x386, 0x389, 0x3, 0x2, 0x2, 0x2,
- 0x387, 0x385, 0x3, 0x2, 0x2, 0x2, 0x387, 0x388, 0x3, 0x2, 0x2, 0x2,
- 0x388, 0x6b, 0x3, 0x2, 0x2, 0x2, 0x389, 0x387, 0x3, 0x2, 0x2, 0x2, 0x38a,
- 0x394, 0x5, 0x6e, 0x38, 0x2, 0x38b, 0x38d, 0x7, 0x6f, 0x2, 0x2, 0x38c,
- 0x38b, 0x3, 0x2, 0x2, 0x2, 0x38c, 0x38d, 0x3, 0x2, 0x2, 0x2, 0x38d,
- 0x390, 0x3, 0x2, 0x2, 0x2, 0x38e, 0x391, 0x5, 0x88, 0x45, 0x2, 0x38f,
- 0x391, 0x5, 0x4c, 0x27, 0x2, 0x390, 0x38e, 0x3, 0x2, 0x2, 0x2, 0x390,
- 0x38f, 0x3, 0x2, 0x2, 0x2, 0x391, 0x393, 0x3, 0x2, 0x2, 0x2, 0x392,
- 0x38c, 0x3, 0x2, 0x2, 0x2, 0x393, 0x396, 0x3, 0x2, 0x2, 0x2, 0x394,
- 0x392, 0x3, 0x2, 0x2, 0x2, 0x394, 0x395, 0x3, 0x2, 0x2, 0x2, 0x395,
- 0x6d, 0x3, 0x2, 0x2, 0x2, 0x396, 0x394, 0x3, 0x2, 0x2, 0x2, 0x397, 0x408,
- 0x5, 0x70, 0x39, 0x2, 0x398, 0x408, 0x5, 0x90, 0x49, 0x2, 0x399, 0x39b,
- 0x7, 0x63, 0x2, 0x2, 0x39a, 0x39c, 0x7, 0x6f, 0x2, 0x2, 0x39b, 0x39a,
- 0x3, 0x2, 0x2, 0x2, 0x39b, 0x39c, 0x3, 0x2, 0x2, 0x2, 0x39c, 0x39d,
- 0x3, 0x2, 0x2, 0x2, 0x39d, 0x39f, 0x7, 0x8, 0x2, 0x2, 0x39e, 0x3a0,
- 0x7, 0x6f, 0x2, 0x2, 0x39f, 0x39e, 0x3, 0x2, 0x2, 0x2, 0x39f, 0x3a0,
- 0x3, 0x2, 0x2, 0x2, 0x3a0, 0x3a1, 0x3, 0x2, 0x2, 0x2, 0x3a1, 0x3a3,
- 0x7, 0x7, 0x2, 0x2, 0x3a2, 0x3a4, 0x7, 0x6f, 0x2, 0x2, 0x3a3, 0x3a2,
- 0x3, 0x2, 0x2, 0x2, 0x3a3, 0x3a4, 0x3, 0x2, 0x2, 0x2, 0x3a4, 0x3a5,
- 0x3, 0x2, 0x2, 0x2, 0x3a5, 0x408, 0x7, 0x9, 0x2, 0x2, 0x3a6, 0x408,
- 0x5, 0x84, 0x43, 0x2, 0x3a7, 0x408, 0x5, 0x86, 0x44, 0x2, 0x3a8, 0x3aa,
- 0x7, 0x64, 0x2, 0x2, 0x3a9, 0x3ab, 0x7, 0x6f, 0x2, 0x2, 0x3aa, 0x3a9,
- 0x3, 0x2, 0x2, 0x2, 0x3aa, 0x3ab, 0x3, 0x2, 0x2, 0x2, 0x3ab, 0x3ac,
- 0x3, 0x2, 0x2, 0x2, 0x3ac, 0x3ae, 0x7, 0x8, 0x2, 0x2, 0x3ad, 0x3af,
- 0x7, 0x6f, 0x2, 0x2, 0x3ae, 0x3ad, 0x3, 0x2, 0x2, 0x2, 0x3ae, 0x3af,
- 0x3, 0x2, 0x2, 0x2, 0x3af, 0x3b0, 0x3, 0x2, 0x2, 0x2, 0x3b0, 0x3b2,
- 0x5, 0x7c, 0x3f, 0x2, 0x3b1, 0x3b3, 0x7, 0x6f, 0x2, 0x2, 0x3b2, 0x3b1,
- 0x3, 0x2, 0x2, 0x2, 0x3b2, 0x3b3, 0x3, 0x2, 0x2, 0x2, 0x3b3, 0x3b4,
- 0x3, 0x2, 0x2, 0x2, 0x3b4, 0x3b5, 0x7, 0x9, 0x2, 0x2, 0x3b5, 0x408,
- 0x3, 0x2, 0x2, 0x2, 0x3b6, 0x3b8, 0x7, 0x65, 0x2, 0x2, 0x3b7, 0x3b9,
- 0x7, 0x6f, 0x2, 0x2, 0x3b8, 0x3b7, 0x3, 0x2, 0x2, 0x2, 0x3b8, 0x3b9,
- 0x3, 0x2, 0x2, 0x2, 0x3b9, 0x3ba, 0x3, 0x2, 0x2, 0x2, 0x3ba, 0x3bc,
- 0x7, 0x8, 0x2, 0x2, 0x3bb, 0x3bd, 0x7, 0x6f, 0x2, 0x2, 0x3bc, 0x3bb,
- 0x3, 0x2, 0x2, 0x2, 0x3bc, 0x3bd, 0x3, 0x2, 0x2, 0x2, 0x3bd, 0x3be,
- 0x3, 0x2, 0x2, 0x2, 0x3be, 0x3c0, 0x5, 0x7c, 0x3f, 0x2, 0x3bf, 0x3c1,
- 0x7, 0x6f, 0x2, 0x2, 0x3c0, 0x3bf, 0x3, 0x2, 0x2, 0x2, 0x3c0, 0x3c1,
- 0x3, 0x2, 0x2, 0x2, 0x3c1, 0x3c7, 0x3, 0x2, 0x2, 0x2, 0x3c2, 0x3c4,
- 0x7, 0x6f, 0x2, 0x2, 0x3c3, 0x3c2, 0x3, 0x2, 0x2, 0x2, 0x3c3, 0x3c4,
- 0x3, 0x2, 0x2, 0x2, 0x3c4, 0x3c5, 0x3, 0x2, 0x2, 0x2, 0x3c5, 0x3c6,
- 0x7, 0xd, 0x2, 0x2, 0x3c6, 0x3c8, 0x5, 0x56, 0x2c, 0x2, 0x3c7, 0x3c3,
- 0x3, 0x2, 0x2, 0x2, 0x3c7, 0x3c8, 0x3, 0x2, 0x2, 0x2, 0x3c8, 0x3c9,
- 0x3, 0x2, 0x2, 0x2, 0x3c9, 0x3ca, 0x7, 0x9, 0x2, 0x2, 0x3ca, 0x408,
- 0x3, 0x2, 0x2, 0x2, 0x3cb, 0x3cd, 0x7, 0x41, 0x2, 0x2, 0x3cc, 0x3ce,
- 0x7, 0x6f, 0x2, 0x2, 0x3cd, 0x3cc, 0x3, 0x2, 0x2, 0x2, 0x3cd, 0x3ce,
- 0x3, 0x2, 0x2, 0x2, 0x3ce, 0x3cf, 0x3, 0x2, 0x2, 0x2, 0x3cf, 0x3d1,
- 0x7, 0x8, 0x2, 0x2, 0x3d0, 0x3d2, 0x7, 0x6f, 0x2, 0x2, 0x3d1, 0x3d0,
- 0x3, 0x2, 0x2, 0x2, 0x3d1, 0x3d2, 0x3, 0x2, 0x2, 0x2, 0x3d2, 0x3d3,
- 0x3, 0x2, 0x2, 0x2, 0x3d3, 0x3d5, 0x5, 0x7c, 0x3f, 0x2, 0x3d4, 0x3d6,
- 0x7, 0x6f, 0x2, 0x2, 0x3d5, 0x3d4, 0x3, 0x2, 0x2, 0x2, 0x3d5, 0x3d6,
- 0x3, 0x2, 0x2, 0x2, 0x3d6, 0x3d7, 0x3, 0x2, 0x2, 0x2, 0x3d7, 0x3d8,
- 0x7, 0x9, 0x2, 0x2, 0x3d8, 0x408, 0x3, 0x2, 0x2, 0x2, 0x3d9, 0x3db,
- 0x7, 0x66, 0x2, 0x2, 0x3da, 0x3dc, 0x7, 0x6f, 0x2, 0x2, 0x3db, 0x3da,
- 0x3, 0x2, 0x2, 0x2, 0x3db, 0x3dc, 0x3, 0x2, 0x2, 0x2, 0x3dc, 0x3dd,
- 0x3, 0x2, 0x2, 0x2, 0x3dd, 0x3df, 0x7, 0x8, 0x2, 0x2, 0x3de, 0x3e0,
- 0x7, 0x6f, 0x2, 0x2, 0x3df, 0x3de, 0x3, 0x2, 0x2, 0x2, 0x3df, 0x3e0,
- 0x3, 0x2, 0x2, 0x2, 0x3e0, 0x3e1, 0x3, 0x2, 0x2, 0x2, 0x3e1, 0x3e3,
- 0x5, 0x7c, 0x3f, 0x2, 0x3e2, 0x3e4, 0x7, 0x6f, 0x2, 0x2, 0x3e3, 0x3e2,
- 0x3, 0x2, 0x2, 0x2, 0x3e3, 0x3e4, 0x3, 0x2, 0x2, 0x2, 0x3e4, 0x3e5,
- 0x3, 0x2, 0x2, 0x2, 0x3e5, 0x3e6, 0x7, 0x9, 0x2, 0x2, 0x3e6, 0x408,
- 0x3, 0x2, 0x2, 0x2, 0x3e7, 0x3e9, 0x7, 0x67, 0x2, 0x2, 0x3e8, 0x3ea,
- 0x7, 0x6f, 0x2, 0x2, 0x3e9, 0x3e8, 0x3, 0x2, 0x2, 0x2, 0x3e9, 0x3ea,
- 0x3, 0x2, 0x2, 0x2, 0x3ea, 0x3eb, 0x3, 0x2, 0x2, 0x2, 0x3eb, 0x3ed,
- 0x7, 0x8, 0x2, 0x2, 0x3ec, 0x3ee, 0x7, 0x6f, 0x2, 0x2, 0x3ed, 0x3ec,
- 0x3, 0x2, 0x2, 0x2, 0x3ed, 0x3ee, 0x3, 0x2, 0x2, 0x2, 0x3ee, 0x3ef,
- 0x3, 0x2, 0x2, 0x2, 0x3ef, 0x3f1, 0x5, 0x7c, 0x3f, 0x2, 0x3f0, 0x3f2,
- 0x7, 0x6f, 0x2, 0x2, 0x3f1, 0x3f0, 0x3, 0x2, 0x2, 0x2, 0x3f1, 0x3f2,
- 0x3, 0x2, 0x2, 0x2, 0x3f2, 0x3f3, 0x3, 0x2, 0x2, 0x2, 0x3f3, 0x3f4,
- 0x7, 0x9, 0x2, 0x2, 0x3f4, 0x408, 0x3, 0x2, 0x2, 0x2, 0x3f5, 0x3f7,
- 0x7, 0x68, 0x2, 0x2, 0x3f6, 0x3f8, 0x7, 0x6f, 0x2, 0x2, 0x3f7, 0x3f6,
- 0x3, 0x2, 0x2, 0x2, 0x3f7, 0x3f8, 0x3, 0x2, 0x2, 0x2, 0x3f8, 0x3f9,
- 0x3, 0x2, 0x2, 0x2, 0x3f9, 0x3fb, 0x7, 0x8, 0x2, 0x2, 0x3fa, 0x3fc,
- 0x7, 0x6f, 0x2, 0x2, 0x3fb, 0x3fa, 0x3, 0x2, 0x2, 0x2, 0x3fb, 0x3fc,
- 0x3, 0x2, 0x2, 0x2, 0x3fc, 0x3fd, 0x3, 0x2, 0x2, 0x2, 0x3fd, 0x3ff,
- 0x5, 0x7c, 0x3f, 0x2, 0x3fe, 0x400, 0x7, 0x6f, 0x2, 0x2, 0x3ff, 0x3fe,
- 0x3, 0x2, 0x2, 0x2, 0x3ff, 0x400, 0x3, 0x2, 0x2, 0x2, 0x400, 0x401,
- 0x3, 0x2, 0x2, 0x2, 0x401, 0x402, 0x7, 0x9, 0x2, 0x2, 0x402, 0x408,
- 0x3, 0x2, 0x2, 0x2, 0x403, 0x408, 0x5, 0x7a, 0x3e, 0x2, 0x404, 0x408,
- 0x5, 0x78, 0x3d, 0x2, 0x405, 0x408, 0x5, 0x80, 0x41, 0x2, 0x406, 0x408,
- 0x5, 0x8a, 0x46, 0x2, 0x407, 0x397, 0x3, 0x2, 0x2, 0x2, 0x407, 0x398,
- 0x3, 0x2, 0x2, 0x2, 0x407, 0x399, 0x3, 0x2, 0x2, 0x2, 0x407, 0x3a6,
- 0x3, 0x2, 0x2, 0x2, 0x407, 0x3a7, 0x3, 0x2, 0x2, 0x2, 0x407, 0x3a8,
- 0x3, 0x2, 0x2, 0x2, 0x407, 0x3b6, 0x3, 0x2, 0x2, 0x2, 0x407, 0x3cb,
- 0x3, 0x2, 0x2, 0x2, 0x407, 0x3d9, 0x3, 0x2, 0x2, 0x2, 0x407, 0x3e7,
- 0x3, 0x2, 0x2, 0x2, 0x407, 0x3f5, 0x3, 0x2, 0x2, 0x2, 0x407, 0x403,
- 0x3, 0x2, 0x2, 0x2, 0x407, 0x404, 0x3, 0x2, 0x2, 0x2, 0x407, 0x405,
- 0x3, 0x2, 0x2, 0x2, 0x407, 0x406, 0x3, 0x2, 0x2, 0x2, 0x408, 0x6f, 0x3,
- 0x2, 0x2, 0x2, 0x409, 0x410, 0x5, 0x8c, 0x47, 0x2, 0x40a, 0x410, 0x7,
- 0x32, 0x2, 0x2, 0x40b, 0x410, 0x5, 0x72, 0x3a, 0x2, 0x40c, 0x410, 0x7,
- 0x62, 0x2, 0x2, 0x40d, 0x410, 0x5, 0x8e, 0x48, 0x2, 0x40e, 0x410, 0x5,
- 0x74, 0x3b, 0x2, 0x40f, 0x409, 0x3, 0x2, 0x2, 0x2, 0x40f, 0x40a, 0x3,
- 0x2, 0x2, 0x2, 0x40f, 0x40b, 0x3, 0x2, 0x2, 0x2, 0x40f, 0x40c, 0x3,
- 0x2, 0x2, 0x2, 0x40f, 0x40d, 0x3, 0x2, 0x2, 0x2, 0x40f, 0x40e, 0x3,
- 0x2, 0x2, 0x2, 0x410, 0x71, 0x3, 0x2, 0x2, 0x2, 0x411, 0x412, 0x9, 0x4,
- 0x2, 0x2, 0x412, 0x73, 0x3, 0x2, 0x2, 0x2, 0x413, 0x415, 0x7, 0xa, 0x2,
- 0x2, 0x414, 0x416, 0x7, 0x6f, 0x2, 0x2, 0x415, 0x414, 0x3, 0x2, 0x2,
- 0x2, 0x415, 0x416, 0x3, 0x2, 0x2, 0x2, 0x416, 0x428, 0x3, 0x2, 0x2,
- 0x2, 0x417, 0x419, 0x5, 0x56, 0x2c, 0x2, 0x418, 0x41a, 0x7, 0x6f, 0x2,
- 0x2, 0x419, 0x418, 0x3, 0x2, 0x2, 0x2, 0x419, 0x41a, 0x3, 0x2, 0x2,
- 0x2, 0x41a, 0x425, 0x3, 0x2, 0x2, 0x2, 0x41b, 0x41d, 0x7, 0x4, 0x2,
- 0x2, 0x41c, 0x41e, 0x7, 0x6f, 0x2, 0x2, 0x41d, 0x41c, 0x3, 0x2, 0x2,
- 0x2, 0x41d, 0x41e, 0x3, 0x2, 0x2, 0x2, 0x41e, 0x41f, 0x3, 0x2, 0x2,
- 0x2, 0x41f, 0x421, 0x5, 0x56, 0x2c, 0x2, 0x420, 0x422, 0x7, 0x6f, 0x2,
- 0x2, 0x421, 0x420, 0x3, 0x2, 0x2, 0x2, 0x421, 0x422, 0x3, 0x2, 0x2,
- 0x2, 0x422, 0x424, 0x3, 0x2, 0x2, 0x2, 0x423, 0x41b, 0x3, 0x2, 0x2,
- 0x2, 0x424, 0x427, 0x3, 0x2, 0x2, 0x2, 0x425, 0x423, 0x3, 0x2, 0x2,
- 0x2, 0x425, 0x426, 0x3, 0x2, 0x2, 0x2, 0x426, 0x429, 0x3, 0x2, 0x2,
- 0x2, 0x427, 0x425, 0x3, 0x2, 0x2, 0x2, 0x428, 0x417, 0x3, 0x2, 0x2,
- 0x2, 0x428, 0x429, 0x3, 0x2, 0x2, 0x2, 0x429, 0x42a, 0x3, 0x2, 0x2,
- 0x2, 0x42a, 0x42b, 0x7, 0xb, 0x2, 0x2, 0x42b, 0x75, 0x3, 0x2, 0x2, 0x2,
- 0x42c, 0x42e, 0x7, 0x5, 0x2, 0x2, 0x42d, 0x42f, 0x7, 0x6f, 0x2, 0x2,
- 0x42e, 0x42d, 0x3, 0x2, 0x2, 0x2, 0x42e, 0x42f, 0x3, 0x2, 0x2, 0x2,
- 0x42f, 0x430, 0x3, 0x2, 0x2, 0x2, 0x430, 0x450, 0x5, 0x62, 0x32, 0x2,
- 0x431, 0x433, 0x7, 0x15, 0x2, 0x2, 0x432, 0x434, 0x7, 0x6f, 0x2, 0x2,
- 0x433, 0x432, 0x3, 0x2, 0x2, 0x2, 0x433, 0x434, 0x3, 0x2, 0x2, 0x2,
- 0x434, 0x435, 0x3, 0x2, 0x2, 0x2, 0x435, 0x450, 0x5, 0x62, 0x32, 0x2,
- 0x436, 0x438, 0x7, 0x16, 0x2, 0x2, 0x437, 0x439, 0x7, 0x6f, 0x2, 0x2,
- 0x438, 0x437, 0x3, 0x2, 0x2, 0x2, 0x438, 0x439, 0x3, 0x2, 0x2, 0x2,
- 0x439, 0x43a, 0x3, 0x2, 0x2, 0x2, 0x43a, 0x450, 0x5, 0x62, 0x32, 0x2,
- 0x43b, 0x43d, 0x7, 0x17, 0x2, 0x2, 0x43c, 0x43e, 0x7, 0x6f, 0x2, 0x2,
- 0x43d, 0x43c, 0x3, 0x2, 0x2, 0x2, 0x43d, 0x43e, 0x3, 0x2, 0x2, 0x2,
- 0x43e, 0x43f, 0x3, 0x2, 0x2, 0x2, 0x43f, 0x450, 0x5, 0x62, 0x32, 0x2,
- 0x440, 0x442, 0x7, 0x18, 0x2, 0x2, 0x441, 0x443, 0x7, 0x6f, 0x2, 0x2,
- 0x442, 0x441, 0x3, 0x2, 0x2, 0x2, 0x442, 0x443, 0x3, 0x2, 0x2, 0x2,
- 0x443, 0x444, 0x3, 0x2, 0x2, 0x2, 0x444, 0x450, 0x5, 0x62, 0x32, 0x2,
- 0x445, 0x447, 0x7, 0x19, 0x2, 0x2, 0x446, 0x448, 0x7, 0x6f, 0x2, 0x2,
- 0x447, 0x446, 0x3, 0x2, 0x2, 0x2, 0x447, 0x448, 0x3, 0x2, 0x2, 0x2,
- 0x448, 0x449, 0x3, 0x2, 0x2, 0x2, 0x449, 0x450, 0x5, 0x62, 0x32, 0x2,
- 0x44a, 0x44c, 0x7, 0x1a, 0x2, 0x2, 0x44b, 0x44d, 0x7, 0x6f, 0x2, 0x2,
- 0x44c, 0x44b, 0x3, 0x2, 0x2, 0x2, 0x44c, 0x44d, 0x3, 0x2, 0x2, 0x2,
- 0x44d, 0x44e, 0x3, 0x2, 0x2, 0x2, 0x44e, 0x450, 0x5, 0x62, 0x32, 0x2,
- 0x44f, 0x42c, 0x3, 0x2, 0x2, 0x2, 0x44f, 0x431, 0x3, 0x2, 0x2, 0x2,
- 0x44f, 0x436, 0x3, 0x2, 0x2, 0x2, 0x44f, 0x43b, 0x3, 0x2, 0x2, 0x2,
- 0x44f, 0x440, 0x3, 0x2, 0x2, 0x2, 0x44f, 0x445, 0x3, 0x2, 0x2, 0x2,
- 0x44f, 0x44a, 0x3, 0x2, 0x2, 0x2, 0x450, 0x77, 0x3, 0x2, 0x2, 0x2, 0x451,
- 0x453, 0x7, 0x8, 0x2, 0x2, 0x452, 0x454, 0x7, 0x6f, 0x2, 0x2, 0x453,
- 0x452, 0x3, 0x2, 0x2, 0x2, 0x453, 0x454, 0x3, 0x2, 0x2, 0x2, 0x454,
- 0x455, 0x3, 0x2, 0x2, 0x2, 0x455, 0x457, 0x5, 0x56, 0x2c, 0x2, 0x456,
- 0x458, 0x7, 0x6f, 0x2, 0x2, 0x457, 0x456, 0x3, 0x2, 0x2, 0x2, 0x457,
- 0x458, 0x3, 0x2, 0x2, 0x2, 0x458, 0x459, 0x3, 0x2, 0x2, 0x2, 0x459,
- 0x45a, 0x7, 0x9, 0x2, 0x2, 0x45a, 0x79, 0x3, 0x2, 0x2, 0x2, 0x45b, 0x460,
- 0x5, 0x40, 0x21, 0x2, 0x45c, 0x45e, 0x7, 0x6f, 0x2, 0x2, 0x45d, 0x45c,
- 0x3, 0x2, 0x2, 0x2, 0x45d, 0x45e, 0x3, 0x2, 0x2, 0x2, 0x45e, 0x45f,
- 0x3, 0x2, 0x2, 0x2, 0x45f, 0x461, 0x5, 0x42, 0x22, 0x2, 0x460, 0x45d,
- 0x3, 0x2, 0x2, 0x2, 0x461, 0x462, 0x3, 0x2, 0x2, 0x2, 0x462, 0x460,
- 0x3, 0x2, 0x2, 0x2, 0x462, 0x463, 0x3, 0x2, 0x2, 0x2, 0x463, 0x7b, 0x3,
- 0x2, 0x2, 0x2, 0x464, 0x469, 0x5, 0x7e, 0x40, 0x2, 0x465, 0x467, 0x7,
- 0x6f, 0x2, 0x2, 0x466, 0x465, 0x3, 0x2, 0x2, 0x2, 0x466, 0x467, 0x3,
- 0x2, 0x2, 0x2, 0x467, 0x468, 0x3, 0x2, 0x2, 0x2, 0x468, 0x46a, 0x5,
- 0x36, 0x1c, 0x2, 0x469, 0x466, 0x3, 0x2, 0x2, 0x2, 0x469, 0x46a, 0x3,
- 0x2, 0x2, 0x2, 0x46a, 0x7d, 0x3, 0x2, 0x2, 0x2, 0x46b, 0x46c, 0x5, 0x8a,
- 0x46, 0x2, 0x46c, 0x46d, 0x7, 0x6f, 0x2, 0x2, 0x46d, 0x46e, 0x7, 0x5d,
- 0x2, 0x2, 0x46e, 0x46f, 0x7, 0x6f, 0x2, 0x2, 0x46f, 0x470, 0x5, 0x56,
- 0x2c, 0x2, 0x470, 0x7f, 0x3, 0x2, 0x2, 0x2, 0x471, 0x473, 0x5, 0x82,
- 0x42, 0x2, 0x472, 0x474, 0x7, 0x6f, 0x2, 0x2, 0x473, 0x472, 0x3, 0x2,
- 0x2, 0x2, 0x473, 0x474, 0x3, 0x2, 0x2, 0x2, 0x474, 0x475, 0x3, 0x2,
- 0x2, 0x2, 0x475, 0x477, 0x7, 0x8, 0x2, 0x2, 0x476, 0x478, 0x7, 0x6f,
- 0x2, 0x2, 0x477, 0x476, 0x3, 0x2, 0x2, 0x2, 0x477, 0x478, 0x3, 0x2,
- 0x2, 0x2, 0x478, 0x47d, 0x3, 0x2, 0x2, 0x2, 0x479, 0x47b, 0x7, 0x4e,
- 0x2, 0x2, 0x47a, 0x47c, 0x7, 0x6f, 0x2, 0x2, 0x47b, 0x47a, 0x3, 0x2,
- 0x2, 0x2, 0x47b, 0x47c, 0x3, 0x2, 0x2, 0x2, 0x47c, 0x47e, 0x3, 0x2,
- 0x2, 0x2, 0x47d, 0x479, 0x3, 0x2, 0x2, 0x2, 0x47d, 0x47e, 0x3, 0x2,
- 0x2, 0x2, 0x47e, 0x490, 0x3, 0x2, 0x2, 0x2, 0x47f, 0x481, 0x5, 0x56,
- 0x2c, 0x2, 0x480, 0x482, 0x7, 0x6f, 0x2, 0x2, 0x481, 0x480, 0x3, 0x2,
- 0x2, 0x2, 0x481, 0x482, 0x3, 0x2, 0x2, 0x2, 0x482, 0x48d, 0x3, 0x2,
- 0x2, 0x2, 0x483, 0x485, 0x7, 0x4, 0x2, 0x2, 0x484, 0x486, 0x7, 0x6f,
- 0x2, 0x2, 0x485, 0x484, 0x3, 0x2, 0x2, 0x2, 0x485, 0x486, 0x3, 0x2,
- 0x2, 0x2, 0x486, 0x487, 0x3, 0x2, 0x2, 0x2, 0x487, 0x489, 0x5, 0x56,
- 0x2c, 0x2, 0x488, 0x48a, 0x7, 0x6f, 0x2, 0x2, 0x489, 0x488, 0x3, 0x2,
- 0x2, 0x2, 0x489, 0x48a, 0x3, 0x2, 0x2, 0x2, 0x48a, 0x48c, 0x3, 0x2,
- 0x2, 0x2, 0x48b, 0x483, 0x3, 0x2, 0x2, 0x2, 0x48c, 0x48f, 0x3, 0x2,
- 0x2, 0x2, 0x48d, 0x48b, 0x3, 0x2, 0x2, 0x2, 0x48d, 0x48e, 0x3, 0x2,
- 0x2, 0x2, 0x48e, 0x491, 0x3, 0x2, 0x2, 0x2, 0x48f, 0x48d, 0x3, 0x2,
- 0x2, 0x2, 0x490, 0x47f, 0x3, 0x2, 0x2, 0x2, 0x490, 0x491, 0x3, 0x2,
- 0x2, 0x2, 0x491, 0x492, 0x3, 0x2, 0x2, 0x2, 0x492, 0x493, 0x7, 0x9,
- 0x2, 0x2, 0x493, 0x81, 0x3, 0x2, 0x2, 0x2, 0x494, 0x495, 0x9, 0x5, 0x2,
- 0x2, 0x495, 0x83, 0x3, 0x2, 0x2, 0x2, 0x496, 0x498, 0x7, 0xa, 0x2, 0x2,
- 0x497, 0x499, 0x7, 0x6f, 0x2, 0x2, 0x498, 0x497, 0x3, 0x2, 0x2, 0x2,
- 0x498, 0x499, 0x3, 0x2, 0x2, 0x2, 0x499, 0x49a, 0x3, 0x2, 0x2, 0x2,
- 0x49a, 0x4a3, 0x5, 0x7c, 0x3f, 0x2, 0x49b, 0x49d, 0x7, 0x6f, 0x2, 0x2,
- 0x49c, 0x49b, 0x3, 0x2, 0x2, 0x2, 0x49c, 0x49d, 0x3, 0x2, 0x2, 0x2,
- 0x49d, 0x49e, 0x3, 0x2, 0x2, 0x2, 0x49e, 0x4a0, 0x7, 0xd, 0x2, 0x2,
- 0x49f, 0x4a1, 0x7, 0x6f, 0x2, 0x2, 0x4a0, 0x49f, 0x3, 0x2, 0x2, 0x2,
- 0x4a0, 0x4a1, 0x3, 0x2, 0x2, 0x2, 0x4a1, 0x4a2, 0x3, 0x2, 0x2, 0x2,
- 0x4a2, 0x4a4, 0x5, 0x56, 0x2c, 0x2, 0x4a3, 0x49c, 0x3, 0x2, 0x2, 0x2,
- 0x4a3, 0x4a4, 0x3, 0x2, 0x2, 0x2, 0x4a4, 0x4a6, 0x3, 0x2, 0x2, 0x2,
- 0x4a5, 0x4a7, 0x7, 0x6f, 0x2, 0x2, 0x4a6, 0x4a5, 0x3, 0x2, 0x2, 0x2,
- 0x4a6, 0x4a7, 0x3, 0x2, 0x2, 0x2, 0x4a7, 0x4a8, 0x3, 0x2, 0x2, 0x2,
- 0x4a8, 0x4a9, 0x7, 0xb, 0x2, 0x2, 0x4a9, 0x85, 0x3, 0x2, 0x2, 0x2, 0x4aa,
- 0x4ac, 0x7, 0xa, 0x2, 0x2, 0x4ab, 0x4ad, 0x7, 0x6f, 0x2, 0x2, 0x4ac,
- 0x4ab, 0x3, 0x2, 0x2, 0x2, 0x4ac, 0x4ad, 0x3, 0x2, 0x2, 0x2, 0x4ad,
- 0x4b6, 0x3, 0x2, 0x2, 0x2, 0x4ae, 0x4b0, 0x5, 0x8a, 0x46, 0x2, 0x4af,
- 0x4b1, 0x7, 0x6f, 0x2, 0x2, 0x4b0, 0x4af, 0x3, 0x2, 0x2, 0x2, 0x4b0,
- 0x4b1, 0x3, 0x2, 0x2, 0x2, 0x4b1, 0x4b2, 0x3, 0x2, 0x2, 0x2, 0x4b2,
- 0x4b4, 0x7, 0x5, 0x2, 0x2, 0x4b3, 0x4b5, 0x7, 0x6f, 0x2, 0x2, 0x4b4,
- 0x4b3, 0x3, 0x2, 0x2, 0x2, 0x4b4, 0x4b5, 0x3, 0x2, 0x2, 0x2, 0x4b5,
- 0x4b7, 0x3, 0x2, 0x2, 0x2, 0x4b6, 0x4ae, 0x3, 0x2, 0x2, 0x2, 0x4b6,
- 0x4b7, 0x3, 0x2, 0x2, 0x2, 0x4b7, 0x4b8, 0x3, 0x2, 0x2, 0x2, 0x4b8,
- 0x4ba, 0x5, 0x7a, 0x3e, 0x2, 0x4b9, 0x4bb, 0x7, 0x6f, 0x2, 0x2, 0x4ba,
- 0x4b9, 0x3, 0x2, 0x2, 0x2, 0x4ba, 0x4bb, 0x3, 0x2, 0x2, 0x2, 0x4bb,
- 0x4c4, 0x3, 0x2, 0x2, 0x2, 0x4bc, 0x4be, 0x7, 0x58, 0x2, 0x2, 0x4bd,
- 0x4bf, 0x7, 0x6f, 0x2, 0x2, 0x4be, 0x4bd, 0x3, 0x2, 0x2, 0x2, 0x4be,
- 0x4bf, 0x3, 0x2, 0x2, 0x2, 0x4bf, 0x4c0, 0x3, 0x2, 0x2, 0x2, 0x4c0,
- 0x4c2, 0x5, 0x56, 0x2c, 0x2, 0x4c1, 0x4c3, 0x7, 0x6f, 0x2, 0x2, 0x4c2,
- 0x4c1, 0x3, 0x2, 0x2, 0x2, 0x4c2, 0x4c3, 0x3, 0x2, 0x2, 0x2, 0x4c3,
- 0x4c5, 0x3, 0x2, 0x2, 0x2, 0x4c4, 0x4bc, 0x3, 0x2, 0x2, 0x2, 0x4c4,
- 0x4c5, 0x3, 0x2, 0x2, 0x2, 0x4c5, 0x4c6, 0x3, 0x2, 0x2, 0x2, 0x4c6,
- 0x4c8, 0x7, 0xd, 0x2, 0x2, 0x4c7, 0x4c9, 0x7, 0x6f, 0x2, 0x2, 0x4c8,
- 0x4c7, 0x3, 0x2, 0x2, 0x2, 0x4c8, 0x4c9, 0x3, 0x2, 0x2, 0x2, 0x4c9,
- 0x4ca, 0x3, 0x2, 0x2, 0x2, 0x4ca, 0x4cc, 0x5, 0x56, 0x2c, 0x2, 0x4cb,
- 0x4cd, 0x7, 0x6f, 0x2, 0x2, 0x4cc, 0x4cb, 0x3, 0x2, 0x2, 0x2, 0x4cc,
- 0x4cd, 0x3, 0x2, 0x2, 0x2, 0x4cd, 0x4ce, 0x3, 0x2, 0x2, 0x2, 0x4ce,
- 0x4cf, 0x7, 0xb, 0x2, 0x2, 0x4cf, 0x87, 0x3, 0x2, 0x2, 0x2, 0x4d0, 0x4d2,
- 0x7, 0x1b, 0x2, 0x2, 0x4d1, 0x4d3, 0x7, 0x6f, 0x2, 0x2, 0x4d2, 0x4d1,
- 0x3, 0x2, 0x2, 0x2, 0x4d2, 0x4d3, 0x3, 0x2, 0x2, 0x2, 0x4d3, 0x4d4,
- 0x3, 0x2, 0x2, 0x2, 0x4d4, 0x4d5, 0x5, 0x94, 0x4b, 0x2, 0x4d5, 0x89,
- 0x3, 0x2, 0x2, 0x2, 0x4d6, 0x4d7, 0x5, 0x9a, 0x4e, 0x2, 0x4d7, 0x8b,
- 0x3, 0x2, 0x2, 0x2, 0x4d8, 0x4db, 0x5, 0x98, 0x4d, 0x2, 0x4d9, 0x4db,
- 0x5, 0x96, 0x4c, 0x2, 0x4da, 0x4d8, 0x3, 0x2, 0x2, 0x2, 0x4da, 0x4d9,
- 0x3, 0x2, 0x2, 0x2, 0x4db, 0x8d, 0x3, 0x2, 0x2, 0x2, 0x4dc, 0x4de, 0x7,
- 0x1c, 0x2, 0x2, 0x4dd, 0x4df, 0x7, 0x6f, 0x2, 0x2, 0x4de, 0x4dd, 0x3,
- 0x2, 0x2, 0x2, 0x4de, 0x4df, 0x3, 0x2, 0x2, 0x2, 0x4df, 0x501, 0x3,
- 0x2, 0x2, 0x2, 0x4e0, 0x4e2, 0x5, 0x94, 0x4b, 0x2, 0x4e1, 0x4e3, 0x7,
- 0x6f, 0x2, 0x2, 0x4e2, 0x4e1, 0x3, 0x2, 0x2, 0x2, 0x4e2, 0x4e3, 0x3,
- 0x2, 0x2, 0x2, 0x4e3, 0x4e4, 0x3, 0x2, 0x2, 0x2, 0x4e4, 0x4e6, 0x7,
- 0xc, 0x2, 0x2, 0x4e5, 0x4e7, 0x7, 0x6f, 0x2, 0x2, 0x4e6, 0x4e5, 0x3,
- 0x2, 0x2, 0x2, 0x4e6, 0x4e7, 0x3, 0x2, 0x2, 0x2, 0x4e7, 0x4e8, 0x3,
- 0x2, 0x2, 0x2, 0x4e8, 0x4ea, 0x5, 0x56, 0x2c, 0x2, 0x4e9, 0x4eb, 0x7,
- 0x6f, 0x2, 0x2, 0x4ea, 0x4e9, 0x3, 0x2, 0x2, 0x2, 0x4ea, 0x4eb, 0x3,
- 0x2, 0x2, 0x2, 0x4eb, 0x4fe, 0x3, 0x2, 0x2, 0x2, 0x4ec, 0x4ee, 0x7,
- 0x4, 0x2, 0x2, 0x4ed, 0x4ef, 0x7, 0x6f, 0x2, 0x2, 0x4ee, 0x4ed, 0x3,
- 0x2, 0x2, 0x2, 0x4ee, 0x4ef, 0x3, 0x2, 0x2, 0x2, 0x4ef, 0x4f0, 0x3,
- 0x2, 0x2, 0x2, 0x4f0, 0x4f2, 0x5, 0x94, 0x4b, 0x2, 0x4f1, 0x4f3, 0x7,
- 0x6f, 0x2, 0x2, 0x4f2, 0x4f1, 0x3, 0x2, 0x2, 0x2, 0x4f2, 0x4f3, 0x3,
- 0x2, 0x2, 0x2, 0x4f3, 0x4f4, 0x3, 0x2, 0x2, 0x2, 0x4f4, 0x4f6, 0x7,
- 0xc, 0x2, 0x2, 0x4f5, 0x4f7, 0x7, 0x6f, 0x2, 0x2, 0x4f6, 0x4f5, 0x3,
- 0x2, 0x2, 0x2, 0x4f6, 0x4f7, 0x3, 0x2, 0x2, 0x2, 0x4f7, 0x4f8, 0x3,
- 0x2, 0x2, 0x2, 0x4f8, 0x4fa, 0x5, 0x56, 0x2c, 0x2, 0x4f9, 0x4fb, 0x7,
- 0x6f, 0x2, 0x2, 0x4fa, 0x4f9, 0x3, 0x2, 0x2, 0x2, 0x4fa, 0x4fb, 0x3,
- 0x2, 0x2, 0x2, 0x4fb, 0x4fd, 0x3, 0x2, 0x2, 0x2, 0x4fc, 0x4ec, 0x3,
- 0x2, 0x2, 0x2, 0x4fd, 0x500, 0x3, 0x2, 0x2, 0x2, 0x4fe, 0x4fc, 0x3,
- 0x2, 0x2, 0x2, 0x4fe, 0x4ff, 0x3, 0x2, 0x2, 0x2, 0x4ff, 0x502, 0x3,
- 0x2, 0x2, 0x2, 0x500, 0x4fe, 0x3, 0x2, 0x2, 0x2, 0x501, 0x4e0, 0x3,
- 0x2, 0x2, 0x2, 0x501, 0x502, 0x3, 0x2, 0x2, 0x2, 0x502, 0x503, 0x3,
- 0x2, 0x2, 0x2, 0x503, 0x504, 0x7, 0x1d, 0x2, 0x2, 0x504, 0x8f, 0x3,
- 0x2, 0x2, 0x2, 0x505, 0x508, 0x7, 0x1e, 0x2, 0x2, 0x506, 0x509, 0x5,
- 0x9a, 0x4e, 0x2, 0x507, 0x509, 0x7, 0x35, 0x2, 0x2, 0x508, 0x506, 0x3,
- 0x2, 0x2, 0x2, 0x508, 0x507, 0x3, 0x2, 0x2, 0x2, 0x509, 0x91, 0x3, 0x2,
- 0x2, 0x2, 0x50a, 0x50f, 0x5, 0x6e, 0x38, 0x2, 0x50b, 0x50d, 0x7, 0x6f,
- 0x2, 0x2, 0x50c, 0x50b, 0x3, 0x2, 0x2, 0x2, 0x50c, 0x50d, 0x3, 0x2,
- 0x2, 0x2, 0x50d, 0x50e, 0x3, 0x2, 0x2, 0x2, 0x50e, 0x510, 0x5, 0x88,
- 0x45, 0x2, 0x50f, 0x50c, 0x3, 0x2, 0x2, 0x2, 0x510, 0x511, 0x3, 0x2,
- 0x2, 0x2, 0x511, 0x50f, 0x3, 0x2, 0x2, 0x2, 0x511, 0x512, 0x3, 0x2,
- 0x2, 0x2, 0x512, 0x93, 0x3, 0x2, 0x2, 0x2, 0x513, 0x514, 0x5, 0x9a,
- 0x4e, 0x2, 0x514, 0x95, 0x3, 0x2, 0x2, 0x2, 0x515, 0x516, 0x9, 0x6,
- 0x2, 0x2, 0x516, 0x97, 0x3, 0x2, 0x2, 0x2, 0x517, 0x518, 0x9, 0x7, 0x2,
- 0x2, 0x518, 0x99, 0x3, 0x2, 0x2, 0x2, 0x519, 0x51a, 0x9, 0x8, 0x2, 0x2,
- 0x51a, 0x9b, 0x3, 0x2, 0x2, 0x2, 0x51b, 0x51c, 0x9, 0x9, 0x2, 0x2, 0x51c,
- 0x9d, 0x3, 0x2, 0x2, 0x2, 0x51d, 0x51e, 0x9, 0xa, 0x2, 0x2, 0x51e, 0x9f,
- 0x3, 0x2, 0x2, 0x2, 0x51f, 0x520, 0x9, 0xb, 0x2, 0x2, 0x520, 0xa1, 0x3,
- 0x2, 0x2, 0x2, 0xf3, 0xa3, 0xa7, 0xaa, 0xad, 0xb5, 0xba, 0xbf, 0xc4,
- 0xcb, 0xd0, 0xd3, 0xde, 0xe2, 0xe6, 0xea, 0xed, 0xf1, 0xfb, 0x102, 0x10f,
- 0x113, 0x119, 0x120, 0x125, 0x129, 0x12f, 0x133, 0x139, 0x13d, 0x143,
- 0x147, 0x14b, 0x14f, 0x153, 0x157, 0x15c, 0x163, 0x167, 0x16c, 0x173,
- 0x177, 0x17a, 0x17f, 0x182, 0x186, 0x189, 0x191, 0x195, 0x199, 0x19d,
- 0x1a1, 0x1a6, 0x1ab, 0x1af, 0x1b4, 0x1b7, 0x1c0, 0x1c9, 0x1ce, 0x1db,
- 0x1de, 0x1e6, 0x1ea, 0x1ef, 0x1f4, 0x1f8, 0x1fd, 0x203, 0x208, 0x20f,
- 0x213, 0x217, 0x219, 0x21d, 0x21f, 0x223, 0x225, 0x22b, 0x231, 0x235,
- 0x238, 0x23b, 0x23f, 0x245, 0x249, 0x24c, 0x24f, 0x255, 0x258, 0x25b,
- 0x25f, 0x265, 0x268, 0x26b, 0x26f, 0x273, 0x277, 0x279, 0x27d, 0x27f,
- 0x282, 0x286, 0x288, 0x28e, 0x292, 0x296, 0x29a, 0x29d, 0x2a2, 0x2a7,
- 0x2ac, 0x2b1, 0x2b7, 0x2bb, 0x2bd, 0x2c1, 0x2c5, 0x2c7, 0x2c9, 0x2d8,
- 0x2e2, 0x2ec, 0x2f1, 0x2f5, 0x2fc, 0x301, 0x306, 0x30a, 0x30e, 0x312,
- 0x315, 0x317, 0x31c, 0x320, 0x324, 0x328, 0x32c, 0x330, 0x333, 0x335,
- 0x33a, 0x33e, 0x343, 0x348, 0x34c, 0x353, 0x35a, 0x35e, 0x362, 0x366,
- 0x375, 0x378, 0x385, 0x387, 0x38c, 0x390, 0x394, 0x39b, 0x39f, 0x3a3,
- 0x3aa, 0x3ae, 0x3b2, 0x3b8, 0x3bc, 0x3c0, 0x3c3, 0x3c7, 0x3cd, 0x3d1,
- 0x3d5, 0x3db, 0x3df, 0x3e3, 0x3e9, 0x3ed, 0x3f1, 0x3f7, 0x3fb, 0x3ff,
- 0x407, 0x40f, 0x415, 0x419, 0x41d, 0x421, 0x425, 0x428, 0x42e, 0x433,
- 0x438, 0x43d, 0x442, 0x447, 0x44c, 0x44f, 0x453, 0x457, 0x45d, 0x462,
- 0x466, 0x469, 0x473, 0x477, 0x47b, 0x47d, 0x481, 0x485, 0x489, 0x48d,
- 0x490, 0x498, 0x49c, 0x4a0, 0x4a3, 0x4a6, 0x4ac, 0x4b0, 0x4b4, 0x4b6,
- 0x4ba, 0x4be, 0x4c2, 0x4c4, 0x4c8, 0x4cc, 0x4d2, 0x4da, 0x4de, 0x4e2,
- 0x4e6, 0x4ea, 0x4ee, 0x4f2, 0x4f6, 0x4fa, 0x4fe, 0x501, 0x508, 0x50c,
- 0x511,
- };
-
- atn::ATNDeserializer deserializer;
- _atn = deserializer.deserialize(_serializedATN);
-
- size_t count = _atn.getNumberOfDecisions();
- _decisionToDFA.reserve(count);
- for (size_t i = 0; i < count; i++) {
- _decisionToDFA.emplace_back(_atn.getDecisionState(i), i);
- }
-}
-
-CypherParser::Initializer CypherParser::_init;
diff --git a/src/query/frontend/opencypher/generated/CypherParser.h b/src/query/frontend/opencypher/generated/CypherParser.h
deleted file mode 100644
index ad6859560..000000000
--- a/src/query/frontend/opencypher/generated/CypherParser.h
+++ /dev/null
@@ -1,1687 +0,0 @@
-
-// Generated from /home/mislav/code/memgraph/memgraph/src/query/frontend/opencypher/grammar/Cypher.g4 by ANTLR 4.6
-
-#pragma once
-
-
-#include "antlr4-runtime.h"
-
-
-namespace antlropencypher {
-
-
-class CypherParser : public antlr4::Parser {
-public:
- enum {
- T__0 = 1, T__1 = 2, T__2 = 3, T__3 = 4, T__4 = 5, T__5 = 6, T__6 = 7,
- T__7 = 8, T__8 = 9, T__9 = 10, T__10 = 11, T__11 = 12, T__12 = 13, T__13 = 14,
- T__14 = 15, T__15 = 16, T__16 = 17, T__17 = 18, T__18 = 19, T__19 = 20,
- T__20 = 21, T__21 = 22, T__22 = 23, T__23 = 24, T__24 = 25, T__25 = 26,
- T__26 = 27, T__27 = 28, T__28 = 29, T__29 = 30, T__30 = 31, T__31 = 32,
- T__32 = 33, T__33 = 34, T__34 = 35, T__35 = 36, T__36 = 37, T__37 = 38,
- T__38 = 39, T__39 = 40, T__40 = 41, T__41 = 42, T__42 = 43, T__43 = 44,
- T__44 = 45, T__45 = 46, T__46 = 47, StringLiteral = 48, EscapedChar = 49,
- HexInteger = 50, DecimalInteger = 51, OctalInteger = 52, HexLetter = 53,
- HexDigit = 54, Digit = 55, NonZeroDigit = 56, NonZeroOctDigit = 57,
- OctDigit = 58, ZeroDigit = 59, ExponentDecimalReal = 60, RegularDecimalReal = 61,
- UNION = 62, ALL = 63, OPTIONAL = 64, MATCH = 65, UNWIND = 66, AS = 67,
- MERGE = 68, ON = 69, CREATE = 70, SET = 71, DETACH = 72, DELETE = 73,
- REMOVE = 74, WITH = 75, DISTINCT = 76, RETURN = 77, ORDER = 78, BY = 79,
- L_SKIP = 80, LIMIT = 81, ASCENDING = 82, ASC = 83, DESCENDING = 84,
- DESC = 85, WHERE = 86, OR = 87, XOR = 88, AND = 89, NOT = 90, IN = 91,
- STARTS = 92, ENDS = 93, CONTAINS = 94, IS = 95, CYPHERNULL = 96, COUNT = 97,
- FILTER = 98, EXTRACT = 99, ANY = 100, NONE = 101, SINGLE = 102, TRUE = 103,
- FALSE = 104, UnescapedSymbolicName = 105, IdentifierStart = 106, IdentifierPart = 107,
- EscapedSymbolicName = 108, SP = 109, WHITESPACE = 110, Comment = 111
- };
-
- enum {
- RuleCypher = 0, RuleStatement = 1, RuleQuery = 2, RuleRegularQuery = 3,
- RuleSingleQuery = 4, RuleCypherUnion = 5, RuleClause = 6, RuleCypherMatch = 7,
- RuleUnwind = 8, RuleMerge = 9, RuleMergeAction = 10, RuleCreate = 11,
- RuleSet = 12, RuleSetItem = 13, RuleCypherDelete = 14, RuleRemove = 15,
- RuleRemoveItem = 16, RuleWith = 17, RuleCypherReturn = 18, RuleReturnBody = 19,
- RuleReturnItems = 20, RuleReturnItem = 21, RuleOrder = 22, RuleSkip = 23,
- RuleLimit = 24, RuleSortItem = 25, RuleWhere = 26, RulePattern = 27,
- RulePatternPart = 28, RuleAnonymousPatternPart = 29, RulePatternElement = 30,
- RuleNodePattern = 31, RulePatternElementChain = 32, RuleRelationshipPattern = 33,
- RuleRelationshipDetail = 34, RuleProperties = 35, RuleRelationshipTypes = 36,
- RuleNodeLabels = 37, RuleNodeLabel = 38, RuleRangeLiteral = 39, RuleLabelName = 40,
- RuleRelTypeName = 41, RuleExpression = 42, RuleExpression12 = 43, RuleExpression11 = 44,
- RuleExpression10 = 45, RuleExpression9 = 46, RuleExpression8 = 47, RuleExpression7 = 48,
- RuleExpression6 = 49, RuleExpression5 = 50, RuleExpression4 = 51, RuleExpression3 = 52,
- RuleExpression2 = 53, RuleAtom = 54, RuleLiteral = 55, RuleBooleanLiteral = 56,
- RuleListLiteral = 57, RulePartialComparisonExpression = 58, RuleParenthesizedExpression = 59,
- RuleRelationshipsPattern = 60, RuleFilterExpression = 61, RuleIdInColl = 62,
- RuleFunctionInvocation = 63, RuleFunctionName = 64, RuleListComprehension = 65,
- RulePatternComprehension = 66, RulePropertyLookup = 67, RuleVariable = 68,
- RuleNumberLiteral = 69, RuleMapLiteral = 70, RuleParameter = 71, RulePropertyExpression = 72,
- RulePropertyKeyName = 73, RuleIntegerLiteral = 74, RuleDoubleLiteral = 75,
- RuleSymbolicName = 76, RuleLeftArrowHead = 77, RuleRightArrowHead = 78,
- RuleDash = 79
- };
-
- CypherParser(antlr4::TokenStream *input);
- ~CypherParser();
-
- virtual std::string getGrammarFileName() const override;
- virtual const antlr4::atn::ATN& getATN() const override { return _atn; };
- virtual const std::vector<std::string>& getTokenNames() const override { return _tokenNames; }; // deprecated: use vocabulary instead.
- virtual const std::vector<std::string>& getRuleNames() const override;
- virtual antlr4::dfa::Vocabulary& getVocabulary() const override;
-
-
- class CypherContext;
- class StatementContext;
- class QueryContext;
- class RegularQueryContext;
- class SingleQueryContext;
- class CypherUnionContext;
- class ClauseContext;
- class CypherMatchContext;
- class UnwindContext;
- class MergeContext;
- class MergeActionContext;
- class CreateContext;
- class SetContext;
- class SetItemContext;
- class CypherDeleteContext;
- class RemoveContext;
- class RemoveItemContext;
- class WithContext;
- class CypherReturnContext;
- class ReturnBodyContext;
- class ReturnItemsContext;
- class ReturnItemContext;
- class OrderContext;
- class SkipContext;
- class LimitContext;
- class SortItemContext;
- class WhereContext;
- class PatternContext;
- class PatternPartContext;
- class AnonymousPatternPartContext;
- class PatternElementContext;
- class NodePatternContext;
- class PatternElementChainContext;
- class RelationshipPatternContext;
- class RelationshipDetailContext;
- class PropertiesContext;
- class RelationshipTypesContext;
- class NodeLabelsContext;
- class NodeLabelContext;
- class RangeLiteralContext;
- class LabelNameContext;
- class RelTypeNameContext;
- class ExpressionContext;
- class Expression12Context;
- class Expression11Context;
- class Expression10Context;
- class Expression9Context;
- class Expression8Context;
- class Expression7Context;
- class Expression6Context;
- class Expression5Context;
- class Expression4Context;
- class Expression3Context;
- class Expression2Context;
- class AtomContext;
- class LiteralContext;
- class BooleanLiteralContext;
- class ListLiteralContext;
- class PartialComparisonExpressionContext;
- class ParenthesizedExpressionContext;
- class RelationshipsPatternContext;
- class FilterExpressionContext;
- class IdInCollContext;
- class FunctionInvocationContext;
- class FunctionNameContext;
- class ListComprehensionContext;
- class PatternComprehensionContext;
- class PropertyLookupContext;
- class VariableContext;
- class NumberLiteralContext;
- class MapLiteralContext;
- class ParameterContext;
- class PropertyExpressionContext;
- class PropertyKeyNameContext;
- class IntegerLiteralContext;
- class DoubleLiteralContext;
- class SymbolicNameContext;
- class LeftArrowHeadContext;
- class RightArrowHeadContext;
- class DashContext;
-
- class CypherContext : public antlr4::ParserRuleContext {
- public:
- CypherContext(antlr4::ParserRuleContext *parent, size_t invokingState);
- virtual size_t getRuleIndex() const override;
- StatementContext *statement();
- std::vector<antlr4::tree::TerminalNode *> SP();
- antlr4::tree::TerminalNode* SP(size_t i);
-
- virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
- virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
-
- virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
-
- };
-
- CypherContext* cypher();
-
- class StatementContext : public antlr4::ParserRuleContext {
- public:
- StatementContext(antlr4::ParserRuleContext *parent, size_t invokingState);
- virtual size_t getRuleIndex() const override;
- QueryContext *query();
-
- virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
- virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
-
- virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
-
- };
-
- StatementContext* statement();
-
- class QueryContext : public antlr4::ParserRuleContext {
- public:
- QueryContext(antlr4::ParserRuleContext *parent, size_t invokingState);
- virtual size_t getRuleIndex() const override;
- RegularQueryContext *regularQuery();
-
- virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
- virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
-
- virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
-
- };
-
- QueryContext* query();
-
- class RegularQueryContext : public antlr4::ParserRuleContext {
- public:
- RegularQueryContext(antlr4::ParserRuleContext *parent, size_t invokingState);
- virtual size_t getRuleIndex() const override;
- SingleQueryContext *singleQuery();
- std::vector<CypherUnionContext *> cypherUnion();
- CypherUnionContext* cypherUnion(size_t i);
- std::vector<antlr4::tree::TerminalNode *> SP();
- antlr4::tree::TerminalNode* SP(size_t i);
-
- virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
- virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
-
- virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
-
- };
-
- RegularQueryContext* regularQuery();
-
- class SingleQueryContext : public antlr4::ParserRuleContext {
- public:
- SingleQueryContext(antlr4::ParserRuleContext *parent, size_t invokingState);
- virtual size_t getRuleIndex() const override;
- std::vector<ClauseContext *> clause();
- ClauseContext* clause(size_t i);
- std::vector<antlr4::tree::TerminalNode *> SP();
- antlr4::tree::TerminalNode* SP(size_t i);
-
- virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
- virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
-
- virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
-
- };
-
- SingleQueryContext* singleQuery();
-
- class CypherUnionContext : public antlr4::ParserRuleContext {
- public:
- CypherUnionContext(antlr4::ParserRuleContext *parent, size_t invokingState);
- virtual size_t getRuleIndex() const override;
- antlr4::tree::TerminalNode *UNION();
- std::vector<antlr4::tree::TerminalNode *> SP();
- antlr4::tree::TerminalNode* SP(size_t i);
- antlr4::tree::TerminalNode *ALL();
- SingleQueryContext *singleQuery();
-
- virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
- virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
-
- virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
-
- };
-
- CypherUnionContext* cypherUnion();
-
- class ClauseContext : public antlr4::ParserRuleContext {
- public:
- ClauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
- virtual size_t getRuleIndex() const override;
- CypherMatchContext *cypherMatch();
- UnwindContext *unwind();
- MergeContext *merge();
- CreateContext *create();
- SetContext *set();
- CypherDeleteContext *cypherDelete();
- RemoveContext *remove();
- WithContext *with();
- CypherReturnContext *cypherReturn();
-
- virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
- virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
-
- virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
-
- };
-
- ClauseContext* clause();
-
- class CypherMatchContext : public antlr4::ParserRuleContext {
- public:
- CypherMatchContext(antlr4::ParserRuleContext *parent, size_t invokingState);
- virtual size_t getRuleIndex() const override;
- antlr4::tree::TerminalNode *MATCH();
- PatternContext *pattern();
- antlr4::tree::TerminalNode *OPTIONAL();
- std::vector<antlr4::tree::TerminalNode *> SP();
- antlr4::tree::TerminalNode* SP(size_t i);
- WhereContext *where();
-
- virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
- virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
-
- virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
-
- };
-
- CypherMatchContext* cypherMatch();
-
- class UnwindContext : public antlr4::ParserRuleContext {
- public:
- UnwindContext(antlr4::ParserRuleContext *parent, size_t invokingState);
- virtual size_t getRuleIndex() const override;
- antlr4::tree::TerminalNode *UNWIND();
- ExpressionContext *expression();
- std::vector<antlr4::tree::TerminalNode *> SP();
- antlr4::tree::TerminalNode* SP(size_t i);
- antlr4::tree::TerminalNode *AS();
- VariableContext *variable();
-
- virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
- virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
-
- virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
-
- };
-
- UnwindContext* unwind();
-
- class MergeContext : public antlr4::ParserRuleContext {
- public:
- MergeContext(antlr4::ParserRuleContext *parent, size_t invokingState);
- virtual size_t getRuleIndex() const override;
- antlr4::tree::TerminalNode *MERGE();
- PatternPartContext *patternPart();
- std::vector<antlr4::tree::TerminalNode *> SP();
- antlr4::tree::TerminalNode* SP(size_t i);
- std::vector<MergeActionContext *> mergeAction();
- MergeActionContext* mergeAction(size_t i);
-
- virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
- virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
-
- virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
-
- };
-
- MergeContext* merge();
-
- class MergeActionContext : public antlr4::ParserRuleContext {
- public:
- MergeActionContext(antlr4::ParserRuleContext *parent, size_t invokingState);
- virtual size_t getRuleIndex() const override;
- antlr4::tree::TerminalNode *ON();
- std::vector<antlr4::tree::TerminalNode *> SP();
- antlr4::tree::TerminalNode* SP(size_t i);
- antlr4::tree::TerminalNode *MATCH();
- SetContext *set();
- antlr4::tree::TerminalNode *CREATE();
-
- virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
- virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
-
- virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
-
- };
-
- MergeActionContext* mergeAction();
-
- class CreateContext : public antlr4::ParserRuleContext {
- public:
- CreateContext(antlr4::ParserRuleContext *parent, size_t invokingState);
- virtual size_t getRuleIndex() const override;
- antlr4::tree::TerminalNode *CREATE();
- PatternContext *pattern();
- antlr4::tree::TerminalNode *SP();
-
- virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
- virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
-
- virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
-
- };
-
- CreateContext* create();
-
- class SetContext : public antlr4::ParserRuleContext {
- public:
- SetContext(antlr4::ParserRuleContext *parent, size_t invokingState);
- virtual size_t getRuleIndex() const override;
- antlr4::tree::TerminalNode *SET();
- std::vector<SetItemContext *> setItem();
- SetItemContext* setItem(size_t i);
- antlr4::tree::TerminalNode *SP();
-
- virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
- virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
-
- virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
-
- };
-
- SetContext* set();
-
- class SetItemContext : public antlr4::ParserRuleContext {
- public:
- SetItemContext(antlr4::ParserRuleContext *parent, size_t invokingState);
- virtual size_t getRuleIndex() const override;
- PropertyExpressionContext *propertyExpression();
- ExpressionContext *expression();
- std::vector<antlr4::tree::TerminalNode *> SP();
- antlr4::tree::TerminalNode* SP(size_t i);
- VariableContext *variable();
- NodeLabelsContext *nodeLabels();
-
- virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
- virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
-
- virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
-
- };
-
- SetItemContext* setItem();
-
- class CypherDeleteContext : public antlr4::ParserRuleContext {
- public:
- CypherDeleteContext(antlr4::ParserRuleContext *parent, size_t invokingState);
- virtual size_t getRuleIndex() const override;
- antlr4::tree::TerminalNode *DELETE();
- std::vector<ExpressionContext *> expression();
- ExpressionContext* expression(size_t i);
- antlr4::tree::TerminalNode *DETACH();
- std::vector<antlr4::tree::TerminalNode *> SP();
- antlr4::tree::TerminalNode* SP(size_t i);
-
- virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
- virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
-
- virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
-
- };
-
- CypherDeleteContext* cypherDelete();
-
- class RemoveContext : public antlr4::ParserRuleContext {
- public:
- RemoveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
- virtual size_t getRuleIndex() const override;
- antlr4::tree::TerminalNode *REMOVE();
- std::vector<antlr4::tree::TerminalNode *> SP();
- antlr4::tree::TerminalNode* SP(size_t i);
- std::vector<RemoveItemContext *> removeItem();
- RemoveItemContext* removeItem(size_t i);
-
- virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
- virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
-
- virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
-
- };
-
- RemoveContext* remove();
-
- class RemoveItemContext : public antlr4::ParserRuleContext {
- public:
- RemoveItemContext(antlr4::ParserRuleContext *parent, size_t invokingState);
- virtual size_t getRuleIndex() const override;
- VariableContext *variable();
- NodeLabelsContext *nodeLabels();
- PropertyExpressionContext *propertyExpression();
-
- virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
- virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
-
- virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
-
- };
-
- RemoveItemContext* removeItem();
-
- class WithContext : public antlr4::ParserRuleContext {
- public:
- WithContext(antlr4::ParserRuleContext *parent, size_t invokingState);
- virtual size_t getRuleIndex() const override;
- antlr4::tree::TerminalNode *WITH();
- std::vector<antlr4::tree::TerminalNode *> SP();
- antlr4::tree::TerminalNode* SP(size_t i);
- ReturnBodyContext *returnBody();
- antlr4::tree::TerminalNode *DISTINCT();
- WhereContext *where();
-
- virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
- virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
-
- virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
-
- };
-
- WithContext* with();
-
- class CypherReturnContext : public antlr4::ParserRuleContext {
- public:
- CypherReturnContext(antlr4::ParserRuleContext *parent, size_t invokingState);
- virtual size_t getRuleIndex() const override;
- antlr4::tree::TerminalNode *RETURN();
- std::vector<antlr4::tree::TerminalNode *> SP();
- antlr4::tree::TerminalNode* SP(size_t i);
- ReturnBodyContext *returnBody();
- antlr4::tree::TerminalNode *DISTINCT();
-
- virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
- virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
-
- virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
-
- };
-
- CypherReturnContext* cypherReturn();
-
- class ReturnBodyContext : public antlr4::ParserRuleContext {
- public:
- ReturnBodyContext(antlr4::ParserRuleContext *parent, size_t invokingState);
- virtual size_t getRuleIndex() const override;
- ReturnItemsContext *returnItems();
- std::vector<antlr4::tree::TerminalNode *> SP();
- antlr4::tree::TerminalNode* SP(size_t i);
- OrderContext *order();
- SkipContext *skip();
- LimitContext *limit();
-
- virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
- virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
-
- virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
-
- };
-
- ReturnBodyContext* returnBody();
-
- class ReturnItemsContext : public antlr4::ParserRuleContext {
- public:
- ReturnItemsContext(antlr4::ParserRuleContext *parent, size_t invokingState);
- virtual size_t getRuleIndex() const override;
- std::vector<ReturnItemContext *> returnItem();
- ReturnItemContext* returnItem(size_t i);
- std::vector<antlr4::tree::TerminalNode *> SP();
- antlr4::tree::TerminalNode* SP(size_t i);
-
- virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
- virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
-
- virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
-
- };
-
- ReturnItemsContext* returnItems();
-
- class ReturnItemContext : public antlr4::ParserRuleContext {
- public:
- ReturnItemContext(antlr4::ParserRuleContext *parent, size_t invokingState);
- virtual size_t getRuleIndex() const override;
- ExpressionContext *expression();
- std::vector<antlr4::tree::TerminalNode *> SP();
- antlr4::tree::TerminalNode* SP(size_t i);
- antlr4::tree::TerminalNode *AS();
- VariableContext *variable();
-
- virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
- virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
-
- virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
-
- };
-
- ReturnItemContext* returnItem();
-
- class OrderContext : public antlr4::ParserRuleContext {
- public:
- OrderContext(antlr4::ParserRuleContext *parent, size_t invokingState);
- virtual size_t getRuleIndex() const override;
- antlr4::tree::TerminalNode *ORDER();
- std::vector<antlr4::tree::TerminalNode *> SP();
- antlr4::tree::TerminalNode* SP(size_t i);
- antlr4::tree::TerminalNode *BY();
- std::vector<SortItemContext *> sortItem();
- SortItemContext* sortItem(size_t i);
-
- virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
- virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
-
- virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
-
- };
-
- OrderContext* order();
-
- class SkipContext : public antlr4::ParserRuleContext {
- public:
- SkipContext(antlr4::ParserRuleContext *parent, size_t invokingState);
- virtual size_t getRuleIndex() const override;
- antlr4::tree::TerminalNode *L_SKIP();
- antlr4::tree::TerminalNode *SP();
- ExpressionContext *expression();
-
- virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
- virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
-
- virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
-
- };
-
- SkipContext* skip();
-
- class LimitContext : public antlr4::ParserRuleContext {
- public:
- LimitContext(antlr4::ParserRuleContext *parent, size_t invokingState);
- virtual size_t getRuleIndex() const override;
- antlr4::tree::TerminalNode *LIMIT();
- antlr4::tree::TerminalNode *SP();
- ExpressionContext *expression();
-
- virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
- virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
-
- virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
-
- };
-
- LimitContext* limit();
-
- class SortItemContext : public antlr4::ParserRuleContext {
- public:
- SortItemContext(antlr4::ParserRuleContext *parent, size_t invokingState);
- virtual size_t getRuleIndex() const override;
- ExpressionContext *expression();
- antlr4::tree::TerminalNode *ASCENDING();
- antlr4::tree::TerminalNode *ASC();
- antlr4::tree::TerminalNode *DESCENDING();
- antlr4::tree::TerminalNode *DESC();
- antlr4::tree::TerminalNode *SP();
-
- virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
- virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
-
- virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
-
- };
-
- SortItemContext* sortItem();
-
- class WhereContext : public antlr4::ParserRuleContext {
- public:
- WhereContext(antlr4::ParserRuleContext *parent, size_t invokingState);
- virtual size_t getRuleIndex() const override;
- antlr4::tree::TerminalNode *WHERE();
- antlr4::tree::TerminalNode *SP();
- ExpressionContext *expression();
-
- virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
- virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
-
- virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
-
- };
-
- WhereContext* where();
-
- class PatternContext : public antlr4::ParserRuleContext {
- public:
- PatternContext(antlr4::ParserRuleContext *parent, size_t invokingState);
- virtual size_t getRuleIndex() const override;
- std::vector<PatternPartContext *> patternPart();
- PatternPartContext* patternPart(size_t i);
- std::vector<antlr4::tree::TerminalNode *> SP();
- antlr4::tree::TerminalNode* SP(size_t i);
-
- virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
- virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
-
- virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
-
- };
-
- PatternContext* pattern();
-
- class PatternPartContext : public antlr4::ParserRuleContext {
- public:
- PatternPartContext(antlr4::ParserRuleContext *parent, size_t invokingState);
- virtual size_t getRuleIndex() const override;
- VariableContext *variable();
- AnonymousPatternPartContext *anonymousPatternPart();
- std::vector<antlr4::tree::TerminalNode *> SP();
- antlr4::tree::TerminalNode* SP(size_t i);
-
- virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
- virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
-
- virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
-
- };
-
- PatternPartContext* patternPart();
-
- class AnonymousPatternPartContext : public antlr4::ParserRuleContext {
- public:
- AnonymousPatternPartContext(antlr4::ParserRuleContext *parent, size_t invokingState);
- virtual size_t getRuleIndex() const override;
- PatternElementContext *patternElement();
-
- virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
- virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
-
- virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
-
- };
-
- AnonymousPatternPartContext* anonymousPatternPart();
-
- class PatternElementContext : public antlr4::ParserRuleContext {
- public:
- PatternElementContext(antlr4::ParserRuleContext *parent, size_t invokingState);
- virtual size_t getRuleIndex() const override;
- NodePatternContext *nodePattern();
- std::vector<PatternElementChainContext *> patternElementChain();
- PatternElementChainContext* patternElementChain(size_t i);
- std::vector<antlr4::tree::TerminalNode *> SP();
- antlr4::tree::TerminalNode* SP(size_t i);
- PatternElementContext *patternElement();
-
- virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
- virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
-
- virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
-
- };
-
- PatternElementContext* patternElement();
-
- class NodePatternContext : public antlr4::ParserRuleContext {
- public:
- NodePatternContext(antlr4::ParserRuleContext *parent, size_t invokingState);
- virtual size_t getRuleIndex() const override;
- std::vector<antlr4::tree::TerminalNode *> SP();
- antlr4::tree::TerminalNode* SP(size_t i);
- VariableContext *variable();
- NodeLabelsContext *nodeLabels();
- PropertiesContext *properties();
-
- virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
- virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
-
- virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
-
- };
-
- NodePatternContext* nodePattern();
-
- class PatternElementChainContext : public antlr4::ParserRuleContext {
- public:
- PatternElementChainContext(antlr4::ParserRuleContext *parent, size_t invokingState);
- virtual size_t getRuleIndex() const override;
- RelationshipPatternContext *relationshipPattern();
- NodePatternContext *nodePattern();
- antlr4::tree::TerminalNode *SP();
-
- virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
- virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
-
- virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
-
- };
-
- PatternElementChainContext* patternElementChain();
-
- class RelationshipPatternContext : public antlr4::ParserRuleContext {
- public:
- RelationshipPatternContext(antlr4::ParserRuleContext *parent, size_t invokingState);
- virtual size_t getRuleIndex() const override;
- LeftArrowHeadContext *leftArrowHead();
- std::vector<DashContext *> dash();
- DashContext* dash(size_t i);
- RightArrowHeadContext *rightArrowHead();
- std::vector<antlr4::tree::TerminalNode *> SP();
- antlr4::tree::TerminalNode* SP(size_t i);
- RelationshipDetailContext *relationshipDetail();
-
- virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
- virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
-
- virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
-
- };
-
- RelationshipPatternContext* relationshipPattern();
-
- class RelationshipDetailContext : public antlr4::ParserRuleContext {
- public:
- RelationshipDetailContext(antlr4::ParserRuleContext *parent, size_t invokingState);
- virtual size_t getRuleIndex() const override;
- std::vector<antlr4::tree::TerminalNode *> SP();
- antlr4::tree::TerminalNode* SP(size_t i);
- VariableContext *variable();
- RelationshipTypesContext *relationshipTypes();
- RangeLiteralContext *rangeLiteral();
- PropertiesContext *properties();
-
- virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
- virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
-
- virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
-
- };
-
- RelationshipDetailContext* relationshipDetail();
-
- class PropertiesContext : public antlr4::ParserRuleContext {
- public:
- PropertiesContext(antlr4::ParserRuleContext *parent, size_t invokingState);
- virtual size_t getRuleIndex() const override;
- MapLiteralContext *mapLiteral();
- ParameterContext *parameter();
-
- virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
- virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
-
- virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
-
- };
-
- PropertiesContext* properties();
-
- class RelationshipTypesContext : public antlr4::ParserRuleContext {
- public:
- RelationshipTypesContext(antlr4::ParserRuleContext *parent, size_t invokingState);
- virtual size_t getRuleIndex() const override;
- std::vector<RelTypeNameContext *> relTypeName();
- RelTypeNameContext* relTypeName(size_t i);
- std::vector<antlr4::tree::TerminalNode *> SP();
- antlr4::tree::TerminalNode* SP(size_t i);
-
- virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
- virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
-
- virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
-
- };
-
- RelationshipTypesContext* relationshipTypes();
-
- class NodeLabelsContext : public antlr4::ParserRuleContext {
- public:
- NodeLabelsContext(antlr4::ParserRuleContext *parent, size_t invokingState);
- virtual size_t getRuleIndex() const override;
- std::vector<NodeLabelContext *> nodeLabel();
- NodeLabelContext* nodeLabel(size_t i);
- std::vector<antlr4::tree::TerminalNode *> SP();
- antlr4::tree::TerminalNode* SP(size_t i);
-
- virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
- virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
-
- virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
-
- };
-
- NodeLabelsContext* nodeLabels();
-
- class NodeLabelContext : public antlr4::ParserRuleContext {
- public:
- NodeLabelContext(antlr4::ParserRuleContext *parent, size_t invokingState);
- virtual size_t getRuleIndex() const override;
- LabelNameContext *labelName();
- antlr4::tree::TerminalNode *SP();
-
- virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
- virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
-
- virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
-
- };
-
- NodeLabelContext* nodeLabel();
-
- class RangeLiteralContext : public antlr4::ParserRuleContext {
- public:
- RangeLiteralContext(antlr4::ParserRuleContext *parent, size_t invokingState);
- virtual size_t getRuleIndex() const override;
- std::vector<antlr4::tree::TerminalNode *> SP();
- antlr4::tree::TerminalNode* SP(size_t i);
- std::vector<IntegerLiteralContext *> integerLiteral();
- IntegerLiteralContext* integerLiteral(size_t i);
-
- virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
- virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
-
- virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
-
- };
-
- RangeLiteralContext* rangeLiteral();
-
- class LabelNameContext : public antlr4::ParserRuleContext {
- public:
- LabelNameContext(antlr4::ParserRuleContext *parent, size_t invokingState);
- virtual size_t getRuleIndex() const override;
- SymbolicNameContext *symbolicName();
-
- virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
- virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
-
- virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
-
- };
-
- LabelNameContext* labelName();
-
- class RelTypeNameContext : public antlr4::ParserRuleContext {
- public:
- RelTypeNameContext(antlr4::ParserRuleContext *parent, size_t invokingState);
- virtual size_t getRuleIndex() const override;
- SymbolicNameContext *symbolicName();
-
- virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
- virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
-
- virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
-
- };
-
- RelTypeNameContext* relTypeName();
-
- class ExpressionContext : public antlr4::ParserRuleContext {
- public:
- ExpressionContext(antlr4::ParserRuleContext *parent, size_t invokingState);
- virtual size_t getRuleIndex() const override;
- Expression12Context *expression12();
-
- virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
- virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
-
- virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
-
- };
-
- ExpressionContext* expression();
-
- class Expression12Context : public antlr4::ParserRuleContext {
- public:
- Expression12Context(antlr4::ParserRuleContext *parent, size_t invokingState);
- virtual size_t getRuleIndex() const override;
- std::vector<Expression11Context *> expression11();
- Expression11Context* expression11(size_t i);
- std::vector<antlr4::tree::TerminalNode *> SP();
- antlr4::tree::TerminalNode* SP(size_t i);
- std::vector<antlr4::tree::TerminalNode *> OR();
- antlr4::tree::TerminalNode* OR(size_t i);
-
- virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
- virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
-
- virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
-
- };
-
- Expression12Context* expression12();
-
- class Expression11Context : public antlr4::ParserRuleContext {
- public:
- Expression11Context(antlr4::ParserRuleContext *parent, size_t invokingState);
- virtual size_t getRuleIndex() const override;
- std::vector<Expression10Context *> expression10();
- Expression10Context* expression10(size_t i);
- std::vector<antlr4::tree::TerminalNode *> SP();
- antlr4::tree::TerminalNode* SP(size_t i);
- std::vector<antlr4::tree::TerminalNode *> XOR();
- antlr4::tree::TerminalNode* XOR(size_t i);
-
- virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
- virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
-
- virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
-
- };
-
- Expression11Context* expression11();
-
- class Expression10Context : public antlr4::ParserRuleContext {
- public:
- Expression10Context(antlr4::ParserRuleContext *parent, size_t invokingState);
- virtual size_t getRuleIndex() const override;
- std::vector<Expression9Context *> expression9();
- Expression9Context* expression9(size_t i);
- std::vector<antlr4::tree::TerminalNode *> SP();
- antlr4::tree::TerminalNode* SP(size_t i);
- std::vector<antlr4::tree::TerminalNode *> AND();
- antlr4::tree::TerminalNode* AND(size_t i);
-
- virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
- virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
-
- virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
-
- };
-
- Expression10Context* expression10();
-
- class Expression9Context : public antlr4::ParserRuleContext {
- public:
- Expression9Context(antlr4::ParserRuleContext *parent, size_t invokingState);
- virtual size_t getRuleIndex() const override;
- Expression8Context *expression8();
- std::vector<antlr4::tree::TerminalNode *> NOT();
- antlr4::tree::TerminalNode* NOT(size_t i);
- std::vector<antlr4::tree::TerminalNode *> SP();
- antlr4::tree::TerminalNode* SP(size_t i);
-
- virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
- virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
-
- virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
-
- };
-
- Expression9Context* expression9();
-
- class Expression8Context : public antlr4::ParserRuleContext {
- public:
- Expression8Context(antlr4::ParserRuleContext *parent, size_t invokingState);
- virtual size_t getRuleIndex() const override;
- Expression7Context *expression7();
- std::vector<PartialComparisonExpressionContext *> partialComparisonExpression();
- PartialComparisonExpressionContext* partialComparisonExpression(size_t i);
- std::vector<antlr4::tree::TerminalNode *> SP();
- antlr4::tree::TerminalNode* SP(size_t i);
-
- virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
- virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
-
- virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
-
- };
-
- Expression8Context* expression8();
-
- class Expression7Context : public antlr4::ParserRuleContext {
- public:
- Expression7Context(antlr4::ParserRuleContext *parent, size_t invokingState);
- virtual size_t getRuleIndex() const override;
- std::vector<Expression6Context *> expression6();
- Expression6Context* expression6(size_t i);
- std::vector<antlr4::tree::TerminalNode *> SP();
- antlr4::tree::TerminalNode* SP(size_t i);
-
- virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
- virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
-
- virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
-
- };
-
- Expression7Context* expression7();
-
- class Expression6Context : public antlr4::ParserRuleContext {
- public:
- Expression6Context(antlr4::ParserRuleContext *parent, size_t invokingState);
- virtual size_t getRuleIndex() const override;
- std::vector<Expression5Context *> expression5();
- Expression5Context* expression5(size_t i);
- std::vector<antlr4::tree::TerminalNode *> SP();
- antlr4::tree::TerminalNode* SP(size_t i);
-
- virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
- virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
-
- virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
-
- };
-
- Expression6Context* expression6();
-
- class Expression5Context : public antlr4::ParserRuleContext {
- public:
- Expression5Context(antlr4::ParserRuleContext *parent, size_t invokingState);
- virtual size_t getRuleIndex() const override;
- std::vector<Expression4Context *> expression4();
- Expression4Context* expression4(size_t i);
- std::vector<antlr4::tree::TerminalNode *> SP();
- antlr4::tree::TerminalNode* SP(size_t i);
-
- virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
- virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
-
- virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
-
- };
-
- Expression5Context* expression5();
-
- class Expression4Context : public antlr4::ParserRuleContext {
- public:
- Expression4Context(antlr4::ParserRuleContext *parent, size_t invokingState);
- virtual size_t getRuleIndex() const override;
- Expression3Context *expression3();
- std::vector<antlr4::tree::TerminalNode *> SP();
- antlr4::tree::TerminalNode* SP(size_t i);
-
- virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
- virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
-
- virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
-
- };
-
- Expression4Context* expression4();
-
- class Expression3Context : public antlr4::ParserRuleContext {
- public:
- Expression3Context(antlr4::ParserRuleContext *parent, size_t invokingState);
- virtual size_t getRuleIndex() const override;
- std::vector<Expression2Context *> expression2();
- Expression2Context* expression2(size_t i);
- std::vector<ExpressionContext *> expression();
- ExpressionContext* expression(size_t i);
- std::vector<antlr4::tree::TerminalNode *> SP();
- antlr4::tree::TerminalNode* SP(size_t i);
- std::vector<antlr4::tree::TerminalNode *> IS();
- antlr4::tree::TerminalNode* IS(size_t i);
- std::vector<antlr4::tree::TerminalNode *> CYPHERNULL();
- antlr4::tree::TerminalNode* CYPHERNULL(size_t i);
- std::vector<antlr4::tree::TerminalNode *> NOT();
- antlr4::tree::TerminalNode* NOT(size_t i);
- std::vector<antlr4::tree::TerminalNode *> IN();
- antlr4::tree::TerminalNode* IN(size_t i);
- std::vector<antlr4::tree::TerminalNode *> STARTS();
- antlr4::tree::TerminalNode* STARTS(size_t i);
- std::vector<antlr4::tree::TerminalNode *> WITH();
- antlr4::tree::TerminalNode* WITH(size_t i);
- std::vector<antlr4::tree::TerminalNode *> ENDS();
- antlr4::tree::TerminalNode* ENDS(size_t i);
- std::vector<antlr4::tree::TerminalNode *> CONTAINS();
- antlr4::tree::TerminalNode* CONTAINS(size_t i);
-
- virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
- virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
-
- virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
-
- };
-
- Expression3Context* expression3();
-
- class Expression2Context : public antlr4::ParserRuleContext {
- public:
- Expression2Context(antlr4::ParserRuleContext *parent, size_t invokingState);
- virtual size_t getRuleIndex() const override;
- AtomContext *atom();
- std::vector<PropertyLookupContext *> propertyLookup();
- PropertyLookupContext* propertyLookup(size_t i);
- std::vector<NodeLabelsContext *> nodeLabels();
- NodeLabelsContext* nodeLabels(size_t i);
- std::vector<antlr4::tree::TerminalNode *> SP();
- antlr4::tree::TerminalNode* SP(size_t i);
-
- virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
- virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
-
- virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
-
- };
-
- Expression2Context* expression2();
-
- class AtomContext : public antlr4::ParserRuleContext {
- public:
- AtomContext(antlr4::ParserRuleContext *parent, size_t invokingState);
- virtual size_t getRuleIndex() const override;
- LiteralContext *literal();
- ParameterContext *parameter();
- antlr4::tree::TerminalNode *COUNT();
- std::vector<antlr4::tree::TerminalNode *> SP();
- antlr4::tree::TerminalNode* SP(size_t i);
- ListComprehensionContext *listComprehension();
- PatternComprehensionContext *patternComprehension();
- antlr4::tree::TerminalNode *FILTER();
- FilterExpressionContext *filterExpression();
- antlr4::tree::TerminalNode *EXTRACT();
- ExpressionContext *expression();
- antlr4::tree::TerminalNode *ALL();
- antlr4::tree::TerminalNode *ANY();
- antlr4::tree::TerminalNode *NONE();
- antlr4::tree::TerminalNode *SINGLE();
- RelationshipsPatternContext *relationshipsPattern();
- ParenthesizedExpressionContext *parenthesizedExpression();
- FunctionInvocationContext *functionInvocation();
- VariableContext *variable();
-
- virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
- virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
-
- virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
-
- };
-
- AtomContext* atom();
-
- class LiteralContext : public antlr4::ParserRuleContext {
- public:
- LiteralContext(antlr4::ParserRuleContext *parent, size_t invokingState);
- virtual size_t getRuleIndex() const override;
- NumberLiteralContext *numberLiteral();
- antlr4::tree::TerminalNode *StringLiteral();
- BooleanLiteralContext *booleanLiteral();
- antlr4::tree::TerminalNode *CYPHERNULL();
- MapLiteralContext *mapLiteral();
- ListLiteralContext *listLiteral();
-
- virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
- virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
-
- virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
-
- };
-
- LiteralContext* literal();
-
- class BooleanLiteralContext : public antlr4::ParserRuleContext {
- public:
- BooleanLiteralContext(antlr4::ParserRuleContext *parent, size_t invokingState);
- virtual size_t getRuleIndex() const override;
- antlr4::tree::TerminalNode *TRUE();
- antlr4::tree::TerminalNode *FALSE();
-
- virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
- virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
-
- virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
-
- };
-
- BooleanLiteralContext* booleanLiteral();
-
- class ListLiteralContext : public antlr4::ParserRuleContext {
- public:
- ListLiteralContext(antlr4::ParserRuleContext *parent, size_t invokingState);
- virtual size_t getRuleIndex() const override;
- std::vector<antlr4::tree::TerminalNode *> SP();
- antlr4::tree::TerminalNode* SP(size_t i);
- std::vector<ExpressionContext *> expression();
- ExpressionContext* expression(size_t i);
-
- virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
- virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
-
- virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
-
- };
-
- ListLiteralContext* listLiteral();
-
- class PartialComparisonExpressionContext : public antlr4::ParserRuleContext {
- public:
- PartialComparisonExpressionContext(antlr4::ParserRuleContext *parent, size_t invokingState);
- virtual size_t getRuleIndex() const override;
- Expression7Context *expression7();
- antlr4::tree::TerminalNode *SP();
-
- virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
- virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
-
- virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
-
- };
-
- PartialComparisonExpressionContext* partialComparisonExpression();
-
- class ParenthesizedExpressionContext : public antlr4::ParserRuleContext {
- public:
- ParenthesizedExpressionContext(antlr4::ParserRuleContext *parent, size_t invokingState);
- virtual size_t getRuleIndex() const override;
- ExpressionContext *expression();
- std::vector<antlr4::tree::TerminalNode *> SP();
- antlr4::tree::TerminalNode* SP(size_t i);
-
- virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
- virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
-
- virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
-
- };
-
- ParenthesizedExpressionContext* parenthesizedExpression();
-
- class RelationshipsPatternContext : public antlr4::ParserRuleContext {
- public:
- RelationshipsPatternContext(antlr4::ParserRuleContext *parent, size_t invokingState);
- virtual size_t getRuleIndex() const override;
- NodePatternContext *nodePattern();
- std::vector<PatternElementChainContext *> patternElementChain();
- PatternElementChainContext* patternElementChain(size_t i);
- std::vector<antlr4::tree::TerminalNode *> SP();
- antlr4::tree::TerminalNode* SP(size_t i);
-
- virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
- virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
-
- virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
-
- };
-
- RelationshipsPatternContext* relationshipsPattern();
-
- class FilterExpressionContext : public antlr4::ParserRuleContext {
- public:
- FilterExpressionContext(antlr4::ParserRuleContext *parent, size_t invokingState);
- virtual size_t getRuleIndex() const override;
- IdInCollContext *idInColl();
- WhereContext *where();
- antlr4::tree::TerminalNode *SP();
-
- virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
- virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
-
- virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
-
- };
-
- FilterExpressionContext* filterExpression();
-
- class IdInCollContext : public antlr4::ParserRuleContext {
- public:
- IdInCollContext(antlr4::ParserRuleContext *parent, size_t invokingState);
- virtual size_t getRuleIndex() const override;
- VariableContext *variable();
- std::vector<antlr4::tree::TerminalNode *> SP();
- antlr4::tree::TerminalNode* SP(size_t i);
- antlr4::tree::TerminalNode *IN();
- ExpressionContext *expression();
-
- virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
- virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
-
- virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
-
- };
-
- IdInCollContext* idInColl();
-
- class FunctionInvocationContext : public antlr4::ParserRuleContext {
- public:
- FunctionInvocationContext(antlr4::ParserRuleContext *parent, size_t invokingState);
- virtual size_t getRuleIndex() const override;
- FunctionNameContext *functionName();
- std::vector<antlr4::tree::TerminalNode *> SP();
- antlr4::tree::TerminalNode* SP(size_t i);
- antlr4::tree::TerminalNode *DISTINCT();
- std::vector<ExpressionContext *> expression();
- ExpressionContext* expression(size_t i);
-
- virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
- virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
-
- virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
-
- };
-
- FunctionInvocationContext* functionInvocation();
-
- class FunctionNameContext : public antlr4::ParserRuleContext {
- public:
- FunctionNameContext(antlr4::ParserRuleContext *parent, size_t invokingState);
- virtual size_t getRuleIndex() const override;
- antlr4::tree::TerminalNode *UnescapedSymbolicName();
- antlr4::tree::TerminalNode *EscapedSymbolicName();
- antlr4::tree::TerminalNode *COUNT();
-
- virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
- virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
-
- virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
-
- };
-
- FunctionNameContext* functionName();
-
- class ListComprehensionContext : public antlr4::ParserRuleContext {
- public:
- ListComprehensionContext(antlr4::ParserRuleContext *parent, size_t invokingState);
- virtual size_t getRuleIndex() const override;
- FilterExpressionContext *filterExpression();
- std::vector<antlr4::tree::TerminalNode *> SP();
- antlr4::tree::TerminalNode* SP(size_t i);
- ExpressionContext *expression();
-
- virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
- virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
-
- virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
-
- };
-
- ListComprehensionContext* listComprehension();
-
- class PatternComprehensionContext : public antlr4::ParserRuleContext {
- public:
- PatternComprehensionContext(antlr4::ParserRuleContext *parent, size_t invokingState);
- virtual size_t getRuleIndex() const override;
- RelationshipsPatternContext *relationshipsPattern();
- std::vector<ExpressionContext *> expression();
- ExpressionContext* expression(size_t i);
- std::vector<antlr4::tree::TerminalNode *> SP();
- antlr4::tree::TerminalNode* SP(size_t i);
- VariableContext *variable();
- antlr4::tree::TerminalNode *WHERE();
-
- virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
- virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
-
- virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
-
- };
-
- PatternComprehensionContext* patternComprehension();
-
- class PropertyLookupContext : public antlr4::ParserRuleContext {
- public:
- PropertyLookupContext(antlr4::ParserRuleContext *parent, size_t invokingState);
- virtual size_t getRuleIndex() const override;
- PropertyKeyNameContext *propertyKeyName();
- antlr4::tree::TerminalNode *SP();
-
- virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
- virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
-
- virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
-
- };
-
- PropertyLookupContext* propertyLookup();
-
- class VariableContext : public antlr4::ParserRuleContext {
- public:
- VariableContext(antlr4::ParserRuleContext *parent, size_t invokingState);
- virtual size_t getRuleIndex() const override;
- SymbolicNameContext *symbolicName();
-
- virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
- virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
-
- virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
-
- };
-
- VariableContext* variable();
-
- class NumberLiteralContext : public antlr4::ParserRuleContext {
- public:
- NumberLiteralContext(antlr4::ParserRuleContext *parent, size_t invokingState);
- virtual size_t getRuleIndex() const override;
- DoubleLiteralContext *doubleLiteral();
- IntegerLiteralContext *integerLiteral();
-
- virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
- virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
-
- virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
-
- };
-
- NumberLiteralContext* numberLiteral();
-
- class MapLiteralContext : public antlr4::ParserRuleContext {
- public:
- MapLiteralContext(antlr4::ParserRuleContext *parent, size_t invokingState);
- virtual size_t getRuleIndex() const override;
- std::vector<antlr4::tree::TerminalNode *> SP();
- antlr4::tree::TerminalNode* SP(size_t i);
- std::vector<PropertyKeyNameContext *> propertyKeyName();
- PropertyKeyNameContext* propertyKeyName(size_t i);
- std::vector<ExpressionContext *> expression();
- ExpressionContext* expression(size_t i);
-
- virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
- virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
-
- virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
-
- };
-
- MapLiteralContext* mapLiteral();
-
- class ParameterContext : public antlr4::ParserRuleContext {
- public:
- ParameterContext(antlr4::ParserRuleContext *parent, size_t invokingState);
- virtual size_t getRuleIndex() const override;
- SymbolicNameContext *symbolicName();
- antlr4::tree::TerminalNode *DecimalInteger();
-
- virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
- virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
-
- virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
-
- };
-
- ParameterContext* parameter();
-
- class PropertyExpressionContext : public antlr4::ParserRuleContext {
- public:
- PropertyExpressionContext(antlr4::ParserRuleContext *parent, size_t invokingState);
- virtual size_t getRuleIndex() const override;
- AtomContext *atom();
- std::vector<PropertyLookupContext *> propertyLookup();
- PropertyLookupContext* propertyLookup(size_t i);
- std::vector<antlr4::tree::TerminalNode *> SP();
- antlr4::tree::TerminalNode* SP(size_t i);
-
- virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
- virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
-
- virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
-
- };
-
- PropertyExpressionContext* propertyExpression();
-
- class PropertyKeyNameContext : public antlr4::ParserRuleContext {
- public:
- PropertyKeyNameContext(antlr4::ParserRuleContext *parent, size_t invokingState);
- virtual size_t getRuleIndex() const override;
- SymbolicNameContext *symbolicName();
-
- virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
- virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
-
- virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
-
- };
-
- PropertyKeyNameContext* propertyKeyName();
-
- class IntegerLiteralContext : public antlr4::ParserRuleContext {
- public:
- IntegerLiteralContext(antlr4::ParserRuleContext *parent, size_t invokingState);
- virtual size_t getRuleIndex() const override;
- antlr4::tree::TerminalNode *HexInteger();
- antlr4::tree::TerminalNode *OctalInteger();
- antlr4::tree::TerminalNode *DecimalInteger();
-
- virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
- virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
-
- virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
-
- };
-
- IntegerLiteralContext* integerLiteral();
-
- class DoubleLiteralContext : public antlr4::ParserRuleContext {
- public:
- DoubleLiteralContext(antlr4::ParserRuleContext *parent, size_t invokingState);
- virtual size_t getRuleIndex() const override;
- antlr4::tree::TerminalNode *ExponentDecimalReal();
- antlr4::tree::TerminalNode *RegularDecimalReal();
-
- virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
- virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
-
- virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
-
- };
-
- DoubleLiteralContext* doubleLiteral();
-
- class SymbolicNameContext : public antlr4::ParserRuleContext {
- public:
- SymbolicNameContext(antlr4::ParserRuleContext *parent, size_t invokingState);
- virtual size_t getRuleIndex() const override;
- antlr4::tree::TerminalNode *UnescapedSymbolicName();
- antlr4::tree::TerminalNode *EscapedSymbolicName();
- antlr4::tree::TerminalNode *UNION();
- antlr4::tree::TerminalNode *ALL();
- antlr4::tree::TerminalNode *OPTIONAL();
- antlr4::tree::TerminalNode *MATCH();
- antlr4::tree::TerminalNode *UNWIND();
- antlr4::tree::TerminalNode *AS();
- antlr4::tree::TerminalNode *MERGE();
- antlr4::tree::TerminalNode *ON();
- antlr4::tree::TerminalNode *CREATE();
- antlr4::tree::TerminalNode *SET();
- antlr4::tree::TerminalNode *DETACH();
- antlr4::tree::TerminalNode *DELETE();
- antlr4::tree::TerminalNode *REMOVE();
- antlr4::tree::TerminalNode *WITH();
- antlr4::tree::TerminalNode *DISTINCT();
- antlr4::tree::TerminalNode *RETURN();
- antlr4::tree::TerminalNode *ORDER();
- antlr4::tree::TerminalNode *BY();
- antlr4::tree::TerminalNode *L_SKIP();
- antlr4::tree::TerminalNode *LIMIT();
- antlr4::tree::TerminalNode *ASCENDING();
- antlr4::tree::TerminalNode *ASC();
- antlr4::tree::TerminalNode *DESCENDING();
- antlr4::tree::TerminalNode *DESC();
- antlr4::tree::TerminalNode *WHERE();
- antlr4::tree::TerminalNode *OR();
- antlr4::tree::TerminalNode *XOR();
- antlr4::tree::TerminalNode *AND();
- antlr4::tree::TerminalNode *NOT();
- antlr4::tree::TerminalNode *IN();
- antlr4::tree::TerminalNode *STARTS();
- antlr4::tree::TerminalNode *ENDS();
- antlr4::tree::TerminalNode *CONTAINS();
- antlr4::tree::TerminalNode *IS();
- antlr4::tree::TerminalNode *CYPHERNULL();
- antlr4::tree::TerminalNode *COUNT();
- antlr4::tree::TerminalNode *FILTER();
- antlr4::tree::TerminalNode *EXTRACT();
- antlr4::tree::TerminalNode *ANY();
- antlr4::tree::TerminalNode *NONE();
- antlr4::tree::TerminalNode *SINGLE();
- antlr4::tree::TerminalNode *TRUE();
- antlr4::tree::TerminalNode *FALSE();
- antlr4::tree::TerminalNode *HexLetter();
-
- virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
- virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
-
- virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
-
- };
-
- SymbolicNameContext* symbolicName();
-
- class LeftArrowHeadContext : public antlr4::ParserRuleContext {
- public:
- LeftArrowHeadContext(antlr4::ParserRuleContext *parent, size_t invokingState);
- virtual size_t getRuleIndex() const override;
-
- virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
- virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
-
- virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
-
- };
-
- LeftArrowHeadContext* leftArrowHead();
-
- class RightArrowHeadContext : public antlr4::ParserRuleContext {
- public:
- RightArrowHeadContext(antlr4::ParserRuleContext *parent, size_t invokingState);
- virtual size_t getRuleIndex() const override;
-
- virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
- virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
-
- virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
-
- };
-
- RightArrowHeadContext* rightArrowHead();
-
- class DashContext : public antlr4::ParserRuleContext {
- public:
- DashContext(antlr4::ParserRuleContext *parent, size_t invokingState);
- virtual size_t getRuleIndex() const override;
-
- virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
- virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
-
- virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
-
- };
-
- DashContext* dash();
-
-
-private:
- static std::vector<antlr4::dfa::DFA> _decisionToDFA;
- static antlr4::atn::PredictionContextCache _sharedContextCache;
- static std::vector<std::string> _ruleNames;
- static std::vector<std::string> _tokenNames;
-
- static std::vector<std::string> _literalNames;
- static std::vector<std::string> _symbolicNames;
- static antlr4::dfa::Vocabulary _vocabulary;
- static antlr4::atn::ATN _atn;
- static std::vector<uint16_t> _serializedATN;
-
-
- struct Initializer {
- Initializer();
- };
- static Initializer _init;
-};
-
-} // namespace antlropencypher
diff --git a/src/query/frontend/opencypher/generated/CypherVisitor.cpp b/src/query/frontend/opencypher/generated/CypherVisitor.cpp
deleted file mode 100644
index 085ce56dd..000000000
--- a/src/query/frontend/opencypher/generated/CypherVisitor.cpp
+++ /dev/null
@@ -1,9 +0,0 @@
-
-// Generated from /home/mislav/code/memgraph/memgraph/src/query/frontend/opencypher/grammar/Cypher.g4 by ANTLR 4.6
-
-
-#include "CypherVisitor.h"
-
-
-using namespace antlropencypher;
-
diff --git a/src/query/frontend/opencypher/generated/CypherVisitor.h b/src/query/frontend/opencypher/generated/CypherVisitor.h
deleted file mode 100644
index 80936bedf..000000000
--- a/src/query/frontend/opencypher/generated/CypherVisitor.h
+++ /dev/null
@@ -1,186 +0,0 @@
-
-// Generated from /home/mislav/code/memgraph/memgraph/src/query/frontend/opencypher/grammar/Cypher.g4 by ANTLR 4.6
-
-#pragma once
-
-
-#include "antlr4-runtime.h"
-#include "CypherParser.h"
-
-
-namespace antlropencypher {
-
-/**
- * This class defines an abstract visitor for a parse tree
- * produced by CypherParser.
- */
-class CypherVisitor : public antlr4::tree::AbstractParseTreeVisitor {
-public:
-
- /**
- * Visit parse trees produced by CypherParser.
- */
- virtual antlrcpp::Any visitCypher(CypherParser::CypherContext *context) = 0;
-
- virtual antlrcpp::Any visitStatement(CypherParser::StatementContext *context) = 0;
-
- virtual antlrcpp::Any visitQuery(CypherParser::QueryContext *context) = 0;
-
- virtual antlrcpp::Any visitRegularQuery(CypherParser::RegularQueryContext *context) = 0;
-
- virtual antlrcpp::Any visitSingleQuery(CypherParser::SingleQueryContext *context) = 0;
-
- virtual antlrcpp::Any visitCypherUnion(CypherParser::CypherUnionContext *context) = 0;
-
- virtual antlrcpp::Any visitClause(CypherParser::ClauseContext *context) = 0;
-
- virtual antlrcpp::Any visitCypherMatch(CypherParser::CypherMatchContext *context) = 0;
-
- virtual antlrcpp::Any visitUnwind(CypherParser::UnwindContext *context) = 0;
-
- virtual antlrcpp::Any visitMerge(CypherParser::MergeContext *context) = 0;
-
- virtual antlrcpp::Any visitMergeAction(CypherParser::MergeActionContext *context) = 0;
-
- virtual antlrcpp::Any visitCreate(CypherParser::CreateContext *context) = 0;
-
- virtual antlrcpp::Any visitSet(CypherParser::SetContext *context) = 0;
-
- virtual antlrcpp::Any visitSetItem(CypherParser::SetItemContext *context) = 0;
-
- virtual antlrcpp::Any visitCypherDelete(CypherParser::CypherDeleteContext *context) = 0;
-
- virtual antlrcpp::Any visitRemove(CypherParser::RemoveContext *context) = 0;
-
- virtual antlrcpp::Any visitRemoveItem(CypherParser::RemoveItemContext *context) = 0;
-
- virtual antlrcpp::Any visitWith(CypherParser::WithContext *context) = 0;
-
- virtual antlrcpp::Any visitCypherReturn(CypherParser::CypherReturnContext *context) = 0;
-
- virtual antlrcpp::Any visitReturnBody(CypherParser::ReturnBodyContext *context) = 0;
-
- virtual antlrcpp::Any visitReturnItems(CypherParser::ReturnItemsContext *context) = 0;
-
- virtual antlrcpp::Any visitReturnItem(CypherParser::ReturnItemContext *context) = 0;
-
- virtual antlrcpp::Any visitOrder(CypherParser::OrderContext *context) = 0;
-
- virtual antlrcpp::Any visitSkip(CypherParser::SkipContext *context) = 0;
-
- virtual antlrcpp::Any visitLimit(CypherParser::LimitContext *context) = 0;
-
- virtual antlrcpp::Any visitSortItem(CypherParser::SortItemContext *context) = 0;
-
- virtual antlrcpp::Any visitWhere(CypherParser::WhereContext *context) = 0;
-
- virtual antlrcpp::Any visitPattern(CypherParser::PatternContext *context) = 0;
-
- virtual antlrcpp::Any visitPatternPart(CypherParser::PatternPartContext *context) = 0;
-
- virtual antlrcpp::Any visitAnonymousPatternPart(CypherParser::AnonymousPatternPartContext *context) = 0;
-
- virtual antlrcpp::Any visitPatternElement(CypherParser::PatternElementContext *context) = 0;
-
- virtual antlrcpp::Any visitNodePattern(CypherParser::NodePatternContext *context) = 0;
-
- virtual antlrcpp::Any visitPatternElementChain(CypherParser::PatternElementChainContext *context) = 0;
-
- virtual antlrcpp::Any visitRelationshipPattern(CypherParser::RelationshipPatternContext *context) = 0;
-
- virtual antlrcpp::Any visitRelationshipDetail(CypherParser::RelationshipDetailContext *context) = 0;
-
- virtual antlrcpp::Any visitProperties(CypherParser::PropertiesContext *context) = 0;
-
- virtual antlrcpp::Any visitRelationshipTypes(CypherParser::RelationshipTypesContext *context) = 0;
-
- virtual antlrcpp::Any visitNodeLabels(CypherParser::NodeLabelsContext *context) = 0;
-
- virtual antlrcpp::Any visitNodeLabel(CypherParser::NodeLabelContext *context) = 0;
-
- virtual antlrcpp::Any visitRangeLiteral(CypherParser::RangeLiteralContext *context) = 0;
-
- virtual antlrcpp::Any visitLabelName(CypherParser::LabelNameContext *context) = 0;
-
- virtual antlrcpp::Any visitRelTypeName(CypherParser::RelTypeNameContext *context) = 0;
-
- virtual antlrcpp::Any visitExpression(CypherParser::ExpressionContext *context) = 0;
-
- virtual antlrcpp::Any visitExpression12(CypherParser::Expression12Context *context) = 0;
-
- virtual antlrcpp::Any visitExpression11(CypherParser::Expression11Context *context) = 0;
-
- virtual antlrcpp::Any visitExpression10(CypherParser::Expression10Context *context) = 0;
-
- virtual antlrcpp::Any visitExpression9(CypherParser::Expression9Context *context) = 0;
-
- virtual antlrcpp::Any visitExpression8(CypherParser::Expression8Context *context) = 0;
-
- virtual antlrcpp::Any visitExpression7(CypherParser::Expression7Context *context) = 0;
-
- virtual antlrcpp::Any visitExpression6(CypherParser::Expression6Context *context) = 0;
-
- virtual antlrcpp::Any visitExpression5(CypherParser::Expression5Context *context) = 0;
-
- virtual antlrcpp::Any visitExpression4(CypherParser::Expression4Context *context) = 0;
-
- virtual antlrcpp::Any visitExpression3(CypherParser::Expression3Context *context) = 0;
-
- virtual antlrcpp::Any visitExpression2(CypherParser::Expression2Context *context) = 0;
-
- virtual antlrcpp::Any visitAtom(CypherParser::AtomContext *context) = 0;
-
- virtual antlrcpp::Any visitLiteral(CypherParser::LiteralContext *context) = 0;
-
- virtual antlrcpp::Any visitBooleanLiteral(CypherParser::BooleanLiteralContext *context) = 0;
-
- virtual antlrcpp::Any visitListLiteral(CypherParser::ListLiteralContext *context) = 0;
-
- virtual antlrcpp::Any visitPartialComparisonExpression(CypherParser::PartialComparisonExpressionContext *context) = 0;
-
- virtual antlrcpp::Any visitParenthesizedExpression(CypherParser::ParenthesizedExpressionContext *context) = 0;
-
- virtual antlrcpp::Any visitRelationshipsPattern(CypherParser::RelationshipsPatternContext *context) = 0;
-
- virtual antlrcpp::Any visitFilterExpression(CypherParser::FilterExpressionContext *context) = 0;
-
- virtual antlrcpp::Any visitIdInColl(CypherParser::IdInCollContext *context) = 0;
-
- virtual antlrcpp::Any visitFunctionInvocation(CypherParser::FunctionInvocationContext *context) = 0;
-
- virtual antlrcpp::Any visitFunctionName(CypherParser::FunctionNameContext *context) = 0;
-
- virtual antlrcpp::Any visitListComprehension(CypherParser::ListComprehensionContext *context) = 0;
-
- virtual antlrcpp::Any visitPatternComprehension(CypherParser::PatternComprehensionContext *context) = 0;
-
- virtual antlrcpp::Any visitPropertyLookup(CypherParser::PropertyLookupContext *context) = 0;
-
- virtual antlrcpp::Any visitVariable(CypherParser::VariableContext *context) = 0;
-
- virtual antlrcpp::Any visitNumberLiteral(CypherParser::NumberLiteralContext *context) = 0;
-
- virtual antlrcpp::Any visitMapLiteral(CypherParser::MapLiteralContext *context) = 0;
-
- virtual antlrcpp::Any visitParameter(CypherParser::ParameterContext *context) = 0;
-
- virtual antlrcpp::Any visitPropertyExpression(CypherParser::PropertyExpressionContext *context) = 0;
-
- virtual antlrcpp::Any visitPropertyKeyName(CypherParser::PropertyKeyNameContext *context) = 0;
-
- virtual antlrcpp::Any visitIntegerLiteral(CypherParser::IntegerLiteralContext *context) = 0;
-
- virtual antlrcpp::Any visitDoubleLiteral(CypherParser::DoubleLiteralContext *context) = 0;
-
- virtual antlrcpp::Any visitSymbolicName(CypherParser::SymbolicNameContext *context) = 0;
-
- virtual antlrcpp::Any visitLeftArrowHead(CypherParser::LeftArrowHeadContext *context) = 0;
-
- virtual antlrcpp::Any visitRightArrowHead(CypherParser::RightArrowHeadContext *context) = 0;
-
- virtual antlrcpp::Any visitDash(CypherParser::DashContext *context) = 0;
-
-
-};
-
-} // namespace antlropencypher
diff --git a/src/query/frontend/typecheck/typecheck.hpp b/src/query/frontend/typecheck/typecheck.hpp
index 9923e6ee3..0014afc15 100644
--- a/src/query/frontend/typecheck/typecheck.hpp
+++ b/src/query/frontend/typecheck/typecheck.hpp
@@ -1,5 +1,7 @@
#pragma once
+#include <iostream>
+
#include "utils/exceptions/basic_exception.hpp"
#include "query/frontend/ast/ast.hpp"
#include "query/frontend/typecheck/symbol_table.hpp"
@@ -19,6 +21,7 @@ class TypeCheckVisitor : public TreeVisitorBase {
void Visit(NamedExpr& named_expr) override {}
void Visit(Ident& ident) override {
Symbol symbol;
+ std::cout << ident.identifier_ << std::endl;
if (scope_.in_named_expr) {
// TODO: Handle this better, so that the `with` variables aren't
// shadowed.
diff --git a/tests/manual/compiler_prototype.cpp b/tests/manual/compiler_prototype.cpp
index 0763cacc1..256285809 100644
--- a/tests/manual/compiler_prototype.cpp
+++ b/tests/manual/compiler_prototype.cpp
@@ -27,6 +27,11 @@ int main(int argc, char* argv[]) {
// initialize the database
auto dba = dbms.active();
+ // labels
+ auto company = dba.label("Company");
+ auto person = dba.label("Person");
+ auto device = dba.label("Device");
+
// props
auto name = dba.property("name");
auto age = dba.property("age");
@@ -35,18 +40,23 @@ int main(int argc, char* argv[]) {
// vertices
auto memgraph = dba.insert_vertex();
memgraph.PropsSet(name, "Memgraph");
+ memgraph.add_label(company);
auto teon = dba.insert_vertex();
memgraph.PropsSet(name, "Teon");
memgraph.PropsSet(age, 26);
+ teon.add_label(person);
auto mislav = dba.insert_vertex();
memgraph.PropsSet(name, "Mislav");
memgraph.PropsSet(age, 22);
+ mislav.add_label(person);
auto florijan = dba.insert_vertex();
memgraph.PropsSet(name, "Florijan");
memgraph.PropsSet(age, 31);
+ florijan.add_label(person);
auto xps_15 = dba.insert_vertex();
memgraph.PropsSet(type, "PC");
memgraph.PropsSet(name, "Dell XPS 15");
+ xps_15.add_label(device);
// edges
dba.insert_edge(teon, memgraph, dba.edge_type("MEMBER_OF"));
@@ -66,6 +76,8 @@ int main(int argc, char* argv[]) {
dba.insert_edge(mislav, xps_15, dba.edge_type("USES"));
dba.insert_edge(florijan, xps_15, dba.edge_type("USES"));
+ dba.advance_command();
+
cout << "-- Memgraph Query Engine --" << endl;
while (true) {
@@ -75,14 +87,15 @@ int main(int argc, char* argv[]) {
std::getline(cin, command);
if (command == "quit") break;
// execute command / query
- try {
- auto db_accessor = dbms.active();
- query_engine.Execute(command, db_accessor, stream);
- } catch (const std::exception& e) {
- cout << e.what() << endl;
- } catch (...) {
- // pass
- }
+ // try {
+ // auto db_accessor = dbms.active();
+ query_engine.Execute(command, dba, stream);
+ // } catch (const std::exception& e) {
+ // cout << e.what() << endl;
+ // } catch (...) {
+ // // pass
+ // }
+//
}
return 0;