12 files changed, 4214 insertions, 0 deletions
diff --git a/gen/Toc.interp b/gen/Toc.interp
new file mode 100644
index 0000000..f384fe1
--- /dev/null
+++ b/gen/Toc.interp
@@ -0,0 +1,90 @@
+token literal names:
+null
+'var'
+':'
+'='
+'func'
+'('
+')'
+','
+'{'
+'}'
+'struct'
+'if'
+'while'
+'return'
+'['
+']'
+'.'
+null
+null
+null
+null
+null
+
+token symbolic names:
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+BINARY_OPERATOR
+INTLIT
+NAME
+WS
+NEWLINE
+
+rule names:
+prog
+decl
+varDecl
+var
+type
+funcDecl
+func
+parameter
+firstParameter
+additionalParameter
+body
+structDecl
+structMember
+structVar
+structMethod
+stmt
+conditional
+ifCond
+loop
+whileLoop
+assignment
+returnStmt
+expr
+nonOpExpr
+nonSubscriptExpr
+funcCall
+operatorExpr
+binaryOperator
+identifier
+literal
+subscript
+memberAccess
+parenExpr
+funcName
+varName
+typeName
+structName
+
+
+atn:
+[3, 24715, 42794, 33075, 47597, 16764, 15335, 30598, 22884, 3, 23, 257, 4, 2, 9, 2, 4, 3, 9, 3, 4, 4, 9, 4, 4, 5, 9, 5, 4, 6, 9, 6, 4, 7, 9, 7, 4, 8, 9, 8, 4, 9, 9, 9, 4, 10, 9, 10, 4, 11, 9, 11, 4, 12, 9, 12, 4, 13, 9, 13, 4, 14, 9, 14, 4, 15, 9, 15, 4, 16, 9, 16, 4, 17, 9, 17, 4, 18, 9, 18, 4, 19, 9, 19, 4, 20, 9, 20, 4, 21, 9, 21, 4, 22, 9, 22, 4, 23, 9, 23, 4, 24, 9, 24, 4, 25, 9, 25, 4, 26, 9, 26, 4, 27, 9, 27, 4, 28, 9, 28, 4, 29, 9, 29, 4, 30, 9, 30, 4, 31, 9, 31, 4, 32, 9, 32, 4, 33, 9, 33, 4, 34, 9, 34, 4, 35, 9, 35, 4, 36, 9, 36, 4, 37, 9, 37, 4, 38, 9, 38, 3, 2, 6, 2, 78, 10, 2, 13, 2, 14, 2, 79, 3, 2, 3, 2, 3, 3, 3, 3, 3, 3, 5, 3, 87, 10, 3, 3, 4, 3, 4, 3, 4, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 5, 5, 98, 10, 5, 3, 6, 3, 6, 3, 7, 3, 7, 3, 7, 3, 8, 3, 8, 3, 8, 3, 8, 3, 8, 3, 8, 3, 8, 3, 8, 3, 8, 3, 9, 3, 9, 7, 9, 116, 10, 9, 12, 9, 14, 9, 119, 11, 9, 5, 9, 121, 10, 9, 3, 10, 3, 10, 3, 11, 3, 11, 3, 11, 3, 12, 3, 12, 7, 12, 130, 10, 12, 12, 12, 14, 12, 133, 11, 12, 3, 12, 3, 12, 3, 13, 3, 13, 3, 13, 3, 13, 7, 13, 141, 10, 13, 12, 13, 14, 13, 144, 11, 13, 3, 13, 3, 13, 3, 14, 3, 14, 5, 14, 150, 10, 14, 3, 15, 3, 15, 3, 16, 3, 16, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 5, 17, 162, 10, 17, 3, 18, 3, 18, 3, 19, 3, 19, 3, 19, 3, 19, 3, 20, 3, 20, 3, 21, 3, 21, 3, 21, 3, 21, 3, 22, 3, 22, 3, 22, 3, 22, 3, 23, 3, 23, 3, 23, 3, 24, 3, 24, 3, 24, 3, 24, 3, 24, 3, 24, 3, 24, 5, 24, 190, 10, 24, 3, 25, 3, 25, 3, 25, 3, 25, 3, 25, 3, 25, 5, 25, 198, 10, 25, 3, 26, 3, 26, 3, 26, 3, 26, 5, 26, 204, 10, 26, 3, 27, 3, 27, 3, 27, 3, 27, 3, 27, 7, 27, 211, 10, 27, 12, 27, 14, 27, 214, 11, 27, 5, 27, 216, 10, 27, 3, 27, 3, 27, 3, 28, 3, 28, 3, 29, 3, 29, 3, 29, 3, 29, 3, 29, 7, 29, 227, 10, 29, 12, 29, 14, 29, 230, 11, 29, 3, 30, 3, 30, 3, 31, 3, 31, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 33, 3, 33, 3, 33, 3, 33, 3, 34, 3, 34, 3, 34, 3, 34, 3, 35, 3, 35, 3, 36, 3, 36, 3, 37, 3, 37, 3, 38, 3, 38, 3, 38, 2, 2, 39, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 2, 2, 2, 250, 2, 77, 3, 2, 2, 2, 4, 86, 3, 2, 2, 2, 6, 88, 3, 2, 2, 2, 8, 91, 3, 2, 2, 2, 10, 99, 3, 2, 2, 2, 12, 101, 3, 2, 2, 2, 14, 104, 3, 2, 2, 2, 16, 120, 3, 2, 2, 2, 18, 122, 3, 2, 2, 2, 20, 124, 3, 2, 2, 2, 22, 127, 3, 2, 2, 2, 24, 136, 3, 2, 2, 2, 26, 149, 3, 2, 2, 2, 28, 151, 3, 2, 2, 2, 30, 153, 3, 2, 2, 2, 32, 161, 3, 2, 2, 2, 34, 163, 3, 2, 2, 2, 36, 165, 3, 2, 2, 2, 38, 169, 3, 2, 2, 2, 40, 171, 3, 2, 2, 2, 42, 175, 3, 2, 2, 2, 44, 179, 3, 2, 2, 2, 46, 189, 3, 2, 2, 2, 48, 197, 3, 2, 2, 2, 50, 203, 3, 2, 2, 2, 52, 205, 3, 2, 2, 2, 54, 219, 3, 2, 2, 2, 56, 221, 3, 2, 2, 2, 58, 231, 3, 2, 2, 2, 60, 233, 3, 2, 2, 2, 62, 235, 3, 2, 2, 2, 64, 240, 3, 2, 2, 2, 66, 244, 3, 2, 2, 2, 68, 248, 3, 2, 2, 2, 70, 250, 3, 2, 2, 2, 72, 252, 3, 2, 2, 2, 74, 254, 3, 2, 2, 2, 76, 78, 5, 4, 3, 2, 77, 76, 3, 2, 2, 2, 78, 79, 3, 2, 2, 2, 79, 77, 3, 2, 2, 2, 79, 80, 3, 2, 2, 2, 80, 81, 3, 2, 2, 2, 81, 82, 7, 2, 2, 3, 82, 3, 3, 2, 2, 2, 83, 87, 5, 6, 4, 2, 84, 87, 5, 12, 7, 2, 85, 87, 5, 24, 13, 2, 86, 83, 3, 2, 2, 2, 86, 84, 3, 2, 2, 2, 86, 85, 3, 2, 2, 2, 87, 5, 3, 2, 2, 2, 88, 89, 7, 3, 2, 2, 89, 90, 5, 8, 5, 2, 90, 7, 3, 2, 2, 2, 91, 92, 5, 70, 36, 2, 92, 93, 7, 4, 2, 2, 93, 94, 5, 10, 6, 2, 94, 97, 3, 2, 2, 2, 95, 96, 7, 5, 2, 2, 96, 98, 5, 46, 24, 2, 97, 95, 3, 2, 2, 2, 97, 98, 3, 2, 2, 2, 98, 9, 3, 2, 2, 2, 99, 100, 5, 72, 37, 2, 100, 11, 3, 2, 2, 2, 101, 102, 7, 6, 2, 2, 102, 103, 5, 14, 8, 2, 103, 13, 3, 2, 2, 2, 104, 105, 5, 68, 35, 2, 105, 106, 7, 7, 2, 2, 106, 107, 5, 16, 9, 2, 107, 108, 7, 8, 2, 2, 108, 109, 7, 4, 2, 2, 109, 110, 5, 10, 6, 2, 110, 111, 3, 2, 2, 2, 111, 112, 5, 22, 12, 2, 112, 15, 3, 2, 2, 2, 113, 117, 5, 18, 10, 2, 114, 116, 5, 20, 11, 2, 115, 114, 3, 2, 2, 2, 116, 119, 3, 2, 2, 2, 117, 115, 3, 2, 2, 2, 117, 118, 3, 2, 2, 2, 118, 121, 3, 2, 2, 2, 119, 117, 3, 2, 2, 2, 120, 113, 3, 2, 2, 2, 120, 121, 3, 2, 2, 2, 121, 17, 3, 2, 2, 2, 122, 123, 5, 8, 5, 2, 123, 19, 3, 2, 2, 2, 124, 125, 7, 9, 2, 2, 125, 126, 5, 8, 5, 2, 126, 21, 3, 2, 2, 2, 127, 131, 7, 10, 2, 2, 128, 130, 5, 32, 17, 2, 129, 128, 3, 2, 2, 2, 130, 133, 3, 2, 2, 2, 131, 129, 3, 2, 2, 2, 131, 132, 3, 2, 2, 2, 132, 134, 3, 2, 2, 2, 133, 131, 3, 2, 2, 2, 134, 135, 7, 11, 2, 2, 135, 23, 3, 2, 2, 2, 136, 137, 7, 12, 2, 2, 137, 138, 5, 74, 38, 2, 138, 142, 7, 10, 2, 2, 139, 141, 5, 26, 14, 2, 140, 139, 3, 2, 2, 2, 141, 144, 3, 2, 2, 2, 142, 140, 3, 2, 2, 2, 142, 143, 3, 2, 2, 2, 143, 145, 3, 2, 2, 2, 144, 142, 3, 2, 2, 2, 145, 146, 7, 11, 2, 2, 146, 25, 3, 2, 2, 2, 147, 150, 5, 28, 15, 2, 148, 150, 5, 30, 16, 2, 149, 147, 3, 2, 2, 2, 149, 148, 3, 2, 2, 2, 150, 27, 3, 2, 2, 2, 151, 152, 5, 8, 5, 2, 152, 29, 3, 2, 2, 2, 153, 154, 5, 14, 8, 2, 154, 31, 3, 2, 2, 2, 155, 162, 5, 6, 4, 2, 156, 162, 5, 34, 18, 2, 157, 162, 5, 38, 20, 2, 158, 162, 5, 42, 22, 2, 159, 162, 5, 44, 23, 2, 160, 162, 5, 46, 24, 2, 161, 155, 3, 2, 2, 2, 161, 156, 3, 2, 2, 2, 161, 157, 3, 2, 2, 2, 161, 158, 3, 2, 2, 2, 161, 159, 3, 2, 2, 2, 161, 160, 3, 2, 2, 2, 162, 33, 3, 2, 2, 2, 163, 164, 5, 36, 19, 2, 164, 35, 3, 2, 2, 2, 165, 166, 7, 13, 2, 2, 166, 167, 5, 46, 24, 2, 167, 168, 5, 22, 12, 2, 168, 37, 3, 2, 2, 2, 169, 170, 5, 40, 21, 2, 170, 39, 3, 2, 2, 2, 171, 172, 7, 14, 2, 2, 172, 173, 5, 46, 24, 2, 173, 174, 5, 22, 12, 2, 174, 41, 3, 2, 2, 2, 175, 176, 5, 58, 30, 2, 176, 177, 7, 5, 2, 2, 177, 178, 5, 46, 24, 2, 178, 43, 3, 2, 2, 2, 179, 180, 7, 15, 2, 2, 180, 181, 5, 46, 24, 2, 181, 45, 3, 2, 2, 2, 182, 190, 5, 52, 27, 2, 183, 190, 5, 60, 31, 2, 184, 190, 5, 58, 30, 2, 185, 190, 5, 62, 32, 2, 186, 190, 5, 64, 33, 2, 187, 190, 5, 66, 34, 2, 188, 190, 5, 54, 28, 2, 189, 182, 3, 2, 2, 2, 189, 183, 3, 2, 2, 2, 189, 184, 3, 2, 2, 2, 189, 185, 3, 2, 2, 2, 189, 186, 3, 2, 2, 2, 189, 187, 3, 2, 2, 2, 189, 188, 3, 2, 2, 2, 190, 47, 3, 2, 2, 2, 191, 198, 5, 52, 27, 2, 192, 198, 5, 60, 31, 2, 193, 198, 5, 58, 30, 2, 194, 198, 5, 62, 32, 2, 195, 198, 5, 64, 33, 2, 196, 198, 5, 66, 34, 2, 197, 191, 3, 2, 2, 2, 197, 192, 3, 2, 2, 2, 197, 193, 3, 2, 2, 2, 197, 194, 3, 2, 2, 2, 197, 195, 3, 2, 2, 2, 197, 196, 3, 2, 2, 2, 198, 49, 3, 2, 2, 2, 199, 204, 5, 52, 27, 2, 200, 204, 5, 58, 30, 2, 201, 204, 5, 64, 33, 2, 202, 204, 5, 66, 34, 2, 203, 199, 3, 2, 2, 2, 203, 200, 3, 2, 2, 2, 203, 201, 3, 2, 2, 2, 203, 202, 3, 2, 2, 2, 204, 51, 3, 2, 2, 2, 205, 206, 5, 68, 35, 2, 206, 215, 7, 7, 2, 2, 207, 212, 5, 46, 24, 2, 208, 209, 7, 9, 2, 2, 209, 211, 5, 46, 24, 2, 210, 208, 3, 2, 2, 2, 211, 214, 3, 2, 2, 2, 212, 210, 3, 2, 2, 2, 212, 213, 3, 2, 2, 2, 213, 216, 3, 2, 2, 2, 214, 212, 3, 2, 2, 2, 215, 207, 3, 2, 2, 2, 215, 216, 3, 2, 2, 2, 216, 217, 3, 2, 2, 2, 217, 218, 7, 8, 2, 2, 218, 53, 3, 2, 2, 2, 219, 220, 5, 56, 29, 2, 220, 55, 3, 2, 2, 2, 221, 222, 5, 48, 25, 2, 222, 223, 7, 19, 2, 2, 223, 228, 5, 48, 25, 2, 224, 225, 7, 19, 2, 2, 225, 227, 5, 48, 25, 2, 226, 224, 3, 2, 2, 2, 227, 230, 3, 2, 2, 2, 228, 226, 3, 2, 2, 2, 228, 229, 3, 2, 2, 2, 229, 57, 3, 2, 2, 2, 230, 228, 3, 2, 2, 2, 231, 232, 5, 70, 36, 2, 232, 59, 3, 2, 2, 2, 233, 234, 7, 20, 2, 2, 234, 61, 3, 2, 2, 2, 235, 236, 5, 50, 26, 2, 236, 237, 7, 16, 2, 2, 237, 238, 5, 46, 24, 2, 238, 239, 7, 17, 2, 2, 239, 63, 3, 2, 2, 2, 240, 241, 5, 58, 30, 2, 241, 242, 7, 18, 2, 2, 242, 243, 5, 58, 30, 2, 243, 65, 3, 2, 2, 2, 244, 245, 7, 7, 2, 2, 245, 246, 5, 46, 24, 2, 246, 247, 7, 8, 2, 2, 247, 67, 3, 2, 2, 2, 248, 249, 7, 21, 2, 2, 249, 69, 3, 2, 2, 2, 250, 251, 7, 21, 2, 2, 251, 71, 3, 2, 2, 2, 252, 253, 7, 21, 2, 2, 253, 73, 3, 2, 2, 2, 254, 255, 7, 21, 2, 2, 255, 75, 3, 2, 2, 2, 17, 79, 86, 97, 117, 120, 131, 142, 149, 161, 189, 197, 203, 212, 215, 228]
+\ No newline at end of file
diff --git a/gen/Toc.tokens b/gen/Toc.tokens
new file mode 100644
index 0000000..980b6cf
--- /dev/null
+++ b/gen/Toc.tokens
@@ -0,0 +1,37 @@
+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
+BINARY_OPERATOR=17
+INTLIT=18
+NAME=19
+WS=20
+NEWLINE=21
+'var'=1
+':'=2
+'='=3
+'func'=4
+'('=5
+')'=6
+','=7
+'{'=8
+'}'=9
+'struct'=10
+'if'=11
+'while'=12
+'return'=13
+'['=14
+']'=15
+'.'=16
diff --git a/gen/TocBaseListener.cpp b/gen/TocBaseListener.cpp
new file mode 100644
index 0000000..b0952f9
--- /dev/null
+++ b/gen/TocBaseListener.cpp
@@ -0,0 +1,7 @@
+
+// Generated from Toc.g4 by ANTLR 4.9.2
+
+
+#include "TocBaseListener.h"
+
+
diff --git a/gen/TocBaseListener.h b/gen/TocBaseListener.h
new file mode 100644
index 0000000..f2439fb
--- /dev/null
+++ b/gen/TocBaseListener.h
@@ -0,0 +1,137 @@
+
+// Generated from Toc.g4 by ANTLR 4.9.2
+
+#pragma once
+
+
+#include "antlr4-runtime.h"
+#include "TocListener.h"
+
+
+/**
+ * This class provides an empty implementation of TocListener,
+ * which can be extended to create a listener which only needs to handle a subset
+ * of the available methods.
+ */
+class  TocBaseListener : public TocListener {
+public:
+
+  virtual void enterProg(TocParser::ProgContext * /*ctx*/) override { }
+  virtual void exitProg(TocParser::ProgContext * /*ctx*/) override { }
+
+  virtual void enterDecl(TocParser::DeclContext * /*ctx*/) override { }
+  virtual void exitDecl(TocParser::DeclContext * /*ctx*/) override { }
+
+  virtual void enterVarDecl(TocParser::VarDeclContext * /*ctx*/) override { }
+  virtual void exitVarDecl(TocParser::VarDeclContext * /*ctx*/) override { }
+
+  virtual void enterVar(TocParser::VarContext * /*ctx*/) override { }
+  virtual void exitVar(TocParser::VarContext * /*ctx*/) override { }
+
+  virtual void enterType(TocParser::TypeContext * /*ctx*/) override { }
+  virtual void exitType(TocParser::TypeContext * /*ctx*/) override { }
+
+  virtual void enterFuncDecl(TocParser::FuncDeclContext * /*ctx*/) override { }
+  virtual void exitFuncDecl(TocParser::FuncDeclContext * /*ctx*/) override { }
+
+  virtual void enterFunc(TocParser::FuncContext * /*ctx*/) override { }
+  virtual void exitFunc(TocParser::FuncContext * /*ctx*/) override { }
+
+  virtual void enterParameter(TocParser::ParameterContext * /*ctx*/) override { }
+  virtual void exitParameter(TocParser::ParameterContext * /*ctx*/) override { }
+
+  virtual void enterFirstParameter(TocParser::FirstParameterContext * /*ctx*/) override { }
+  virtual void exitFirstParameter(TocParser::FirstParameterContext * /*ctx*/) override { }
+
+  virtual void enterAdditionalParameter(TocParser::AdditionalParameterContext * /*ctx*/) override { }
+  virtual void exitAdditionalParameter(TocParser::AdditionalParameterContext * /*ctx*/) override { }
+
+  virtual void enterBody(TocParser::BodyContext * /*ctx*/) override { }
+  virtual void exitBody(TocParser::BodyContext * /*ctx*/) override { }
+
+  virtual void enterStructDecl(TocParser::StructDeclContext * /*ctx*/) override { }
+  virtual void exitStructDecl(TocParser::StructDeclContext * /*ctx*/) override { }
+
+  virtual void enterStructMember(TocParser::StructMemberContext * /*ctx*/) override { }
+  virtual void exitStructMember(TocParser::StructMemberContext * /*ctx*/) override { }
+
+  virtual void enterStructVar(TocParser::StructVarContext * /*ctx*/) override { }
+  virtual void exitStructVar(TocParser::StructVarContext * /*ctx*/) override { }
+
+  virtual void enterStructMethod(TocParser::StructMethodContext * /*ctx*/) override { }
+  virtual void exitStructMethod(TocParser::StructMethodContext * /*ctx*/) override { }
+
+  virtual void enterStmt(TocParser::StmtContext * /*ctx*/) override { }
+  virtual void exitStmt(TocParser::StmtContext * /*ctx*/) override { }
+
+  virtual void enterConditional(TocParser::ConditionalContext * /*ctx*/) override { }
+  virtual void exitConditional(TocParser::ConditionalContext * /*ctx*/) override { }
+
+  virtual void enterIfCond(TocParser::IfCondContext * /*ctx*/) override { }
+  virtual void exitIfCond(TocParser::IfCondContext * /*ctx*/) override { }
+
+  virtual void enterLoop(TocParser::LoopContext * /*ctx*/) override { }
+  virtual void exitLoop(TocParser::LoopContext * /*ctx*/) override { }
+
+  virtual void enterWhileLoop(TocParser::WhileLoopContext * /*ctx*/) override { }
+  virtual void exitWhileLoop(TocParser::WhileLoopContext * /*ctx*/) override { }
+
+  virtual void enterAssignment(TocParser::AssignmentContext * /*ctx*/) override { }
+  virtual void exitAssignment(TocParser::AssignmentContext * /*ctx*/) override { }
+
+  virtual void enterReturnStmt(TocParser::ReturnStmtContext * /*ctx*/) override { }
+  virtual void exitReturnStmt(TocParser::ReturnStmtContext * /*ctx*/) override { }
+
+  virtual void enterExpr(TocParser::ExprContext * /*ctx*/) override { }
+  virtual void exitExpr(TocParser::ExprContext * /*ctx*/) override { }
+
+  virtual void enterNonOpExpr(TocParser::NonOpExprContext * /*ctx*/) override { }
+  virtual void exitNonOpExpr(TocParser::NonOpExprContext * /*ctx*/) override { }
+
+  virtual void enterNonSubscriptExpr(TocParser::NonSubscriptExprContext * /*ctx*/) override { }
+  virtual void exitNonSubscriptExpr(TocParser::NonSubscriptExprContext * /*ctx*/) override { }
+
+  virtual void enterFuncCall(TocParser::FuncCallContext * /*ctx*/) override { }
+  virtual void exitFuncCall(TocParser::FuncCallContext * /*ctx*/) override { }
+
+  virtual void enterOperatorExpr(TocParser::OperatorExprContext * /*ctx*/) override { }
+  virtual void exitOperatorExpr(TocParser::OperatorExprContext * /*ctx*/) override { }
+
+  virtual void enterBinaryOperator(TocParser::BinaryOperatorContext * /*ctx*/) override { }
+  virtual void exitBinaryOperator(TocParser::BinaryOperatorContext * /*ctx*/) override { }
+
+  virtual void enterIdentifier(TocParser::IdentifierContext * /*ctx*/) override { }
+  virtual void exitIdentifier(TocParser::IdentifierContext * /*ctx*/) override { }
+
+  virtual void enterLiteral(TocParser::LiteralContext * /*ctx*/) override { }
+  virtual void exitLiteral(TocParser::LiteralContext * /*ctx*/) override { }
+
+  virtual void enterSubscript(TocParser::SubscriptContext * /*ctx*/) override { }
+  virtual void exitSubscript(TocParser::SubscriptContext * /*ctx*/) override { }
+
+  virtual void enterMemberAccess(TocParser::MemberAccessContext * /*ctx*/) override { }
+  virtual void exitMemberAccess(TocParser::MemberAccessContext * /*ctx*/) override { }
+
+  virtual void enterParenExpr(TocParser::ParenExprContext * /*ctx*/) override { }
+  virtual void exitParenExpr(TocParser::ParenExprContext * /*ctx*/) override { }
+
+  virtual void enterFuncName(TocParser::FuncNameContext * /*ctx*/) override { }
+  virtual void exitFuncName(TocParser::FuncNameContext * /*ctx*/) override { }
+
+  virtual void enterVarName(TocParser::VarNameContext * /*ctx*/) override { }
+  virtual void exitVarName(TocParser::VarNameContext * /*ctx*/) override { }
+
+  virtual void enterTypeName(TocParser::TypeNameContext * /*ctx*/) override { }
+  virtual void exitTypeName(TocParser::TypeNameContext * /*ctx*/) override { }
+
+  virtual void enterStructName(TocParser::StructNameContext * /*ctx*/) override { }
+  virtual void exitStructName(TocParser::StructNameContext * /*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 { }
+
+};
+
diff --git a/gen/TocLexer.cpp b/gen/TocLexer.cpp
new file mode 100644
index 0000000..5e7a299
--- /dev/null
+++ b/gen/TocLexer.cpp
@@ -0,0 +1,218 @@
+
+// Generated from Toc.g4 by ANTLR 4.9.2
+
+
+#include "TocLexer.h"
+
+
+using namespace antlr4;
+
+
+TocLexer::TocLexer(CharStream *input) : Lexer(input) {
+  _interpreter = new atn::LexerATNSimulator(this, _atn, _decisionToDFA, _sharedContextCache);
+}
+
+TocLexer::~TocLexer() {
+  delete _interpreter;
+}
+
+std::string TocLexer::getGrammarFileName() const {
+  return "Toc.g4";
+}
+
+const std::vector<std::string>& TocLexer::getRuleNames() const {
+  return _ruleNames;
+}
+
+const std::vector<std::string>& TocLexer::getChannelNames() const {
+  return _channelNames;
+}
+
+const std::vector<std::string>& TocLexer::getModeNames() const {
+  return _modeNames;
+}
+
+const std::vector<std::string>& TocLexer::getTokenNames() const {
+  return _tokenNames;
+}
+
+dfa::Vocabulary& TocLexer::getVocabulary() const {
+  return _vocabulary;
+}
+
+const std::vector<uint16_t> TocLexer::getSerializedATN() const {
+  return _serializedATN;
+}
+
+const atn::ATN& TocLexer::getATN() const {
+  return _atn;
+}
+
+
+
+
+// Static vars and initialization.
+std::vector<dfa::DFA> TocLexer::_decisionToDFA;
+atn::PredictionContextCache TocLexer::_sharedContextCache;
+
+// We own the ATN which in turn owns the ATN states.
+atn::ATN TocLexer::_atn;
+std::vector<uint16_t> TocLexer::_serializedATN;
+
+std::vector<std::string> TocLexer::_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", "BINARY_OPERATOR", 
+  "INTLIT", "NAME", "WS", "NEWLINE"
+};
+
+std::vector<std::string> TocLexer::_channelNames = {
+  "DEFAULT_TOKEN_CHANNEL", "HIDDEN"
+};
+
+std::vector<std::string> TocLexer::_modeNames = {
+  "DEFAULT_MODE"
+};
+
+std::vector<std::string> TocLexer::_literalNames = {
+  "", "'var'", "':'", "'='", "'func'", "'('", "')'", "','", "'{'", "'}'", 
+  "'struct'", "'if'", "'while'", "'return'", "'['", "']'", "'.'"
+};
+
+std::vector<std::string> TocLexer::_symbolicNames = {
+  "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "BINARY_OPERATOR", 
+  "INTLIT", "NAME", "WS", "NEWLINE"
+};
+
+dfa::Vocabulary TocLexer::_vocabulary(_literalNames, _symbolicNames);
+
+std::vector<std::string> TocLexer::_tokenNames;
+
+TocLexer::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);
+    }
+	}
+
+  static const uint16_t serializedATNSegment0[] = {
+    0x3, 0x608b, 0xa72a, 0x8133, 0xb9ed, 0x417c, 0x3be7, 0x7786, 0x5964, 
+       0x2, 0x17, 0x82, 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, 
+       0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x3, 0x3, 0x3, 0x3, 
+       0x4, 0x3, 0x4, 0x3, 0x5, 0x3, 0x5, 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, 0xb, 
+       0x3, 0xb, 0x3, 0xb, 0x3, 0xb, 0x3, 0xb, 0x3, 0xc, 0x3, 0xc, 0x3, 
+       0xc, 0x3, 0xd, 0x3, 0xd, 0x3, 0xd, 0x3, 0xd, 0x3, 0xd, 0x3, 0xd, 
+       0x3, 0xe, 0x3, 0xe, 0x3, 0xe, 0x3, 0xe, 0x3, 0xe, 0x3, 0xe, 0x3, 
+       0xe, 0x3, 0xf, 0x3, 0xf, 0x3, 0x10, 0x3, 0x10, 0x3, 0x11, 0x3, 0x11, 
+       0x3, 0x12, 0x3, 0x12, 0x3, 0x12, 0x3, 0x12, 0x3, 0x12, 0x3, 0x12, 
+       0x5, 0x12, 0x68, 0xa, 0x12, 0x3, 0x13, 0x5, 0x13, 0x6b, 0xa, 0x13, 
+       0x3, 0x13, 0x6, 0x13, 0x6e, 0xa, 0x13, 0xd, 0x13, 0xe, 0x13, 0x6f, 
+       0x3, 0x14, 0x6, 0x14, 0x73, 0xa, 0x14, 0xd, 0x14, 0xe, 0x14, 0x74, 
+       0x3, 0x15, 0x6, 0x15, 0x78, 0xa, 0x15, 0xd, 0x15, 0xe, 0x15, 0x79, 
+       0x3, 0x15, 0x3, 0x15, 0x3, 0x16, 0x6, 0x16, 0x7f, 0xa, 0x16, 0xd, 
+       0x16, 0xe, 0x16, 0x80, 0x2, 0x2, 0x17, 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, 
+       0x3, 0x2, 0x9, 0x5, 0x2, 0x2c, 0x2d, 0x2f, 0x2f, 0x31, 0x31, 0x4, 
+       0x2, 0x3e, 0x3e, 0x40, 0x40, 0x4, 0x2, 0x2d, 0x2d, 0x2f, 0x2f, 0x3, 
+       0x2, 0x32, 0x3b, 0x5, 0x2, 0x32, 0x3b, 0x43, 0x5c, 0x63, 0x7c, 0x5, 
+       0x2, 0xb, 0xc, 0xf, 0xf, 0x22, 0x22, 0x4, 0x2, 0xc, 0xc, 0xf, 0xf, 
+       0x2, 0x89, 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, 0x3, 0x2d, 
+       0x3, 0x2, 0x2, 0x2, 0x5, 0x31, 0x3, 0x2, 0x2, 0x2, 0x7, 0x33, 0x3, 
+       0x2, 0x2, 0x2, 0x9, 0x35, 0x3, 0x2, 0x2, 0x2, 0xb, 0x3a, 0x3, 0x2, 
+       0x2, 0x2, 0xd, 0x3c, 0x3, 0x2, 0x2, 0x2, 0xf, 0x3e, 0x3, 0x2, 0x2, 
+       0x2, 0x11, 0x40, 0x3, 0x2, 0x2, 0x2, 0x13, 0x42, 0x3, 0x2, 0x2, 0x2, 
+       0x15, 0x44, 0x3, 0x2, 0x2, 0x2, 0x17, 0x4b, 0x3, 0x2, 0x2, 0x2, 0x19, 
+       0x4e, 0x3, 0x2, 0x2, 0x2, 0x1b, 0x54, 0x3, 0x2, 0x2, 0x2, 0x1d, 0x5b, 
+       0x3, 0x2, 0x2, 0x2, 0x1f, 0x5d, 0x3, 0x2, 0x2, 0x2, 0x21, 0x5f, 0x3, 
+       0x2, 0x2, 0x2, 0x23, 0x67, 0x3, 0x2, 0x2, 0x2, 0x25, 0x6a, 0x3, 0x2, 
+       0x2, 0x2, 0x27, 0x72, 0x3, 0x2, 0x2, 0x2, 0x29, 0x77, 0x3, 0x2, 0x2, 
+       0x2, 0x2b, 0x7e, 0x3, 0x2, 0x2, 0x2, 0x2d, 0x2e, 0x7, 0x78, 0x2, 
+       0x2, 0x2e, 0x2f, 0x7, 0x63, 0x2, 0x2, 0x2f, 0x30, 0x7, 0x74, 0x2, 
+       0x2, 0x30, 0x4, 0x3, 0x2, 0x2, 0x2, 0x31, 0x32, 0x7, 0x3c, 0x2, 0x2, 
+       0x32, 0x6, 0x3, 0x2, 0x2, 0x2, 0x33, 0x34, 0x7, 0x3f, 0x2, 0x2, 0x34, 
+       0x8, 0x3, 0x2, 0x2, 0x2, 0x35, 0x36, 0x7, 0x68, 0x2, 0x2, 0x36, 0x37, 
+       0x7, 0x77, 0x2, 0x2, 0x37, 0x38, 0x7, 0x70, 0x2, 0x2, 0x38, 0x39, 
+       0x7, 0x65, 0x2, 0x2, 0x39, 0xa, 0x3, 0x2, 0x2, 0x2, 0x3a, 0x3b, 0x7, 
+       0x2a, 0x2, 0x2, 0x3b, 0xc, 0x3, 0x2, 0x2, 0x2, 0x3c, 0x3d, 0x7, 0x2b, 
+       0x2, 0x2, 0x3d, 0xe, 0x3, 0x2, 0x2, 0x2, 0x3e, 0x3f, 0x7, 0x2e, 0x2, 
+       0x2, 0x3f, 0x10, 0x3, 0x2, 0x2, 0x2, 0x40, 0x41, 0x7, 0x7d, 0x2, 
+       0x2, 0x41, 0x12, 0x3, 0x2, 0x2, 0x2, 0x42, 0x43, 0x7, 0x7f, 0x2, 
+       0x2, 0x43, 0x14, 0x3, 0x2, 0x2, 0x2, 0x44, 0x45, 0x7, 0x75, 0x2, 
+       0x2, 0x45, 0x46, 0x7, 0x76, 0x2, 0x2, 0x46, 0x47, 0x7, 0x74, 0x2, 
+       0x2, 0x47, 0x48, 0x7, 0x77, 0x2, 0x2, 0x48, 0x49, 0x7, 0x65, 0x2, 
+       0x2, 0x49, 0x4a, 0x7, 0x76, 0x2, 0x2, 0x4a, 0x16, 0x3, 0x2, 0x2, 
+       0x2, 0x4b, 0x4c, 0x7, 0x6b, 0x2, 0x2, 0x4c, 0x4d, 0x7, 0x68, 0x2, 
+       0x2, 0x4d, 0x18, 0x3, 0x2, 0x2, 0x2, 0x4e, 0x4f, 0x7, 0x79, 0x2, 
+       0x2, 0x4f, 0x50, 0x7, 0x6a, 0x2, 0x2, 0x50, 0x51, 0x7, 0x6b, 0x2, 
+       0x2, 0x51, 0x52, 0x7, 0x6e, 0x2, 0x2, 0x52, 0x53, 0x7, 0x67, 0x2, 
+       0x2, 0x53, 0x1a, 0x3, 0x2, 0x2, 0x2, 0x54, 0x55, 0x7, 0x74, 0x2, 
+       0x2, 0x55, 0x56, 0x7, 0x67, 0x2, 0x2, 0x56, 0x57, 0x7, 0x76, 0x2, 
+       0x2, 0x57, 0x58, 0x7, 0x77, 0x2, 0x2, 0x58, 0x59, 0x7, 0x74, 0x2, 
+       0x2, 0x59, 0x5a, 0x7, 0x70, 0x2, 0x2, 0x5a, 0x1c, 0x3, 0x2, 0x2, 
+       0x2, 0x5b, 0x5c, 0x7, 0x5d, 0x2, 0x2, 0x5c, 0x1e, 0x3, 0x2, 0x2, 
+       0x2, 0x5d, 0x5e, 0x7, 0x5f, 0x2, 0x2, 0x5e, 0x20, 0x3, 0x2, 0x2, 
+       0x2, 0x5f, 0x60, 0x7, 0x30, 0x2, 0x2, 0x60, 0x22, 0x3, 0x2, 0x2, 
+       0x2, 0x61, 0x68, 0x9, 0x2, 0x2, 0x2, 0x62, 0x63, 0x7, 0x3f, 0x2, 
+       0x2, 0x63, 0x68, 0x7, 0x3f, 0x2, 0x2, 0x64, 0x65, 0x7, 0x23, 0x2, 
+       0x2, 0x65, 0x68, 0x7, 0x3f, 0x2, 0x2, 0x66, 0x68, 0x9, 0x3, 0x2, 
+       0x2, 0x67, 0x61, 0x3, 0x2, 0x2, 0x2, 0x67, 0x62, 0x3, 0x2, 0x2, 0x2, 
+       0x67, 0x64, 0x3, 0x2, 0x2, 0x2, 0x67, 0x66, 0x3, 0x2, 0x2, 0x2, 0x68, 
+       0x24, 0x3, 0x2, 0x2, 0x2, 0x69, 0x6b, 0x9, 0x4, 0x2, 0x2, 0x6a, 0x69, 
+       0x3, 0x2, 0x2, 0x2, 0x6a, 0x6b, 0x3, 0x2, 0x2, 0x2, 0x6b, 0x6d, 0x3, 
+       0x2, 0x2, 0x2, 0x6c, 0x6e, 0x9, 0x5, 0x2, 0x2, 0x6d, 0x6c, 0x3, 0x2, 
+       0x2, 0x2, 0x6e, 0x6f, 0x3, 0x2, 0x2, 0x2, 0x6f, 0x6d, 0x3, 0x2, 0x2, 
+       0x2, 0x6f, 0x70, 0x3, 0x2, 0x2, 0x2, 0x70, 0x26, 0x3, 0x2, 0x2, 0x2, 
+       0x71, 0x73, 0x9, 0x6, 0x2, 0x2, 0x72, 0x71, 0x3, 0x2, 0x2, 0x2, 0x73, 
+       0x74, 0x3, 0x2, 0x2, 0x2, 0x74, 0x72, 0x3, 0x2, 0x2, 0x2, 0x74, 0x75, 
+       0x3, 0x2, 0x2, 0x2, 0x75, 0x28, 0x3, 0x2, 0x2, 0x2, 0x76, 0x78, 0x9, 
+       0x7, 0x2, 0x2, 0x77, 0x76, 0x3, 0x2, 0x2, 0x2, 0x78, 0x79, 0x3, 0x2, 
+       0x2, 0x2, 0x79, 0x77, 0x3, 0x2, 0x2, 0x2, 0x79, 0x7a, 0x3, 0x2, 0x2, 
+       0x2, 0x7a, 0x7b, 0x3, 0x2, 0x2, 0x2, 0x7b, 0x7c, 0x8, 0x15, 0x2, 
+       0x2, 0x7c, 0x2a, 0x3, 0x2, 0x2, 0x2, 0x7d, 0x7f, 0x9, 0x8, 0x2, 0x2, 
+       0x7e, 0x7d, 0x3, 0x2, 0x2, 0x2, 0x7f, 0x80, 0x3, 0x2, 0x2, 0x2, 0x80, 
+       0x7e, 0x3, 0x2, 0x2, 0x2, 0x80, 0x81, 0x3, 0x2, 0x2, 0x2, 0x81, 0x2c, 
+       0x3, 0x2, 0x2, 0x2, 0xa, 0x2, 0x67, 0x6a, 0x6f, 0x72, 0x74, 0x79, 
+       0x80, 0x3, 0x8, 0x2, 0x2, 
+  };
+
+  _serializedATN.insert(_serializedATN.end(), serializedATNSegment0,
+    serializedATNSegment0 + sizeof(serializedATNSegment0) / sizeof(serializedATNSegment0[0]));
+
+
+  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);
+  }
+}
+
+TocLexer::Initializer TocLexer::_init;
diff --git a/gen/TocLexer.h b/gen/TocLexer.h
new file mode 100644
index 0000000..f2f1ecb
--- /dev/null
+++ b/gen/TocLexer.h
@@ -0,0 +1,59 @@
+
+// Generated from Toc.g4 by ANTLR 4.9.2
+
+#pragma once
+
+
+#include "antlr4-runtime.h"
+
+
+
+
+class  TocLexer : 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, BINARY_OPERATOR = 17, INTLIT = 18, NAME = 19, 
+    WS = 20, NEWLINE = 21
+  };
+
+  explicit TocLexer(antlr4::CharStream *input);
+  ~TocLexer();
+
+  virtual std::string getGrammarFileName() const override;
+  virtual const std::vector<std::string>& getRuleNames() const override;
+
+  virtual const std::vector<std::string>& getChannelNames() 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> _channelNames;
+  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;
+};
+
diff --git a/gen/TocLexer.interp b/gen/TocLexer.interp
new file mode 100644
index 0000000..4f0a6ba
--- /dev/null
+++ b/gen/TocLexer.interp
@@ -0,0 +1,80 @@
+token literal names:
+null
+'var'
+':'
+'='
+'func'
+'('
+')'
+','
+'{'
+'}'
+'struct'
+'if'
+'while'
+'return'
+'['
+']'
+'.'
+null
+null
+null
+null
+null
+
+token symbolic names:
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+BINARY_OPERATOR
+INTLIT
+NAME
+WS
+NEWLINE
+
+rule names:
+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
+BINARY_OPERATOR
+INTLIT
+NAME
+WS
+NEWLINE
+
+channel names:
+DEFAULT_TOKEN_CHANNEL
+HIDDEN
+
+mode names:
+DEFAULT_MODE
+
+atn:
+[3, 24715, 42794, 33075, 47597, 16764, 15335, 30598, 22884, 2, 23, 130, 8, 1, 4, 2, 9, 2, 4, 3, 9, 3, 4, 4, 9, 4, 4, 5, 9, 5, 4, 6, 9, 6, 4, 7, 9, 7, 4, 8, 9, 8, 4, 9, 9, 9, 4, 10, 9, 10, 4, 11, 9, 11, 4, 12, 9, 12, 4, 13, 9, 13, 4, 14, 9, 14, 4, 15, 9, 15, 4, 16, 9, 16, 4, 17, 9, 17, 4, 18, 9, 18, 4, 19, 9, 19, 4, 20, 9, 20, 4, 21, 9, 21, 4, 22, 9, 22, 3, 2, 3, 2, 3, 2, 3, 2, 3, 3, 3, 3, 3, 4, 3, 4, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 6, 3, 6, 3, 7, 3, 7, 3, 8, 3, 8, 3, 9, 3, 9, 3, 10, 3, 10, 3, 11, 3, 11, 3, 11, 3, 11, 3, 11, 3, 11, 3, 11, 3, 12, 3, 12, 3, 12, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 14, 3, 14, 3, 14, 3, 14, 3, 14, 3, 14, 3, 14, 3, 15, 3, 15, 3, 16, 3, 16, 3, 17, 3, 17, 3, 18, 3, 18, 3, 18, 3, 18, 3, 18, 3, 18, 5, 18, 104, 10, 18, 3, 19, 5, 19, 107, 10, 19, 3, 19, 6, 19, 110, 10, 19, 13, 19, 14, 19, 111, 3, 20, 6, 20, 115, 10, 20, 13, 20, 14, 20, 116, 3, 21, 6, 21, 120, 10, 21, 13, 21, 14, 21, 121, 3, 21, 3, 21, 3, 22, 6, 22, 127, 10, 22, 13, 22, 14, 22, 128, 2, 2, 23, 3, 3, 5, 4, 7, 5, 9, 6, 11, 7, 13, 8, 15, 9, 17, 10, 19, 11, 21, 12, 23, 13, 25, 14, 27, 15, 29, 16, 31, 17, 33, 18, 35, 19, 37, 20, 39, 21, 41, 22, 43, 23, 3, 2, 9, 5, 2, 44, 45, 47, 47, 49, 49, 4, 2, 62, 62, 64, 64, 4, 2, 45, 45, 47, 47, 3, 2, 50, 59, 5, 2, 50, 59, 67, 92, 99, 124, 5, 2, 11, 12, 15, 15, 34, 34, 4, 2, 12, 12, 15, 15, 2, 137, 2, 3, 3, 2, 2, 2, 2, 5, 3, 2, 2, 2, 2, 7, 3, 2, 2, 2, 2, 9, 3, 2, 2, 2, 2, 11, 3, 2, 2, 2, 2, 13, 3, 2, 2, 2, 2, 15, 3, 2, 2, 2, 2, 17, 3, 2, 2, 2, 2, 19, 3, 2, 2, 2, 2, 21, 3, 2, 2, 2, 2, 23, 3, 2, 2, 2, 2, 25, 3, 2, 2, 2, 2, 27, 3, 2, 2, 2, 2, 29, 3, 2, 2, 2, 2, 31, 3, 2, 2, 2, 2, 33, 3, 2, 2, 2, 2, 35, 3, 2, 2, 2, 2, 37, 3, 2, 2, 2, 2, 39, 3, 2, 2, 2, 2, 41, 3, 2, 2, 2, 2, 43, 3, 2, 2, 2, 3, 45, 3, 2, 2, 2, 5, 49, 3, 2, 2, 2, 7, 51, 3, 2, 2, 2, 9, 53, 3, 2, 2, 2, 11, 58, 3, 2, 2, 2, 13, 60, 3, 2, 2, 2, 15, 62, 3, 2, 2, 2, 17, 64, 3, 2, 2, 2, 19, 66, 3, 2, 2, 2, 21, 68, 3, 2, 2, 2, 23, 75, 3, 2, 2, 2, 25, 78, 3, 2, 2, 2, 27, 84, 3, 2, 2, 2, 29, 91, 3, 2, 2, 2, 31, 93, 3, 2, 2, 2, 33, 95, 3, 2, 2, 2, 35, 103, 3, 2, 2, 2, 37, 106, 3, 2, 2, 2, 39, 114, 3, 2, 2, 2, 41, 119, 3, 2, 2, 2, 43, 126, 3, 2, 2, 2, 45, 46, 7, 120, 2, 2, 46, 47, 7, 99, 2, 2, 47, 48, 7, 116, 2, 2, 48, 4, 3, 2, 2, 2, 49, 50, 7, 60, 2, 2, 50, 6, 3, 2, 2, 2, 51, 52, 7, 63, 2, 2, 52, 8, 3, 2, 2, 2, 53, 54, 7, 104, 2, 2, 54, 55, 7, 119, 2, 2, 55, 56, 7, 112, 2, 2, 56, 57, 7, 101, 2, 2, 57, 10, 3, 2, 2, 2, 58, 59, 7, 42, 2, 2, 59, 12, 3, 2, 2, 2, 60, 61, 7, 43, 2, 2, 61, 14, 3, 2, 2, 2, 62, 63, 7, 46, 2, 2, 63, 16, 3, 2, 2, 2, 64, 65, 7, 125, 2, 2, 65, 18, 3, 2, 2, 2, 66, 67, 7, 127, 2, 2, 67, 20, 3, 2, 2, 2, 68, 69, 7, 117, 2, 2, 69, 70, 7, 118, 2, 2, 70, 71, 7, 116, 2, 2, 71, 72, 7, 119, 2, 2, 72, 73, 7, 101, 2, 2, 73, 74, 7, 118, 2, 2, 74, 22, 3, 2, 2, 2, 75, 76, 7, 107, 2, 2, 76, 77, 7, 104, 2, 2, 77, 24, 3, 2, 2, 2, 78, 79, 7, 121, 2, 2, 79, 80, 7, 106, 2, 2, 80, 81, 7, 107, 2, 2, 81, 82, 7, 110, 2, 2, 82, 83, 7, 103, 2, 2, 83, 26, 3, 2, 2, 2, 84, 85, 7, 116, 2, 2, 85, 86, 7, 103, 2, 2, 86, 87, 7, 118, 2, 2, 87, 88, 7, 119, 2, 2, 88, 89, 7, 116, 2, 2, 89, 90, 7, 112, 2, 2, 90, 28, 3, 2, 2, 2, 91, 92, 7, 93, 2, 2, 92, 30, 3, 2, 2, 2, 93, 94, 7, 95, 2, 2, 94, 32, 3, 2, 2, 2, 95, 96, 7, 48, 2, 2, 96, 34, 3, 2, 2, 2, 97, 104, 9, 2, 2, 2, 98, 99, 7, 63, 2, 2, 99, 104, 7, 63, 2, 2, 100, 101, 7, 35, 2, 2, 101, 104, 7, 63, 2, 2, 102, 104, 9, 3, 2, 2, 103, 97, 3, 2, 2, 2, 103, 98, 3, 2, 2, 2, 103, 100, 3, 2, 2, 2, 103, 102, 3, 2, 2, 2, 104, 36, 3, 2, 2, 2, 105, 107, 9, 4, 2, 2, 106, 105, 3, 2, 2, 2, 106, 107, 3, 2, 2, 2, 107, 109, 3, 2, 2, 2, 108, 110, 9, 5, 2, 2, 109, 108, 3, 2, 2, 2, 110, 111, 3, 2, 2, 2, 111, 109, 3, 2, 2, 2, 111, 112, 3, 2, 2, 2, 112, 38, 3, 2, 2, 2, 113, 115, 9, 6, 2, 2, 114, 113, 3, 2, 2, 2, 115, 116, 3, 2, 2, 2, 116, 114, 3, 2, 2, 2, 116, 117, 3, 2, 2, 2, 117, 40, 3, 2, 2, 2, 118, 120, 9, 7, 2, 2, 119, 118, 3, 2, 2, 2, 120, 121, 3, 2, 2, 2, 121, 119, 3, 2, 2, 2, 121, 122, 3, 2, 2, 2, 122, 123, 3, 2, 2, 2, 123, 124, 8, 21, 2, 2, 124, 42, 3, 2, 2, 2, 125, 127, 9, 8, 2, 2, 126, 125, 3, 2, 2, 2, 127, 128, 3, 2, 2, 2, 128, 126, 3, 2, 2, 2, 128, 129, 3, 2, 2, 2, 129, 44, 3, 2, 2, 2, 10, 2, 103, 106, 111, 114, 116, 121, 128, 3, 8, 2, 2]
+\ No newline at end of file
diff --git a/gen/TocLexer.tokens b/gen/TocLexer.tokens
new file mode 100644
index 0000000..980b6cf
--- /dev/null
+++ b/gen/TocLexer.tokens
@@ -0,0 +1,37 @@
+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
+BINARY_OPERATOR=17
+INTLIT=18
+NAME=19
+WS=20
+NEWLINE=21
+'var'=1
+':'=2
+'='=3
+'func'=4
+'('=5
+')'=6
+','=7
+'{'=8
+'}'=9
+'struct'=10
+'if'=11
+'while'=12
+'return'=13
+'['=14
+']'=15
+'.'=16
diff --git a/gen/TocListener.cpp b/gen/TocListener.cpp
new file mode 100644
index 0000000..098fe90
--- /dev/null
+++ b/gen/TocListener.cpp
@@ -0,0 +1,7 @@
+
+// Generated from Toc.g4 by ANTLR 4.9.2
+
+
+#include "TocListener.h"
+
+
diff --git a/gen/TocListener.h b/gen/TocListener.h
new file mode 100644
index 0000000..58cb4cd
--- /dev/null
+++ b/gen/TocListener.h
@@ -0,0 +1,130 @@
+
+// Generated from Toc.g4 by ANTLR 4.9.2
+
+#pragma once
+
+
+#include "antlr4-runtime.h"
+#include "TocParser.h"
+
+
+/**
+ * This interface defines an abstract listener for a parse tree produced by TocParser.
+ */
+class  TocListener : public antlr4::tree::ParseTreeListener {
+public:
+
+  virtual void enterProg(TocParser::ProgContext *ctx) = 0;
+  virtual void exitProg(TocParser::ProgContext *ctx) = 0;
+
+  virtual void enterDecl(TocParser::DeclContext *ctx) = 0;
+  virtual void exitDecl(TocParser::DeclContext *ctx) = 0;
+
+  virtual void enterVarDecl(TocParser::VarDeclContext *ctx) = 0;
+  virtual void exitVarDecl(TocParser::VarDeclContext *ctx) = 0;
+
+  virtual void enterVar(TocParser::VarContext *ctx) = 0;
+  virtual void exitVar(TocParser::VarContext *ctx) = 0;
+
+  virtual void enterType(TocParser::TypeContext *ctx) = 0;
+  virtual void exitType(TocParser::TypeContext *ctx) = 0;
+
+  virtual void enterFuncDecl(TocParser::FuncDeclContext *ctx) = 0;
+  virtual void exitFuncDecl(TocParser::FuncDeclContext *ctx) = 0;
+
+  virtual void enterFunc(TocParser::FuncContext *ctx) = 0;
+  virtual void exitFunc(TocParser::FuncContext *ctx) = 0;
+
+  virtual void enterParameter(TocParser::ParameterContext *ctx) = 0;
+  virtual void exitParameter(TocParser::ParameterContext *ctx) = 0;
+
+  virtual void enterFirstParameter(TocParser::FirstParameterContext *ctx) = 0;
+  virtual void exitFirstParameter(TocParser::FirstParameterContext *ctx) = 0;
+
+  virtual void enterAdditionalParameter(TocParser::AdditionalParameterContext *ctx) = 0;
+  virtual void exitAdditionalParameter(TocParser::AdditionalParameterContext *ctx) = 0;
+
+  virtual void enterBody(TocParser::BodyContext *ctx) = 0;
+  virtual void exitBody(TocParser::BodyContext *ctx) = 0;
+
+  virtual void enterStructDecl(TocParser::StructDeclContext *ctx) = 0;
+  virtual void exitStructDecl(TocParser::StructDeclContext *ctx) = 0;
+
+  virtual void enterStructMember(TocParser::StructMemberContext *ctx) = 0;
+  virtual void exitStructMember(TocParser::StructMemberContext *ctx) = 0;
+
+  virtual void enterStructVar(TocParser::StructVarContext *ctx) = 0;
+  virtual void exitStructVar(TocParser::StructVarContext *ctx) = 0;
+
+  virtual void enterStructMethod(TocParser::StructMethodContext *ctx) = 0;
+  virtual void exitStructMethod(TocParser::StructMethodContext *ctx) = 0;
+
+  virtual void enterStmt(TocParser::StmtContext *ctx) = 0;
+  virtual void exitStmt(TocParser::StmtContext *ctx) = 0;
+
+  virtual void enterConditional(TocParser::ConditionalContext *ctx) = 0;
+  virtual void exitConditional(TocParser::ConditionalContext *ctx) = 0;
+
+  virtual void enterIfCond(TocParser::IfCondContext *ctx) = 0;
+  virtual void exitIfCond(TocParser::IfCondContext *ctx) = 0;
+
+  virtual void enterLoop(TocParser::LoopContext *ctx) = 0;
+  virtual void exitLoop(TocParser::LoopContext *ctx) = 0;
+
+  virtual void enterWhileLoop(TocParser::WhileLoopContext *ctx) = 0;
+  virtual void exitWhileLoop(TocParser::WhileLoopContext *ctx) = 0;
+
+  virtual void enterAssignment(TocParser::AssignmentContext *ctx) = 0;
+  virtual void exitAssignment(TocParser::AssignmentContext *ctx) = 0;
+
+  virtual void enterReturnStmt(TocParser::ReturnStmtContext *ctx) = 0;
+  virtual void exitReturnStmt(TocParser::ReturnStmtContext *ctx) = 0;
+
+  virtual void enterExpr(TocParser::ExprContext *ctx) = 0;
+  virtual void exitExpr(TocParser::ExprContext *ctx) = 0;
+
+  virtual void enterNonOpExpr(TocParser::NonOpExprContext *ctx) = 0;
+  virtual void exitNonOpExpr(TocParser::NonOpExprContext *ctx) = 0;
+
+  virtual void enterNonSubscriptExpr(TocParser::NonSubscriptExprContext *ctx) = 0;
+  virtual void exitNonSubscriptExpr(TocParser::NonSubscriptExprContext *ctx) = 0;
+
+  virtual void enterFuncCall(TocParser::FuncCallContext *ctx) = 0;
+  virtual void exitFuncCall(TocParser::FuncCallContext *ctx) = 0;
+
+  virtual void enterOperatorExpr(TocParser::OperatorExprContext *ctx) = 0;
+  virtual void exitOperatorExpr(TocParser::OperatorExprContext *ctx) = 0;
+
+  virtual void enterBinaryOperator(TocParser::BinaryOperatorContext *ctx) = 0;
+  virtual void exitBinaryOperator(TocParser::BinaryOperatorContext *ctx) = 0;
+
+  virtual void enterIdentifier(TocParser::IdentifierContext *ctx) = 0;
+  virtual void exitIdentifier(TocParser::IdentifierContext *ctx) = 0;
+
+  virtual void enterLiteral(TocParser::LiteralContext *ctx) = 0;
+  virtual void exitLiteral(TocParser::LiteralContext *ctx) = 0;
+
+  virtual void enterSubscript(TocParser::SubscriptContext *ctx) = 0;
+  virtual void exitSubscript(TocParser::SubscriptContext *ctx) = 0;
+
+  virtual void enterMemberAccess(TocParser::MemberAccessContext *ctx) = 0;
+  virtual void exitMemberAccess(TocParser::MemberAccessContext *ctx) = 0;
+
+  virtual void enterParenExpr(TocParser::ParenExprContext *ctx) = 0;
+  virtual void exitParenExpr(TocParser::ParenExprContext *ctx) = 0;
+
+  virtual void enterFuncName(TocParser::FuncNameContext *ctx) = 0;
+  virtual void exitFuncName(TocParser::FuncNameContext *ctx) = 0;
+
+  virtual void enterVarName(TocParser::VarNameContext *ctx) = 0;
+  virtual void exitVarName(TocParser::VarNameContext *ctx) = 0;
+
+  virtual void enterTypeName(TocParser::TypeNameContext *ctx) = 0;
+  virtual void exitTypeName(TocParser::TypeNameContext *ctx) = 0;
+
+  virtual void enterStructName(TocParser::StructNameContext *ctx) = 0;
+  virtual void exitStructName(TocParser::StructNameContext *ctx) = 0;
+
+
+};
+
diff --git a/gen/TocParser.cpp b/gen/TocParser.cpp
new file mode 100644
index 0000000..8c58634
--- /dev/null
+++ b/gen/TocParser.cpp
@@ -0,0 +1,2787 @@
+
+// Generated from Toc.g4 by ANTLR 4.9.2
+
+
+#include "TocListener.h"
+
+#include "TocParser.h"
+
+
+using namespace antlrcpp;
+using namespace antlr4;
+
+TocParser::TocParser(TokenStream *input) : Parser(input) {
+  _interpreter = new atn::ParserATNSimulator(this, _atn, _decisionToDFA, _sharedContextCache);
+}
+
+TocParser::~TocParser() {
+  delete _interpreter;
+}
+
+std::string TocParser::getGrammarFileName() const {
+  return "Toc.g4";
+}
+
+const std::vector<std::string>& TocParser::getRuleNames() const {
+  return _ruleNames;
+}
+
+dfa::Vocabulary& TocParser::getVocabulary() const {
+  return _vocabulary;
+}
+
+
+//----------------- ProgContext ------------------------------------------------------------------
+
+TocParser::ProgContext::ProgContext(ParserRuleContext *parent, size_t invokingState)
+  : ParserRuleContext(parent, invokingState) {
+}
+
+tree::TerminalNode* TocParser::ProgContext::EOF() {
+  return getToken(TocParser::EOF, 0);
+}
+
+std::vector<TocParser::DeclContext *> TocParser::ProgContext::decl() {
+  return getRuleContexts<TocParser::DeclContext>();
+}
+
+TocParser::DeclContext* TocParser::ProgContext::decl(size_t i) {
+  return getRuleContext<TocParser::DeclContext>(i);
+}
+
+
+size_t TocParser::ProgContext::getRuleIndex() const {
+  return TocParser::RuleProg;
+}
+
+void TocParser::ProgContext::enterRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<TocListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->enterProg(this);
+}
+
+void TocParser::ProgContext::exitRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<TocListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->exitProg(this);
+}
+
+TocParser::ProgContext* TocParser::prog() {
+  ProgContext *_localctx = _tracker.createInstance<ProgContext>(_ctx, getState());
+  enterRule(_localctx, 0, TocParser::RuleProg);
+  size_t _la = 0;
+
+#if __cplusplus > 201703L
+  auto onExit = finally([=, this] {
+#else
+  auto onExit = finally([=] {
+#endif
+    exitRule();
+  });
+  try {
+    enterOuterAlt(_localctx, 1);
+    setState(75); 
+    _errHandler->sync(this);
+    _la = _input->LA(1);
+    do {
+      setState(74);
+      decl();
+      setState(77); 
+      _errHandler->sync(this);
+      _la = _input->LA(1);
+    } while ((((_la & ~ 0x3fULL) == 0) &&
+      ((1ULL << _la) & ((1ULL << TocParser::T__0)
+      | (1ULL << TocParser::T__3)
+      | (1ULL << TocParser::T__9))) != 0));
+    setState(79);
+    match(TocParser::EOF);
+   
+  }
+  catch (RecognitionException &e) {
+    _errHandler->reportError(this, e);
+    _localctx->exception = std::current_exception();
+    _errHandler->recover(this, _localctx->exception);
+  }
+
+  return _localctx;
+}
+
+//----------------- DeclContext ------------------------------------------------------------------
+
+TocParser::DeclContext::DeclContext(ParserRuleContext *parent, size_t invokingState)
+  : ParserRuleContext(parent, invokingState) {
+}
+
+TocParser::VarDeclContext* TocParser::DeclContext::varDecl() {
+  return getRuleContext<TocParser::VarDeclContext>(0);
+}
+
+TocParser::FuncDeclContext* TocParser::DeclContext::funcDecl() {
+  return getRuleContext<TocParser::FuncDeclContext>(0);
+}
+
+TocParser::StructDeclContext* TocParser::DeclContext::structDecl() {
+  return getRuleContext<TocParser::StructDeclContext>(0);
+}
+
+
+size_t TocParser::DeclContext::getRuleIndex() const {
+  return TocParser::RuleDecl;
+}
+
+void TocParser::DeclContext::enterRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<TocListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->enterDecl(this);
+}
+
+void TocParser::DeclContext::exitRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<TocListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->exitDecl(this);
+}
+
+TocParser::DeclContext* TocParser::decl() {
+  DeclContext *_localctx = _tracker.createInstance<DeclContext>(_ctx, getState());
+  enterRule(_localctx, 2, TocParser::RuleDecl);
+
+#if __cplusplus > 201703L
+  auto onExit = finally([=, this] {
+#else
+  auto onExit = finally([=] {
+#endif
+    exitRule();
+  });
+  try {
+    setState(84);
+    _errHandler->sync(this);
+    switch (_input->LA(1)) {
+      case TocParser::T__0: {
+        enterOuterAlt(_localctx, 1);
+        setState(81);
+        varDecl();
+        break;
+      }
+
+      case TocParser::T__3: {
+        enterOuterAlt(_localctx, 2);
+        setState(82);
+        funcDecl();
+        break;
+      }
+
+      case TocParser::T__9: {
+        enterOuterAlt(_localctx, 3);
+        setState(83);
+        structDecl();
+        break;
+      }
+
+    default:
+      throw NoViableAltException(this);
+    }
+   
+  }
+  catch (RecognitionException &e) {
+    _errHandler->reportError(this, e);
+    _localctx->exception = std::current_exception();
+    _errHandler->recover(this, _localctx->exception);
+  }
+
+  return _localctx;
+}
+
+//----------------- VarDeclContext ------------------------------------------------------------------
+
+TocParser::VarDeclContext::VarDeclContext(ParserRuleContext *parent, size_t invokingState)
+  : ParserRuleContext(parent, invokingState) {
+}
+
+TocParser::VarContext* TocParser::VarDeclContext::var() {
+  return getRuleContext<TocParser::VarContext>(0);
+}
+
+
+size_t TocParser::VarDeclContext::getRuleIndex() const {
+  return TocParser::RuleVarDecl;
+}
+
+void TocParser::VarDeclContext::enterRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<TocListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->enterVarDecl(this);
+}
+
+void TocParser::VarDeclContext::exitRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<TocListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->exitVarDecl(this);
+}
+
+TocParser::VarDeclContext* TocParser::varDecl() {
+  VarDeclContext *_localctx = _tracker.createInstance<VarDeclContext>(_ctx, getState());
+  enterRule(_localctx, 4, TocParser::RuleVarDecl);
+
+#if __cplusplus > 201703L
+  auto onExit = finally([=, this] {
+#else
+  auto onExit = finally([=] {
+#endif
+    exitRule();
+  });
+  try {
+    enterOuterAlt(_localctx, 1);
+    setState(86);
+    match(TocParser::T__0);
+    setState(87);
+    var();
+   
+  }
+  catch (RecognitionException &e) {
+    _errHandler->reportError(this, e);
+    _localctx->exception = std::current_exception();
+    _errHandler->recover(this, _localctx->exception);
+  }
+
+  return _localctx;
+}
+
+//----------------- VarContext ------------------------------------------------------------------
+
+TocParser::VarContext::VarContext(ParserRuleContext *parent, size_t invokingState)
+  : ParserRuleContext(parent, invokingState) {
+}
+
+TocParser::VarNameContext* TocParser::VarContext::varName() {
+  return getRuleContext<TocParser::VarNameContext>(0);
+}
+
+TocParser::TypeContext* TocParser::VarContext::type() {
+  return getRuleContext<TocParser::TypeContext>(0);
+}
+
+TocParser::ExprContext* TocParser::VarContext::expr() {
+  return getRuleContext<TocParser::ExprContext>(0);
+}
+
+
+size_t TocParser::VarContext::getRuleIndex() const {
+  return TocParser::RuleVar;
+}
+
+void TocParser::VarContext::enterRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<TocListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->enterVar(this);
+}
+
+void TocParser::VarContext::exitRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<TocListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->exitVar(this);
+}
+
+TocParser::VarContext* TocParser::var() {
+  VarContext *_localctx = _tracker.createInstance<VarContext>(_ctx, getState());
+  enterRule(_localctx, 6, TocParser::RuleVar);
+  size_t _la = 0;
+
+#if __cplusplus > 201703L
+  auto onExit = finally([=, this] {
+#else
+  auto onExit = finally([=] {
+#endif
+    exitRule();
+  });
+  try {
+    enterOuterAlt(_localctx, 1);
+    setState(89);
+    varName();
+
+    setState(90);
+    match(TocParser::T__1);
+    setState(91);
+    type();
+    setState(95);
+    _errHandler->sync(this);
+
+    _la = _input->LA(1);
+    if (_la == TocParser::T__2) {
+      setState(93);
+      match(TocParser::T__2);
+      setState(94);
+      expr();
+    }
+   
+  }
+  catch (RecognitionException &e) {
+    _errHandler->reportError(this, e);
+    _localctx->exception = std::current_exception();
+    _errHandler->recover(this, _localctx->exception);
+  }
+
+  return _localctx;
+}
+
+//----------------- TypeContext ------------------------------------------------------------------
+
+TocParser::TypeContext::TypeContext(ParserRuleContext *parent, size_t invokingState)
+  : ParserRuleContext(parent, invokingState) {
+}
+
+TocParser::TypeNameContext* TocParser::TypeContext::typeName() {
+  return getRuleContext<TocParser::TypeNameContext>(0);
+}
+
+
+size_t TocParser::TypeContext::getRuleIndex() const {
+  return TocParser::RuleType;
+}
+
+void TocParser::TypeContext::enterRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<TocListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->enterType(this);
+}
+
+void TocParser::TypeContext::exitRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<TocListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->exitType(this);
+}
+
+TocParser::TypeContext* TocParser::type() {
+  TypeContext *_localctx = _tracker.createInstance<TypeContext>(_ctx, getState());
+  enterRule(_localctx, 8, TocParser::RuleType);
+
+#if __cplusplus > 201703L
+  auto onExit = finally([=, this] {
+#else
+  auto onExit = finally([=] {
+#endif
+    exitRule();
+  });
+  try {
+    enterOuterAlt(_localctx, 1);
+    setState(97);
+    typeName();
+   
+  }
+  catch (RecognitionException &e) {
+    _errHandler->reportError(this, e);
+    _localctx->exception = std::current_exception();
+    _errHandler->recover(this, _localctx->exception);
+  }
+
+  return _localctx;
+}
+
+//----------------- FuncDeclContext ------------------------------------------------------------------
+
+TocParser::FuncDeclContext::FuncDeclContext(ParserRuleContext *parent, size_t invokingState)
+  : ParserRuleContext(parent, invokingState) {
+}
+
+TocParser::FuncContext* TocParser::FuncDeclContext::func() {
+  return getRuleContext<TocParser::FuncContext>(0);
+}
+
+
+size_t TocParser::FuncDeclContext::getRuleIndex() const {
+  return TocParser::RuleFuncDecl;
+}
+
+void TocParser::FuncDeclContext::enterRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<TocListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->enterFuncDecl(this);
+}
+
+void TocParser::FuncDeclContext::exitRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<TocListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->exitFuncDecl(this);
+}
+
+TocParser::FuncDeclContext* TocParser::funcDecl() {
+  FuncDeclContext *_localctx = _tracker.createInstance<FuncDeclContext>(_ctx, getState());
+  enterRule(_localctx, 10, TocParser::RuleFuncDecl);
+
+#if __cplusplus > 201703L
+  auto onExit = finally([=, this] {
+#else
+  auto onExit = finally([=] {
+#endif
+    exitRule();
+  });
+  try {
+    enterOuterAlt(_localctx, 1);
+    setState(99);
+    match(TocParser::T__3);
+    setState(100);
+    func();
+   
+  }
+  catch (RecognitionException &e) {
+    _errHandler->reportError(this, e);
+    _localctx->exception = std::current_exception();
+    _errHandler->recover(this, _localctx->exception);
+  }
+
+  return _localctx;
+}
+
+//----------------- FuncContext ------------------------------------------------------------------
+
+TocParser::FuncContext::FuncContext(ParserRuleContext *parent, size_t invokingState)
+  : ParserRuleContext(parent, invokingState) {
+}
+
+TocParser::FuncNameContext* TocParser::FuncContext::funcName() {
+  return getRuleContext<TocParser::FuncNameContext>(0);
+}
+
+TocParser::ParameterContext* TocParser::FuncContext::parameter() {
+  return getRuleContext<TocParser::ParameterContext>(0);
+}
+
+TocParser::BodyContext* TocParser::FuncContext::body() {
+  return getRuleContext<TocParser::BodyContext>(0);
+}
+
+TocParser::TypeContext* TocParser::FuncContext::type() {
+  return getRuleContext<TocParser::TypeContext>(0);
+}
+
+
+size_t TocParser::FuncContext::getRuleIndex() const {
+  return TocParser::RuleFunc;
+}
+
+void TocParser::FuncContext::enterRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<TocListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->enterFunc(this);
+}
+
+void TocParser::FuncContext::exitRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<TocListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->exitFunc(this);
+}
+
+TocParser::FuncContext* TocParser::func() {
+  FuncContext *_localctx = _tracker.createInstance<FuncContext>(_ctx, getState());
+  enterRule(_localctx, 12, TocParser::RuleFunc);
+
+#if __cplusplus > 201703L
+  auto onExit = finally([=, this] {
+#else
+  auto onExit = finally([=] {
+#endif
+    exitRule();
+  });
+  try {
+    enterOuterAlt(_localctx, 1);
+    setState(102);
+    funcName();
+    setState(103);
+    match(TocParser::T__4);
+    setState(104);
+    parameter();
+    setState(105);
+    match(TocParser::T__5);
+
+    setState(106);
+    match(TocParser::T__1);
+    setState(107);
+    type();
+    setState(109);
+    body();
+   
+  }
+  catch (RecognitionException &e) {
+    _errHandler->reportError(this, e);
+    _localctx->exception = std::current_exception();
+    _errHandler->recover(this, _localctx->exception);
+  }
+
+  return _localctx;
+}
+
+//----------------- ParameterContext ------------------------------------------------------------------
+
+TocParser::ParameterContext::ParameterContext(ParserRuleContext *parent, size_t invokingState)
+  : ParserRuleContext(parent, invokingState) {
+}
+
+TocParser::FirstParameterContext* TocParser::ParameterContext::firstParameter() {
+  return getRuleContext<TocParser::FirstParameterContext>(0);
+}
+
+std::vector<TocParser::AdditionalParameterContext *> TocParser::ParameterContext::additionalParameter() {
+  return getRuleContexts<TocParser::AdditionalParameterContext>();
+}
+
+TocParser::AdditionalParameterContext* TocParser::ParameterContext::additionalParameter(size_t i) {
+  return getRuleContext<TocParser::AdditionalParameterContext>(i);
+}
+
+
+size_t TocParser::ParameterContext::getRuleIndex() const {
+  return TocParser::RuleParameter;
+}
+
+void TocParser::ParameterContext::enterRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<TocListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->enterParameter(this);
+}
+
+void TocParser::ParameterContext::exitRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<TocListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->exitParameter(this);
+}
+
+TocParser::ParameterContext* TocParser::parameter() {
+  ParameterContext *_localctx = _tracker.createInstance<ParameterContext>(_ctx, getState());
+  enterRule(_localctx, 14, TocParser::RuleParameter);
+  size_t _la = 0;
+
+#if __cplusplus > 201703L
+  auto onExit = finally([=, this] {
+#else
+  auto onExit = finally([=] {
+#endif
+    exitRule();
+  });
+  try {
+    enterOuterAlt(_localctx, 1);
+    setState(118);
+    _errHandler->sync(this);
+
+    _la = _input->LA(1);
+    if (_la == TocParser::NAME) {
+      setState(111);
+      firstParameter();
+      setState(115);
+      _errHandler->sync(this);
+      _la = _input->LA(1);
+      while (_la == TocParser::T__6) {
+        setState(112);
+        additionalParameter();
+        setState(117);
+        _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;
+}
+
+//----------------- FirstParameterContext ------------------------------------------------------------------
+
+TocParser::FirstParameterContext::FirstParameterContext(ParserRuleContext *parent, size_t invokingState)
+  : ParserRuleContext(parent, invokingState) {
+}
+
+TocParser::VarContext* TocParser::FirstParameterContext::var() {
+  return getRuleContext<TocParser::VarContext>(0);
+}
+
+
+size_t TocParser::FirstParameterContext::getRuleIndex() const {
+  return TocParser::RuleFirstParameter;
+}
+
+void TocParser::FirstParameterContext::enterRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<TocListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->enterFirstParameter(this);
+}
+
+void TocParser::FirstParameterContext::exitRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<TocListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->exitFirstParameter(this);
+}
+
+TocParser::FirstParameterContext* TocParser::firstParameter() {
+  FirstParameterContext *_localctx = _tracker.createInstance<FirstParameterContext>(_ctx, getState());
+  enterRule(_localctx, 16, TocParser::RuleFirstParameter);
+
+#if __cplusplus > 201703L
+  auto onExit = finally([=, this] {
+#else
+  auto onExit = finally([=] {
+#endif
+    exitRule();
+  });
+  try {
+    enterOuterAlt(_localctx, 1);
+    setState(120);
+    var();
+   
+  }
+  catch (RecognitionException &e) {
+    _errHandler->reportError(this, e);
+    _localctx->exception = std::current_exception();
+    _errHandler->recover(this, _localctx->exception);
+  }
+
+  return _localctx;
+}
+
+//----------------- AdditionalParameterContext ------------------------------------------------------------------
+
+TocParser::AdditionalParameterContext::AdditionalParameterContext(ParserRuleContext *parent, size_t invokingState)
+  : ParserRuleContext(parent, invokingState) {
+}
+
+TocParser::VarContext* TocParser::AdditionalParameterContext::var() {
+  return getRuleContext<TocParser::VarContext>(0);
+}
+
+
+size_t TocParser::AdditionalParameterContext::getRuleIndex() const {
+  return TocParser::RuleAdditionalParameter;
+}
+
+void TocParser::AdditionalParameterContext::enterRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<TocListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->enterAdditionalParameter(this);
+}
+
+void TocParser::AdditionalParameterContext::exitRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<TocListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->exitAdditionalParameter(this);
+}
+
+TocParser::AdditionalParameterContext* TocParser::additionalParameter() {
+  AdditionalParameterContext *_localctx = _tracker.createInstance<AdditionalParameterContext>(_ctx, getState());
+  enterRule(_localctx, 18, TocParser::RuleAdditionalParameter);
+
+#if __cplusplus > 201703L
+  auto onExit = finally([=, this] {
+#else
+  auto onExit = finally([=] {
+#endif
+    exitRule();
+  });
+  try {
+    enterOuterAlt(_localctx, 1);
+    setState(122);
+    match(TocParser::T__6);
+    setState(123);
+    var();
+   
+  }
+  catch (RecognitionException &e) {
+    _errHandler->reportError(this, e);
+    _localctx->exception = std::current_exception();
+    _errHandler->recover(this, _localctx->exception);
+  }
+
+  return _localctx;
+}
+
+//----------------- BodyContext ------------------------------------------------------------------
+
+TocParser::BodyContext::BodyContext(ParserRuleContext *parent, size_t invokingState)
+  : ParserRuleContext(parent, invokingState) {
+}
+
+std::vector<TocParser::StmtContext *> TocParser::BodyContext::stmt() {
+  return getRuleContexts<TocParser::StmtContext>();
+}
+
+TocParser::StmtContext* TocParser::BodyContext::stmt(size_t i) {
+  return getRuleContext<TocParser::StmtContext>(i);
+}
+
+
+size_t TocParser::BodyContext::getRuleIndex() const {
+  return TocParser::RuleBody;
+}
+
+void TocParser::BodyContext::enterRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<TocListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->enterBody(this);
+}
+
+void TocParser::BodyContext::exitRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<TocListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->exitBody(this);
+}
+
+TocParser::BodyContext* TocParser::body() {
+  BodyContext *_localctx = _tracker.createInstance<BodyContext>(_ctx, getState());
+  enterRule(_localctx, 20, TocParser::RuleBody);
+  size_t _la = 0;
+
+#if __cplusplus > 201703L
+  auto onExit = finally([=, this] {
+#else
+  auto onExit = finally([=] {
+#endif
+    exitRule();
+  });
+  try {
+    enterOuterAlt(_localctx, 1);
+    setState(125);
+    match(TocParser::T__7);
+    setState(129);
+    _errHandler->sync(this);
+    _la = _input->LA(1);
+    while ((((_la & ~ 0x3fULL) == 0) &&
+      ((1ULL << _la) & ((1ULL << TocParser::T__0)
+      | (1ULL << TocParser::T__4)
+      | (1ULL << TocParser::T__10)
+      | (1ULL << TocParser::T__11)
+      | (1ULL << TocParser::T__12)
+      | (1ULL << TocParser::INTLIT)
+      | (1ULL << TocParser::NAME))) != 0)) {
+      setState(126);
+      stmt();
+      setState(131);
+      _errHandler->sync(this);
+      _la = _input->LA(1);
+    }
+    setState(132);
+    match(TocParser::T__8);
+   
+  }
+  catch (RecognitionException &e) {
+    _errHandler->reportError(this, e);
+    _localctx->exception = std::current_exception();
+    _errHandler->recover(this, _localctx->exception);
+  }
+
+  return _localctx;
+}
+
+//----------------- StructDeclContext ------------------------------------------------------------------
+
+TocParser::StructDeclContext::StructDeclContext(ParserRuleContext *parent, size_t invokingState)
+  : ParserRuleContext(parent, invokingState) {
+}
+
+TocParser::StructNameContext* TocParser::StructDeclContext::structName() {
+  return getRuleContext<TocParser::StructNameContext>(0);
+}
+
+std::vector<TocParser::StructMemberContext *> TocParser::StructDeclContext::structMember() {
+  return getRuleContexts<TocParser::StructMemberContext>();
+}
+
+TocParser::StructMemberContext* TocParser::StructDeclContext::structMember(size_t i) {
+  return getRuleContext<TocParser::StructMemberContext>(i);
+}
+
+
+size_t TocParser::StructDeclContext::getRuleIndex() const {
+  return TocParser::RuleStructDecl;
+}
+
+void TocParser::StructDeclContext::enterRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<TocListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->enterStructDecl(this);
+}
+
+void TocParser::StructDeclContext::exitRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<TocListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->exitStructDecl(this);
+}
+
+TocParser::StructDeclContext* TocParser::structDecl() {
+  StructDeclContext *_localctx = _tracker.createInstance<StructDeclContext>(_ctx, getState());
+  enterRule(_localctx, 22, TocParser::RuleStructDecl);
+  size_t _la = 0;
+
+#if __cplusplus > 201703L
+  auto onExit = finally([=, this] {
+#else
+  auto onExit = finally([=] {
+#endif
+    exitRule();
+  });
+  try {
+    enterOuterAlt(_localctx, 1);
+    setState(134);
+    match(TocParser::T__9);
+    setState(135);
+    structName();
+    setState(136);
+    match(TocParser::T__7);
+    setState(140);
+    _errHandler->sync(this);
+    _la = _input->LA(1);
+    while (_la == TocParser::NAME) {
+      setState(137);
+      structMember();
+      setState(142);
+      _errHandler->sync(this);
+      _la = _input->LA(1);
+    }
+    setState(143);
+    match(TocParser::T__8);
+   
+  }
+  catch (RecognitionException &e) {
+    _errHandler->reportError(this, e);
+    _localctx->exception = std::current_exception();
+    _errHandler->recover(this, _localctx->exception);
+  }
+
+  return _localctx;
+}
+
+//----------------- StructMemberContext ------------------------------------------------------------------
+
+TocParser::StructMemberContext::StructMemberContext(ParserRuleContext *parent, size_t invokingState)
+  : ParserRuleContext(parent, invokingState) {
+}
+
+TocParser::StructVarContext* TocParser::StructMemberContext::structVar() {
+  return getRuleContext<TocParser::StructVarContext>(0);
+}
+
+TocParser::StructMethodContext* TocParser::StructMemberContext::structMethod() {
+  return getRuleContext<TocParser::StructMethodContext>(0);
+}
+
+
+size_t TocParser::StructMemberContext::getRuleIndex() const {
+  return TocParser::RuleStructMember;
+}
+
+void TocParser::StructMemberContext::enterRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<TocListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->enterStructMember(this);
+}
+
+void TocParser::StructMemberContext::exitRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<TocListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->exitStructMember(this);
+}
+
+TocParser::StructMemberContext* TocParser::structMember() {
+  StructMemberContext *_localctx = _tracker.createInstance<StructMemberContext>(_ctx, getState());
+  enterRule(_localctx, 24, TocParser::RuleStructMember);
+
+#if __cplusplus > 201703L
+  auto onExit = finally([=, this] {
+#else
+  auto onExit = finally([=] {
+#endif
+    exitRule();
+  });
+  try {
+    setState(147);
+    _errHandler->sync(this);
+    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 7, _ctx)) {
+    case 1: {
+      enterOuterAlt(_localctx, 1);
+      setState(145);
+      structVar();
+      break;
+    }
+
+    case 2: {
+      enterOuterAlt(_localctx, 2);
+      setState(146);
+      structMethod();
+      break;
+    }
+
+    default:
+      break;
+    }
+   
+  }
+  catch (RecognitionException &e) {
+    _errHandler->reportError(this, e);
+    _localctx->exception = std::current_exception();
+    _errHandler->recover(this, _localctx->exception);
+  }
+
+  return _localctx;
+}
+
+//----------------- StructVarContext ------------------------------------------------------------------
+
+TocParser::StructVarContext::StructVarContext(ParserRuleContext *parent, size_t invokingState)
+  : ParserRuleContext(parent, invokingState) {
+}
+
+TocParser::VarContext* TocParser::StructVarContext::var() {
+  return getRuleContext<TocParser::VarContext>(0);
+}
+
+
+size_t TocParser::StructVarContext::getRuleIndex() const {
+  return TocParser::RuleStructVar;
+}
+
+void TocParser::StructVarContext::enterRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<TocListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->enterStructVar(this);
+}
+
+void TocParser::StructVarContext::exitRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<TocListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->exitStructVar(this);
+}
+
+TocParser::StructVarContext* TocParser::structVar() {
+  StructVarContext *_localctx = _tracker.createInstance<StructVarContext>(_ctx, getState());
+  enterRule(_localctx, 26, TocParser::RuleStructVar);
+
+#if __cplusplus > 201703L
+  auto onExit = finally([=, this] {
+#else
+  auto onExit = finally([=] {
+#endif
+    exitRule();
+  });
+  try {
+    enterOuterAlt(_localctx, 1);
+    setState(149);
+    var();
+   
+  }
+  catch (RecognitionException &e) {
+    _errHandler->reportError(this, e);
+    _localctx->exception = std::current_exception();
+    _errHandler->recover(this, _localctx->exception);
+  }
+
+  return _localctx;
+}
+
+//----------------- StructMethodContext ------------------------------------------------------------------
+
+TocParser::StructMethodContext::StructMethodContext(ParserRuleContext *parent, size_t invokingState)
+  : ParserRuleContext(parent, invokingState) {
+}
+
+TocParser::FuncContext* TocParser::StructMethodContext::func() {
+  return getRuleContext<TocParser::FuncContext>(0);
+}
+
+
+size_t TocParser::StructMethodContext::getRuleIndex() const {
+  return TocParser::RuleStructMethod;
+}
+
+void TocParser::StructMethodContext::enterRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<TocListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->enterStructMethod(this);
+}
+
+void TocParser::StructMethodContext::exitRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<TocListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->exitStructMethod(this);
+}
+
+TocParser::StructMethodContext* TocParser::structMethod() {
+  StructMethodContext *_localctx = _tracker.createInstance<StructMethodContext>(_ctx, getState());
+  enterRule(_localctx, 28, TocParser::RuleStructMethod);
+
+#if __cplusplus > 201703L
+  auto onExit = finally([=, this] {
+#else
+  auto onExit = finally([=] {
+#endif
+    exitRule();
+  });
+  try {
+    enterOuterAlt(_localctx, 1);
+    setState(151);
+    func();
+   
+  }
+  catch (RecognitionException &e) {
+    _errHandler->reportError(this, e);
+    _localctx->exception = std::current_exception();
+    _errHandler->recover(this, _localctx->exception);
+  }
+
+  return _localctx;
+}
+
+//----------------- StmtContext ------------------------------------------------------------------
+
+TocParser::StmtContext::StmtContext(ParserRuleContext *parent, size_t invokingState)
+  : ParserRuleContext(parent, invokingState) {
+}
+
+TocParser::VarDeclContext* TocParser::StmtContext::varDecl() {
+  return getRuleContext<TocParser::VarDeclContext>(0);
+}
+
+TocParser::ConditionalContext* TocParser::StmtContext::conditional() {
+  return getRuleContext<TocParser::ConditionalContext>(0);
+}
+
+TocParser::LoopContext* TocParser::StmtContext::loop() {
+  return getRuleContext<TocParser::LoopContext>(0);
+}
+
+TocParser::AssignmentContext* TocParser::StmtContext::assignment() {
+  return getRuleContext<TocParser::AssignmentContext>(0);
+}
+
+TocParser::ReturnStmtContext* TocParser::StmtContext::returnStmt() {
+  return getRuleContext<TocParser::ReturnStmtContext>(0);
+}
+
+TocParser::ExprContext* TocParser::StmtContext::expr() {
+  return getRuleContext<TocParser::ExprContext>(0);
+}
+
+
+size_t TocParser::StmtContext::getRuleIndex() const {
+  return TocParser::RuleStmt;
+}
+
+void TocParser::StmtContext::enterRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<TocListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->enterStmt(this);
+}
+
+void TocParser::StmtContext::exitRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<TocListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->exitStmt(this);
+}
+
+TocParser::StmtContext* TocParser::stmt() {
+  StmtContext *_localctx = _tracker.createInstance<StmtContext>(_ctx, getState());
+  enterRule(_localctx, 30, TocParser::RuleStmt);
+
+#if __cplusplus > 201703L
+  auto onExit = finally([=, this] {
+#else
+  auto onExit = finally([=] {
+#endif
+    exitRule();
+  });
+  try {
+    enterOuterAlt(_localctx, 1);
+    setState(159);
+    _errHandler->sync(this);
+    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 8, _ctx)) {
+    case 1: {
+      setState(153);
+      varDecl();
+      break;
+    }
+
+    case 2: {
+      setState(154);
+      conditional();
+      break;
+    }
+
+    case 3: {
+      setState(155);
+      loop();
+      break;
+    }
+
+    case 4: {
+      setState(156);
+      assignment();
+      break;
+    }
+
+    case 5: {
+      setState(157);
+      returnStmt();
+      break;
+    }
+
+    case 6: {
+      setState(158);
+      expr();
+      break;
+    }
+
+    default:
+      break;
+    }
+   
+  }
+  catch (RecognitionException &e) {
+    _errHandler->reportError(this, e);
+    _localctx->exception = std::current_exception();
+    _errHandler->recover(this, _localctx->exception);
+  }
+
+  return _localctx;
+}
+
+//----------------- ConditionalContext ------------------------------------------------------------------
+
+TocParser::ConditionalContext::ConditionalContext(ParserRuleContext *parent, size_t invokingState)
+  : ParserRuleContext(parent, invokingState) {
+}
+
+TocParser::IfCondContext* TocParser::ConditionalContext::ifCond() {
+  return getRuleContext<TocParser::IfCondContext>(0);
+}
+
+
+size_t TocParser::ConditionalContext::getRuleIndex() const {
+  return TocParser::RuleConditional;
+}
+
+void TocParser::ConditionalContext::enterRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<TocListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->enterConditional(this);
+}
+
+void TocParser::ConditionalContext::exitRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<TocListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->exitConditional(this);
+}
+
+TocParser::ConditionalContext* TocParser::conditional() {
+  ConditionalContext *_localctx = _tracker.createInstance<ConditionalContext>(_ctx, getState());
+  enterRule(_localctx, 32, TocParser::RuleConditional);
+
+#if __cplusplus > 201703L
+  auto onExit = finally([=, this] {
+#else
+  auto onExit = finally([=] {
+#endif
+    exitRule();
+  });
+  try {
+    enterOuterAlt(_localctx, 1);
+    setState(161);
+    ifCond();
+   
+  }
+  catch (RecognitionException &e) {
+    _errHandler->reportError(this, e);
+    _localctx->exception = std::current_exception();
+    _errHandler->recover(this, _localctx->exception);
+  }
+
+  return _localctx;
+}
+
+//----------------- IfCondContext ------------------------------------------------------------------
+
+TocParser::IfCondContext::IfCondContext(ParserRuleContext *parent, size_t invokingState)
+  : ParserRuleContext(parent, invokingState) {
+}
+
+TocParser::ExprContext* TocParser::IfCondContext::expr() {
+  return getRuleContext<TocParser::ExprContext>(0);
+}
+
+TocParser::BodyContext* TocParser::IfCondContext::body() {
+  return getRuleContext<TocParser::BodyContext>(0);
+}
+
+
+size_t TocParser::IfCondContext::getRuleIndex() const {
+  return TocParser::RuleIfCond;
+}
+
+void TocParser::IfCondContext::enterRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<TocListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->enterIfCond(this);
+}
+
+void TocParser::IfCondContext::exitRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<TocListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->exitIfCond(this);
+}
+
+TocParser::IfCondContext* TocParser::ifCond() {
+  IfCondContext *_localctx = _tracker.createInstance<IfCondContext>(_ctx, getState());
+  enterRule(_localctx, 34, TocParser::RuleIfCond);
+
+#if __cplusplus > 201703L
+  auto onExit = finally([=, this] {
+#else
+  auto onExit = finally([=] {
+#endif
+    exitRule();
+  });
+  try {
+    enterOuterAlt(_localctx, 1);
+    setState(163);
+    match(TocParser::T__10);
+    setState(164);
+    expr();
+    setState(165);
+    body();
+   
+  }
+  catch (RecognitionException &e) {
+    _errHandler->reportError(this, e);
+    _localctx->exception = std::current_exception();
+    _errHandler->recover(this, _localctx->exception);
+  }
+
+  return _localctx;
+}
+
+//----------------- LoopContext ------------------------------------------------------------------
+
+TocParser::LoopContext::LoopContext(ParserRuleContext *parent, size_t invokingState)
+  : ParserRuleContext(parent, invokingState) {
+}
+
+TocParser::WhileLoopContext* TocParser::LoopContext::whileLoop() {
+  return getRuleContext<TocParser::WhileLoopContext>(0);
+}
+
+
+size_t TocParser::LoopContext::getRuleIndex() const {
+  return TocParser::RuleLoop;
+}
+
+void TocParser::LoopContext::enterRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<TocListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->enterLoop(this);
+}
+
+void TocParser::LoopContext::exitRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<TocListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->exitLoop(this);
+}
+
+TocParser::LoopContext* TocParser::loop() {
+  LoopContext *_localctx = _tracker.createInstance<LoopContext>(_ctx, getState());
+  enterRule(_localctx, 36, TocParser::RuleLoop);
+
+#if __cplusplus > 201703L
+  auto onExit = finally([=, this] {
+#else
+  auto onExit = finally([=] {
+#endif
+    exitRule();
+  });
+  try {
+    enterOuterAlt(_localctx, 1);
+    setState(167);
+    whileLoop();
+   
+  }
+  catch (RecognitionException &e) {
+    _errHandler->reportError(this, e);
+    _localctx->exception = std::current_exception();
+    _errHandler->recover(this, _localctx->exception);
+  }
+
+  return _localctx;
+}
+
+//----------------- WhileLoopContext ------------------------------------------------------------------
+
+TocParser::WhileLoopContext::WhileLoopContext(ParserRuleContext *parent, size_t invokingState)
+  : ParserRuleContext(parent, invokingState) {
+}
+
+TocParser::ExprContext* TocParser::WhileLoopContext::expr() {
+  return getRuleContext<TocParser::ExprContext>(0);
+}
+
+TocParser::BodyContext* TocParser::WhileLoopContext::body() {
+  return getRuleContext<TocParser::BodyContext>(0);
+}
+
+
+size_t TocParser::WhileLoopContext::getRuleIndex() const {
+  return TocParser::RuleWhileLoop;
+}
+
+void TocParser::WhileLoopContext::enterRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<TocListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->enterWhileLoop(this);
+}
+
+void TocParser::WhileLoopContext::exitRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<TocListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->exitWhileLoop(this);
+}
+
+TocParser::WhileLoopContext* TocParser::whileLoop() {
+  WhileLoopContext *_localctx = _tracker.createInstance<WhileLoopContext>(_ctx, getState());
+  enterRule(_localctx, 38, TocParser::RuleWhileLoop);
+
+#if __cplusplus > 201703L
+  auto onExit = finally([=, this] {
+#else
+  auto onExit = finally([=] {
+#endif
+    exitRule();
+  });
+  try {
+    enterOuterAlt(_localctx, 1);
+    setState(169);
+    match(TocParser::T__11);
+    setState(170);
+    expr();
+    setState(171);
+    body();
+   
+  }
+  catch (RecognitionException &e) {
+    _errHandler->reportError(this, e);
+    _localctx->exception = std::current_exception();
+    _errHandler->recover(this, _localctx->exception);
+  }
+
+  return _localctx;
+}
+
+//----------------- AssignmentContext ------------------------------------------------------------------
+
+TocParser::AssignmentContext::AssignmentContext(ParserRuleContext *parent, size_t invokingState)
+  : ParserRuleContext(parent, invokingState) {
+}
+
+TocParser::IdentifierContext* TocParser::AssignmentContext::identifier() {
+  return getRuleContext<TocParser::IdentifierContext>(0);
+}
+
+TocParser::ExprContext* TocParser::AssignmentContext::expr() {
+  return getRuleContext<TocParser::ExprContext>(0);
+}
+
+
+size_t TocParser::AssignmentContext::getRuleIndex() const {
+  return TocParser::RuleAssignment;
+}
+
+void TocParser::AssignmentContext::enterRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<TocListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->enterAssignment(this);
+}
+
+void TocParser::AssignmentContext::exitRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<TocListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->exitAssignment(this);
+}
+
+TocParser::AssignmentContext* TocParser::assignment() {
+  AssignmentContext *_localctx = _tracker.createInstance<AssignmentContext>(_ctx, getState());
+  enterRule(_localctx, 40, TocParser::RuleAssignment);
+
+#if __cplusplus > 201703L
+  auto onExit = finally([=, this] {
+#else
+  auto onExit = finally([=] {
+#endif
+    exitRule();
+  });
+  try {
+    enterOuterAlt(_localctx, 1);
+    setState(173);
+    identifier();
+    setState(174);
+    match(TocParser::T__2);
+    setState(175);
+    expr();
+   
+  }
+  catch (RecognitionException &e) {
+    _errHandler->reportError(this, e);
+    _localctx->exception = std::current_exception();
+    _errHandler->recover(this, _localctx->exception);
+  }
+
+  return _localctx;
+}
+
+//----------------- ReturnStmtContext ------------------------------------------------------------------
+
+TocParser::ReturnStmtContext::ReturnStmtContext(ParserRuleContext *parent, size_t invokingState)
+  : ParserRuleContext(parent, invokingState) {
+}
+
+TocParser::ExprContext* TocParser::ReturnStmtContext::expr() {
+  return getRuleContext<TocParser::ExprContext>(0);
+}
+
+
+size_t TocParser::ReturnStmtContext::getRuleIndex() const {
+  return TocParser::RuleReturnStmt;
+}
+
+void TocParser::ReturnStmtContext::enterRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<TocListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->enterReturnStmt(this);
+}
+
+void TocParser::ReturnStmtContext::exitRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<TocListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->exitReturnStmt(this);
+}
+
+TocParser::ReturnStmtContext* TocParser::returnStmt() {
+  ReturnStmtContext *_localctx = _tracker.createInstance<ReturnStmtContext>(_ctx, getState());
+  enterRule(_localctx, 42, TocParser::RuleReturnStmt);
+
+#if __cplusplus > 201703L
+  auto onExit = finally([=, this] {
+#else
+  auto onExit = finally([=] {
+#endif
+    exitRule();
+  });
+  try {
+    enterOuterAlt(_localctx, 1);
+    setState(177);
+    match(TocParser::T__12);
+    setState(178);
+    expr();
+   
+  }
+  catch (RecognitionException &e) {
+    _errHandler->reportError(this, e);
+    _localctx->exception = std::current_exception();
+    _errHandler->recover(this, _localctx->exception);
+  }
+
+  return _localctx;
+}
+
+//----------------- ExprContext ------------------------------------------------------------------
+
+TocParser::ExprContext::ExprContext(ParserRuleContext *parent, size_t invokingState)
+  : ParserRuleContext(parent, invokingState) {
+}
+
+TocParser::FuncCallContext* TocParser::ExprContext::funcCall() {
+  return getRuleContext<TocParser::FuncCallContext>(0);
+}
+
+TocParser::LiteralContext* TocParser::ExprContext::literal() {
+  return getRuleContext<TocParser::LiteralContext>(0);
+}
+
+TocParser::IdentifierContext* TocParser::ExprContext::identifier() {
+  return getRuleContext<TocParser::IdentifierContext>(0);
+}
+
+TocParser::SubscriptContext* TocParser::ExprContext::subscript() {
+  return getRuleContext<TocParser::SubscriptContext>(0);
+}
+
+TocParser::MemberAccessContext* TocParser::ExprContext::memberAccess() {
+  return getRuleContext<TocParser::MemberAccessContext>(0);
+}
+
+TocParser::ParenExprContext* TocParser::ExprContext::parenExpr() {
+  return getRuleContext<TocParser::ParenExprContext>(0);
+}
+
+TocParser::OperatorExprContext* TocParser::ExprContext::operatorExpr() {
+  return getRuleContext<TocParser::OperatorExprContext>(0);
+}
+
+
+size_t TocParser::ExprContext::getRuleIndex() const {
+  return TocParser::RuleExpr;
+}
+
+void TocParser::ExprContext::enterRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<TocListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->enterExpr(this);
+}
+
+void TocParser::ExprContext::exitRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<TocListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->exitExpr(this);
+}
+
+TocParser::ExprContext* TocParser::expr() {
+  ExprContext *_localctx = _tracker.createInstance<ExprContext>(_ctx, getState());
+  enterRule(_localctx, 44, TocParser::RuleExpr);
+
+#if __cplusplus > 201703L
+  auto onExit = finally([=, this] {
+#else
+  auto onExit = finally([=] {
+#endif
+    exitRule();
+  });
+  try {
+    setState(187);
+    _errHandler->sync(this);
+    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 9, _ctx)) {
+    case 1: {
+      enterOuterAlt(_localctx, 1);
+      setState(180);
+      funcCall();
+      break;
+    }
+
+    case 2: {
+      enterOuterAlt(_localctx, 2);
+      setState(181);
+      literal();
+      break;
+    }
+
+    case 3: {
+      enterOuterAlt(_localctx, 3);
+      setState(182);
+      identifier();
+      break;
+    }
+
+    case 4: {
+      enterOuterAlt(_localctx, 4);
+      setState(183);
+      subscript();
+      break;
+    }
+
+    case 5: {
+      enterOuterAlt(_localctx, 5);
+      setState(184);
+      memberAccess();
+      break;
+    }
+
+    case 6: {
+      enterOuterAlt(_localctx, 6);
+      setState(185);
+      parenExpr();
+      break;
+    }
+
+    case 7: {
+      enterOuterAlt(_localctx, 7);
+      setState(186);
+      operatorExpr();
+      break;
+    }
+
+    default:
+      break;
+    }
+   
+  }
+  catch (RecognitionException &e) {
+    _errHandler->reportError(this, e);
+    _localctx->exception = std::current_exception();
+    _errHandler->recover(this, _localctx->exception);
+  }
+
+  return _localctx;
+}
+
+//----------------- NonOpExprContext ------------------------------------------------------------------
+
+TocParser::NonOpExprContext::NonOpExprContext(ParserRuleContext *parent, size_t invokingState)
+  : ParserRuleContext(parent, invokingState) {
+}
+
+TocParser::FuncCallContext* TocParser::NonOpExprContext::funcCall() {
+  return getRuleContext<TocParser::FuncCallContext>(0);
+}
+
+TocParser::LiteralContext* TocParser::NonOpExprContext::literal() {
+  return getRuleContext<TocParser::LiteralContext>(0);
+}
+
+TocParser::IdentifierContext* TocParser::NonOpExprContext::identifier() {
+  return getRuleContext<TocParser::IdentifierContext>(0);
+}
+
+TocParser::SubscriptContext* TocParser::NonOpExprContext::subscript() {
+  return getRuleContext<TocParser::SubscriptContext>(0);
+}
+
+TocParser::MemberAccessContext* TocParser::NonOpExprContext::memberAccess() {
+  return getRuleContext<TocParser::MemberAccessContext>(0);
+}
+
+TocParser::ParenExprContext* TocParser::NonOpExprContext::parenExpr() {
+  return getRuleContext<TocParser::ParenExprContext>(0);
+}
+
+
+size_t TocParser::NonOpExprContext::getRuleIndex() const {
+  return TocParser::RuleNonOpExpr;
+}
+
+void TocParser::NonOpExprContext::enterRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<TocListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->enterNonOpExpr(this);
+}
+
+void TocParser::NonOpExprContext::exitRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<TocListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->exitNonOpExpr(this);
+}
+
+TocParser::NonOpExprContext* TocParser::nonOpExpr() {
+  NonOpExprContext *_localctx = _tracker.createInstance<NonOpExprContext>(_ctx, getState());
+  enterRule(_localctx, 46, TocParser::RuleNonOpExpr);
+
+#if __cplusplus > 201703L
+  auto onExit = finally([=, this] {
+#else
+  auto onExit = finally([=] {
+#endif
+    exitRule();
+  });
+  try {
+    setState(195);
+    _errHandler->sync(this);
+    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 10, _ctx)) {
+    case 1: {
+      enterOuterAlt(_localctx, 1);
+      setState(189);
+      funcCall();
+      break;
+    }
+
+    case 2: {
+      enterOuterAlt(_localctx, 2);
+      setState(190);
+      literal();
+      break;
+    }
+
+    case 3: {
+      enterOuterAlt(_localctx, 3);
+      setState(191);
+      identifier();
+      break;
+    }
+
+    case 4: {
+      enterOuterAlt(_localctx, 4);
+      setState(192);
+      subscript();
+      break;
+    }
+
+    case 5: {
+      enterOuterAlt(_localctx, 5);
+      setState(193);
+      memberAccess();
+      break;
+    }
+
+    case 6: {
+      enterOuterAlt(_localctx, 6);
+      setState(194);
+      parenExpr();
+      break;
+    }
+
+    default:
+      break;
+    }
+   
+  }
+  catch (RecognitionException &e) {
+    _errHandler->reportError(this, e);
+    _localctx->exception = std::current_exception();
+    _errHandler->recover(this, _localctx->exception);
+  }
+
+  return _localctx;
+}
+
+//----------------- NonSubscriptExprContext ------------------------------------------------------------------
+
+TocParser::NonSubscriptExprContext::NonSubscriptExprContext(ParserRuleContext *parent, size_t invokingState)
+  : ParserRuleContext(parent, invokingState) {
+}
+
+TocParser::FuncCallContext* TocParser::NonSubscriptExprContext::funcCall() {
+  return getRuleContext<TocParser::FuncCallContext>(0);
+}
+
+TocParser::IdentifierContext* TocParser::NonSubscriptExprContext::identifier() {
+  return getRuleContext<TocParser::IdentifierContext>(0);
+}
+
+TocParser::MemberAccessContext* TocParser::NonSubscriptExprContext::memberAccess() {
+  return getRuleContext<TocParser::MemberAccessContext>(0);
+}
+
+TocParser::ParenExprContext* TocParser::NonSubscriptExprContext::parenExpr() {
+  return getRuleContext<TocParser::ParenExprContext>(0);
+}
+
+
+size_t TocParser::NonSubscriptExprContext::getRuleIndex() const {
+  return TocParser::RuleNonSubscriptExpr;
+}
+
+void TocParser::NonSubscriptExprContext::enterRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<TocListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->enterNonSubscriptExpr(this);
+}
+
+void TocParser::NonSubscriptExprContext::exitRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<TocListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->exitNonSubscriptExpr(this);
+}
+
+TocParser::NonSubscriptExprContext* TocParser::nonSubscriptExpr() {
+  NonSubscriptExprContext *_localctx = _tracker.createInstance<NonSubscriptExprContext>(_ctx, getState());
+  enterRule(_localctx, 48, TocParser::RuleNonSubscriptExpr);
+
+#if __cplusplus > 201703L
+  auto onExit = finally([=, this] {
+#else
+  auto onExit = finally([=] {
+#endif
+    exitRule();
+  });
+  try {
+    setState(201);
+    _errHandler->sync(this);
+    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 11, _ctx)) {
+    case 1: {
+      enterOuterAlt(_localctx, 1);
+      setState(197);
+      funcCall();
+      break;
+    }
+
+    case 2: {
+      enterOuterAlt(_localctx, 2);
+      setState(198);
+      identifier();
+      break;
+    }
+
+    case 3: {
+      enterOuterAlt(_localctx, 3);
+      setState(199);
+      memberAccess();
+      break;
+    }
+
+    case 4: {
+      enterOuterAlt(_localctx, 4);
+      setState(200);
+      parenExpr();
+      break;
+    }
+
+    default:
+      break;
+    }
+   
+  }
+  catch (RecognitionException &e) {
+    _errHandler->reportError(this, e);
+    _localctx->exception = std::current_exception();
+    _errHandler->recover(this, _localctx->exception);
+  }
+
+  return _localctx;
+}
+
+//----------------- FuncCallContext ------------------------------------------------------------------
+
+TocParser::FuncCallContext::FuncCallContext(ParserRuleContext *parent, size_t invokingState)
+  : ParserRuleContext(parent, invokingState) {
+}
+
+TocParser::FuncNameContext* TocParser::FuncCallContext::funcName() {
+  return getRuleContext<TocParser::FuncNameContext>(0);
+}
+
+std::vector<TocParser::ExprContext *> TocParser::FuncCallContext::expr() {
+  return getRuleContexts<TocParser::ExprContext>();
+}
+
+TocParser::ExprContext* TocParser::FuncCallContext::expr(size_t i) {
+  return getRuleContext<TocParser::ExprContext>(i);
+}
+
+
+size_t TocParser::FuncCallContext::getRuleIndex() const {
+  return TocParser::RuleFuncCall;
+}
+
+void TocParser::FuncCallContext::enterRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<TocListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->enterFuncCall(this);
+}
+
+void TocParser::FuncCallContext::exitRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<TocListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->exitFuncCall(this);
+}
+
+TocParser::FuncCallContext* TocParser::funcCall() {
+  FuncCallContext *_localctx = _tracker.createInstance<FuncCallContext>(_ctx, getState());
+  enterRule(_localctx, 50, TocParser::RuleFuncCall);
+  size_t _la = 0;
+
+#if __cplusplus > 201703L
+  auto onExit = finally([=, this] {
+#else
+  auto onExit = finally([=] {
+#endif
+    exitRule();
+  });
+  try {
+    enterOuterAlt(_localctx, 1);
+    setState(203);
+    funcName();
+    setState(204);
+    match(TocParser::T__4);
+    setState(213);
+    _errHandler->sync(this);
+
+    _la = _input->LA(1);
+    if ((((_la & ~ 0x3fULL) == 0) &&
+      ((1ULL << _la) & ((1ULL << TocParser::T__4)
+      | (1ULL << TocParser::INTLIT)
+      | (1ULL << TocParser::NAME))) != 0)) {
+      setState(205);
+      expr();
+      setState(210);
+      _errHandler->sync(this);
+      _la = _input->LA(1);
+      while (_la == TocParser::T__6) {
+        setState(206);
+        match(TocParser::T__6);
+        setState(207);
+        expr();
+        setState(212);
+        _errHandler->sync(this);
+        _la = _input->LA(1);
+      }
+    }
+    setState(215);
+    match(TocParser::T__5);
+   
+  }
+  catch (RecognitionException &e) {
+    _errHandler->reportError(this, e);
+    _localctx->exception = std::current_exception();
+    _errHandler->recover(this, _localctx->exception);
+  }
+
+  return _localctx;
+}
+
+//----------------- OperatorExprContext ------------------------------------------------------------------
+
+TocParser::OperatorExprContext::OperatorExprContext(ParserRuleContext *parent, size_t invokingState)
+  : ParserRuleContext(parent, invokingState) {
+}
+
+TocParser::BinaryOperatorContext* TocParser::OperatorExprContext::binaryOperator() {
+  return getRuleContext<TocParser::BinaryOperatorContext>(0);
+}
+
+
+size_t TocParser::OperatorExprContext::getRuleIndex() const {
+  return TocParser::RuleOperatorExpr;
+}
+
+void TocParser::OperatorExprContext::enterRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<TocListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->enterOperatorExpr(this);
+}
+
+void TocParser::OperatorExprContext::exitRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<TocListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->exitOperatorExpr(this);
+}
+
+TocParser::OperatorExprContext* TocParser::operatorExpr() {
+  OperatorExprContext *_localctx = _tracker.createInstance<OperatorExprContext>(_ctx, getState());
+  enterRule(_localctx, 52, TocParser::RuleOperatorExpr);
+
+#if __cplusplus > 201703L
+  auto onExit = finally([=, this] {
+#else
+  auto onExit = finally([=] {
+#endif
+    exitRule();
+  });
+  try {
+    enterOuterAlt(_localctx, 1);
+    setState(217);
+    binaryOperator();
+   
+  }
+  catch (RecognitionException &e) {
+    _errHandler->reportError(this, e);
+    _localctx->exception = std::current_exception();
+    _errHandler->recover(this, _localctx->exception);
+  }
+
+  return _localctx;
+}
+
+//----------------- BinaryOperatorContext ------------------------------------------------------------------
+
+TocParser::BinaryOperatorContext::BinaryOperatorContext(ParserRuleContext *parent, size_t invokingState)
+  : ParserRuleContext(parent, invokingState) {
+}
+
+std::vector<TocParser::NonOpExprContext *> TocParser::BinaryOperatorContext::nonOpExpr() {
+  return getRuleContexts<TocParser::NonOpExprContext>();
+}
+
+TocParser::NonOpExprContext* TocParser::BinaryOperatorContext::nonOpExpr(size_t i) {
+  return getRuleContext<TocParser::NonOpExprContext>(i);
+}
+
+std::vector<tree::TerminalNode *> TocParser::BinaryOperatorContext::BINARY_OPERATOR() {
+  return getTokens(TocParser::BINARY_OPERATOR);
+}
+
+tree::TerminalNode* TocParser::BinaryOperatorContext::BINARY_OPERATOR(size_t i) {
+  return getToken(TocParser::BINARY_OPERATOR, i);
+}
+
+
+size_t TocParser::BinaryOperatorContext::getRuleIndex() const {
+  return TocParser::RuleBinaryOperator;
+}
+
+void TocParser::BinaryOperatorContext::enterRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<TocListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->enterBinaryOperator(this);
+}
+
+void TocParser::BinaryOperatorContext::exitRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<TocListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->exitBinaryOperator(this);
+}
+
+TocParser::BinaryOperatorContext* TocParser::binaryOperator() {
+  BinaryOperatorContext *_localctx = _tracker.createInstance<BinaryOperatorContext>(_ctx, getState());
+  enterRule(_localctx, 54, TocParser::RuleBinaryOperator);
+  size_t _la = 0;
+
+#if __cplusplus > 201703L
+  auto onExit = finally([=, this] {
+#else
+  auto onExit = finally([=] {
+#endif
+    exitRule();
+  });
+  try {
+    enterOuterAlt(_localctx, 1);
+    setState(219);
+    nonOpExpr();
+    setState(220);
+    match(TocParser::BINARY_OPERATOR);
+    setState(221);
+    nonOpExpr();
+    setState(226);
+    _errHandler->sync(this);
+    _la = _input->LA(1);
+    while (_la == TocParser::BINARY_OPERATOR) {
+      setState(222);
+      match(TocParser::BINARY_OPERATOR);
+      setState(223);
+      nonOpExpr();
+      setState(228);
+      _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;
+}
+
+//----------------- IdentifierContext ------------------------------------------------------------------
+
+TocParser::IdentifierContext::IdentifierContext(ParserRuleContext *parent, size_t invokingState)
+  : ParserRuleContext(parent, invokingState) {
+}
+
+TocParser::VarNameContext* TocParser::IdentifierContext::varName() {
+  return getRuleContext<TocParser::VarNameContext>(0);
+}
+
+
+size_t TocParser::IdentifierContext::getRuleIndex() const {
+  return TocParser::RuleIdentifier;
+}
+
+void TocParser::IdentifierContext::enterRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<TocListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->enterIdentifier(this);
+}
+
+void TocParser::IdentifierContext::exitRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<TocListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->exitIdentifier(this);
+}
+
+TocParser::IdentifierContext* TocParser::identifier() {
+  IdentifierContext *_localctx = _tracker.createInstance<IdentifierContext>(_ctx, getState());
+  enterRule(_localctx, 56, TocParser::RuleIdentifier);
+
+#if __cplusplus > 201703L
+  auto onExit = finally([=, this] {
+#else
+  auto onExit = finally([=] {
+#endif
+    exitRule();
+  });
+  try {
+    enterOuterAlt(_localctx, 1);
+    setState(229);
+    varName();
+   
+  }
+  catch (RecognitionException &e) {
+    _errHandler->reportError(this, e);
+    _localctx->exception = std::current_exception();
+    _errHandler->recover(this, _localctx->exception);
+  }
+
+  return _localctx;
+}
+
+//----------------- LiteralContext ------------------------------------------------------------------
+
+TocParser::LiteralContext::LiteralContext(ParserRuleContext *parent, size_t invokingState)
+  : ParserRuleContext(parent, invokingState) {
+}
+
+tree::TerminalNode* TocParser::LiteralContext::INTLIT() {
+  return getToken(TocParser::INTLIT, 0);
+}
+
+
+size_t TocParser::LiteralContext::getRuleIndex() const {
+  return TocParser::RuleLiteral;
+}
+
+void TocParser::LiteralContext::enterRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<TocListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->enterLiteral(this);
+}
+
+void TocParser::LiteralContext::exitRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<TocListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->exitLiteral(this);
+}
+
+TocParser::LiteralContext* TocParser::literal() {
+  LiteralContext *_localctx = _tracker.createInstance<LiteralContext>(_ctx, getState());
+  enterRule(_localctx, 58, TocParser::RuleLiteral);
+
+#if __cplusplus > 201703L
+  auto onExit = finally([=, this] {
+#else
+  auto onExit = finally([=] {
+#endif
+    exitRule();
+  });
+  try {
+    enterOuterAlt(_localctx, 1);
+    setState(231);
+    match(TocParser::INTLIT);
+   
+  }
+  catch (RecognitionException &e) {
+    _errHandler->reportError(this, e);
+    _localctx->exception = std::current_exception();
+    _errHandler->recover(this, _localctx->exception);
+  }
+
+  return _localctx;
+}
+
+//----------------- SubscriptContext ------------------------------------------------------------------
+
+TocParser::SubscriptContext::SubscriptContext(ParserRuleContext *parent, size_t invokingState)
+  : ParserRuleContext(parent, invokingState) {
+}
+
+TocParser::NonSubscriptExprContext* TocParser::SubscriptContext::nonSubscriptExpr() {
+  return getRuleContext<TocParser::NonSubscriptExprContext>(0);
+}
+
+TocParser::ExprContext* TocParser::SubscriptContext::expr() {
+  return getRuleContext<TocParser::ExprContext>(0);
+}
+
+
+size_t TocParser::SubscriptContext::getRuleIndex() const {
+  return TocParser::RuleSubscript;
+}
+
+void TocParser::SubscriptContext::enterRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<TocListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->enterSubscript(this);
+}
+
+void TocParser::SubscriptContext::exitRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<TocListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->exitSubscript(this);
+}
+
+TocParser::SubscriptContext* TocParser::subscript() {
+  SubscriptContext *_localctx = _tracker.createInstance<SubscriptContext>(_ctx, getState());
+  enterRule(_localctx, 60, TocParser::RuleSubscript);
+
+#if __cplusplus > 201703L
+  auto onExit = finally([=, this] {
+#else
+  auto onExit = finally([=] {
+#endif
+    exitRule();
+  });
+  try {
+    enterOuterAlt(_localctx, 1);
+    setState(233);
+    nonSubscriptExpr();
+    setState(234);
+    match(TocParser::T__13);
+    setState(235);
+    expr();
+    setState(236);
+    match(TocParser::T__14);
+   
+  }
+  catch (RecognitionException &e) {
+    _errHandler->reportError(this, e);
+    _localctx->exception = std::current_exception();
+    _errHandler->recover(this, _localctx->exception);
+  }
+
+  return _localctx;
+}
+
+//----------------- MemberAccessContext ------------------------------------------------------------------
+
+TocParser::MemberAccessContext::MemberAccessContext(ParserRuleContext *parent, size_t invokingState)
+  : ParserRuleContext(parent, invokingState) {
+}
+
+std::vector<TocParser::IdentifierContext *> TocParser::MemberAccessContext::identifier() {
+  return getRuleContexts<TocParser::IdentifierContext>();
+}
+
+TocParser::IdentifierContext* TocParser::MemberAccessContext::identifier(size_t i) {
+  return getRuleContext<TocParser::IdentifierContext>(i);
+}
+
+
+size_t TocParser::MemberAccessContext::getRuleIndex() const {
+  return TocParser::RuleMemberAccess;
+}
+
+void TocParser::MemberAccessContext::enterRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<TocListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->enterMemberAccess(this);
+}
+
+void TocParser::MemberAccessContext::exitRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<TocListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->exitMemberAccess(this);
+}
+
+TocParser::MemberAccessContext* TocParser::memberAccess() {
+  MemberAccessContext *_localctx = _tracker.createInstance<MemberAccessContext>(_ctx, getState());
+  enterRule(_localctx, 62, TocParser::RuleMemberAccess);
+
+#if __cplusplus > 201703L
+  auto onExit = finally([=, this] {
+#else
+  auto onExit = finally([=] {
+#endif
+    exitRule();
+  });
+  try {
+    enterOuterAlt(_localctx, 1);
+    setState(238);
+    identifier();
+    setState(239);
+    match(TocParser::T__15);
+    setState(240);
+    identifier();
+   
+  }
+  catch (RecognitionException &e) {
+    _errHandler->reportError(this, e);
+    _localctx->exception = std::current_exception();
+    _errHandler->recover(this, _localctx->exception);
+  }
+
+  return _localctx;
+}
+
+//----------------- ParenExprContext ------------------------------------------------------------------
+
+TocParser::ParenExprContext::ParenExprContext(ParserRuleContext *parent, size_t invokingState)
+  : ParserRuleContext(parent, invokingState) {
+}
+
+TocParser::ExprContext* TocParser::ParenExprContext::expr() {
+  return getRuleContext<TocParser::ExprContext>(0);
+}
+
+
+size_t TocParser::ParenExprContext::getRuleIndex() const {
+  return TocParser::RuleParenExpr;
+}
+
+void TocParser::ParenExprContext::enterRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<TocListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->enterParenExpr(this);
+}
+
+void TocParser::ParenExprContext::exitRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<TocListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->exitParenExpr(this);
+}
+
+TocParser::ParenExprContext* TocParser::parenExpr() {
+  ParenExprContext *_localctx = _tracker.createInstance<ParenExprContext>(_ctx, getState());
+  enterRule(_localctx, 64, TocParser::RuleParenExpr);
+
+#if __cplusplus > 201703L
+  auto onExit = finally([=, this] {
+#else
+  auto onExit = finally([=] {
+#endif
+    exitRule();
+  });
+  try {
+    enterOuterAlt(_localctx, 1);
+    setState(242);
+    match(TocParser::T__4);
+    setState(243);
+    expr();
+    setState(244);
+    match(TocParser::T__5);
+   
+  }
+  catch (RecognitionException &e) {
+    _errHandler->reportError(this, e);
+    _localctx->exception = std::current_exception();
+    _errHandler->recover(this, _localctx->exception);
+  }
+
+  return _localctx;
+}
+
+//----------------- FuncNameContext ------------------------------------------------------------------
+
+TocParser::FuncNameContext::FuncNameContext(ParserRuleContext *parent, size_t invokingState)
+  : ParserRuleContext(parent, invokingState) {
+}
+
+tree::TerminalNode* TocParser::FuncNameContext::NAME() {
+  return getToken(TocParser::NAME, 0);
+}
+
+
+size_t TocParser::FuncNameContext::getRuleIndex() const {
+  return TocParser::RuleFuncName;
+}
+
+void TocParser::FuncNameContext::enterRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<TocListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->enterFuncName(this);
+}
+
+void TocParser::FuncNameContext::exitRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<TocListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->exitFuncName(this);
+}
+
+TocParser::FuncNameContext* TocParser::funcName() {
+  FuncNameContext *_localctx = _tracker.createInstance<FuncNameContext>(_ctx, getState());
+  enterRule(_localctx, 66, TocParser::RuleFuncName);
+
+#if __cplusplus > 201703L
+  auto onExit = finally([=, this] {
+#else
+  auto onExit = finally([=] {
+#endif
+    exitRule();
+  });
+  try {
+    enterOuterAlt(_localctx, 1);
+    setState(246);
+    match(TocParser::NAME);
+   
+  }
+  catch (RecognitionException &e) {
+    _errHandler->reportError(this, e);
+    _localctx->exception = std::current_exception();
+    _errHandler->recover(this, _localctx->exception);
+  }
+
+  return _localctx;
+}
+
+//----------------- VarNameContext ------------------------------------------------------------------
+
+TocParser::VarNameContext::VarNameContext(ParserRuleContext *parent, size_t invokingState)
+  : ParserRuleContext(parent, invokingState) {
+}
+
+tree::TerminalNode* TocParser::VarNameContext::NAME() {
+  return getToken(TocParser::NAME, 0);
+}
+
+
+size_t TocParser::VarNameContext::getRuleIndex() const {
+  return TocParser::RuleVarName;
+}
+
+void TocParser::VarNameContext::enterRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<TocListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->enterVarName(this);
+}
+
+void TocParser::VarNameContext::exitRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<TocListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->exitVarName(this);
+}
+
+TocParser::VarNameContext* TocParser::varName() {
+  VarNameContext *_localctx = _tracker.createInstance<VarNameContext>(_ctx, getState());
+  enterRule(_localctx, 68, TocParser::RuleVarName);
+
+#if __cplusplus > 201703L
+  auto onExit = finally([=, this] {
+#else
+  auto onExit = finally([=] {
+#endif
+    exitRule();
+  });
+  try {
+    enterOuterAlt(_localctx, 1);
+    setState(248);
+    match(TocParser::NAME);
+   
+  }
+  catch (RecognitionException &e) {
+    _errHandler->reportError(this, e);
+    _localctx->exception = std::current_exception();
+    _errHandler->recover(this, _localctx->exception);
+  }
+
+  return _localctx;
+}
+
+//----------------- TypeNameContext ------------------------------------------------------------------
+
+TocParser::TypeNameContext::TypeNameContext(ParserRuleContext *parent, size_t invokingState)
+  : ParserRuleContext(parent, invokingState) {
+}
+
+tree::TerminalNode* TocParser::TypeNameContext::NAME() {
+  return getToken(TocParser::NAME, 0);
+}
+
+
+size_t TocParser::TypeNameContext::getRuleIndex() const {
+  return TocParser::RuleTypeName;
+}
+
+void TocParser::TypeNameContext::enterRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<TocListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->enterTypeName(this);
+}
+
+void TocParser::TypeNameContext::exitRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<TocListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->exitTypeName(this);
+}
+
+TocParser::TypeNameContext* TocParser::typeName() {
+  TypeNameContext *_localctx = _tracker.createInstance<TypeNameContext>(_ctx, getState());
+  enterRule(_localctx, 70, TocParser::RuleTypeName);
+
+#if __cplusplus > 201703L
+  auto onExit = finally([=, this] {
+#else
+  auto onExit = finally([=] {
+#endif
+    exitRule();
+  });
+  try {
+    enterOuterAlt(_localctx, 1);
+    setState(250);
+    match(TocParser::NAME);
+   
+  }
+  catch (RecognitionException &e) {
+    _errHandler->reportError(this, e);
+    _localctx->exception = std::current_exception();
+    _errHandler->recover(this, _localctx->exception);
+  }
+
+  return _localctx;
+}
+
+//----------------- StructNameContext ------------------------------------------------------------------
+
+TocParser::StructNameContext::StructNameContext(ParserRuleContext *parent, size_t invokingState)
+  : ParserRuleContext(parent, invokingState) {
+}
+
+tree::TerminalNode* TocParser::StructNameContext::NAME() {
+  return getToken(TocParser::NAME, 0);
+}
+
+
+size_t TocParser::StructNameContext::getRuleIndex() const {
+  return TocParser::RuleStructName;
+}
+
+void TocParser::StructNameContext::enterRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<TocListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->enterStructName(this);
+}
+
+void TocParser::StructNameContext::exitRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<TocListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->exitStructName(this);
+}
+
+TocParser::StructNameContext* TocParser::structName() {
+  StructNameContext *_localctx = _tracker.createInstance<StructNameContext>(_ctx, getState());
+  enterRule(_localctx, 72, TocParser::RuleStructName);
+
+#if __cplusplus > 201703L
+  auto onExit = finally([=, this] {
+#else
+  auto onExit = finally([=] {
+#endif
+    exitRule();
+  });
+  try {
+    enterOuterAlt(_localctx, 1);
+    setState(252);
+    match(TocParser::NAME);
+   
+  }
+  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> TocParser::_decisionToDFA;
+atn::PredictionContextCache TocParser::_sharedContextCache;
+
+// We own the ATN which in turn owns the ATN states.
+atn::ATN TocParser::_atn;
+std::vector<uint16_t> TocParser::_serializedATN;
+
+std::vector<std::string> TocParser::_ruleNames = {
+  "prog", "decl", "varDecl", "var", "type", "funcDecl", "func", "parameter", 
+  "firstParameter", "additionalParameter", "body", "structDecl", "structMember", 
+  "structVar", "structMethod", "stmt", "conditional", "ifCond", "loop", 
+  "whileLoop", "assignment", "returnStmt", "expr", "nonOpExpr", "nonSubscriptExpr", 
+  "funcCall", "operatorExpr", "binaryOperator", "identifier", "literal", 
+  "subscript", "memberAccess", "parenExpr", "funcName", "varName", "typeName", 
+  "structName"
+};
+
+std::vector<std::string> TocParser::_literalNames = {
+  "", "'var'", "':'", "'='", "'func'", "'('", "')'", "','", "'{'", "'}'", 
+  "'struct'", "'if'", "'while'", "'return'", "'['", "']'", "'.'"
+};
+
+std::vector<std::string> TocParser::_symbolicNames = {
+  "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "BINARY_OPERATOR", 
+  "INTLIT", "NAME", "WS", "NEWLINE"
+};
+
+dfa::Vocabulary TocParser::_vocabulary(_literalNames, _symbolicNames);
+
+std::vector<std::string> TocParser::_tokenNames;
+
+TocParser::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);
+    }
+	}
+
+  static const uint16_t serializedATNSegment0[] = {
+    0x3, 0x608b, 0xa72a, 0x8133, 0xb9ed, 0x417c, 0x3be7, 0x7786, 0x5964, 
+       0x3, 0x17, 0x101, 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, 0x3, 0x2, 0x6, 0x2, 0x4e, 0xa, 0x2, 0xd, 0x2, 0xe, 0x2, 
+       0x4f, 0x3, 0x2, 0x3, 0x2, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x5, 0x3, 
+       0x57, 0xa, 0x3, 0x3, 0x4, 0x3, 0x4, 0x3, 0x4, 0x3, 0x5, 0x3, 0x5, 
+       0x3, 0x5, 0x3, 0x5, 0x3, 0x5, 0x3, 0x5, 0x5, 0x5, 0x62, 0xa, 0x5, 
+       0x3, 0x6, 0x3, 0x6, 0x3, 0x7, 0x3, 0x7, 0x3, 0x7, 0x3, 0x8, 0x3, 
+       0x8, 0x3, 0x8, 0x3, 0x8, 0x3, 0x8, 0x3, 0x8, 0x3, 0x8, 0x3, 0x8, 
+       0x3, 0x8, 0x3, 0x9, 0x3, 0x9, 0x7, 0x9, 0x74, 0xa, 0x9, 0xc, 0x9, 
+       0xe, 0x9, 0x77, 0xb, 0x9, 0x5, 0x9, 0x79, 0xa, 0x9, 0x3, 0xa, 0x3, 
+       0xa, 0x3, 0xb, 0x3, 0xb, 0x3, 0xb, 0x3, 0xc, 0x3, 0xc, 0x7, 0xc, 
+       0x82, 0xa, 0xc, 0xc, 0xc, 0xe, 0xc, 0x85, 0xb, 0xc, 0x3, 0xc, 0x3, 
+       0xc, 0x3, 0xd, 0x3, 0xd, 0x3, 0xd, 0x3, 0xd, 0x7, 0xd, 0x8d, 0xa, 
+       0xd, 0xc, 0xd, 0xe, 0xd, 0x90, 0xb, 0xd, 0x3, 0xd, 0x3, 0xd, 0x3, 
+       0xe, 0x3, 0xe, 0x5, 0xe, 0x96, 0xa, 0xe, 0x3, 0xf, 0x3, 0xf, 0x3, 
+       0x10, 0x3, 0x10, 0x3, 0x11, 0x3, 0x11, 0x3, 0x11, 0x3, 0x11, 0x3, 
+       0x11, 0x3, 0x11, 0x5, 0x11, 0xa2, 0xa, 0x11, 0x3, 0x12, 0x3, 0x12, 
+       0x3, 0x13, 0x3, 0x13, 0x3, 0x13, 0x3, 0x13, 0x3, 0x14, 0x3, 0x14, 
+       0x3, 0x15, 0x3, 0x15, 0x3, 0x15, 0x3, 0x15, 0x3, 0x16, 0x3, 0x16, 
+       0x3, 0x16, 0x3, 0x16, 0x3, 0x17, 0x3, 0x17, 0x3, 0x17, 0x3, 0x18, 
+       0x3, 0x18, 0x3, 0x18, 0x3, 0x18, 0x3, 0x18, 0x3, 0x18, 0x3, 0x18, 
+       0x5, 0x18, 0xbe, 0xa, 0x18, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 
+       0x19, 0x3, 0x19, 0x3, 0x19, 0x5, 0x19, 0xc6, 0xa, 0x19, 0x3, 0x1a, 
+       0x3, 0x1a, 0x3, 0x1a, 0x3, 0x1a, 0x5, 0x1a, 0xcc, 0xa, 0x1a, 0x3, 
+       0x1b, 0x3, 0x1b, 0x3, 0x1b, 0x3, 0x1b, 0x3, 0x1b, 0x7, 0x1b, 0xd3, 
+       0xa, 0x1b, 0xc, 0x1b, 0xe, 0x1b, 0xd6, 0xb, 0x1b, 0x5, 0x1b, 0xd8, 
+       0xa, 0x1b, 0x3, 0x1b, 0x3, 0x1b, 0x3, 0x1c, 0x3, 0x1c, 0x3, 0x1d, 
+       0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x7, 0x1d, 0xe3, 0xa, 
+       0x1d, 0xc, 0x1d, 0xe, 0x1d, 0xe6, 0xb, 0x1d, 0x3, 0x1e, 0x3, 0x1e, 
+       0x3, 0x1f, 0x3, 0x1f, 0x3, 0x20, 0x3, 0x20, 0x3, 0x20, 0x3, 0x20, 
+       0x3, 0x20, 0x3, 0x21, 0x3, 0x21, 0x3, 0x21, 0x3, 0x21, 0x3, 0x22, 
+       0x3, 0x22, 0x3, 0x22, 0x3, 0x22, 0x3, 0x23, 0x3, 0x23, 0x3, 0x24, 
+       0x3, 0x24, 0x3, 0x25, 0x3, 0x25, 0x3, 0x26, 0x3, 0x26, 0x3, 0x26, 
+       0x2, 0x2, 0x27, 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, 0x2, 0x2, 0x2, 0xfa, 0x2, 0x4d, 0x3, 
+       0x2, 0x2, 0x2, 0x4, 0x56, 0x3, 0x2, 0x2, 0x2, 0x6, 0x58, 0x3, 0x2, 
+       0x2, 0x2, 0x8, 0x5b, 0x3, 0x2, 0x2, 0x2, 0xa, 0x63, 0x3, 0x2, 0x2, 
+       0x2, 0xc, 0x65, 0x3, 0x2, 0x2, 0x2, 0xe, 0x68, 0x3, 0x2, 0x2, 0x2, 
+       0x10, 0x78, 0x3, 0x2, 0x2, 0x2, 0x12, 0x7a, 0x3, 0x2, 0x2, 0x2, 0x14, 
+       0x7c, 0x3, 0x2, 0x2, 0x2, 0x16, 0x7f, 0x3, 0x2, 0x2, 0x2, 0x18, 0x88, 
+       0x3, 0x2, 0x2, 0x2, 0x1a, 0x95, 0x3, 0x2, 0x2, 0x2, 0x1c, 0x97, 0x3, 
+       0x2, 0x2, 0x2, 0x1e, 0x99, 0x3, 0x2, 0x2, 0x2, 0x20, 0xa1, 0x3, 0x2, 
+       0x2, 0x2, 0x22, 0xa3, 0x3, 0x2, 0x2, 0x2, 0x24, 0xa5, 0x3, 0x2, 0x2, 
+       0x2, 0x26, 0xa9, 0x3, 0x2, 0x2, 0x2, 0x28, 0xab, 0x3, 0x2, 0x2, 0x2, 
+       0x2a, 0xaf, 0x3, 0x2, 0x2, 0x2, 0x2c, 0xb3, 0x3, 0x2, 0x2, 0x2, 0x2e, 
+       0xbd, 0x3, 0x2, 0x2, 0x2, 0x30, 0xc5, 0x3, 0x2, 0x2, 0x2, 0x32, 0xcb, 
+       0x3, 0x2, 0x2, 0x2, 0x34, 0xcd, 0x3, 0x2, 0x2, 0x2, 0x36, 0xdb, 0x3, 
+       0x2, 0x2, 0x2, 0x38, 0xdd, 0x3, 0x2, 0x2, 0x2, 0x3a, 0xe7, 0x3, 0x2, 
+       0x2, 0x2, 0x3c, 0xe9, 0x3, 0x2, 0x2, 0x2, 0x3e, 0xeb, 0x3, 0x2, 0x2, 
+       0x2, 0x40, 0xf0, 0x3, 0x2, 0x2, 0x2, 0x42, 0xf4, 0x3, 0x2, 0x2, 0x2, 
+       0x44, 0xf8, 0x3, 0x2, 0x2, 0x2, 0x46, 0xfa, 0x3, 0x2, 0x2, 0x2, 0x48, 
+       0xfc, 0x3, 0x2, 0x2, 0x2, 0x4a, 0xfe, 0x3, 0x2, 0x2, 0x2, 0x4c, 0x4e, 
+       0x5, 0x4, 0x3, 0x2, 0x4d, 0x4c, 0x3, 0x2, 0x2, 0x2, 0x4e, 0x4f, 0x3, 
+       0x2, 0x2, 0x2, 0x4f, 0x4d, 0x3, 0x2, 0x2, 0x2, 0x4f, 0x50, 0x3, 0x2, 
+       0x2, 0x2, 0x50, 0x51, 0x3, 0x2, 0x2, 0x2, 0x51, 0x52, 0x7, 0x2, 0x2, 
+       0x3, 0x52, 0x3, 0x3, 0x2, 0x2, 0x2, 0x53, 0x57, 0x5, 0x6, 0x4, 0x2, 
+       0x54, 0x57, 0x5, 0xc, 0x7, 0x2, 0x55, 0x57, 0x5, 0x18, 0xd, 0x2, 
+       0x56, 0x53, 0x3, 0x2, 0x2, 0x2, 0x56, 0x54, 0x3, 0x2, 0x2, 0x2, 0x56, 
+       0x55, 0x3, 0x2, 0x2, 0x2, 0x57, 0x5, 0x3, 0x2, 0x2, 0x2, 0x58, 0x59, 
+       0x7, 0x3, 0x2, 0x2, 0x59, 0x5a, 0x5, 0x8, 0x5, 0x2, 0x5a, 0x7, 0x3, 
+       0x2, 0x2, 0x2, 0x5b, 0x5c, 0x5, 0x46, 0x24, 0x2, 0x5c, 0x5d, 0x7, 
+       0x4, 0x2, 0x2, 0x5d, 0x5e, 0x5, 0xa, 0x6, 0x2, 0x5e, 0x61, 0x3, 0x2, 
+       0x2, 0x2, 0x5f, 0x60, 0x7, 0x5, 0x2, 0x2, 0x60, 0x62, 0x5, 0x2e, 
+       0x18, 0x2, 0x61, 0x5f, 0x3, 0x2, 0x2, 0x2, 0x61, 0x62, 0x3, 0x2, 
+       0x2, 0x2, 0x62, 0x9, 0x3, 0x2, 0x2, 0x2, 0x63, 0x64, 0x5, 0x48, 0x25, 
+       0x2, 0x64, 0xb, 0x3, 0x2, 0x2, 0x2, 0x65, 0x66, 0x7, 0x6, 0x2, 0x2, 
+       0x66, 0x67, 0x5, 0xe, 0x8, 0x2, 0x67, 0xd, 0x3, 0x2, 0x2, 0x2, 0x68, 
+       0x69, 0x5, 0x44, 0x23, 0x2, 0x69, 0x6a, 0x7, 0x7, 0x2, 0x2, 0x6a, 
+       0x6b, 0x5, 0x10, 0x9, 0x2, 0x6b, 0x6c, 0x7, 0x8, 0x2, 0x2, 0x6c, 
+       0x6d, 0x7, 0x4, 0x2, 0x2, 0x6d, 0x6e, 0x5, 0xa, 0x6, 0x2, 0x6e, 0x6f, 
+       0x3, 0x2, 0x2, 0x2, 0x6f, 0x70, 0x5, 0x16, 0xc, 0x2, 0x70, 0xf, 0x3, 
+       0x2, 0x2, 0x2, 0x71, 0x75, 0x5, 0x12, 0xa, 0x2, 0x72, 0x74, 0x5, 
+       0x14, 0xb, 0x2, 0x73, 0x72, 0x3, 0x2, 0x2, 0x2, 0x74, 0x77, 0x3, 
+       0x2, 0x2, 0x2, 0x75, 0x73, 0x3, 0x2, 0x2, 0x2, 0x75, 0x76, 0x3, 0x2, 
+       0x2, 0x2, 0x76, 0x79, 0x3, 0x2, 0x2, 0x2, 0x77, 0x75, 0x3, 0x2, 0x2, 
+       0x2, 0x78, 0x71, 0x3, 0x2, 0x2, 0x2, 0x78, 0x79, 0x3, 0x2, 0x2, 0x2, 
+       0x79, 0x11, 0x3, 0x2, 0x2, 0x2, 0x7a, 0x7b, 0x5, 0x8, 0x5, 0x2, 0x7b, 
+       0x13, 0x3, 0x2, 0x2, 0x2, 0x7c, 0x7d, 0x7, 0x9, 0x2, 0x2, 0x7d, 0x7e, 
+       0x5, 0x8, 0x5, 0x2, 0x7e, 0x15, 0x3, 0x2, 0x2, 0x2, 0x7f, 0x83, 0x7, 
+       0xa, 0x2, 0x2, 0x80, 0x82, 0x5, 0x20, 0x11, 0x2, 0x81, 0x80, 0x3, 
+       0x2, 0x2, 0x2, 0x82, 0x85, 0x3, 0x2, 0x2, 0x2, 0x83, 0x81, 0x3, 0x2, 
+       0x2, 0x2, 0x83, 0x84, 0x3, 0x2, 0x2, 0x2, 0x84, 0x86, 0x3, 0x2, 0x2, 
+       0x2, 0x85, 0x83, 0x3, 0x2, 0x2, 0x2, 0x86, 0x87, 0x7, 0xb, 0x2, 0x2, 
+       0x87, 0x17, 0x3, 0x2, 0x2, 0x2, 0x88, 0x89, 0x7, 0xc, 0x2, 0x2, 0x89, 
+       0x8a, 0x5, 0x4a, 0x26, 0x2, 0x8a, 0x8e, 0x7, 0xa, 0x2, 0x2, 0x8b, 
+       0x8d, 0x5, 0x1a, 0xe, 0x2, 0x8c, 0x8b, 0x3, 0x2, 0x2, 0x2, 0x8d, 
+       0x90, 0x3, 0x2, 0x2, 0x2, 0x8e, 0x8c, 0x3, 0x2, 0x2, 0x2, 0x8e, 0x8f, 
+       0x3, 0x2, 0x2, 0x2, 0x8f, 0x91, 0x3, 0x2, 0x2, 0x2, 0x90, 0x8e, 0x3, 
+       0x2, 0x2, 0x2, 0x91, 0x92, 0x7, 0xb, 0x2, 0x2, 0x92, 0x19, 0x3, 0x2, 
+       0x2, 0x2, 0x93, 0x96, 0x5, 0x1c, 0xf, 0x2, 0x94, 0x96, 0x5, 0x1e, 
+       0x10, 0x2, 0x95, 0x93, 0x3, 0x2, 0x2, 0x2, 0x95, 0x94, 0x3, 0x2, 
+       0x2, 0x2, 0x96, 0x1b, 0x3, 0x2, 0x2, 0x2, 0x97, 0x98, 0x5, 0x8, 0x5, 
+       0x2, 0x98, 0x1d, 0x3, 0x2, 0x2, 0x2, 0x99, 0x9a, 0x5, 0xe, 0x8, 0x2, 
+       0x9a, 0x1f, 0x3, 0x2, 0x2, 0x2, 0x9b, 0xa2, 0x5, 0x6, 0x4, 0x2, 0x9c, 
+       0xa2, 0x5, 0x22, 0x12, 0x2, 0x9d, 0xa2, 0x5, 0x26, 0x14, 0x2, 0x9e, 
+       0xa2, 0x5, 0x2a, 0x16, 0x2, 0x9f, 0xa2, 0x5, 0x2c, 0x17, 0x2, 0xa0, 
+       0xa2, 0x5, 0x2e, 0x18, 0x2, 0xa1, 0x9b, 0x3, 0x2, 0x2, 0x2, 0xa1, 
+       0x9c, 0x3, 0x2, 0x2, 0x2, 0xa1, 0x9d, 0x3, 0x2, 0x2, 0x2, 0xa1, 0x9e, 
+       0x3, 0x2, 0x2, 0x2, 0xa1, 0x9f, 0x3, 0x2, 0x2, 0x2, 0xa1, 0xa0, 0x3, 
+       0x2, 0x2, 0x2, 0xa2, 0x21, 0x3, 0x2, 0x2, 0x2, 0xa3, 0xa4, 0x5, 0x24, 
+       0x13, 0x2, 0xa4, 0x23, 0x3, 0x2, 0x2, 0x2, 0xa5, 0xa6, 0x7, 0xd, 
+       0x2, 0x2, 0xa6, 0xa7, 0x5, 0x2e, 0x18, 0x2, 0xa7, 0xa8, 0x5, 0x16, 
+       0xc, 0x2, 0xa8, 0x25, 0x3, 0x2, 0x2, 0x2, 0xa9, 0xaa, 0x5, 0x28, 
+       0x15, 0x2, 0xaa, 0x27, 0x3, 0x2, 0x2, 0x2, 0xab, 0xac, 0x7, 0xe, 
+       0x2, 0x2, 0xac, 0xad, 0x5, 0x2e, 0x18, 0x2, 0xad, 0xae, 0x5, 0x16, 
+       0xc, 0x2, 0xae, 0x29, 0x3, 0x2, 0x2, 0x2, 0xaf, 0xb0, 0x5, 0x3a, 
+       0x1e, 0x2, 0xb0, 0xb1, 0x7, 0x5, 0x2, 0x2, 0xb1, 0xb2, 0x5, 0x2e, 
+       0x18, 0x2, 0xb2, 0x2b, 0x3, 0x2, 0x2, 0x2, 0xb3, 0xb4, 0x7, 0xf, 
+       0x2, 0x2, 0xb4, 0xb5, 0x5, 0x2e, 0x18, 0x2, 0xb5, 0x2d, 0x3, 0x2, 
+       0x2, 0x2, 0xb6, 0xbe, 0x5, 0x34, 0x1b, 0x2, 0xb7, 0xbe, 0x5, 0x3c, 
+       0x1f, 0x2, 0xb8, 0xbe, 0x5, 0x3a, 0x1e, 0x2, 0xb9, 0xbe, 0x5, 0x3e, 
+       0x20, 0x2, 0xba, 0xbe, 0x5, 0x40, 0x21, 0x2, 0xbb, 0xbe, 0x5, 0x42, 
+       0x22, 0x2, 0xbc, 0xbe, 0x5, 0x36, 0x1c, 0x2, 0xbd, 0xb6, 0x3, 0x2, 
+       0x2, 0x2, 0xbd, 0xb7, 0x3, 0x2, 0x2, 0x2, 0xbd, 0xb8, 0x3, 0x2, 0x2, 
+       0x2, 0xbd, 0xb9, 0x3, 0x2, 0x2, 0x2, 0xbd, 0xba, 0x3, 0x2, 0x2, 0x2, 
+       0xbd, 0xbb, 0x3, 0x2, 0x2, 0x2, 0xbd, 0xbc, 0x3, 0x2, 0x2, 0x2, 0xbe, 
+       0x2f, 0x3, 0x2, 0x2, 0x2, 0xbf, 0xc6, 0x5, 0x34, 0x1b, 0x2, 0xc0, 
+       0xc6, 0x5, 0x3c, 0x1f, 0x2, 0xc1, 0xc6, 0x5, 0x3a, 0x1e, 0x2, 0xc2, 
+       0xc6, 0x5, 0x3e, 0x20, 0x2, 0xc3, 0xc6, 0x5, 0x40, 0x21, 0x2, 0xc4, 
+       0xc6, 0x5, 0x42, 0x22, 0x2, 0xc5, 0xbf, 0x3, 0x2, 0x2, 0x2, 0xc5, 
+       0xc0, 0x3, 0x2, 0x2, 0x2, 0xc5, 0xc1, 0x3, 0x2, 0x2, 0x2, 0xc5, 0xc2, 
+       0x3, 0x2, 0x2, 0x2, 0xc5, 0xc3, 0x3, 0x2, 0x2, 0x2, 0xc5, 0xc4, 0x3, 
+       0x2, 0x2, 0x2, 0xc6, 0x31, 0x3, 0x2, 0x2, 0x2, 0xc7, 0xcc, 0x5, 0x34, 
+       0x1b, 0x2, 0xc8, 0xcc, 0x5, 0x3a, 0x1e, 0x2, 0xc9, 0xcc, 0x5, 0x40, 
+       0x21, 0x2, 0xca, 0xcc, 0x5, 0x42, 0x22, 0x2, 0xcb, 0xc7, 0x3, 0x2, 
+       0x2, 0x2, 0xcb, 0xc8, 0x3, 0x2, 0x2, 0x2, 0xcb, 0xc9, 0x3, 0x2, 0x2, 
+       0x2, 0xcb, 0xca, 0x3, 0x2, 0x2, 0x2, 0xcc, 0x33, 0x3, 0x2, 0x2, 0x2, 
+       0xcd, 0xce, 0x5, 0x44, 0x23, 0x2, 0xce, 0xd7, 0x7, 0x7, 0x2, 0x2, 
+       0xcf, 0xd4, 0x5, 0x2e, 0x18, 0x2, 0xd0, 0xd1, 0x7, 0x9, 0x2, 0x2, 
+       0xd1, 0xd3, 0x5, 0x2e, 0x18, 0x2, 0xd2, 0xd0, 0x3, 0x2, 0x2, 0x2, 
+       0xd3, 0xd6, 0x3, 0x2, 0x2, 0x2, 0xd4, 0xd2, 0x3, 0x2, 0x2, 0x2, 0xd4, 
+       0xd5, 0x3, 0x2, 0x2, 0x2, 0xd5, 0xd8, 0x3, 0x2, 0x2, 0x2, 0xd6, 0xd4, 
+       0x3, 0x2, 0x2, 0x2, 0xd7, 0xcf, 0x3, 0x2, 0x2, 0x2, 0xd7, 0xd8, 0x3, 
+       0x2, 0x2, 0x2, 0xd8, 0xd9, 0x3, 0x2, 0x2, 0x2, 0xd9, 0xda, 0x7, 0x8, 
+       0x2, 0x2, 0xda, 0x35, 0x3, 0x2, 0x2, 0x2, 0xdb, 0xdc, 0x5, 0x38, 
+       0x1d, 0x2, 0xdc, 0x37, 0x3, 0x2, 0x2, 0x2, 0xdd, 0xde, 0x5, 0x30, 
+       0x19, 0x2, 0xde, 0xdf, 0x7, 0x13, 0x2, 0x2, 0xdf, 0xe4, 0x5, 0x30, 
+       0x19, 0x2, 0xe0, 0xe1, 0x7, 0x13, 0x2, 0x2, 0xe1, 0xe3, 0x5, 0x30, 
+       0x19, 0x2, 0xe2, 0xe0, 0x3, 0x2, 0x2, 0x2, 0xe3, 0xe6, 0x3, 0x2, 
+       0x2, 0x2, 0xe4, 0xe2, 0x3, 0x2, 0x2, 0x2, 0xe4, 0xe5, 0x3, 0x2, 0x2, 
+       0x2, 0xe5, 0x39, 0x3, 0x2, 0x2, 0x2, 0xe6, 0xe4, 0x3, 0x2, 0x2, 0x2, 
+       0xe7, 0xe8, 0x5, 0x46, 0x24, 0x2, 0xe8, 0x3b, 0x3, 0x2, 0x2, 0x2, 
+       0xe9, 0xea, 0x7, 0x14, 0x2, 0x2, 0xea, 0x3d, 0x3, 0x2, 0x2, 0x2, 
+       0xeb, 0xec, 0x5, 0x32, 0x1a, 0x2, 0xec, 0xed, 0x7, 0x10, 0x2, 0x2, 
+       0xed, 0xee, 0x5, 0x2e, 0x18, 0x2, 0xee, 0xef, 0x7, 0x11, 0x2, 0x2, 
+       0xef, 0x3f, 0x3, 0x2, 0x2, 0x2, 0xf0, 0xf1, 0x5, 0x3a, 0x1e, 0x2, 
+       0xf1, 0xf2, 0x7, 0x12, 0x2, 0x2, 0xf2, 0xf3, 0x5, 0x3a, 0x1e, 0x2, 
+       0xf3, 0x41, 0x3, 0x2, 0x2, 0x2, 0xf4, 0xf5, 0x7, 0x7, 0x2, 0x2, 0xf5, 
+       0xf6, 0x5, 0x2e, 0x18, 0x2, 0xf6, 0xf7, 0x7, 0x8, 0x2, 0x2, 0xf7, 
+       0x43, 0x3, 0x2, 0x2, 0x2, 0xf8, 0xf9, 0x7, 0x15, 0x2, 0x2, 0xf9, 
+       0x45, 0x3, 0x2, 0x2, 0x2, 0xfa, 0xfb, 0x7, 0x15, 0x2, 0x2, 0xfb, 
+       0x47, 0x3, 0x2, 0x2, 0x2, 0xfc, 0xfd, 0x7, 0x15, 0x2, 0x2, 0xfd, 
+       0x49, 0x3, 0x2, 0x2, 0x2, 0xfe, 0xff, 0x7, 0x15, 0x2, 0x2, 0xff, 
+       0x4b, 0x3, 0x2, 0x2, 0x2, 0x11, 0x4f, 0x56, 0x61, 0x75, 0x78, 0x83, 
+       0x8e, 0x95, 0xa1, 0xbd, 0xc5, 0xcb, 0xd4, 0xd7, 0xe4, 
+  };
+
+  _serializedATN.insert(_serializedATN.end(), serializedATNSegment0,
+    serializedATNSegment0 + sizeof(serializedATNSegment0) / sizeof(serializedATNSegment0[0]));
+
+
+  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);
+  }
+}
+
+TocParser::Initializer TocParser::_init;
diff --git a/gen/TocParser.h b/gen/TocParser.h
new file mode 100644
index 0000000..6dc941c
--- /dev/null
+++ b/gen/TocParser.h
@@ -0,0 +1,625 @@
+
+// Generated from Toc.g4 by ANTLR 4.9.2
+
+#pragma once
+
+
+#include "antlr4-runtime.h"
+
+
+
+
+class  TocParser : 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, BINARY_OPERATOR = 17, INTLIT = 18, NAME = 19, 
+    WS = 20, NEWLINE = 21
+  };
+
+  enum {
+    RuleProg = 0, RuleDecl = 1, RuleVarDecl = 2, RuleVar = 3, RuleType = 4, 
+    RuleFuncDecl = 5, RuleFunc = 6, RuleParameter = 7, RuleFirstParameter = 8, 
+    RuleAdditionalParameter = 9, RuleBody = 10, RuleStructDecl = 11, RuleStructMember = 12, 
+    RuleStructVar = 13, RuleStructMethod = 14, RuleStmt = 15, RuleConditional = 16, 
+    RuleIfCond = 17, RuleLoop = 18, RuleWhileLoop = 19, RuleAssignment = 20, 
+    RuleReturnStmt = 21, RuleExpr = 22, RuleNonOpExpr = 23, RuleNonSubscriptExpr = 24, 
+    RuleFuncCall = 25, RuleOperatorExpr = 26, RuleBinaryOperator = 27, RuleIdentifier = 28, 
+    RuleLiteral = 29, RuleSubscript = 30, RuleMemberAccess = 31, RuleParenExpr = 32, 
+    RuleFuncName = 33, RuleVarName = 34, RuleTypeName = 35, RuleStructName = 36
+  };
+
+  explicit TocParser(antlr4::TokenStream *input);
+  ~TocParser();
+
+  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 ProgContext;
+  class DeclContext;
+  class VarDeclContext;
+  class VarContext;
+  class TypeContext;
+  class FuncDeclContext;
+  class FuncContext;
+  class ParameterContext;
+  class FirstParameterContext;
+  class AdditionalParameterContext;
+  class BodyContext;
+  class StructDeclContext;
+  class StructMemberContext;
+  class StructVarContext;
+  class StructMethodContext;
+  class StmtContext;
+  class ConditionalContext;
+  class IfCondContext;
+  class LoopContext;
+  class WhileLoopContext;
+  class AssignmentContext;
+  class ReturnStmtContext;
+  class ExprContext;
+  class NonOpExprContext;
+  class NonSubscriptExprContext;
+  class FuncCallContext;
+  class OperatorExprContext;
+  class BinaryOperatorContext;
+  class IdentifierContext;
+  class LiteralContext;
+  class SubscriptContext;
+  class MemberAccessContext;
+  class ParenExprContext;
+  class FuncNameContext;
+  class VarNameContext;
+  class TypeNameContext;
+  class StructNameContext; 
+
+  class  ProgContext : public antlr4::ParserRuleContext {
+  public:
+    ProgContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+    antlr4::tree::TerminalNode *EOF();
+    std::vector<DeclContext *> decl();
+    DeclContext* decl(size_t i);
+
+    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
+    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
+   
+  };
+
+  ProgContext* prog();
+
+  class  DeclContext : public antlr4::ParserRuleContext {
+  public:
+    DeclContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+    VarDeclContext *varDecl();
+    FuncDeclContext *funcDecl();
+    StructDeclContext *structDecl();
+
+    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
+    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
+   
+  };
+
+  DeclContext* decl();
+
+  class  VarDeclContext : public antlr4::ParserRuleContext {
+  public:
+    VarDeclContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+    VarContext *var();
+
+    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
+    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
+   
+  };
+
+  VarDeclContext* varDecl();
+
+  class  VarContext : public antlr4::ParserRuleContext {
+  public:
+    VarContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+    VarNameContext *varName();
+    TypeContext *type();
+    ExprContext *expr();
+
+    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
+    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
+   
+  };
+
+  VarContext* var();
+
+  class  TypeContext : public antlr4::ParserRuleContext {
+  public:
+    TypeContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+    TypeNameContext *typeName();
+
+    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
+    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
+   
+  };
+
+  TypeContext* type();
+
+  class  FuncDeclContext : public antlr4::ParserRuleContext {
+  public:
+    FuncDeclContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+    FuncContext *func();
+
+    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
+    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
+   
+  };
+
+  FuncDeclContext* funcDecl();
+
+  class  FuncContext : public antlr4::ParserRuleContext {
+  public:
+    FuncContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+    FuncNameContext *funcName();
+    ParameterContext *parameter();
+    BodyContext *body();
+    TypeContext *type();
+
+    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
+    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
+   
+  };
+
+  FuncContext* func();
+
+  class  ParameterContext : public antlr4::ParserRuleContext {
+  public:
+    ParameterContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+    FirstParameterContext *firstParameter();
+    std::vector<AdditionalParameterContext *> additionalParameter();
+    AdditionalParameterContext* additionalParameter(size_t i);
+
+    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
+    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
+   
+  };
+
+  ParameterContext* parameter();
+
+  class  FirstParameterContext : public antlr4::ParserRuleContext {
+  public:
+    FirstParameterContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+    VarContext *var();
+
+    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
+    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
+   
+  };
+
+  FirstParameterContext* firstParameter();
+
+  class  AdditionalParameterContext : public antlr4::ParserRuleContext {
+  public:
+    AdditionalParameterContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+    VarContext *var();
+
+    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
+    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
+   
+  };
+
+  AdditionalParameterContext* additionalParameter();
+
+  class  BodyContext : public antlr4::ParserRuleContext {
+  public:
+    BodyContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+    std::vector<StmtContext *> stmt();
+    StmtContext* stmt(size_t i);
+
+    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
+    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
+   
+  };
+
+  BodyContext* body();
+
+  class  StructDeclContext : public antlr4::ParserRuleContext {
+  public:
+    StructDeclContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+    StructNameContext *structName();
+    std::vector<StructMemberContext *> structMember();
+    StructMemberContext* structMember(size_t i);
+
+    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
+    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
+   
+  };
+
+  StructDeclContext* structDecl();
+
+  class  StructMemberContext : public antlr4::ParserRuleContext {
+  public:
+    StructMemberContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+    StructVarContext *structVar();
+    StructMethodContext *structMethod();
+
+    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
+    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
+   
+  };
+
+  StructMemberContext* structMember();
+
+  class  StructVarContext : public antlr4::ParserRuleContext {
+  public:
+    StructVarContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+    VarContext *var();
+
+    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
+    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
+   
+  };
+
+  StructVarContext* structVar();
+
+  class  StructMethodContext : public antlr4::ParserRuleContext {
+  public:
+    StructMethodContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+    FuncContext *func();
+
+    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
+    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
+   
+  };
+
+  StructMethodContext* structMethod();
+
+  class  StmtContext : public antlr4::ParserRuleContext {
+  public:
+    StmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+    VarDeclContext *varDecl();
+    ConditionalContext *conditional();
+    LoopContext *loop();
+    AssignmentContext *assignment();
+    ReturnStmtContext *returnStmt();
+    ExprContext *expr();
+
+    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
+    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
+   
+  };
+
+  StmtContext* stmt();
+
+  class  ConditionalContext : public antlr4::ParserRuleContext {
+  public:
+    ConditionalContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+    IfCondContext *ifCond();
+
+    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
+    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
+   
+  };
+
+  ConditionalContext* conditional();
+
+  class  IfCondContext : public antlr4::ParserRuleContext {
+  public:
+    IfCondContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+    ExprContext *expr();
+    BodyContext *body();
+
+    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
+    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
+   
+  };
+
+  IfCondContext* ifCond();
+
+  class  LoopContext : public antlr4::ParserRuleContext {
+  public:
+    LoopContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+    WhileLoopContext *whileLoop();
+
+    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
+    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
+   
+  };
+
+  LoopContext* loop();
+
+  class  WhileLoopContext : public antlr4::ParserRuleContext {
+  public:
+    WhileLoopContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+    ExprContext *expr();
+    BodyContext *body();
+
+    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
+    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
+   
+  };
+
+  WhileLoopContext* whileLoop();
+
+  class  AssignmentContext : public antlr4::ParserRuleContext {
+  public:
+    AssignmentContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+    IdentifierContext *identifier();
+    ExprContext *expr();
+
+    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
+    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
+   
+  };
+
+  AssignmentContext* assignment();
+
+  class  ReturnStmtContext : public antlr4::ParserRuleContext {
+  public:
+    ReturnStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+    ExprContext *expr();
+
+    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
+    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
+   
+  };
+
+  ReturnStmtContext* returnStmt();
+
+  class  ExprContext : public antlr4::ParserRuleContext {
+  public:
+    ExprContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+    FuncCallContext *funcCall();
+    LiteralContext *literal();
+    IdentifierContext *identifier();
+    SubscriptContext *subscript();
+    MemberAccessContext *memberAccess();
+    ParenExprContext *parenExpr();
+    OperatorExprContext *operatorExpr();
+
+    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
+    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
+   
+  };
+
+  ExprContext* expr();
+
+  class  NonOpExprContext : public antlr4::ParserRuleContext {
+  public:
+    NonOpExprContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+    FuncCallContext *funcCall();
+    LiteralContext *literal();
+    IdentifierContext *identifier();
+    SubscriptContext *subscript();
+    MemberAccessContext *memberAccess();
+    ParenExprContext *parenExpr();
+
+    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
+    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
+   
+  };
+
+  NonOpExprContext* nonOpExpr();
+
+  class  NonSubscriptExprContext : public antlr4::ParserRuleContext {
+  public:
+    NonSubscriptExprContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+    FuncCallContext *funcCall();
+    IdentifierContext *identifier();
+    MemberAccessContext *memberAccess();
+    ParenExprContext *parenExpr();
+
+    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
+    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
+   
+  };
+
+  NonSubscriptExprContext* nonSubscriptExpr();
+
+  class  FuncCallContext : public antlr4::ParserRuleContext {
+  public:
+    FuncCallContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+    FuncNameContext *funcName();
+    std::vector<ExprContext *> expr();
+    ExprContext* expr(size_t i);
+
+    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
+    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
+   
+  };
+
+  FuncCallContext* funcCall();
+
+  class  OperatorExprContext : public antlr4::ParserRuleContext {
+  public:
+    OperatorExprContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+    BinaryOperatorContext *binaryOperator();
+
+    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
+    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
+   
+  };
+
+  OperatorExprContext* operatorExpr();
+
+  class  BinaryOperatorContext : public antlr4::ParserRuleContext {
+  public:
+    BinaryOperatorContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+    std::vector<NonOpExprContext *> nonOpExpr();
+    NonOpExprContext* nonOpExpr(size_t i);
+    std::vector<antlr4::tree::TerminalNode *> BINARY_OPERATOR();
+    antlr4::tree::TerminalNode* BINARY_OPERATOR(size_t i);
+
+    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
+    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
+   
+  };
+
+  BinaryOperatorContext* binaryOperator();
+
+  class  IdentifierContext : public antlr4::ParserRuleContext {
+  public:
+    IdentifierContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+    VarNameContext *varName();
+
+    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
+    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
+   
+  };
+
+  IdentifierContext* identifier();
+
+  class  LiteralContext : public antlr4::ParserRuleContext {
+  public:
+    LiteralContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+    antlr4::tree::TerminalNode *INTLIT();
+
+    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
+    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
+   
+  };
+
+  LiteralContext* literal();
+
+  class  SubscriptContext : public antlr4::ParserRuleContext {
+  public:
+    SubscriptContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+    NonSubscriptExprContext *nonSubscriptExpr();
+    ExprContext *expr();
+
+    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
+    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
+   
+  };
+
+  SubscriptContext* subscript();
+
+  class  MemberAccessContext : public antlr4::ParserRuleContext {
+  public:
+    MemberAccessContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+    std::vector<IdentifierContext *> identifier();
+    IdentifierContext* identifier(size_t i);
+
+    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
+    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
+   
+  };
+
+  MemberAccessContext* memberAccess();
+
+  class  ParenExprContext : public antlr4::ParserRuleContext {
+  public:
+    ParenExprContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+    ExprContext *expr();
+
+    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
+    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
+   
+  };
+
+  ParenExprContext* parenExpr();
+
+  class  FuncNameContext : public antlr4::ParserRuleContext {
+  public:
+    FuncNameContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+    antlr4::tree::TerminalNode *NAME();
+
+    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
+    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
+   
+  };
+
+  FuncNameContext* funcName();
+
+  class  VarNameContext : public antlr4::ParserRuleContext {
+  public:
+    VarNameContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+    antlr4::tree::TerminalNode *NAME();
+
+    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
+    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
+   
+  };
+
+  VarNameContext* varName();
+
+  class  TypeNameContext : public antlr4::ParserRuleContext {
+  public:
+    TypeNameContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+    antlr4::tree::TerminalNode *NAME();
+
+    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
+    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
+   
+  };
+
+  TypeNameContext* typeName();
+
+  class  StructNameContext : public antlr4::ParserRuleContext {
+  public:
+    StructNameContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+    virtual size_t getRuleIndex() const override;
+    antlr4::tree::TerminalNode *NAME();
+
+    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
+    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
+   
+  };
+
+  StructNameContext* structName();
+
+
+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;
+};
+