diff --git a/src/spider/CMakeLists.txt b/src/spider/CMakeLists.txt index 068d7b5aa..335f4f1f1 100644 --- a/src/spider/CMakeLists.txt +++ b/src/spider/CMakeLists.txt @@ -225,6 +225,7 @@ set(SPIDER_TDL_SHARED_SOURCES tdl/parser/ast/node_impl/type_impl/primitive_impl/Int.cpp tdl/parser/ast/node_impl/type_impl/Struct.cpp tdl/parser/ast/utils.cpp + tdl/parser/parse.cpp CACHE INTERNAL "spider task definition language shared source files" ) @@ -252,6 +253,7 @@ set(SPIDER_TDL_SHARED_HEADERS tdl/parser/ast/nodes.hpp tdl/parser/ast/utils.hpp tdl/parser/ErrorListener.hpp + tdl/parser/parse.hpp tdl/parser/SourceLocation.hpp CACHE INTERNAL "spider task definition language shared header files" diff --git a/src/spider/tdl/parser/SourceLocation.hpp b/src/spider/tdl/parser/SourceLocation.hpp index c64e871a1..e029a876c 100644 --- a/src/spider/tdl/parser/SourceLocation.hpp +++ b/src/spider/tdl/parser/SourceLocation.hpp @@ -7,13 +7,17 @@ namespace spider::tdl::parser { class SourceLocation { public: // Constructor - SourceLocation(size_t line, size_t column) : m_line{line}, m_column{column} {} + constexpr SourceLocation(size_t line, size_t column) : m_line{line}, m_column{column} {} // Methods [[nodiscard]] auto get_line() const noexcept -> size_t { return m_line; } [[nodiscard]] auto get_column() const noexcept -> size_t { return m_column; } + [[nodiscard]] auto operator==(SourceLocation const& other) const noexcept -> bool { + return m_line == other.m_line && m_column == other.m_column; + } + private: // Variables size_t m_line; diff --git a/src/spider/tdl/parser/TaskDefLang.g4 b/src/spider/tdl/parser/TaskDefLang.g4 index 0c117c805..ef733e370 100644 --- a/src/spider/tdl/parser/TaskDefLang.g4 +++ b/src/spider/tdl/parser/TaskDefLang.g4 @@ -1,5 +1,82 @@ grammar TaskDefLang; -start: EOF ; +translationUnit: (namespace | structDef)* EOF ; +namespace +: 'namespace' id '{' (funcDef)* '}' +; + +funcDef +: 'fn' id '(' params ')' ret ';' +; + +ret +: '->' retType +| +; + +params +: namedVarList +| +; + +namedVar +: id ':' varType +; + +namedVarList +: namedVar +| namedVarList ',' namedVar +; + +structDef +: 'struct' id '{' namedVarList (',')? '}' ';' +; + +id +: ID +; + +varType +: builtinType +| id +; + +retType +: varType +| tupleType +; + +varTypeList +: varType +| varTypeList ',' varType +| +; + +listType +: 'List' '<' varType '>' +; + +mapType +: 'Map' '<' varType ',' varType '>' +; + +tupleType +: 'Tuple' '<' varTypeList '>' +; + +builtinType +: 'int8' +| 'int16' +| 'int32' +| 'int64' +| 'float' +| 'double' +| 'bool' +| listType +| mapType +; + +ID: [a-zA-Z_][a-zA-Z0-9_]* ; SPACE: [ \t\r\n] -> skip ; +COMMENT: '//' (~[\r\n])* -> skip; diff --git a/src/spider/tdl/parser/antlr_generated/TaskDefLangBaseVisitor.h b/src/spider/tdl/parser/antlr_generated/TaskDefLangBaseVisitor.h index 6b6edabef..9444a86b3 100644 --- a/src/spider/tdl/parser/antlr_generated/TaskDefLangBaseVisitor.h +++ b/src/spider/tdl/parser/antlr_generated/TaskDefLangBaseVisitor.h @@ -17,7 +17,67 @@ namespace spider::tdl::parser::antlr_generated { class TaskDefLangBaseVisitor : public TaskDefLangVisitor { public: - virtual std::any visitStart(TaskDefLangParser::StartContext *ctx) override { + virtual std::any visitTranslationUnit(TaskDefLangParser::TranslationUnitContext *ctx) override { + return visitChildren(ctx); + } + + virtual std::any visitNamespace(TaskDefLangParser::NamespaceContext *ctx) override { + return visitChildren(ctx); + } + + virtual std::any visitFuncDef(TaskDefLangParser::FuncDefContext *ctx) override { + return visitChildren(ctx); + } + + virtual std::any visitRet(TaskDefLangParser::RetContext *ctx) override { + return visitChildren(ctx); + } + + virtual std::any visitParams(TaskDefLangParser::ParamsContext *ctx) override { + return visitChildren(ctx); + } + + virtual std::any visitNamedVar(TaskDefLangParser::NamedVarContext *ctx) override { + return visitChildren(ctx); + } + + virtual std::any visitNamedVarList(TaskDefLangParser::NamedVarListContext *ctx) override { + return visitChildren(ctx); + } + + virtual std::any visitStructDef(TaskDefLangParser::StructDefContext *ctx) override { + return visitChildren(ctx); + } + + virtual std::any visitId(TaskDefLangParser::IdContext *ctx) override { + return visitChildren(ctx); + } + + virtual std::any visitVarType(TaskDefLangParser::VarTypeContext *ctx) override { + return visitChildren(ctx); + } + + virtual std::any visitRetType(TaskDefLangParser::RetTypeContext *ctx) override { + return visitChildren(ctx); + } + + virtual std::any visitVarTypeList(TaskDefLangParser::VarTypeListContext *ctx) override { + return visitChildren(ctx); + } + + virtual std::any visitListType(TaskDefLangParser::ListTypeContext *ctx) override { + return visitChildren(ctx); + } + + virtual std::any visitMapType(TaskDefLangParser::MapTypeContext *ctx) override { + return visitChildren(ctx); + } + + virtual std::any visitTupleType(TaskDefLangParser::TupleTypeContext *ctx) override { + return visitChildren(ctx); + } + + virtual std::any visitBuiltinType(TaskDefLangParser::BuiltinTypeContext *ctx) override { return visitChildren(ctx); } diff --git a/src/spider/tdl/parser/antlr_generated/TaskDefLangLexer.cpp b/src/spider/tdl/parser/antlr_generated/TaskDefLangLexer.cpp index 63b6a43e1..7593af99b 100644 --- a/src/spider/tdl/parser/antlr_generated/TaskDefLangLexer.cpp +++ b/src/spider/tdl/parser/antlr_generated/TaskDefLangLexer.cpp @@ -58,7 +58,10 @@ void taskdeflanglexerLexerInitialize() { #endif auto staticData = std::make_unique( std::vector{ - "SPACE" + "T__0", "T__1", "T__2", "T__3", "T__4", "T__5", "T__6", "T__7", "T__8", + "T__9", "T__10", "T__11", "T__12", "T__13", "T__14", "T__15", "T__16", + "T__17", "T__18", "T__19", "T__20", "T__21", "T__22", "ID", "SPACE", + "COMMENT" }, std::vector{ "DEFAULT_TOKEN_CHANNEL", "HIDDEN" @@ -67,15 +70,71 @@ void taskdeflanglexerLexerInitialize() { "DEFAULT_MODE" }, std::vector{ + "", "'namespace'", "'{'", "'}'", "'fn'", "'('", "')'", "';'", "'->'", + "':'", "','", "'struct'", "'List'", "'<'", "'>'", "'Map'", "'Tuple'", + "'int8'", "'int16'", "'int32'", "'int64'", "'float'", "'double'", + "'bool'" }, std::vector{ - "", "SPACE" + "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", + "", "", "", "", "", "", "", "ID", "SPACE", "COMMENT" } ); static const int32_t serializedATNSegment[] = { - 4,0,1,7,6,-1,2,0,7,0,1,0,1,0,1,0,1,0,0,0,1,1,1,1,0,1,3,0,9,10,13,13,32, - 32,6,0,1,1,0,0,0,1,3,1,0,0,0,3,4,7,0,0,0,4,5,1,0,0,0,5,6,6,0,0,0,6,2, - 1,0,0,0,1,0,1,6,0,0 + 4,0,26,172,6,-1,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5,2,6,7, + 6,2,7,7,7,2,8,7,8,2,9,7,9,2,10,7,10,2,11,7,11,2,12,7,12,2,13,7,13,2,14, + 7,14,2,15,7,15,2,16,7,16,2,17,7,17,2,18,7,18,2,19,7,19,2,20,7,20,2,21, + 7,21,2,22,7,22,2,23,7,23,2,24,7,24,2,25,7,25,1,0,1,0,1,0,1,0,1,0,1,0, + 1,0,1,0,1,0,1,0,1,1,1,1,1,2,1,2,1,3,1,3,1,3,1,4,1,4,1,5,1,5,1,6,1,6,1, + 7,1,7,1,7,1,8,1,8,1,9,1,9,1,10,1,10,1,10,1,10,1,10,1,10,1,10,1,11,1,11, + 1,11,1,11,1,11,1,12,1,12,1,13,1,13,1,14,1,14,1,14,1,14,1,15,1,15,1,15, + 1,15,1,15,1,15,1,16,1,16,1,16,1,16,1,16,1,17,1,17,1,17,1,17,1,17,1,17, + 1,18,1,18,1,18,1,18,1,18,1,18,1,19,1,19,1,19,1,19,1,19,1,19,1,20,1,20, + 1,20,1,20,1,20,1,20,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,22,1,22,1,22, + 1,22,1,22,1,23,1,23,5,23,153,8,23,10,23,12,23,156,9,23,1,24,1,24,1,24, + 1,24,1,25,1,25,1,25,1,25,5,25,166,8,25,10,25,12,25,169,9,25,1,25,1,25, + 0,0,26,1,1,3,2,5,3,7,4,9,5,11,6,13,7,15,8,17,9,19,10,21,11,23,12,25,13, + 27,14,29,15,31,16,33,17,35,18,37,19,39,20,41,21,43,22,45,23,47,24,49, + 25,51,26,1,0,4,3,0,65,90,95,95,97,122,4,0,48,57,65,90,95,95,97,122,3, + 0,9,10,13,13,32,32,2,0,10,10,13,13,173,0,1,1,0,0,0,0,3,1,0,0,0,0,5,1, + 0,0,0,0,7,1,0,0,0,0,9,1,0,0,0,0,11,1,0,0,0,0,13,1,0,0,0,0,15,1,0,0,0, + 0,17,1,0,0,0,0,19,1,0,0,0,0,21,1,0,0,0,0,23,1,0,0,0,0,25,1,0,0,0,0,27, + 1,0,0,0,0,29,1,0,0,0,0,31,1,0,0,0,0,33,1,0,0,0,0,35,1,0,0,0,0,37,1,0, + 0,0,0,39,1,0,0,0,0,41,1,0,0,0,0,43,1,0,0,0,0,45,1,0,0,0,0,47,1,0,0,0, + 0,49,1,0,0,0,0,51,1,0,0,0,1,53,1,0,0,0,3,63,1,0,0,0,5,65,1,0,0,0,7,67, + 1,0,0,0,9,70,1,0,0,0,11,72,1,0,0,0,13,74,1,0,0,0,15,76,1,0,0,0,17,79, + 1,0,0,0,19,81,1,0,0,0,21,83,1,0,0,0,23,90,1,0,0,0,25,95,1,0,0,0,27,97, + 1,0,0,0,29,99,1,0,0,0,31,103,1,0,0,0,33,109,1,0,0,0,35,114,1,0,0,0,37, + 120,1,0,0,0,39,126,1,0,0,0,41,132,1,0,0,0,43,138,1,0,0,0,45,145,1,0,0, + 0,47,150,1,0,0,0,49,157,1,0,0,0,51,161,1,0,0,0,53,54,5,110,0,0,54,55, + 5,97,0,0,55,56,5,109,0,0,56,57,5,101,0,0,57,58,5,115,0,0,58,59,5,112, + 0,0,59,60,5,97,0,0,60,61,5,99,0,0,61,62,5,101,0,0,62,2,1,0,0,0,63,64, + 5,123,0,0,64,4,1,0,0,0,65,66,5,125,0,0,66,6,1,0,0,0,67,68,5,102,0,0,68, + 69,5,110,0,0,69,8,1,0,0,0,70,71,5,40,0,0,71,10,1,0,0,0,72,73,5,41,0,0, + 73,12,1,0,0,0,74,75,5,59,0,0,75,14,1,0,0,0,76,77,5,45,0,0,77,78,5,62, + 0,0,78,16,1,0,0,0,79,80,5,58,0,0,80,18,1,0,0,0,81,82,5,44,0,0,82,20,1, + 0,0,0,83,84,5,115,0,0,84,85,5,116,0,0,85,86,5,114,0,0,86,87,5,117,0,0, + 87,88,5,99,0,0,88,89,5,116,0,0,89,22,1,0,0,0,90,91,5,76,0,0,91,92,5,105, + 0,0,92,93,5,115,0,0,93,94,5,116,0,0,94,24,1,0,0,0,95,96,5,60,0,0,96,26, + 1,0,0,0,97,98,5,62,0,0,98,28,1,0,0,0,99,100,5,77,0,0,100,101,5,97,0,0, + 101,102,5,112,0,0,102,30,1,0,0,0,103,104,5,84,0,0,104,105,5,117,0,0,105, + 106,5,112,0,0,106,107,5,108,0,0,107,108,5,101,0,0,108,32,1,0,0,0,109, + 110,5,105,0,0,110,111,5,110,0,0,111,112,5,116,0,0,112,113,5,56,0,0,113, + 34,1,0,0,0,114,115,5,105,0,0,115,116,5,110,0,0,116,117,5,116,0,0,117, + 118,5,49,0,0,118,119,5,54,0,0,119,36,1,0,0,0,120,121,5,105,0,0,121,122, + 5,110,0,0,122,123,5,116,0,0,123,124,5,51,0,0,124,125,5,50,0,0,125,38, + 1,0,0,0,126,127,5,105,0,0,127,128,5,110,0,0,128,129,5,116,0,0,129,130, + 5,54,0,0,130,131,5,52,0,0,131,40,1,0,0,0,132,133,5,102,0,0,133,134,5, + 108,0,0,134,135,5,111,0,0,135,136,5,97,0,0,136,137,5,116,0,0,137,42,1, + 0,0,0,138,139,5,100,0,0,139,140,5,111,0,0,140,141,5,117,0,0,141,142,5, + 98,0,0,142,143,5,108,0,0,143,144,5,101,0,0,144,44,1,0,0,0,145,146,5,98, + 0,0,146,147,5,111,0,0,147,148,5,111,0,0,148,149,5,108,0,0,149,46,1,0, + 0,0,150,154,7,0,0,0,151,153,7,1,0,0,152,151,1,0,0,0,153,156,1,0,0,0,154, + 152,1,0,0,0,154,155,1,0,0,0,155,48,1,0,0,0,156,154,1,0,0,0,157,158,7, + 2,0,0,158,159,1,0,0,0,159,160,6,24,0,0,160,50,1,0,0,0,161,162,5,47,0, + 0,162,163,5,47,0,0,163,167,1,0,0,0,164,166,8,3,0,0,165,164,1,0,0,0,166, + 169,1,0,0,0,167,165,1,0,0,0,167,168,1,0,0,0,168,170,1,0,0,0,169,167,1, + 0,0,0,170,171,6,25,0,0,171,52,1,0,0,0,3,0,154,167,1,6,0,0 }; staticData->serializedATN = antlr4::atn::SerializedATNView(serializedATNSegment, sizeof(serializedATNSegment) / sizeof(serializedATNSegment[0])); diff --git a/src/spider/tdl/parser/antlr_generated/TaskDefLangLexer.h b/src/spider/tdl/parser/antlr_generated/TaskDefLangLexer.h index 29aac16a5..adf3e09d3 100644 --- a/src/spider/tdl/parser/antlr_generated/TaskDefLangLexer.h +++ b/src/spider/tdl/parser/antlr_generated/TaskDefLangLexer.h @@ -13,7 +13,10 @@ namespace spider::tdl::parser::antlr_generated { class TaskDefLangLexer : public antlr4::Lexer { public: enum { - SPACE = 1 + T__0 = 1, T__1 = 2, T__2 = 3, T__3 = 4, T__4 = 5, T__5 = 6, T__6 = 7, + T__7 = 8, T__8 = 9, T__9 = 10, T__10 = 11, T__11 = 12, T__12 = 13, T__13 = 14, + T__14 = 15, T__15 = 16, T__16 = 17, T__17 = 18, T__18 = 19, T__19 = 20, + T__20 = 21, T__21 = 22, T__22 = 23, ID = 24, SPACE = 25, COMMENT = 26 }; explicit TaskDefLangLexer(antlr4::CharStream *input); diff --git a/src/spider/tdl/parser/antlr_generated/TaskDefLangParser.cpp b/src/spider/tdl/parser/antlr_generated/TaskDefLangParser.cpp index f5cba2bf5..4eb6f5cdc 100644 --- a/src/spider/tdl/parser/antlr_generated/TaskDefLangParser.cpp +++ b/src/spider/tdl/parser/antlr_generated/TaskDefLangParser.cpp @@ -53,17 +53,66 @@ void taskdeflangParserInitialize() { #endif auto staticData = std::make_unique( std::vector{ - "start" + "translationUnit", "namespace", "funcDef", "ret", "params", "namedVar", + "namedVarList", "structDef", "id", "varType", "retType", "varTypeList", + "listType", "mapType", "tupleType", "builtinType" }, std::vector{ + "", "'namespace'", "'{'", "'}'", "'fn'", "'('", "')'", "';'", "'->'", + "':'", "','", "'struct'", "'List'", "'<'", "'>'", "'Map'", "'Tuple'", + "'int8'", "'int16'", "'int32'", "'int64'", "'float'", "'double'", + "'bool'" }, std::vector{ - "", "SPACE" + "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", + "", "", "", "", "", "", "", "ID", "SPACE", "COMMENT" } ); static const int32_t serializedATNSegment[] = { - 4,1,1,5,2,0,7,0,1,0,1,0,1,0,0,0,1,0,0,0,3,0,2,1,0,0,0,2,3,5,0,0,1,3,1, - 1,0,0,0,0 + 4,1,26,146,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5,2,6,7,6,2, + 7,7,7,2,8,7,8,2,9,7,9,2,10,7,10,2,11,7,11,2,12,7,12,2,13,7,13,2,14,7, + 14,2,15,7,15,1,0,1,0,5,0,35,8,0,10,0,12,0,38,9,0,1,0,1,0,1,1,1,1,1,1, + 1,1,5,1,46,8,1,10,1,12,1,49,9,1,1,1,1,1,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1, + 2,1,3,1,3,1,3,3,3,64,8,3,1,4,1,4,3,4,68,8,4,1,5,1,5,1,5,1,5,1,6,1,6,1, + 6,1,6,1,6,1,6,5,6,80,8,6,10,6,12,6,83,9,6,1,7,1,7,1,7,1,7,1,7,3,7,90, + 8,7,1,7,1,7,1,7,1,8,1,8,1,9,1,9,3,9,99,8,9,1,10,1,10,3,10,103,8,10,1, + 11,1,11,1,11,3,11,108,8,11,1,11,1,11,1,11,5,11,113,8,11,10,11,12,11,116, + 9,11,1,12,1,12,1,12,1,12,1,12,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,14, + 1,14,1,14,1,14,1,14,1,15,1,15,1,15,1,15,1,15,1,15,1,15,1,15,1,15,3,15, + 144,8,15,1,15,0,2,12,22,16,0,2,4,6,8,10,12,14,16,18,20,22,24,26,28,30, + 0,0,148,0,36,1,0,0,0,2,41,1,0,0,0,4,52,1,0,0,0,6,63,1,0,0,0,8,67,1,0, + 0,0,10,69,1,0,0,0,12,73,1,0,0,0,14,84,1,0,0,0,16,94,1,0,0,0,18,98,1,0, + 0,0,20,102,1,0,0,0,22,107,1,0,0,0,24,117,1,0,0,0,26,122,1,0,0,0,28,129, + 1,0,0,0,30,143,1,0,0,0,32,35,3,2,1,0,33,35,3,14,7,0,34,32,1,0,0,0,34, + 33,1,0,0,0,35,38,1,0,0,0,36,34,1,0,0,0,36,37,1,0,0,0,37,39,1,0,0,0,38, + 36,1,0,0,0,39,40,5,0,0,1,40,1,1,0,0,0,41,42,5,1,0,0,42,43,3,16,8,0,43, + 47,5,2,0,0,44,46,3,4,2,0,45,44,1,0,0,0,46,49,1,0,0,0,47,45,1,0,0,0,47, + 48,1,0,0,0,48,50,1,0,0,0,49,47,1,0,0,0,50,51,5,3,0,0,51,3,1,0,0,0,52, + 53,5,4,0,0,53,54,3,16,8,0,54,55,5,5,0,0,55,56,3,8,4,0,56,57,5,6,0,0,57, + 58,3,6,3,0,58,59,5,7,0,0,59,5,1,0,0,0,60,61,5,8,0,0,61,64,3,20,10,0,62, + 64,1,0,0,0,63,60,1,0,0,0,63,62,1,0,0,0,64,7,1,0,0,0,65,68,3,12,6,0,66, + 68,1,0,0,0,67,65,1,0,0,0,67,66,1,0,0,0,68,9,1,0,0,0,69,70,3,16,8,0,70, + 71,5,9,0,0,71,72,3,18,9,0,72,11,1,0,0,0,73,74,6,6,-1,0,74,75,3,10,5,0, + 75,81,1,0,0,0,76,77,10,1,0,0,77,78,5,10,0,0,78,80,3,10,5,0,79,76,1,0, + 0,0,80,83,1,0,0,0,81,79,1,0,0,0,81,82,1,0,0,0,82,13,1,0,0,0,83,81,1,0, + 0,0,84,85,5,11,0,0,85,86,3,16,8,0,86,87,5,2,0,0,87,89,3,12,6,0,88,90, + 5,10,0,0,89,88,1,0,0,0,89,90,1,0,0,0,90,91,1,0,0,0,91,92,5,3,0,0,92,93, + 5,7,0,0,93,15,1,0,0,0,94,95,5,24,0,0,95,17,1,0,0,0,96,99,3,30,15,0,97, + 99,3,16,8,0,98,96,1,0,0,0,98,97,1,0,0,0,99,19,1,0,0,0,100,103,3,18,9, + 0,101,103,3,28,14,0,102,100,1,0,0,0,102,101,1,0,0,0,103,21,1,0,0,0,104, + 105,6,11,-1,0,105,108,3,18,9,0,106,108,1,0,0,0,107,104,1,0,0,0,107,106, + 1,0,0,0,108,114,1,0,0,0,109,110,10,2,0,0,110,111,5,10,0,0,111,113,3,18, + 9,0,112,109,1,0,0,0,113,116,1,0,0,0,114,112,1,0,0,0,114,115,1,0,0,0,115, + 23,1,0,0,0,116,114,1,0,0,0,117,118,5,12,0,0,118,119,5,13,0,0,119,120, + 3,18,9,0,120,121,5,14,0,0,121,25,1,0,0,0,122,123,5,15,0,0,123,124,5,13, + 0,0,124,125,3,18,9,0,125,126,5,10,0,0,126,127,3,18,9,0,127,128,5,14,0, + 0,128,27,1,0,0,0,129,130,5,16,0,0,130,131,5,13,0,0,131,132,3,22,11,0, + 132,133,5,14,0,0,133,29,1,0,0,0,134,144,5,17,0,0,135,144,5,18,0,0,136, + 144,5,19,0,0,137,144,5,20,0,0,138,144,5,21,0,0,139,144,5,22,0,0,140,144, + 5,23,0,0,141,144,3,24,12,0,142,144,3,26,13,0,143,134,1,0,0,0,143,135, + 1,0,0,0,143,136,1,0,0,0,143,137,1,0,0,0,143,138,1,0,0,0,143,139,1,0,0, + 0,143,140,1,0,0,0,143,141,1,0,0,0,143,142,1,0,0,0,144,31,1,0,0,0,12,34, + 36,47,63,67,81,89,98,102,107,114,143 }; staticData->serializedATN = antlr4::atn::SerializedATNView(serializedATNSegment, sizeof(serializedATNSegment) / sizeof(serializedATNSegment[0])); @@ -112,32 +161,49 @@ antlr4::atn::SerializedATNView TaskDefLangParser::getSerializedATN() const { } -//----------------- StartContext ------------------------------------------------------------------ +//----------------- TranslationUnitContext ------------------------------------------------------------------ -TaskDefLangParser::StartContext::StartContext(ParserRuleContext *parent, size_t invokingState) +TaskDefLangParser::TranslationUnitContext::TranslationUnitContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) { } -tree::TerminalNode* TaskDefLangParser::StartContext::EOF() { +tree::TerminalNode* TaskDefLangParser::TranslationUnitContext::EOF() { return getToken(TaskDefLangParser::EOF, 0); } +std::vector TaskDefLangParser::TranslationUnitContext::namespace_() { + return getRuleContexts(); +} + +TaskDefLangParser::NamespaceContext* TaskDefLangParser::TranslationUnitContext::namespace_(size_t i) { + return getRuleContext(i); +} + +std::vector TaskDefLangParser::TranslationUnitContext::structDef() { + return getRuleContexts(); +} + +TaskDefLangParser::StructDefContext* TaskDefLangParser::TranslationUnitContext::structDef(size_t i) { + return getRuleContext(i); +} + -size_t TaskDefLangParser::StartContext::getRuleIndex() const { - return TaskDefLangParser::RuleStart; +size_t TaskDefLangParser::TranslationUnitContext::getRuleIndex() const { + return TaskDefLangParser::RuleTranslationUnit; } -std::any TaskDefLangParser::StartContext::accept(tree::ParseTreeVisitor *visitor) { +std::any TaskDefLangParser::TranslationUnitContext::accept(tree::ParseTreeVisitor *visitor) { if (auto parserVisitor = dynamic_cast(visitor)) - return parserVisitor->visitStart(this); + return parserVisitor->visitTranslationUnit(this); else return visitor->visitChildren(this); } -TaskDefLangParser::StartContext* TaskDefLangParser::start() { - StartContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 0, TaskDefLangParser::RuleStart); +TaskDefLangParser::TranslationUnitContext* TaskDefLangParser::translationUnit() { + TranslationUnitContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 0, TaskDefLangParser::RuleTranslationUnit); + size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -148,7 +214,35 @@ TaskDefLangParser::StartContext* TaskDefLangParser::start() { }); try { enterOuterAlt(_localctx, 1); - setState(2); + setState(36); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == TaskDefLangParser::T__0 + + || _la == TaskDefLangParser::T__10) { + setState(34); + _errHandler->sync(this); + switch (_input->LA(1)) { + case TaskDefLangParser::T__0: { + setState(32); + namespace_(); + break; + } + + case TaskDefLangParser::T__10: { + setState(33); + structDef(); + break; + } + + default: + throw NoViableAltException(this); + } + setState(38); + _errHandler->sync(this); + _la = _input->LA(1); + } + setState(39); match(TaskDefLangParser::EOF); } @@ -161,6 +255,1127 @@ TaskDefLangParser::StartContext* TaskDefLangParser::start() { return _localctx; } +//----------------- NamespaceContext ------------------------------------------------------------------ + +TaskDefLangParser::NamespaceContext::NamespaceContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +TaskDefLangParser::IdContext* TaskDefLangParser::NamespaceContext::id() { + return getRuleContext(0); +} + +std::vector TaskDefLangParser::NamespaceContext::funcDef() { + return getRuleContexts(); +} + +TaskDefLangParser::FuncDefContext* TaskDefLangParser::NamespaceContext::funcDef(size_t i) { + return getRuleContext(i); +} + + +size_t TaskDefLangParser::NamespaceContext::getRuleIndex() const { + return TaskDefLangParser::RuleNamespace; +} + + +std::any TaskDefLangParser::NamespaceContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitNamespace(this); + else + return visitor->visitChildren(this); +} + +TaskDefLangParser::NamespaceContext* TaskDefLangParser::namespace_() { + NamespaceContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 2, TaskDefLangParser::RuleNamespace); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(41); + match(TaskDefLangParser::T__0); + setState(42); + id(); + setState(43); + match(TaskDefLangParser::T__1); + setState(47); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == TaskDefLangParser::T__3) { + setState(44); + funcDef(); + setState(49); + _errHandler->sync(this); + _la = _input->LA(1); + } + setState(50); + match(TaskDefLangParser::T__2); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- FuncDefContext ------------------------------------------------------------------ + +TaskDefLangParser::FuncDefContext::FuncDefContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +TaskDefLangParser::IdContext* TaskDefLangParser::FuncDefContext::id() { + return getRuleContext(0); +} + +TaskDefLangParser::ParamsContext* TaskDefLangParser::FuncDefContext::params() { + return getRuleContext(0); +} + +TaskDefLangParser::RetContext* TaskDefLangParser::FuncDefContext::ret() { + return getRuleContext(0); +} + + +size_t TaskDefLangParser::FuncDefContext::getRuleIndex() const { + return TaskDefLangParser::RuleFuncDef; +} + + +std::any TaskDefLangParser::FuncDefContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitFuncDef(this); + else + return visitor->visitChildren(this); +} + +TaskDefLangParser::FuncDefContext* TaskDefLangParser::funcDef() { + FuncDefContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 4, TaskDefLangParser::RuleFuncDef); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(52); + match(TaskDefLangParser::T__3); + setState(53); + id(); + setState(54); + match(TaskDefLangParser::T__4); + setState(55); + params(); + setState(56); + match(TaskDefLangParser::T__5); + setState(57); + ret(); + setState(58); + match(TaskDefLangParser::T__6); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- RetContext ------------------------------------------------------------------ + +TaskDefLangParser::RetContext::RetContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +TaskDefLangParser::RetTypeContext* TaskDefLangParser::RetContext::retType() { + return getRuleContext(0); +} + + +size_t TaskDefLangParser::RetContext::getRuleIndex() const { + return TaskDefLangParser::RuleRet; +} + + +std::any TaskDefLangParser::RetContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitRet(this); + else + return visitor->visitChildren(this); +} + +TaskDefLangParser::RetContext* TaskDefLangParser::ret() { + RetContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 6, TaskDefLangParser::RuleRet); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(63); + _errHandler->sync(this); + switch (_input->LA(1)) { + case TaskDefLangParser::T__7: { + enterOuterAlt(_localctx, 1); + setState(60); + match(TaskDefLangParser::T__7); + setState(61); + retType(); + break; + } + + case TaskDefLangParser::T__6: { + enterOuterAlt(_localctx, 2); + + break; + } + + default: + throw NoViableAltException(this); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- ParamsContext ------------------------------------------------------------------ + +TaskDefLangParser::ParamsContext::ParamsContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +TaskDefLangParser::NamedVarListContext* TaskDefLangParser::ParamsContext::namedVarList() { + return getRuleContext(0); +} + + +size_t TaskDefLangParser::ParamsContext::getRuleIndex() const { + return TaskDefLangParser::RuleParams; +} + + +std::any TaskDefLangParser::ParamsContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitParams(this); + else + return visitor->visitChildren(this); +} + +TaskDefLangParser::ParamsContext* TaskDefLangParser::params() { + ParamsContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 8, TaskDefLangParser::RuleParams); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(67); + _errHandler->sync(this); + switch (_input->LA(1)) { + case TaskDefLangParser::ID: { + enterOuterAlt(_localctx, 1); + setState(65); + namedVarList(0); + break; + } + + case TaskDefLangParser::T__5: { + enterOuterAlt(_localctx, 2); + + break; + } + + default: + throw NoViableAltException(this); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- NamedVarContext ------------------------------------------------------------------ + +TaskDefLangParser::NamedVarContext::NamedVarContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +TaskDefLangParser::IdContext* TaskDefLangParser::NamedVarContext::id() { + return getRuleContext(0); +} + +TaskDefLangParser::VarTypeContext* TaskDefLangParser::NamedVarContext::varType() { + return getRuleContext(0); +} + + +size_t TaskDefLangParser::NamedVarContext::getRuleIndex() const { + return TaskDefLangParser::RuleNamedVar; +} + + +std::any TaskDefLangParser::NamedVarContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitNamedVar(this); + else + return visitor->visitChildren(this); +} + +TaskDefLangParser::NamedVarContext* TaskDefLangParser::namedVar() { + NamedVarContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 10, TaskDefLangParser::RuleNamedVar); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(69); + id(); + setState(70); + match(TaskDefLangParser::T__8); + setState(71); + varType(); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- NamedVarListContext ------------------------------------------------------------------ + +TaskDefLangParser::NamedVarListContext::NamedVarListContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +TaskDefLangParser::NamedVarContext* TaskDefLangParser::NamedVarListContext::namedVar() { + return getRuleContext(0); +} + +TaskDefLangParser::NamedVarListContext* TaskDefLangParser::NamedVarListContext::namedVarList() { + return getRuleContext(0); +} + + +size_t TaskDefLangParser::NamedVarListContext::getRuleIndex() const { + return TaskDefLangParser::RuleNamedVarList; +} + + +std::any TaskDefLangParser::NamedVarListContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitNamedVarList(this); + else + return visitor->visitChildren(this); +} + + +TaskDefLangParser::NamedVarListContext* TaskDefLangParser::namedVarList() { + return namedVarList(0); +} + +TaskDefLangParser::NamedVarListContext* TaskDefLangParser::namedVarList(int precedence) { + ParserRuleContext *parentContext = _ctx; + size_t parentState = getState(); + TaskDefLangParser::NamedVarListContext *_localctx = _tracker.createInstance(_ctx, parentState); + TaskDefLangParser::NamedVarListContext *previousContext = _localctx; + (void)previousContext; // Silence compiler, in case the context is not used by generated code. + size_t startState = 12; + enterRecursionRule(_localctx, 12, TaskDefLangParser::RuleNamedVarList, precedence); + + + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + unrollRecursionContexts(parentContext); + }); + try { + size_t alt; + enterOuterAlt(_localctx, 1); + setState(74); + namedVar(); + _ctx->stop = _input->LT(-1); + setState(81); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 5, _ctx); + while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { + if (alt == 1) { + if (!_parseListeners.empty()) + triggerExitRuleEvent(); + previousContext = _localctx; + _localctx = _tracker.createInstance(parentContext, parentState); + pushNewRecursionContext(_localctx, startState, RuleNamedVarList); + setState(76); + + if (!(precpred(_ctx, 1))) throw FailedPredicateException(this, "precpred(_ctx, 1)"); + setState(77); + match(TaskDefLangParser::T__9); + setState(78); + namedVar(); + } + setState(83); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 5, _ctx); + } + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + return _localctx; +} + +//----------------- StructDefContext ------------------------------------------------------------------ + +TaskDefLangParser::StructDefContext::StructDefContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +TaskDefLangParser::IdContext* TaskDefLangParser::StructDefContext::id() { + return getRuleContext(0); +} + +TaskDefLangParser::NamedVarListContext* TaskDefLangParser::StructDefContext::namedVarList() { + return getRuleContext(0); +} + + +size_t TaskDefLangParser::StructDefContext::getRuleIndex() const { + return TaskDefLangParser::RuleStructDef; +} + + +std::any TaskDefLangParser::StructDefContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitStructDef(this); + else + return visitor->visitChildren(this); +} + +TaskDefLangParser::StructDefContext* TaskDefLangParser::structDef() { + StructDefContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 14, TaskDefLangParser::RuleStructDef); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(84); + match(TaskDefLangParser::T__10); + setState(85); + id(); + setState(86); + match(TaskDefLangParser::T__1); + setState(87); + namedVarList(0); + setState(89); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == TaskDefLangParser::T__9) { + setState(88); + match(TaskDefLangParser::T__9); + } + setState(91); + match(TaskDefLangParser::T__2); + setState(92); + match(TaskDefLangParser::T__6); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- IdContext ------------------------------------------------------------------ + +TaskDefLangParser::IdContext::IdContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* TaskDefLangParser::IdContext::ID() { + return getToken(TaskDefLangParser::ID, 0); +} + + +size_t TaskDefLangParser::IdContext::getRuleIndex() const { + return TaskDefLangParser::RuleId; +} + + +std::any TaskDefLangParser::IdContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitId(this); + else + return visitor->visitChildren(this); +} + +TaskDefLangParser::IdContext* TaskDefLangParser::id() { + IdContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 16, TaskDefLangParser::RuleId); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(94); + match(TaskDefLangParser::ID); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- VarTypeContext ------------------------------------------------------------------ + +TaskDefLangParser::VarTypeContext::VarTypeContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +TaskDefLangParser::BuiltinTypeContext* TaskDefLangParser::VarTypeContext::builtinType() { + return getRuleContext(0); +} + +TaskDefLangParser::IdContext* TaskDefLangParser::VarTypeContext::id() { + return getRuleContext(0); +} + + +size_t TaskDefLangParser::VarTypeContext::getRuleIndex() const { + return TaskDefLangParser::RuleVarType; +} + + +std::any TaskDefLangParser::VarTypeContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitVarType(this); + else + return visitor->visitChildren(this); +} + +TaskDefLangParser::VarTypeContext* TaskDefLangParser::varType() { + VarTypeContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 18, TaskDefLangParser::RuleVarType); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(98); + _errHandler->sync(this); + switch (_input->LA(1)) { + case TaskDefLangParser::T__11: + case TaskDefLangParser::T__14: + case TaskDefLangParser::T__16: + case TaskDefLangParser::T__17: + case TaskDefLangParser::T__18: + case TaskDefLangParser::T__19: + case TaskDefLangParser::T__20: + case TaskDefLangParser::T__21: + case TaskDefLangParser::T__22: { + enterOuterAlt(_localctx, 1); + setState(96); + builtinType(); + break; + } + + case TaskDefLangParser::ID: { + enterOuterAlt(_localctx, 2); + setState(97); + id(); + break; + } + + default: + throw NoViableAltException(this); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- RetTypeContext ------------------------------------------------------------------ + +TaskDefLangParser::RetTypeContext::RetTypeContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +TaskDefLangParser::VarTypeContext* TaskDefLangParser::RetTypeContext::varType() { + return getRuleContext(0); +} + +TaskDefLangParser::TupleTypeContext* TaskDefLangParser::RetTypeContext::tupleType() { + return getRuleContext(0); +} + + +size_t TaskDefLangParser::RetTypeContext::getRuleIndex() const { + return TaskDefLangParser::RuleRetType; +} + + +std::any TaskDefLangParser::RetTypeContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitRetType(this); + else + return visitor->visitChildren(this); +} + +TaskDefLangParser::RetTypeContext* TaskDefLangParser::retType() { + RetTypeContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 20, TaskDefLangParser::RuleRetType); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(102); + _errHandler->sync(this); + switch (_input->LA(1)) { + case TaskDefLangParser::T__11: + case TaskDefLangParser::T__14: + case TaskDefLangParser::T__16: + case TaskDefLangParser::T__17: + case TaskDefLangParser::T__18: + case TaskDefLangParser::T__19: + case TaskDefLangParser::T__20: + case TaskDefLangParser::T__21: + case TaskDefLangParser::T__22: + case TaskDefLangParser::ID: { + enterOuterAlt(_localctx, 1); + setState(100); + varType(); + break; + } + + case TaskDefLangParser::T__15: { + enterOuterAlt(_localctx, 2); + setState(101); + tupleType(); + break; + } + + default: + throw NoViableAltException(this); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- VarTypeListContext ------------------------------------------------------------------ + +TaskDefLangParser::VarTypeListContext::VarTypeListContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +TaskDefLangParser::VarTypeContext* TaskDefLangParser::VarTypeListContext::varType() { + return getRuleContext(0); +} + +TaskDefLangParser::VarTypeListContext* TaskDefLangParser::VarTypeListContext::varTypeList() { + return getRuleContext(0); +} + + +size_t TaskDefLangParser::VarTypeListContext::getRuleIndex() const { + return TaskDefLangParser::RuleVarTypeList; +} + + +std::any TaskDefLangParser::VarTypeListContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitVarTypeList(this); + else + return visitor->visitChildren(this); +} + + +TaskDefLangParser::VarTypeListContext* TaskDefLangParser::varTypeList() { + return varTypeList(0); +} + +TaskDefLangParser::VarTypeListContext* TaskDefLangParser::varTypeList(int precedence) { + ParserRuleContext *parentContext = _ctx; + size_t parentState = getState(); + TaskDefLangParser::VarTypeListContext *_localctx = _tracker.createInstance(_ctx, parentState); + TaskDefLangParser::VarTypeListContext *previousContext = _localctx; + (void)previousContext; // Silence compiler, in case the context is not used by generated code. + size_t startState = 22; + enterRecursionRule(_localctx, 22, TaskDefLangParser::RuleVarTypeList, precedence); + + + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + unrollRecursionContexts(parentContext); + }); + try { + size_t alt; + enterOuterAlt(_localctx, 1); + setState(107); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 9, _ctx)) { + case 1: { + setState(105); + varType(); + break; + } + + case 2: { + break; + } + + default: + break; + } + _ctx->stop = _input->LT(-1); + setState(114); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 10, _ctx); + while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { + if (alt == 1) { + if (!_parseListeners.empty()) + triggerExitRuleEvent(); + previousContext = _localctx; + _localctx = _tracker.createInstance(parentContext, parentState); + pushNewRecursionContext(_localctx, startState, RuleVarTypeList); + setState(109); + + if (!(precpred(_ctx, 2))) throw FailedPredicateException(this, "precpred(_ctx, 2)"); + setState(110); + match(TaskDefLangParser::T__9); + setState(111); + varType(); + } + setState(116); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 10, _ctx); + } + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + return _localctx; +} + +//----------------- ListTypeContext ------------------------------------------------------------------ + +TaskDefLangParser::ListTypeContext::ListTypeContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +TaskDefLangParser::VarTypeContext* TaskDefLangParser::ListTypeContext::varType() { + return getRuleContext(0); +} + + +size_t TaskDefLangParser::ListTypeContext::getRuleIndex() const { + return TaskDefLangParser::RuleListType; +} + + +std::any TaskDefLangParser::ListTypeContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitListType(this); + else + return visitor->visitChildren(this); +} + +TaskDefLangParser::ListTypeContext* TaskDefLangParser::listType() { + ListTypeContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 24, TaskDefLangParser::RuleListType); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(117); + match(TaskDefLangParser::T__11); + setState(118); + match(TaskDefLangParser::T__12); + setState(119); + varType(); + setState(120); + match(TaskDefLangParser::T__13); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- MapTypeContext ------------------------------------------------------------------ + +TaskDefLangParser::MapTypeContext::MapTypeContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +std::vector TaskDefLangParser::MapTypeContext::varType() { + return getRuleContexts(); +} + +TaskDefLangParser::VarTypeContext* TaskDefLangParser::MapTypeContext::varType(size_t i) { + return getRuleContext(i); +} + + +size_t TaskDefLangParser::MapTypeContext::getRuleIndex() const { + return TaskDefLangParser::RuleMapType; +} + + +std::any TaskDefLangParser::MapTypeContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitMapType(this); + else + return visitor->visitChildren(this); +} + +TaskDefLangParser::MapTypeContext* TaskDefLangParser::mapType() { + MapTypeContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 26, TaskDefLangParser::RuleMapType); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(122); + match(TaskDefLangParser::T__14); + setState(123); + match(TaskDefLangParser::T__12); + setState(124); + varType(); + setState(125); + match(TaskDefLangParser::T__9); + setState(126); + varType(); + setState(127); + match(TaskDefLangParser::T__13); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- TupleTypeContext ------------------------------------------------------------------ + +TaskDefLangParser::TupleTypeContext::TupleTypeContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +TaskDefLangParser::VarTypeListContext* TaskDefLangParser::TupleTypeContext::varTypeList() { + return getRuleContext(0); +} + + +size_t TaskDefLangParser::TupleTypeContext::getRuleIndex() const { + return TaskDefLangParser::RuleTupleType; +} + + +std::any TaskDefLangParser::TupleTypeContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitTupleType(this); + else + return visitor->visitChildren(this); +} + +TaskDefLangParser::TupleTypeContext* TaskDefLangParser::tupleType() { + TupleTypeContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 28, TaskDefLangParser::RuleTupleType); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(129); + match(TaskDefLangParser::T__15); + setState(130); + match(TaskDefLangParser::T__12); + setState(131); + varTypeList(0); + setState(132); + match(TaskDefLangParser::T__13); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- BuiltinTypeContext ------------------------------------------------------------------ + +TaskDefLangParser::BuiltinTypeContext::BuiltinTypeContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +TaskDefLangParser::ListTypeContext* TaskDefLangParser::BuiltinTypeContext::listType() { + return getRuleContext(0); +} + +TaskDefLangParser::MapTypeContext* TaskDefLangParser::BuiltinTypeContext::mapType() { + return getRuleContext(0); +} + + +size_t TaskDefLangParser::BuiltinTypeContext::getRuleIndex() const { + return TaskDefLangParser::RuleBuiltinType; +} + + +std::any TaskDefLangParser::BuiltinTypeContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitBuiltinType(this); + else + return visitor->visitChildren(this); +} + +TaskDefLangParser::BuiltinTypeContext* TaskDefLangParser::builtinType() { + BuiltinTypeContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 30, TaskDefLangParser::RuleBuiltinType); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(143); + _errHandler->sync(this); + switch (_input->LA(1)) { + case TaskDefLangParser::T__16: { + enterOuterAlt(_localctx, 1); + setState(134); + match(TaskDefLangParser::T__16); + break; + } + + case TaskDefLangParser::T__17: { + enterOuterAlt(_localctx, 2); + setState(135); + match(TaskDefLangParser::T__17); + break; + } + + case TaskDefLangParser::T__18: { + enterOuterAlt(_localctx, 3); + setState(136); + match(TaskDefLangParser::T__18); + break; + } + + case TaskDefLangParser::T__19: { + enterOuterAlt(_localctx, 4); + setState(137); + match(TaskDefLangParser::T__19); + break; + } + + case TaskDefLangParser::T__20: { + enterOuterAlt(_localctx, 5); + setState(138); + match(TaskDefLangParser::T__20); + break; + } + + case TaskDefLangParser::T__21: { + enterOuterAlt(_localctx, 6); + setState(139); + match(TaskDefLangParser::T__21); + break; + } + + case TaskDefLangParser::T__22: { + enterOuterAlt(_localctx, 7); + setState(140); + match(TaskDefLangParser::T__22); + break; + } + + case TaskDefLangParser::T__11: { + enterOuterAlt(_localctx, 8); + setState(141); + listType(); + break; + } + + case TaskDefLangParser::T__14: { + enterOuterAlt(_localctx, 9); + setState(142); + mapType(); + break; + } + + default: + throw NoViableAltException(this); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +bool TaskDefLangParser::sempred(RuleContext *context, size_t ruleIndex, size_t predicateIndex) { + switch (ruleIndex) { + case 6: return namedVarListSempred(antlrcpp::downCast(context), predicateIndex); + case 11: return varTypeListSempred(antlrcpp::downCast(context), predicateIndex); + + default: + break; + } + return true; +} + +bool TaskDefLangParser::namedVarListSempred(NamedVarListContext *_localctx, size_t predicateIndex) { + switch (predicateIndex) { + case 0: return precpred(_ctx, 1); + + default: + break; + } + return true; +} + +bool TaskDefLangParser::varTypeListSempred(VarTypeListContext *_localctx, size_t predicateIndex) { + switch (predicateIndex) { + case 1: return precpred(_ctx, 2); + + default: + break; + } + return true; +} + void TaskDefLangParser::initialize() { #if ANTLR4_USE_THREAD_LOCAL_CACHE taskdeflangParserInitialize(); diff --git a/src/spider/tdl/parser/antlr_generated/TaskDefLangParser.h b/src/spider/tdl/parser/antlr_generated/TaskDefLangParser.h index 74687a10f..bed4767d2 100644 --- a/src/spider/tdl/parser/antlr_generated/TaskDefLangParser.h +++ b/src/spider/tdl/parser/antlr_generated/TaskDefLangParser.h @@ -13,11 +13,17 @@ namespace spider::tdl::parser::antlr_generated { class TaskDefLangParser : public antlr4::Parser { public: enum { - SPACE = 1 + T__0 = 1, T__1 = 2, T__2 = 3, T__3 = 4, T__4 = 5, T__5 = 6, T__6 = 7, + T__7 = 8, T__8 = 9, T__9 = 10, T__10 = 11, T__11 = 12, T__12 = 13, T__13 = 14, + T__14 = 15, T__15 = 16, T__16 = 17, T__17 = 18, T__18 = 19, T__19 = 20, + T__20 = 21, T__21 = 22, T__22 = 23, ID = 24, SPACE = 25, COMMENT = 26 }; enum { - RuleStart = 0 + RuleTranslationUnit = 0, RuleNamespace = 1, RuleFuncDef = 2, RuleRet = 3, + RuleParams = 4, RuleNamedVar = 5, RuleNamedVarList = 6, RuleStructDef = 7, + RuleId = 8, RuleVarType = 9, RuleRetType = 10, RuleVarTypeList = 11, + RuleListType = 12, RuleMapType = 13, RuleTupleType = 14, RuleBuiltinType = 15 }; explicit TaskDefLangParser(antlr4::TokenStream *input); @@ -37,21 +43,252 @@ class TaskDefLangParser : public antlr4::Parser { antlr4::atn::SerializedATNView getSerializedATN() const override; - class StartContext; + class TranslationUnitContext; + class NamespaceContext; + class FuncDefContext; + class RetContext; + class ParamsContext; + class NamedVarContext; + class NamedVarListContext; + class StructDefContext; + class IdContext; + class VarTypeContext; + class RetTypeContext; + class VarTypeListContext; + class ListTypeContext; + class MapTypeContext; + class TupleTypeContext; + class BuiltinTypeContext; - class StartContext : public antlr4::ParserRuleContext { + class TranslationUnitContext : public antlr4::ParserRuleContext { public: - StartContext(antlr4::ParserRuleContext *parent, size_t invokingState); + TranslationUnitContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *EOF(); + std::vector namespace_(); + NamespaceContext* namespace_(size_t i); + std::vector structDef(); + StructDefContext* structDef(size_t i); virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; }; - StartContext* start(); + TranslationUnitContext* translationUnit(); + class NamespaceContext : public antlr4::ParserRuleContext { + public: + NamespaceContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + IdContext *id(); + std::vector funcDef(); + FuncDefContext* funcDef(size_t i); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + NamespaceContext* namespace_(); + + class FuncDefContext : public antlr4::ParserRuleContext { + public: + FuncDefContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + IdContext *id(); + ParamsContext *params(); + RetContext *ret(); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + FuncDefContext* funcDef(); + + class RetContext : public antlr4::ParserRuleContext { + public: + RetContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + RetTypeContext *retType(); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + RetContext* ret(); + + class ParamsContext : public antlr4::ParserRuleContext { + public: + ParamsContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + NamedVarListContext *namedVarList(); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + ParamsContext* params(); + + class NamedVarContext : public antlr4::ParserRuleContext { + public: + NamedVarContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + IdContext *id(); + VarTypeContext *varType(); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + NamedVarContext* namedVar(); + + class NamedVarListContext : public antlr4::ParserRuleContext { + public: + NamedVarListContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + NamedVarContext *namedVar(); + NamedVarListContext *namedVarList(); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + NamedVarListContext* namedVarList(); + NamedVarListContext* namedVarList(int precedence); + class StructDefContext : public antlr4::ParserRuleContext { + public: + StructDefContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + IdContext *id(); + NamedVarListContext *namedVarList(); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + StructDefContext* structDef(); + + class IdContext : public antlr4::ParserRuleContext { + public: + IdContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *ID(); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + IdContext* id(); + + class VarTypeContext : public antlr4::ParserRuleContext { + public: + VarTypeContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + BuiltinTypeContext *builtinType(); + IdContext *id(); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + VarTypeContext* varType(); + + class RetTypeContext : public antlr4::ParserRuleContext { + public: + RetTypeContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + VarTypeContext *varType(); + TupleTypeContext *tupleType(); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + RetTypeContext* retType(); + + class VarTypeListContext : public antlr4::ParserRuleContext { + public: + VarTypeListContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + VarTypeContext *varType(); + VarTypeListContext *varTypeList(); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + VarTypeListContext* varTypeList(); + VarTypeListContext* varTypeList(int precedence); + class ListTypeContext : public antlr4::ParserRuleContext { + public: + ListTypeContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + VarTypeContext *varType(); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + ListTypeContext* listType(); + + class MapTypeContext : public antlr4::ParserRuleContext { + public: + MapTypeContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + std::vector varType(); + VarTypeContext* varType(size_t i); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + MapTypeContext* mapType(); + + class TupleTypeContext : public antlr4::ParserRuleContext { + public: + TupleTypeContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + VarTypeListContext *varTypeList(); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + TupleTypeContext* tupleType(); + + class BuiltinTypeContext : public antlr4::ParserRuleContext { + public: + BuiltinTypeContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + ListTypeContext *listType(); + MapTypeContext *mapType(); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + BuiltinTypeContext* builtinType(); + + + bool sempred(antlr4::RuleContext *_localctx, size_t ruleIndex, size_t predicateIndex) override; + + bool namedVarListSempred(NamedVarListContext *_localctx, size_t predicateIndex); + bool varTypeListSempred(VarTypeListContext *_localctx, size_t predicateIndex); // By default the static state used to implement the parser is lazily initialized during the first // call to the constructor. You can call this function if you wish to initialize the static state diff --git a/src/spider/tdl/parser/antlr_generated/TaskDefLangVisitor.h b/src/spider/tdl/parser/antlr_generated/TaskDefLangVisitor.h index 954517499..64563363b 100644 --- a/src/spider/tdl/parser/antlr_generated/TaskDefLangVisitor.h +++ b/src/spider/tdl/parser/antlr_generated/TaskDefLangVisitor.h @@ -20,7 +20,37 @@ class TaskDefLangVisitor : public antlr4::tree::AbstractParseTreeVisitor { /** * Visit parse trees produced by TaskDefLangParser. */ - virtual std::any visitStart(TaskDefLangParser::StartContext *context) = 0; + virtual std::any visitTranslationUnit(TaskDefLangParser::TranslationUnitContext *context) = 0; + + virtual std::any visitNamespace(TaskDefLangParser::NamespaceContext *context) = 0; + + virtual std::any visitFuncDef(TaskDefLangParser::FuncDefContext *context) = 0; + + virtual std::any visitRet(TaskDefLangParser::RetContext *context) = 0; + + virtual std::any visitParams(TaskDefLangParser::ParamsContext *context) = 0; + + virtual std::any visitNamedVar(TaskDefLangParser::NamedVarContext *context) = 0; + + virtual std::any visitNamedVarList(TaskDefLangParser::NamedVarListContext *context) = 0; + + virtual std::any visitStructDef(TaskDefLangParser::StructDefContext *context) = 0; + + virtual std::any visitId(TaskDefLangParser::IdContext *context) = 0; + + virtual std::any visitVarType(TaskDefLangParser::VarTypeContext *context) = 0; + + virtual std::any visitRetType(TaskDefLangParser::RetTypeContext *context) = 0; + + virtual std::any visitVarTypeList(TaskDefLangParser::VarTypeListContext *context) = 0; + + virtual std::any visitListType(TaskDefLangParser::ListTypeContext *context) = 0; + + virtual std::any visitMapType(TaskDefLangParser::MapTypeContext *context) = 0; + + virtual std::any visitTupleType(TaskDefLangParser::TupleTypeContext *context) = 0; + + virtual std::any visitBuiltinType(TaskDefLangParser::BuiltinTypeContext *context) = 0; }; diff --git a/src/spider/tdl/parser/parse.cpp b/src/spider/tdl/parser/parse.cpp new file mode 100644 index 000000000..be197bda2 --- /dev/null +++ b/src/spider/tdl/parser/parse.cpp @@ -0,0 +1,44 @@ +#include "parse.hpp" + +#include +#include + +#include +#include + +#include +#include +#include +#include + +namespace spider::tdl::parser { +auto parse_translation_unit_from_istream(std::istream& input) + -> boost::outcome_v2::std_checked { + // Setup lexer + antlr4::ANTLRInputStream input_stream{input}; + antlr_generated::TaskDefLangLexer lexer{&input_stream}; + ErrorListener lexer_error_listener{"Lexer"}; + lexer.removeErrorListeners(); + lexer.addErrorListener(&lexer_error_listener); + + // Setup parser + antlr4::CommonTokenStream token_stream{&lexer}; + antlr_generated::TaskDefLangParser parser{&token_stream}; + ErrorListener parser_error_listener{"Parser"}; + parser.removeErrorListeners(); + parser.addErrorListener(&parser_error_listener); + + // Parse the translation unit + std::ignore = parser.translationUnit(); + + if (lexer_error_listener.has_error()) { + return lexer_error_listener.error(); + } + + if (parser_error_listener.has_error()) { + return parser_error_listener.error(); + } + + return boost::outcome_v2::success(); +} +} // namespace spider::tdl::parser diff --git a/src/spider/tdl/parser/parse.hpp b/src/spider/tdl/parser/parse.hpp new file mode 100644 index 000000000..01abfc980 --- /dev/null +++ b/src/spider/tdl/parser/parse.hpp @@ -0,0 +1,23 @@ +#ifndef SPIDER_TDL_PARSER_PARSE_HPP +#define SPIDER_TDL_PARSER_PARSE_HPP + +#include + +#include + +#include + +namespace spider::tdl::parser { +/** + * Parses a TDL file as a translation unit from an input stream. + * @param input The input stream containing the TDL content. The entire content will be considered + * as a single translation unit. + * @return A void result on success, or an error specified by an `Error` instance on failure. + * NOTE: We will update this function to return an actual AST root on success once we add Antlr + * actions. + */ +[[nodiscard]] auto parse_translation_unit_from_istream(std::istream& input) + -> boost::outcome_v2::std_checked; +} // namespace spider::tdl::parser + +#endif // SPIDER_TDL_PARSER_PARSE_HPP diff --git a/tests/.clang-format b/tests/.clang-format index addca8add..3067a0e88 100644 --- a/tests/.clang-format +++ b/tests/.clang-format @@ -7,7 +7,7 @@ IncludeCategories: - Regex: "^<(spider|tests)" Priority: 4 # External library headers. Update when adding new libraries. - - Regex: "^<(absl|boost|catch2|fmt|mariadb|msgpack|spdlog|ystdlib)" + - Regex: "^<(antlr4|absl|boost|catch2|fmt|mariadb|msgpack|spdlog|ystdlib)" Priority: 3 # C system headers - Regex: "^<.+\\.h>" diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index 6c8fa95b1..d0b74b1fd 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -2,6 +2,7 @@ set(SPIDER_TEST_SOURCES storage/test-DataStorage.cpp storage/test-MetadataStorage.cpp storage/StorageTestHelper.hpp + tdl/test-parser.cpp tdl/test-parser-ast.cpp utils/CoreDataUtils.hpp utils/CoreTaskUtils.hpp diff --git a/tests/tdl/test-parser.cpp b/tests/tdl/test-parser.cpp new file mode 100644 index 000000000..43a2f2844 --- /dev/null +++ b/tests/tdl/test-parser.cpp @@ -0,0 +1,92 @@ +// NOLINTBEGIN(cert-err58-cpp,cppcoreguidelines-avoid-do-while,readability-function-cognitive-complexity,cppcoreguidelines-avoid-non-const-global-variables,cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays) + +#include +#include + +#include + +#include +#include + +namespace { +using spider::tdl::parser::parse_translation_unit_from_istream; +using spider::tdl::parser::SourceLocation; + +constexpr std::string_view cTestInput1{R"( +namespace test1 { + // Function with no parameters and no return type + fn empty_func(); + + // Function with parameters and return type + fn add(a: int32, b: int32) -> int64; + + // Function that returns an empty tuple + fn return_empty_tuple() -> Tuple<>; + + // Function that returns a tuple of containers + fn return_tuple_of_containers() -> Tuple, Map, Map>>>; +} + +struct Input { + field_0: int8, + field_1: int16, + field_2: int32, + field_3: int64, + field_4: float, + field_5: double, + field_6: bool, + field_7: List, + field_8: Map, double>, +}; + +struct Output { + // Notice that the field doesn't end with a comma + processed_input: Map +}; + +namespace test2 { + fn process_input(input: Input, task_id: int64) -> Output; + fn process_inputs(inputs: List, task_id: int64) -> Output; +} +)"}; + +TEST_CASE("Parser test basic", "[tdl][parser]") { + std::istringstream input_stream{std::string{cTestInput1}}; + REQUIRE_FALSE(parse_translation_unit_from_istream(input_stream).has_error()); +} + +TEST_CASE("Parser errors", "[tdl][parser]") { + SECTION("Namespace without an identifier") { + constexpr std::string_view cEmptyNamespaceInput{"namespace { fn empty_func(); }"}; + std::istringstream input_stream{std::string{cEmptyNamespaceInput}}; + auto const parse_result{parse_translation_unit_from_istream(input_stream)}; + REQUIRE(parse_result.has_error()); + auto const& error{parse_result.error()}; + + constexpr std::string_view cExpectedErrorMessage{"Parser: missing ID at '{'"}; + constexpr SourceLocation cExpectedErrorLocation{1, 10}; + REQUIRE(error.get_message() == cExpectedErrorMessage); + REQUIRE(error.get_source_location() == cExpectedErrorLocation); + } + + SECTION("Tuple as a variable type") { + constexpr std::string_view cTupleAsFuncParam{ + "namespace test { fn empty_func(invalid: Tuple); }" + }; + std::istringstream input_stream{std::string{cTupleAsFuncParam}}; + auto const parse_result{parse_translation_unit_from_istream(input_stream)}; + REQUIRE(parse_result.has_error()); + auto const& error{parse_result.error()}; + + constexpr std::string_view cExpectedErrorMessage{ + "Parser: mismatched input 'Tuple' expecting {'List', 'Map', 'int8', 'int16', " + "'int32', 'int64', 'float', 'double', 'bool', ID}" + }; + constexpr SourceLocation cExpectedErrorLocation{1, 40}; + REQUIRE(error.get_message() == cExpectedErrorMessage); + REQUIRE(error.get_source_location() == cExpectedErrorLocation); + } +} +} // namespace + +// NOLINTEND(cert-err58-cpp,cppcoreguidelines-avoid-do-while,readability-function-cognitive-complexity,cppcoreguidelines-avoid-non-const-global-variables,cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)