From 45409c781a9e35df68c43b1e2f028d30bf90c0a0 Mon Sep 17 00:00:00 2001 From: Patrick Schönberger Date: Wed, 28 Jul 2021 09:07:53 +0200 Subject: Initial commit --- gen/Toc.interp | 90 ++ gen/Toc.tokens | 37 + gen/TocBaseListener.cpp | 7 + gen/TocBaseListener.h | 137 +++ gen/TocLexer.cpp | 218 ++++ gen/TocLexer.h | 59 + gen/TocLexer.interp | 80 ++ gen/TocLexer.tokens | 37 + gen/TocListener.cpp | 7 + gen/TocListener.h | 130 +++ gen/TocParser.cpp | 2787 +++++++++++++++++++++++++++++++++++++++++++++++ gen/TocParser.h | 625 +++++++++++ 12 files changed, 4214 insertions(+) create mode 100644 gen/Toc.interp create mode 100644 gen/Toc.tokens create mode 100644 gen/TocBaseListener.cpp create mode 100644 gen/TocBaseListener.h create mode 100644 gen/TocLexer.cpp create mode 100644 gen/TocLexer.h create mode 100644 gen/TocLexer.interp create mode 100644 gen/TocLexer.tokens create mode 100644 gen/TocListener.cpp create mode 100644 gen/TocListener.h create mode 100644 gen/TocParser.cpp create mode 100644 gen/TocParser.h (limited to 'gen') 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& TocLexer::getRuleNames() const { + return _ruleNames; +} + +const std::vector& TocLexer::getChannelNames() const { + return _channelNames; +} + +const std::vector& TocLexer::getModeNames() const { + return _modeNames; +} + +const std::vector& TocLexer::getTokenNames() const { + return _tokenNames; +} + +dfa::Vocabulary& TocLexer::getVocabulary() const { + return _vocabulary; +} + +const std::vector TocLexer::getSerializedATN() const { + return _serializedATN; +} + +const atn::ATN& TocLexer::getATN() const { + return _atn; +} + + + + +// Static vars and initialization. +std::vector TocLexer::_decisionToDFA; +atn::PredictionContextCache TocLexer::_sharedContextCache; + +// We own the ATN which in turn owns the ATN states. +atn::ATN TocLexer::_atn; +std::vector TocLexer::_serializedATN; + +std::vector 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 TocLexer::_channelNames = { + "DEFAULT_TOKEN_CHANNEL", "HIDDEN" +}; + +std::vector TocLexer::_modeNames = { + "DEFAULT_MODE" +}; + +std::vector TocLexer::_literalNames = { + "", "'var'", "':'", "'='", "'func'", "'('", "')'", "','", "'{'", "'}'", + "'struct'", "'if'", "'while'", "'return'", "'['", "']'", "'.'" +}; + +std::vector TocLexer::_symbolicNames = { + "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "BINARY_OPERATOR", + "INTLIT", "NAME", "WS", "NEWLINE" +}; + +dfa::Vocabulary TocLexer::_vocabulary(_literalNames, _symbolicNames); + +std::vector 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(""); + } 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& getRuleNames() const override; + + virtual const std::vector& getChannelNames() const override; + virtual const std::vector& getModeNames() const override; + virtual const std::vector& getTokenNames() const override; // deprecated, use vocabulary instead + virtual antlr4::dfa::Vocabulary& getVocabulary() const override; + + virtual const std::vector getSerializedATN() const override; + virtual const antlr4::atn::ATN& getATN() const override; + +private: + static std::vector _decisionToDFA; + static antlr4::atn::PredictionContextCache _sharedContextCache; + static std::vector _ruleNames; + static std::vector _tokenNames; + static std::vector _channelNames; + static std::vector _modeNames; + + static std::vector _literalNames; + static std::vector _symbolicNames; + static antlr4::dfa::Vocabulary _vocabulary; + static antlr4::atn::ATN _atn; + static std::vector _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& 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::ProgContext::decl() { + return getRuleContexts(); +} + +TocParser::DeclContext* TocParser::ProgContext::decl(size_t i) { + return getRuleContext(i); +} + + +size_t TocParser::ProgContext::getRuleIndex() const { + return TocParser::RuleProg; +} + +void TocParser::ProgContext::enterRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->enterProg(this); +} + +void TocParser::ProgContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitProg(this); +} + +TocParser::ProgContext* TocParser::prog() { + ProgContext *_localctx = _tracker.createInstance(_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(0); +} + +TocParser::FuncDeclContext* TocParser::DeclContext::funcDecl() { + return getRuleContext(0); +} + +TocParser::StructDeclContext* TocParser::DeclContext::structDecl() { + return getRuleContext(0); +} + + +size_t TocParser::DeclContext::getRuleIndex() const { + return TocParser::RuleDecl; +} + +void TocParser::DeclContext::enterRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->enterDecl(this); +} + +void TocParser::DeclContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitDecl(this); +} + +TocParser::DeclContext* TocParser::decl() { + DeclContext *_localctx = _tracker.createInstance(_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(0); +} + + +size_t TocParser::VarDeclContext::getRuleIndex() const { + return TocParser::RuleVarDecl; +} + +void TocParser::VarDeclContext::enterRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->enterVarDecl(this); +} + +void TocParser::VarDeclContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitVarDecl(this); +} + +TocParser::VarDeclContext* TocParser::varDecl() { + VarDeclContext *_localctx = _tracker.createInstance(_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(0); +} + +TocParser::TypeContext* TocParser::VarContext::type() { + return getRuleContext(0); +} + +TocParser::ExprContext* TocParser::VarContext::expr() { + return getRuleContext(0); +} + + +size_t TocParser::VarContext::getRuleIndex() const { + return TocParser::RuleVar; +} + +void TocParser::VarContext::enterRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->enterVar(this); +} + +void TocParser::VarContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitVar(this); +} + +TocParser::VarContext* TocParser::var() { + VarContext *_localctx = _tracker.createInstance(_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(0); +} + + +size_t TocParser::TypeContext::getRuleIndex() const { + return TocParser::RuleType; +} + +void TocParser::TypeContext::enterRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->enterType(this); +} + +void TocParser::TypeContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitType(this); +} + +TocParser::TypeContext* TocParser::type() { + TypeContext *_localctx = _tracker.createInstance(_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(0); +} + + +size_t TocParser::FuncDeclContext::getRuleIndex() const { + return TocParser::RuleFuncDecl; +} + +void TocParser::FuncDeclContext::enterRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->enterFuncDecl(this); +} + +void TocParser::FuncDeclContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitFuncDecl(this); +} + +TocParser::FuncDeclContext* TocParser::funcDecl() { + FuncDeclContext *_localctx = _tracker.createInstance(_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(0); +} + +TocParser::ParameterContext* TocParser::FuncContext::parameter() { + return getRuleContext(0); +} + +TocParser::BodyContext* TocParser::FuncContext::body() { + return getRuleContext(0); +} + +TocParser::TypeContext* TocParser::FuncContext::type() { + return getRuleContext(0); +} + + +size_t TocParser::FuncContext::getRuleIndex() const { + return TocParser::RuleFunc; +} + +void TocParser::FuncContext::enterRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->enterFunc(this); +} + +void TocParser::FuncContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitFunc(this); +} + +TocParser::FuncContext* TocParser::func() { + FuncContext *_localctx = _tracker.createInstance(_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(0); +} + +std::vector TocParser::ParameterContext::additionalParameter() { + return getRuleContexts(); +} + +TocParser::AdditionalParameterContext* TocParser::ParameterContext::additionalParameter(size_t i) { + return getRuleContext(i); +} + + +size_t TocParser::ParameterContext::getRuleIndex() const { + return TocParser::RuleParameter; +} + +void TocParser::ParameterContext::enterRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->enterParameter(this); +} + +void TocParser::ParameterContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitParameter(this); +} + +TocParser::ParameterContext* TocParser::parameter() { + ParameterContext *_localctx = _tracker.createInstance(_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(0); +} + + +size_t TocParser::FirstParameterContext::getRuleIndex() const { + return TocParser::RuleFirstParameter; +} + +void TocParser::FirstParameterContext::enterRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->enterFirstParameter(this); +} + +void TocParser::FirstParameterContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitFirstParameter(this); +} + +TocParser::FirstParameterContext* TocParser::firstParameter() { + FirstParameterContext *_localctx = _tracker.createInstance(_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(0); +} + + +size_t TocParser::AdditionalParameterContext::getRuleIndex() const { + return TocParser::RuleAdditionalParameter; +} + +void TocParser::AdditionalParameterContext::enterRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->enterAdditionalParameter(this); +} + +void TocParser::AdditionalParameterContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitAdditionalParameter(this); +} + +TocParser::AdditionalParameterContext* TocParser::additionalParameter() { + AdditionalParameterContext *_localctx = _tracker.createInstance(_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::BodyContext::stmt() { + return getRuleContexts(); +} + +TocParser::StmtContext* TocParser::BodyContext::stmt(size_t i) { + return getRuleContext(i); +} + + +size_t TocParser::BodyContext::getRuleIndex() const { + return TocParser::RuleBody; +} + +void TocParser::BodyContext::enterRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->enterBody(this); +} + +void TocParser::BodyContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitBody(this); +} + +TocParser::BodyContext* TocParser::body() { + BodyContext *_localctx = _tracker.createInstance(_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(0); +} + +std::vector TocParser::StructDeclContext::structMember() { + return getRuleContexts(); +} + +TocParser::StructMemberContext* TocParser::StructDeclContext::structMember(size_t i) { + return getRuleContext(i); +} + + +size_t TocParser::StructDeclContext::getRuleIndex() const { + return TocParser::RuleStructDecl; +} + +void TocParser::StructDeclContext::enterRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->enterStructDecl(this); +} + +void TocParser::StructDeclContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitStructDecl(this); +} + +TocParser::StructDeclContext* TocParser::structDecl() { + StructDeclContext *_localctx = _tracker.createInstance(_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(0); +} + +TocParser::StructMethodContext* TocParser::StructMemberContext::structMethod() { + return getRuleContext(0); +} + + +size_t TocParser::StructMemberContext::getRuleIndex() const { + return TocParser::RuleStructMember; +} + +void TocParser::StructMemberContext::enterRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->enterStructMember(this); +} + +void TocParser::StructMemberContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitStructMember(this); +} + +TocParser::StructMemberContext* TocParser::structMember() { + StructMemberContext *_localctx = _tracker.createInstance(_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()->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(0); +} + + +size_t TocParser::StructVarContext::getRuleIndex() const { + return TocParser::RuleStructVar; +} + +void TocParser::StructVarContext::enterRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->enterStructVar(this); +} + +void TocParser::StructVarContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitStructVar(this); +} + +TocParser::StructVarContext* TocParser::structVar() { + StructVarContext *_localctx = _tracker.createInstance(_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(0); +} + + +size_t TocParser::StructMethodContext::getRuleIndex() const { + return TocParser::RuleStructMethod; +} + +void TocParser::StructMethodContext::enterRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->enterStructMethod(this); +} + +void TocParser::StructMethodContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitStructMethod(this); +} + +TocParser::StructMethodContext* TocParser::structMethod() { + StructMethodContext *_localctx = _tracker.createInstance(_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(0); +} + +TocParser::ConditionalContext* TocParser::StmtContext::conditional() { + return getRuleContext(0); +} + +TocParser::LoopContext* TocParser::StmtContext::loop() { + return getRuleContext(0); +} + +TocParser::AssignmentContext* TocParser::StmtContext::assignment() { + return getRuleContext(0); +} + +TocParser::ReturnStmtContext* TocParser::StmtContext::returnStmt() { + return getRuleContext(0); +} + +TocParser::ExprContext* TocParser::StmtContext::expr() { + return getRuleContext(0); +} + + +size_t TocParser::StmtContext::getRuleIndex() const { + return TocParser::RuleStmt; +} + +void TocParser::StmtContext::enterRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->enterStmt(this); +} + +void TocParser::StmtContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitStmt(this); +} + +TocParser::StmtContext* TocParser::stmt() { + StmtContext *_localctx = _tracker.createInstance(_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()->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(0); +} + + +size_t TocParser::ConditionalContext::getRuleIndex() const { + return TocParser::RuleConditional; +} + +void TocParser::ConditionalContext::enterRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->enterConditional(this); +} + +void TocParser::ConditionalContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitConditional(this); +} + +TocParser::ConditionalContext* TocParser::conditional() { + ConditionalContext *_localctx = _tracker.createInstance(_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(0); +} + +TocParser::BodyContext* TocParser::IfCondContext::body() { + return getRuleContext(0); +} + + +size_t TocParser::IfCondContext::getRuleIndex() const { + return TocParser::RuleIfCond; +} + +void TocParser::IfCondContext::enterRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->enterIfCond(this); +} + +void TocParser::IfCondContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitIfCond(this); +} + +TocParser::IfCondContext* TocParser::ifCond() { + IfCondContext *_localctx = _tracker.createInstance(_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(0); +} + + +size_t TocParser::LoopContext::getRuleIndex() const { + return TocParser::RuleLoop; +} + +void TocParser::LoopContext::enterRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->enterLoop(this); +} + +void TocParser::LoopContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitLoop(this); +} + +TocParser::LoopContext* TocParser::loop() { + LoopContext *_localctx = _tracker.createInstance(_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(0); +} + +TocParser::BodyContext* TocParser::WhileLoopContext::body() { + return getRuleContext(0); +} + + +size_t TocParser::WhileLoopContext::getRuleIndex() const { + return TocParser::RuleWhileLoop; +} + +void TocParser::WhileLoopContext::enterRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->enterWhileLoop(this); +} + +void TocParser::WhileLoopContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitWhileLoop(this); +} + +TocParser::WhileLoopContext* TocParser::whileLoop() { + WhileLoopContext *_localctx = _tracker.createInstance(_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(0); +} + +TocParser::ExprContext* TocParser::AssignmentContext::expr() { + return getRuleContext(0); +} + + +size_t TocParser::AssignmentContext::getRuleIndex() const { + return TocParser::RuleAssignment; +} + +void TocParser::AssignmentContext::enterRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->enterAssignment(this); +} + +void TocParser::AssignmentContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitAssignment(this); +} + +TocParser::AssignmentContext* TocParser::assignment() { + AssignmentContext *_localctx = _tracker.createInstance(_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(0); +} + + +size_t TocParser::ReturnStmtContext::getRuleIndex() const { + return TocParser::RuleReturnStmt; +} + +void TocParser::ReturnStmtContext::enterRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->enterReturnStmt(this); +} + +void TocParser::ReturnStmtContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitReturnStmt(this); +} + +TocParser::ReturnStmtContext* TocParser::returnStmt() { + ReturnStmtContext *_localctx = _tracker.createInstance(_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(0); +} + +TocParser::LiteralContext* TocParser::ExprContext::literal() { + return getRuleContext(0); +} + +TocParser::IdentifierContext* TocParser::ExprContext::identifier() { + return getRuleContext(0); +} + +TocParser::SubscriptContext* TocParser::ExprContext::subscript() { + return getRuleContext(0); +} + +TocParser::MemberAccessContext* TocParser::ExprContext::memberAccess() { + return getRuleContext(0); +} + +TocParser::ParenExprContext* TocParser::ExprContext::parenExpr() { + return getRuleContext(0); +} + +TocParser::OperatorExprContext* TocParser::ExprContext::operatorExpr() { + return getRuleContext(0); +} + + +size_t TocParser::ExprContext::getRuleIndex() const { + return TocParser::RuleExpr; +} + +void TocParser::ExprContext::enterRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->enterExpr(this); +} + +void TocParser::ExprContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitExpr(this); +} + +TocParser::ExprContext* TocParser::expr() { + ExprContext *_localctx = _tracker.createInstance(_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()->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(0); +} + +TocParser::LiteralContext* TocParser::NonOpExprContext::literal() { + return getRuleContext(0); +} + +TocParser::IdentifierContext* TocParser::NonOpExprContext::identifier() { + return getRuleContext(0); +} + +TocParser::SubscriptContext* TocParser::NonOpExprContext::subscript() { + return getRuleContext(0); +} + +TocParser::MemberAccessContext* TocParser::NonOpExprContext::memberAccess() { + return getRuleContext(0); +} + +TocParser::ParenExprContext* TocParser::NonOpExprContext::parenExpr() { + return getRuleContext(0); +} + + +size_t TocParser::NonOpExprContext::getRuleIndex() const { + return TocParser::RuleNonOpExpr; +} + +void TocParser::NonOpExprContext::enterRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->enterNonOpExpr(this); +} + +void TocParser::NonOpExprContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitNonOpExpr(this); +} + +TocParser::NonOpExprContext* TocParser::nonOpExpr() { + NonOpExprContext *_localctx = _tracker.createInstance(_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()->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(0); +} + +TocParser::IdentifierContext* TocParser::NonSubscriptExprContext::identifier() { + return getRuleContext(0); +} + +TocParser::MemberAccessContext* TocParser::NonSubscriptExprContext::memberAccess() { + return getRuleContext(0); +} + +TocParser::ParenExprContext* TocParser::NonSubscriptExprContext::parenExpr() { + return getRuleContext(0); +} + + +size_t TocParser::NonSubscriptExprContext::getRuleIndex() const { + return TocParser::RuleNonSubscriptExpr; +} + +void TocParser::NonSubscriptExprContext::enterRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->enterNonSubscriptExpr(this); +} + +void TocParser::NonSubscriptExprContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitNonSubscriptExpr(this); +} + +TocParser::NonSubscriptExprContext* TocParser::nonSubscriptExpr() { + NonSubscriptExprContext *_localctx = _tracker.createInstance(_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()->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(0); +} + +std::vector TocParser::FuncCallContext::expr() { + return getRuleContexts(); +} + +TocParser::ExprContext* TocParser::FuncCallContext::expr(size_t i) { + return getRuleContext(i); +} + + +size_t TocParser::FuncCallContext::getRuleIndex() const { + return TocParser::RuleFuncCall; +} + +void TocParser::FuncCallContext::enterRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->enterFuncCall(this); +} + +void TocParser::FuncCallContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitFuncCall(this); +} + +TocParser::FuncCallContext* TocParser::funcCall() { + FuncCallContext *_localctx = _tracker.createInstance(_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(0); +} + + +size_t TocParser::OperatorExprContext::getRuleIndex() const { + return TocParser::RuleOperatorExpr; +} + +void TocParser::OperatorExprContext::enterRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->enterOperatorExpr(this); +} + +void TocParser::OperatorExprContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitOperatorExpr(this); +} + +TocParser::OperatorExprContext* TocParser::operatorExpr() { + OperatorExprContext *_localctx = _tracker.createInstance(_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::BinaryOperatorContext::nonOpExpr() { + return getRuleContexts(); +} + +TocParser::NonOpExprContext* TocParser::BinaryOperatorContext::nonOpExpr(size_t i) { + return getRuleContext(i); +} + +std::vector 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(listener); + if (parserListener != nullptr) + parserListener->enterBinaryOperator(this); +} + +void TocParser::BinaryOperatorContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitBinaryOperator(this); +} + +TocParser::BinaryOperatorContext* TocParser::binaryOperator() { + BinaryOperatorContext *_localctx = _tracker.createInstance(_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(0); +} + + +size_t TocParser::IdentifierContext::getRuleIndex() const { + return TocParser::RuleIdentifier; +} + +void TocParser::IdentifierContext::enterRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->enterIdentifier(this); +} + +void TocParser::IdentifierContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitIdentifier(this); +} + +TocParser::IdentifierContext* TocParser::identifier() { + IdentifierContext *_localctx = _tracker.createInstance(_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(listener); + if (parserListener != nullptr) + parserListener->enterLiteral(this); +} + +void TocParser::LiteralContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitLiteral(this); +} + +TocParser::LiteralContext* TocParser::literal() { + LiteralContext *_localctx = _tracker.createInstance(_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(0); +} + +TocParser::ExprContext* TocParser::SubscriptContext::expr() { + return getRuleContext(0); +} + + +size_t TocParser::SubscriptContext::getRuleIndex() const { + return TocParser::RuleSubscript; +} + +void TocParser::SubscriptContext::enterRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->enterSubscript(this); +} + +void TocParser::SubscriptContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitSubscript(this); +} + +TocParser::SubscriptContext* TocParser::subscript() { + SubscriptContext *_localctx = _tracker.createInstance(_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::MemberAccessContext::identifier() { + return getRuleContexts(); +} + +TocParser::IdentifierContext* TocParser::MemberAccessContext::identifier(size_t i) { + return getRuleContext(i); +} + + +size_t TocParser::MemberAccessContext::getRuleIndex() const { + return TocParser::RuleMemberAccess; +} + +void TocParser::MemberAccessContext::enterRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->enterMemberAccess(this); +} + +void TocParser::MemberAccessContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitMemberAccess(this); +} + +TocParser::MemberAccessContext* TocParser::memberAccess() { + MemberAccessContext *_localctx = _tracker.createInstance(_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(0); +} + + +size_t TocParser::ParenExprContext::getRuleIndex() const { + return TocParser::RuleParenExpr; +} + +void TocParser::ParenExprContext::enterRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->enterParenExpr(this); +} + +void TocParser::ParenExprContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitParenExpr(this); +} + +TocParser::ParenExprContext* TocParser::parenExpr() { + ParenExprContext *_localctx = _tracker.createInstance(_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(listener); + if (parserListener != nullptr) + parserListener->enterFuncName(this); +} + +void TocParser::FuncNameContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitFuncName(this); +} + +TocParser::FuncNameContext* TocParser::funcName() { + FuncNameContext *_localctx = _tracker.createInstance(_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(listener); + if (parserListener != nullptr) + parserListener->enterVarName(this); +} + +void TocParser::VarNameContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitVarName(this); +} + +TocParser::VarNameContext* TocParser::varName() { + VarNameContext *_localctx = _tracker.createInstance(_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(listener); + if (parserListener != nullptr) + parserListener->enterTypeName(this); +} + +void TocParser::TypeNameContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitTypeName(this); +} + +TocParser::TypeNameContext* TocParser::typeName() { + TypeNameContext *_localctx = _tracker.createInstance(_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(listener); + if (parserListener != nullptr) + parserListener->enterStructName(this); +} + +void TocParser::StructNameContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitStructName(this); +} + +TocParser::StructNameContext* TocParser::structName() { + StructNameContext *_localctx = _tracker.createInstance(_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 TocParser::_decisionToDFA; +atn::PredictionContextCache TocParser::_sharedContextCache; + +// We own the ATN which in turn owns the ATN states. +atn::ATN TocParser::_atn; +std::vector TocParser::_serializedATN; + +std::vector 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 TocParser::_literalNames = { + "", "'var'", "':'", "'='", "'func'", "'('", "')'", "','", "'{'", "'}'", + "'struct'", "'if'", "'while'", "'return'", "'['", "']'", "'.'" +}; + +std::vector TocParser::_symbolicNames = { + "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "BINARY_OPERATOR", + "INTLIT", "NAME", "WS", "NEWLINE" +}; + +dfa::Vocabulary TocParser::_vocabulary(_literalNames, _symbolicNames); + +std::vector 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(""); + } 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& getTokenNames() const override { return _tokenNames; }; // deprecated: use vocabulary instead. + virtual const std::vector& 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 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 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 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 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 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 nonOpExpr(); + NonOpExprContext* nonOpExpr(size_t i); + std::vector 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 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 _decisionToDFA; + static antlr4::atn::PredictionContextCache _sharedContextCache; + static std::vector _ruleNames; + static std::vector _tokenNames; + + static std::vector _literalNames; + static std::vector _symbolicNames; + static antlr4::dfa::Vocabulary _vocabulary; + static antlr4::atn::ATN _atn; + static std::vector _serializedATN; + + + struct Initializer { + Initializer(); + }; + static Initializer _init; +}; + -- cgit v1.2.3