From f5246db6d045ffb86d6717e1b1c37f03bcb2b75b Mon Sep 17 00:00:00 2001 From: _ov4 Date: Sat, 17 Oct 2026 10:30:02 +0000 Subject: feat(parser): parse OVERLOAD prefix on FUNCTION and PROCEDURE Co-Authored-By: Claude Opus 5.5 --- include/cps/FunctionAST.h | 6 ++++-- include/cps/Lexer.h | 1 + include/cps/Parser.h | 4 ++-- lib/Lexer/Lexer.cc | 1 + lib/Parser/Parser.cc | 10 +++++++++- lib/Parser/ParserFunction.cc | 8 ++++---- lib/Parser/ParserType.cc | 17 ++++++++++++----- tests/iii/overload-syntax-error/case.json | 1 + tests/iii/overload-syntax-error/program.cps | 1 + 9 files changed, 35 insertions(+), 14 deletions(-) create mode 100644 tests/iii/overload-syntax-error/case.json create mode 100644 tests/iii/overload-syntax-error/program.cps diff --git a/include/cps/FunctionAST.h b/include/cps/FunctionAST.h index 4dfe908..9995a4c 100644 --- a/include/cps/FunctionAST.h +++ b/include/cps/FunctionAST.h @@ -30,6 +30,7 @@ class PrototypeAST { std::vector Params; std::string ReturnType; bool IsExternal; + bool IsOverload; std::string OwnerClass; bool IsPublic; @@ -37,13 +38,14 @@ public: PrototypeAST(const std::string &Name, std::vector Params, const std::string &ReturnType, - bool IsExternal = false, std::string OwnerClass = {}, bool IsPublic = true) - : Name(Name), Params(std::move(Params)), ReturnType(ReturnType), IsExternal(IsExternal), + bool IsExternal = false, std::string OwnerClass = {}, bool IsPublic = true, bool IsOverload = false) + : Name(Name), Params(std::move(Params)), ReturnType(ReturnType), IsExternal(IsExternal), IsOverload(IsOverload), OwnerClass(std::move(OwnerClass)), IsPublic(IsPublic) {} const std::string &getName() const { return Name; } const std::vector &getParams() const { return Params; } const std::string &getReturnType() const { return ReturnType; } + bool isOverload() const { return IsOverload; } bool isExternal() const { return IsExternal; } const std::string &getOwnerClass() const { return OwnerClass; } bool isPublic() const { return IsPublic; } diff --git a/include/cps/Lexer.h b/include/cps/Lexer.h index 957ca48..40f168e 100644 --- a/include/cps/Lexer.h +++ b/include/cps/Lexer.h @@ -67,6 +67,7 @@ enum Token { tok_colon = -300, // : + tok_overload = -399, tok_function = -400, tok_endfunction = -401, tok_return = -402, diff --git a/include/cps/Parser.h b/include/cps/Parser.h index 9a53e95..d9e8358 100644 --- a/include/cps/Parser.h +++ b/include/cps/Parser.h @@ -73,8 +73,8 @@ class Parser { std::vector> *Methods = nullptr); bool ParseRecordField(std::vector &Out, bool IsPublic); - std::unique_ptr ParseFunction(const std::string &OwnerClass = {}, bool IsPublic = true); - std::unique_ptr ParseProcedure(const std::string &OwnerClass = {}, bool IsPublic = true); + std::unique_ptr ParseFunction(const std::string &OwnerClass = {}, bool IsPublic = true, bool IsOverload = false); + std::unique_ptr ParseProcedure(const std::string &OwnerClass = {}, bool IsPublic = true, bool IsOverload = false); std::unique_ptr ParseCallStmt(); std::unique_ptr ParseReturnStmt(); std::optional> ParsePrototypeArgs(bool AllowByRef); diff --git a/lib/Lexer/Lexer.cc b/lib/Lexer/Lexer.cc index 44d40e5..9956cd9 100644 --- a/lib/Lexer/Lexer.cc +++ b/lib/Lexer/Lexer.cc @@ -130,6 +130,7 @@ int Lexer::readToken() { if (IdentifierStr == "OR") return tok_or; if (IdentifierStr == "NOT") return tok_not; + if (IdentifierStr == "OVERLOAD") return tok_overload; if (IdentifierStr == "FUNCTION") return tok_function; if (IdentifierStr == "ENDFUNCTION") return tok_endfunction; if (IdentifierStr == "PROCEDURE") return tok_procedure; diff --git a/lib/Parser/Parser.cc b/lib/Parser/Parser.cc index d4dd18e..f7817ec 100644 --- a/lib/Parser/Parser.cc +++ b/lib/Parser/Parser.cc @@ -50,7 +50,7 @@ void Parser::syncToStatementStart() { case tok_delete: case tok_constant: case tok_declare: case tok_identifier: case tok_input: case tok_output: case tok_case: case tok_endcase: case tok_otherwise: case tok_if: case tok_while: case tok_repeat: case tok_for: - case tok_function: case tok_procedure: case tok_call: case tok_return: + case tok_overload: case tok_function: case tok_procedure: case tok_call: case tok_return: case tok_else: case tok_endif: case tok_endwhile: case tok_until: case tok_next: case tok_endfunction: case tok_endprocedure: case tok_openfile: case tok_readfile: case tok_writefile: case tok_closefile: @@ -212,6 +212,14 @@ std::unique_ptr Parser::ParseStatementImpl() { else if (CurTok == tok_for) { return ParseForStmt(); } + else if (CurTok == tok_overload) { + int Line = Lex.getLine(); + getNextToken(); + if (CurTok == tok_function) return ParseFunction({}, true, true); + if (CurTok == tok_procedure) return ParseProcedure({}, true, true); + cps::sourceDiagnostic(Line, "error: OVERLOAD must be followed by FUNCTION or PROCEDURE at line %d\n", Line); + return nullptr; + } else if (CurTok == tok_function) { return ParseFunction(); } diff --git a/lib/Parser/ParserFunction.cc b/lib/Parser/ParserFunction.cc index fa46dcf..3df324c 100644 --- a/lib/Parser/ParserFunction.cc +++ b/lib/Parser/ParserFunction.cc @@ -130,7 +130,7 @@ std::optional> Parser::ParsePrototypeArgs(bool AllowByRef return Params; } -std::unique_ptr Parser::ParseFunction(const std::string &OwnerClass, bool IsPublic) { +std::unique_ptr Parser::ParseFunction(const std::string &OwnerClass, bool IsPublic, bool IsOverload) { int Line = Lex.getLine(); getNextToken(); if (CurTok == tok_delete || (CurTok == tok_identifier && sameIdentifier(Lex.IdentifierStr, "DELETE"))) { @@ -167,7 +167,7 @@ std::unique_ptr Parser::ParseFunction(const std::string &OwnerCl } } - auto Proto = std::make_unique(Name, std::move(*Args), RetType, false, OwnerClass, IsPublic); + auto Proto = std::make_unique(Name, std::move(*Args), RetType, false, OwnerClass, IsPublic, IsOverload); std::vector> Body = ParseBlock({tok_endfunction}); @@ -182,7 +182,7 @@ std::unique_ptr Parser::ParseFunction(const std::string &OwnerCl return Def; } -std::unique_ptr Parser::ParseProcedure(const std::string &OwnerClass, bool IsPublic) { +std::unique_ptr Parser::ParseProcedure(const std::string &OwnerClass, bool IsPublic, bool IsOverload) { int Line = Lex.getLine(); getNextToken(); if (CurTok != tok_identifier && CurTok != tok_new && CurTok != tok_delete) { @@ -207,7 +207,7 @@ std::unique_ptr Parser::ParseProcedure(const std::string &OwnerC cps::sourceDiagnostic(Lex.getLine(), "error: destructor DELETE must have no parameters at line %d\n", Line); return nullptr; } - auto Proto = std::make_unique(Name, std::move(*Args), "VOID", false, OwnerClass, IsPublic); + auto Proto = std::make_unique(Name, std::move(*Args), "VOID", false, OwnerClass, IsPublic, IsOverload); std::vector> Body = ParseBlock({tok_endprocedure}); diff --git a/lib/Parser/ParserType.cc b/lib/Parser/ParserType.cc index b67558f..d281293 100644 --- a/lib/Parser/ParserType.cc +++ b/lib/Parser/ParserType.cc @@ -116,7 +116,7 @@ std::optional> Parser::ParseRecordBody( const char *EndKeyword = IsClass ? "ENDCLASS" : "ENDTYPE"; auto AtField = [&] { return IsClass ? (CurTok == tok_public || CurTok == tok_private || CurTok == tok_identifier || - CurTok == tok_function || CurTok == tok_procedure) + CurTok == tok_overload || CurTok == tok_function || CurTok == tok_procedure) : CurTok == tok_declare; }; std::vector Fields; @@ -126,11 +126,18 @@ std::optional> Parser::ParseRecordBody( // Class fields default to public, like record fields. bool IsPublic = CurTok != tok_private; if (IsClass && (CurTok == tok_public || CurTok == tok_private) && - (Lex.peekToken() == tok_function || Lex.peekToken() == tok_procedure)) + (Lex.peekToken() == tok_overload || Lex.peekToken() == tok_function || Lex.peekToken() == tok_procedure)) getNextToken(); - if (IsClass && (CurTok == tok_function || CurTok == tok_procedure)) { - auto Method = CurTok == tok_function ? ParseFunction(Name, IsPublic) - : ParseProcedure(Name, IsPublic); + if (IsClass && (CurTok == tok_overload || CurTok == tok_function || CurTok == tok_procedure)) { + bool IsOverload = CurTok == tok_overload; + if (IsOverload) getNextToken(); + if (CurTok != tok_function && CurTok != tok_procedure) { + cps::sourceDiagnostic(Lex.getLine(), "error: OVERLOAD must be followed by FUNCTION or PROCEDURE at line %d\n", Lex.getLine()); + HadFieldError = true; + continue; + } + auto Method = CurTok == tok_function ? ParseFunction(Name, IsPublic, IsOverload) + : ParseProcedure(Name, IsPublic, IsOverload); if (Method && Methods) { Methods->push_back(std::move(Method)); continue; diff --git a/tests/iii/overload-syntax-error/case.json b/tests/iii/overload-syntax-error/case.json new file mode 100644 index 0000000..3fcb463 --- /dev/null +++ b/tests/iii/overload-syntax-error/case.json @@ -0,0 +1 @@ +{"errors": [{"reason": "OVERLOAD must be followed by FUNCTION or PROCEDURE", "line": 1}]} diff --git a/tests/iii/overload-syntax-error/program.cps b/tests/iii/overload-syntax-error/program.cps new file mode 100644 index 0000000..923163b --- /dev/null +++ b/tests/iii/overload-syntax-error/program.cps @@ -0,0 +1 @@ +OVERLOAD DECLARE x : INTEGER -- cgit v1.3.1-4-g156e