From 932e0dc27e024253244dbc3e0756480218b35741 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rafa=C5=82=20Grodzi=C5=84ski?= Date: Fri, 1 Aug 2025 23:26:16 +0900 Subject: [PATCH 01/14] Added empty statement type --- samples/test.brc | 55 +------------------------- src/Parser/Parser.cpp | 9 +++++ src/Parser/Parser.h | 1 + src/Parser/Statement/Statement.h | 3 +- src/Parser/Statement/StatementType.cpp | 12 ++++++ src/Parser/Statement/StatementType.h | 19 +++++++++ 6 files changed, 44 insertions(+), 55 deletions(-) create mode 100644 src/Parser/Statement/StatementType.cpp create mode 100644 src/Parser/Statement/StatementType.h diff --git a/samples/test.brc b/samples/test.brc index baa3e8f..3aeb90d 100644 --- a/samples/test.brc +++ b/samples/test.brc @@ -1,61 +1,8 @@ -//@extern putchar fun: character sint32 -> sint32 - -// ./build/brb samples/test.brc -S -x86-asm-syntax=intel - -/* User type - name data - age u32 - successRatio r32 - isActive bool ; -*/ - -/* -i u32 <- 0, rep text[i] != 0: - putchar(text[i]) - i++ -; -*/ - -// text data <- "Hello world!" - -/*addStuff asm<"+r, r">: num1 u32, num2 u32 -> u32 - add $1, $0 -;*/ - -/*normAdd fun: num1 sint32, num2 sint32 -> sint32 - ret num1 + num2 -;*/ - -/*rawAdd raw<"=r,r,r">: num1 sint32, num2 sint32 -> sint32 - add $1, $2 - mov $0, $1 -;*/ - -/*rawAdd raw: num1 sint32, num2 sint32 -> sint32 - add $1, $2 - mov $0, $1 -;*/ - -/*printChar raw - .global REGISTER - .text - .REGISTER: - .byte "Hello", 0xa0 - .long RegisterTable - //push 0x21 - -;*/ main fun -> u32 - num1 u8 <- 42 - num2 s8 <- 3 - +15 - num3 u32 <- 1234123 - num4 s32 <- -345345 - num5 r32 <- -42.58 - - num5 + num3 + //user User ret 0 ; \ No newline at end of file diff --git a/src/Parser/Parser.cpp b/src/Parser/Parser.cpp index bdf291f..1b2a38d 100644 --- a/src/Parser/Parser.cpp +++ b/src/Parser/Parser.cpp @@ -18,6 +18,7 @@ #include "Parser/Statement/StatementFunction.h" #include "Parser/Statement/StatementRawFunction.h" +#include "Parser/Statement/StatementType.h" #include "Parser/Statement/StatementVariable.h" #include "Parser/Statement/StatementAssignment.h" #include "Parser/Statement/StatementReturn.h" @@ -80,6 +81,10 @@ shared_ptr Parser::nextStatement() { if (statement != nullptr || errors.size() > errorsCount) return statement; + statement = matchStatementType(); + if (statement != nullptr || errors.size() > errorsCount) + return statement; + markError({}, {}); return nullptr; } @@ -486,6 +491,10 @@ shared_ptr Parser::matchStatementRawFunction() { return make_shared(name, constraints, arguments, returnType, rawSource); } +shared_ptr Parser::matchStatementType() { + return nullptr; +} + shared_ptr Parser::matchStatementBlock(vector terminalTokenKinds) { vector> statements; diff --git a/src/Parser/Parser.h b/src/Parser/Parser.h index 0e27960..3116875 100644 --- a/src/Parser/Parser.h +++ b/src/Parser/Parser.h @@ -31,6 +31,7 @@ private: shared_ptr matchStatementVariable(); shared_ptr matchStatementFunction(); shared_ptr matchStatementRawFunction(); + shared_ptr matchStatementType(); shared_ptr matchStatementBlock(vector terminalTokenKinds); shared_ptr matchStatementAssignment(); diff --git a/src/Parser/Statement/Statement.h b/src/Parser/Statement/Statement.h index 963a9c5..578bed3 100644 --- a/src/Parser/Statement/Statement.h +++ b/src/Parser/Statement/Statement.h @@ -14,7 +14,8 @@ enum class StatementKind { VARIABLE, ASSIGNMENT, REPEAT, - META_EXTERN_FUNCTION + META_EXTERN_FUNCTION, + TYPE }; class Statement { diff --git a/src/Parser/Statement/StatementType.cpp b/src/Parser/Statement/StatementType.cpp new file mode 100644 index 0000000..a830e9f --- /dev/null +++ b/src/Parser/Statement/StatementType.cpp @@ -0,0 +1,12 @@ +#include "StatementType.h" + +StatementType::StatementType(string identifier, vector> statementVariable): +Statement(StatementKind::TYPE), identifier(identifier), statementVariables(statementVariable) { } + +string StatementType::getIdentifier() { + return identifier; +} + +vector> StatementType::getStatementVariables() { + return statementVariables; +} \ No newline at end of file diff --git a/src/Parser/Statement/StatementType.h b/src/Parser/Statement/StatementType.h new file mode 100644 index 0000000..02f9b40 --- /dev/null +++ b/src/Parser/Statement/StatementType.h @@ -0,0 +1,19 @@ +#ifndef STATEMENT_TYPE_H +#define STATEMENT_TYPE_H + +#include "Statement.h" + +class StatementVariable; + +class StatementType: public Statement { +private: + string identifier; + vector> statementVariables; + +public: + StatementType(string identifier, vector> statementVariables); + string getIdentifier(); + vector> getStatementVariables(); +}; + +#endif \ No newline at end of file From dc8d10c81c9a6806be48825e395a25a42b374dda Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rafa=C5=82=20Grodzi=C5=84ski?= Date: Sat, 2 Aug 2025 00:16:51 +0900 Subject: [PATCH 02/14] Updated the parser a bit --- src/Parser/Parser.cpp | 38 +++++++++++++++++++++++++- src/Parser/Statement/StatementType.cpp | 10 ++++--- src/Parser/Statement/StatementType.h | 7 +++-- 3 files changed, 47 insertions(+), 8 deletions(-) diff --git a/src/Parser/Parser.cpp b/src/Parser/Parser.cpp index 1b2a38d..b2e8161 100644 --- a/src/Parser/Parser.cpp +++ b/src/Parser/Parser.cpp @@ -492,7 +492,43 @@ shared_ptr Parser::matchStatementRawFunction() { } shared_ptr Parser::matchStatementType() { - return nullptr; + ParseeResultsGroup resultsGroup; + + string identifier; + vector>> variables; + + resultsGroup = parseeResultsGroupForParseeGroup( + ParseeGroup( + { + Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true), + Parsee::tokenParsee(TokenKind::TYPE, true, false) + }, + ParseeGroup( + { + Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true), + Parsee::valueTypeParsee(true) + }, + {} + ) + ) + ); + + switch (resultsGroup.getKind()) { + case ParseeResultsGroupKind::SUCCESS: + identifier = resultsGroup.getResults().at(0).getToken()->getLexme(); + for (int i=1; i> arg; + arg.first = resultsGroup.getResults().at(i).getToken()->getLexme(); + arg.second = resultsGroup.getResults().at(i+1).getValueType(); + variables.push_back(arg); + } + case ParseeResultsGroupKind::NO_MATCH: + case ParseeResultsGroupKind::FAILURE: + return nullptr; + break; + } + + return make_shared(identifier, variables); } shared_ptr Parser::matchStatementBlock(vector terminalTokenKinds) { diff --git a/src/Parser/Statement/StatementType.cpp b/src/Parser/Statement/StatementType.cpp index a830e9f..184b5a7 100644 --- a/src/Parser/Statement/StatementType.cpp +++ b/src/Parser/Statement/StatementType.cpp @@ -1,12 +1,14 @@ #include "StatementType.h" -StatementType::StatementType(string identifier, vector> statementVariable): -Statement(StatementKind::TYPE), identifier(identifier), statementVariables(statementVariable) { } +#include "Parser/ValueType.h" + +StatementType::StatementType(string identifier, vector>> variables): +Statement(StatementKind::TYPE), identifier(identifier), variables(variables) { } string StatementType::getIdentifier() { return identifier; } -vector> StatementType::getStatementVariables() { - return statementVariables; +vector>> StatementType::getVariables() { + return variables; } \ No newline at end of file diff --git a/src/Parser/Statement/StatementType.h b/src/Parser/Statement/StatementType.h index 02f9b40..5e3e242 100644 --- a/src/Parser/Statement/StatementType.h +++ b/src/Parser/Statement/StatementType.h @@ -4,16 +4,17 @@ #include "Statement.h" class StatementVariable; +class ValueType; class StatementType: public Statement { private: string identifier; - vector> statementVariables; + vector>> variables; public: - StatementType(string identifier, vector> statementVariables); + StatementType(string identifier, vector>> variables); string getIdentifier(); - vector> getStatementVariables(); + vector>> getVariables(); }; #endif \ No newline at end of file From b6c2ff39838524644e1a2c20001e413f7d062d9f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rafa=C5=82=20Grodzi=C5=84ski?= Date: Tue, 5 Aug 2025 11:16:50 +0900 Subject: [PATCH 03/14] Generate code for custom type --- samples/test.brc | 4 ++-- src/Compiler/ModuleBuilder.cpp | 42 ++++++++++++++++++++++++++++++++++ src/Compiler/ModuleBuilder.h | 6 +++++ src/Logger.cpp | 13 +++++++++++ src/Logger.h | 2 ++ src/Parser/Parser.cpp | 33 +++++++++++++++----------- src/Parser/ValueType.cpp | 27 +++++++++++++++++----- src/Parser/ValueType.h | 8 ++++++- 8 files changed, 113 insertions(+), 22 deletions(-) diff --git a/samples/test.brc b/samples/test.brc index 3aeb90d..001ed1c 100644 --- a/samples/test.brc +++ b/samples/test.brc @@ -1,8 +1,8 @@ -User type +User pack ; main fun -> u32 - //user User + user User <- 0 ret 0 ; \ No newline at end of file diff --git a/src/Compiler/ModuleBuilder.cpp b/src/Compiler/ModuleBuilder.cpp index 4fdd0d8..1f877e8 100644 --- a/src/Compiler/ModuleBuilder.cpp +++ b/src/Compiler/ModuleBuilder.cpp @@ -16,6 +16,7 @@ #include "Parser/Statement/StatementFunction.h" #include "Parser/Statement/StatementRawFunction.h" +#include "Parser/Statement/StatementType.h" #include "Parser/Statement/StatementVariable.h" #include "Parser/Statement/StatementAssignment.h" #include "Parser/Statement/StatementReturn.h" @@ -68,6 +69,9 @@ void ModuleBuilder::buildStatement(shared_ptr statement) { case StatementKind::RAW_FUNCTION: buildRawFunction(dynamic_pointer_cast(statement)); break; + case StatementKind::TYPE: + buildType(dynamic_pointer_cast(statement)); + break; case StatementKind::VARIABLE: buildVarDeclaration(dynamic_pointer_cast(statement)); break; @@ -160,6 +164,14 @@ void ModuleBuilder::buildRawFunction(shared_ptr statement) return; } +void ModuleBuilder::buildType(shared_ptr statement) { + llvm::StructType *structType = llvm::StructType::create(*context, statement->getIdentifier()); + vector elements; + structType->setBody(elements, false); + if (!setStruct(statement->getIdentifier(), structType)) + return; +} + void ModuleBuilder::buildVarDeclaration(shared_ptr statement) { if (statement->getValueType()->getKind() == ValueTypeKind::DATA) { vector values = valuesForExpression(statement->getExpression()); @@ -177,6 +189,11 @@ void ModuleBuilder::buildVarDeclaration(shared_ptr statement) builder->CreateStore(values[i], elementPtr); } + } else if (statement->getValueType()->getKind() == ValueTypeKind::TYPE) { + llvm::StructType *type = (llvm::StructType *)typeForValueType(statement->getValueType(), 0); + llvm::AllocaInst *alloca = builder->CreateAlloca(type, nullptr, statement->getName()); + if (!setAlloca(statement->getName(), alloca)) + return; } else { llvm::Value *value = valueForExpression(statement->getExpression()); if (value == nullptr) @@ -671,6 +688,29 @@ llvm::InlineAsm *ModuleBuilder::getRawFun(string name) { return nullptr; } +bool ModuleBuilder::setStruct(string name, llvm::StructType *structType) { + if (scopes.top().structTypeMap[name] != nullptr) { + markError(0, 0, format("Type \"{}\" already defined in scope", name)); + return false; + } + + scopes.top().structTypeMap[name] = structType; + return true; +} + +llvm::StructType *ModuleBuilder::getStructType(string name) { + stack scopes = this->scopes; + + while (!scopes.empty()) { + llvm::StructType *structType = scopes.top().structTypeMap[name]; + if (structType != nullptr) + return structType; + scopes.pop(); + } + + return nullptr; +} + llvm::Type *ModuleBuilder::typeForValueType(shared_ptr valueType, int count) { if (valueType == nullptr) { markError(0, 0, "Missing type"); @@ -699,6 +739,8 @@ llvm::Type *ModuleBuilder::typeForValueType(shared_ptr valueType, int count = valueType->getValueArg(); return llvm::ArrayType::get(typeForValueType(valueType->getSubType(), count), count); } + case ValueTypeKind::TYPE: + return getStructType(valueType->getTypeName()); } } diff --git a/src/Compiler/ModuleBuilder.h b/src/Compiler/ModuleBuilder.h index 872b4ad..71dcd9c 100644 --- a/src/Compiler/ModuleBuilder.h +++ b/src/Compiler/ModuleBuilder.h @@ -29,6 +29,7 @@ enum class ExpressionBinaryOperation; class Statement; class StatementFunction; class StatementRawFunction; +class StatementType; class StatementVariable; class StatementAssignment; class StatementReturn; @@ -43,6 +44,7 @@ typedef struct { map allocaMap; map funMap; map rawFunMap; + map structTypeMap; } Scope; class ModuleBuilder { @@ -69,6 +71,7 @@ private: void buildStatement(shared_ptr statement); void buildFunction(shared_ptr statement); void buildRawFunction(shared_ptr statement); + void buildType(shared_ptr statement); void buildVarDeclaration(shared_ptr statement); void buildAssignment(shared_ptr statement); void buildBlock(shared_ptr statement); @@ -101,6 +104,9 @@ private: bool setRawFun(string name, llvm::InlineAsm *rawFun); llvm::InlineAsm *getRawFun(string name); + bool setStruct(string name, llvm::StructType *structType); + llvm::StructType *getStructType(string name); + llvm::Type *typeForValueType(shared_ptr valueType, int count = 0); void markError(int line, int column, string message); diff --git a/src/Logger.cpp b/src/Logger.cpp index d5ca83d..0ba1a47 100644 --- a/src/Logger.cpp +++ b/src/Logger.cpp @@ -12,6 +12,7 @@ #include "Parser/Statement/StatementVariable.h" #include "Parser/Statement/StatementFunction.h" #include "Parser/Statement/StatementRawFunction.h" +#include "Parser/Statement/StatementType.h" #include "Parser/Statement/StatementBlock.h" #include "Parser/Statement/StatementAssignment.h" #include "Parser/Statement/StatementReturn.h" @@ -223,6 +224,8 @@ string Logger::toString(shared_ptr valueType) { return "R32"; case ValueTypeKind::DATA: return "[]"; + case ValueTypeKind::TYPE: + return format("TYPE({})", valueType->getTypeName()); } } @@ -236,6 +239,8 @@ string Logger::toString(shared_ptr statement) { return toString(dynamic_pointer_cast(statement)); case StatementKind::RAW_FUNCTION: return toString(dynamic_pointer_cast(statement)); + case StatementKind::TYPE: + return toString(dynamic_pointer_cast(statement)); case StatementKind::BLOCK: return toString(dynamic_pointer_cast(statement)); case StatementKind::ASSIGNMENT: @@ -296,6 +301,14 @@ string Logger::toString(shared_ptr statement) { return text; } +string Logger::toString(shared_ptr statement) { + string text; + + text += format("TYPE(\"{}\"):\n", statement->getIdentifier()); + + return text; +} + string Logger::toString(shared_ptr statement) { string text; diff --git a/src/Logger.h b/src/Logger.h index 72e6746..81521a9 100644 --- a/src/Logger.h +++ b/src/Logger.h @@ -12,6 +12,7 @@ class StatementMetaExternFunction; class StatementVariable; class StatementFunction; class StatementRawFunction; +class StatementType; class StatementBlock; class StatementAssignment; class StatementReturn; @@ -44,6 +45,7 @@ private: static string toString(shared_ptr statement); static string toString(shared_ptr statement); static string toString(shared_ptr statement); + static string toString(shared_ptr statement); static string toString(shared_ptr statement); static string toString(shared_ptr statement); static string toString(shared_ptr statement); diff --git a/src/Parser/Parser.cpp b/src/Parser/Parser.cpp index b2e8161..4bcacba 100644 --- a/src/Parser/Parser.cpp +++ b/src/Parser/Parser.cpp @@ -503,31 +503,38 @@ shared_ptr Parser::matchStatementType() { Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true), Parsee::tokenParsee(TokenKind::TYPE, true, false) }, - ParseeGroup( - { - Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true), - Parsee::valueTypeParsee(true) - }, - {} - ) + {} ) ); switch (resultsGroup.getKind()) { case ParseeResultsGroupKind::SUCCESS: identifier = resultsGroup.getResults().at(0).getToken()->getLexme(); - for (int i=1; i> arg; - arg.first = resultsGroup.getResults().at(i).getToken()->getLexme(); - arg.second = resultsGroup.getResults().at(i+1).getValueType(); - variables.push_back(arg); - } + /*for (int i=1; i> arg; + arg.first = resultsGroup.getResults().at(i).getToken()->getLexme(); + arg.second = resultsGroup.getResults().at(i+1).getValueType(); + variables.push_back(arg); + }*/ + break; case ParseeResultsGroupKind::NO_MATCH: case ParseeResultsGroupKind::FAILURE: return nullptr; break; } + // consume new line + if (!tryMatchingTokenKinds({TokenKind::NEW_LINE}, true, true)) { + markError(TokenKind::NEW_LINE, {}); + return nullptr; + } + + // closing semicolon + if(!tryMatchingTokenKinds({TokenKind::SEMICOLON}, false, true)) { + markError(TokenKind::SEMICOLON, {}); + return nullptr; + } + return make_shared(identifier, variables); } diff --git a/src/Parser/ValueType.cpp b/src/Parser/ValueType.cpp index 566342b..77bc8d1 100644 --- a/src/Parser/ValueType.cpp +++ b/src/Parser/ValueType.cpp @@ -10,27 +10,38 @@ shared_ptr ValueType::S8 = make_shared(ValueTypeKind::S8, shared_ptr ValueType::S32 = make_shared(ValueTypeKind::S32, nullptr, 0); shared_ptr ValueType::R32 = make_shared(ValueTypeKind::R32, nullptr, 0); +ValueType::ValueType() { } + ValueType::ValueType(ValueTypeKind kind, shared_ptr subType, int valueArg): kind(kind), subType(subType), valueArg(valueArg) { } +shared_ptr ValueType::type(string typeName) { + shared_ptr valueType = make_shared(); + valueType->kind = ValueTypeKind::TYPE; + valueType->typeName = typeName; + return valueType; +} + shared_ptr ValueType::valueTypeForToken(shared_ptr token, shared_ptr subType, int valueArg) { switch (token->getKind()) { case TokenKind::TYPE: { string lexme = token->getLexme(); if (lexme.compare("bool") == 0) - return make_shared(ValueTypeKind::BOOL, subType, valueArg); + return make_shared(ValueTypeKind::BOOL, nullptr, 0); else if (lexme.compare("u8") == 0) - return make_shared(ValueTypeKind::U8, subType, valueArg); + return make_shared(ValueTypeKind::U8, nullptr, 0); else if (lexme.compare("u32") == 0) - return make_shared(ValueTypeKind::U32, subType, valueArg); + return make_shared(ValueTypeKind::U32, nullptr, 0); else if (lexme.compare("s8") == 0) - return make_shared(ValueTypeKind::S8, subType, valueArg); + return make_shared(ValueTypeKind::S8, nullptr, 0); else if (lexme.compare("s32") == 0) - return make_shared(ValueTypeKind::S32, subType, valueArg); + return make_shared(ValueTypeKind::S32, nullptr, 0); else if (lexme.compare("r32") == 0) - return make_shared(ValueTypeKind::R32, subType, valueArg); + return make_shared(ValueTypeKind::R32, nullptr, 0); else if (lexme.compare("data") == 0) return make_shared(ValueTypeKind::DATA, subType, valueArg); + else if (lexme.compare("type") != 0) + return ValueType::type(token->getLexme()); else return nullptr; } @@ -59,4 +70,8 @@ shared_ptr ValueType::getSubType() { int ValueType::getValueArg() { return valueArg; +} + +string ValueType::getTypeName() { + return typeName; } \ No newline at end of file diff --git a/src/Parser/ValueType.h b/src/Parser/ValueType.h index 2b77f2f..6ce36ad 100644 --- a/src/Parser/ValueType.h +++ b/src/Parser/ValueType.h @@ -2,6 +2,7 @@ #define VALUE_TYPE_H #include +#include class Token; @@ -15,7 +16,8 @@ enum class ValueTypeKind { S8, S32, R32, - DATA + DATA, + TYPE }; class ValueType { @@ -23,6 +25,7 @@ private: ValueTypeKind kind; shared_ptr subType; int valueArg; + string typeName; public: static shared_ptr NONE; @@ -34,10 +37,13 @@ public: static shared_ptr R32; static shared_ptr valueTypeForToken(shared_ptr token, shared_ptr subType, int valueArg); + ValueType(); ValueType(ValueTypeKind kind, shared_ptr subType, int valueArg); + static shared_ptr type(string typeName); ValueTypeKind getKind(); shared_ptr getSubType(); int getValueArg(); + string getTypeName(); }; #endif \ No newline at end of file From 0a08aaa7b2076afb28a47848bab01d5426e811b7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rafa=C5=82=20Grodzi=C5=84ski?= Date: Tue, 5 Aug 2025 12:03:01 +0900 Subject: [PATCH 04/14] Match token blob --- samples/test.brc | 2 +- src/Lexer/Lexer.cpp | 70 ++++++++++++++++++++++++--------------------- src/Lexer/Lexer.h | 2 +- src/Lexer/Token.cpp | 2 +- src/Lexer/Token.h | 5 ++-- src/Logger.cpp | 10 ++++--- 6 files changed, 49 insertions(+), 42 deletions(-) diff --git a/samples/test.brc b/samples/test.brc index 001ed1c..b30ff0c 100644 --- a/samples/test.brc +++ b/samples/test.brc @@ -1,4 +1,4 @@ -User pack +User blob ; main fun -> u32 diff --git a/src/Lexer/Lexer.cpp b/src/Lexer/Lexer.cpp index 0706245..56fccf4 100644 --- a/src/Lexer/Lexer.cpp +++ b/src/Lexer/Lexer.cpp @@ -208,14 +208,6 @@ shared_ptr Lexer::nextToken() { return token; // keywords - token = match(TokenKind::IF, "if", true); - if (token != nullptr) - return token; - - token = match(TokenKind::ELSE, "else", true); - if (token != nullptr) - return token; - token = match(TokenKind::FUNCTION, "fun", true); if (token != nullptr) return token; @@ -225,12 +217,24 @@ shared_ptr Lexer::nextToken() { foundRawSourceStart = true; return token; } + + token = match(TokenKind::BLOB, "blob", true); + if (token != nullptr) + return token; token = match(TokenKind::RETURN, "ret", true); if (token != nullptr) return token; token = match(TokenKind::REPEAT, "rep", true); + if (token != nullptr) + return token; + + token = match(TokenKind::IF, "if", true); + if (token != nullptr) + return token; + + token = match(TokenKind::ELSE, "else", true); if (token != nullptr) return token; @@ -313,6 +317,31 @@ shared_ptr Lexer::match(TokenKind kind, string lexme, bool needsSeparator return token; } +shared_ptr Lexer::matchReal() { + int nextIndex = currentIndex; + + while (nextIndex < source.length() && isDecDigit(nextIndex)) + nextIndex++; + + if (nextIndex >= source.length() || source.at(nextIndex) != '.') + return nullptr; + else + nextIndex++; + + while (nextIndex < source.length() && isDecDigit(nextIndex)) + nextIndex++; + + if (!isSeparator(nextIndex)) { + markError(); + return nullptr; + } + + string lexme = source.substr(currentIndex, nextIndex - currentIndex); + shared_ptr token = make_shared(TokenKind::REAL, lexme, currentLine, currentColumn); + advanceWithToken(token); + return token; +} + shared_ptr Lexer::matchIntegerDec() { int nextIndex = currentIndex; @@ -399,31 +428,6 @@ shared_ptr Lexer::matchIntegerChar() { return token; } -shared_ptr Lexer::matchReal() { - int nextIndex = currentIndex; - - while (nextIndex < source.length() && isDecDigit(nextIndex)) - nextIndex++; - - if (nextIndex >= source.length() || source.at(nextIndex) != '.') - return nullptr; - else - nextIndex++; - - while (nextIndex < source.length() && isDecDigit(nextIndex)) - nextIndex++; - - if (!isSeparator(nextIndex)) { - markError(); - return nullptr; - } - - string lexme = source.substr(currentIndex, nextIndex - currentIndex); - shared_ptr token = make_shared(TokenKind::REAL, lexme, currentLine, currentColumn); - advanceWithToken(token); - return token; -} - shared_ptr Lexer::matchString() { int nextIndex = currentIndex; diff --git a/src/Lexer/Lexer.h b/src/Lexer/Lexer.h index 805ad50..7c36882 100644 --- a/src/Lexer/Lexer.h +++ b/src/Lexer/Lexer.h @@ -22,11 +22,11 @@ private: shared_ptr nextToken(); shared_ptr match(TokenKind kind, string lexme, bool needsSeparator); + shared_ptr matchReal(); shared_ptr matchIntegerDec(); shared_ptr matchIntegerHex(); shared_ptr matchIntegerBin(); shared_ptr matchIntegerChar(); - shared_ptr matchReal(); shared_ptr matchString(); shared_ptr matchType(); shared_ptr matchIdentifier(); diff --git a/src/Lexer/Token.cpp b/src/Lexer/Token.cpp index 2adddfe..57e5626 100644 --- a/src/Lexer/Token.cpp +++ b/src/Lexer/Token.cpp @@ -47,11 +47,11 @@ vector Token::tokensBinary = { vector Token::tokensLiteral = { TokenKind::BOOL, + TokenKind::REAL, TokenKind::INTEGER_DEC, TokenKind::INTEGER_HEX, TokenKind::INTEGER_BIN, TokenKind::INTEGER_CHAR, - TokenKind::REAL, TokenKind::STRING }; diff --git a/src/Lexer/Token.h b/src/Lexer/Token.h index 4b1ab57..5e6ad36 100644 --- a/src/Lexer/Token.h +++ b/src/Lexer/Token.h @@ -32,20 +32,21 @@ enum class TokenKind { FUNCTION, RAW_FUNCTION, RAW_SOURCE_LINE, + BLOB, RETURN, REPEAT, IF, ELSE, BOOL, + REAL, INTEGER_DEC, INTEGER_HEX, INTEGER_BIN, INTEGER_CHAR, - REAL, STRING, - IDENTIFIER, TYPE, + IDENTIFIER, M_EXTERN, diff --git a/src/Logger.cpp b/src/Logger.cpp index 0ba1a47..9747083 100644 --- a/src/Logger.cpp +++ b/src/Logger.cpp @@ -94,20 +94,22 @@ string Logger::toString(shared_ptr token) { case TokenKind::TYPE: return "TYPE(" + token->getLexme() + ")"; - case TokenKind::IF: - return "IF"; - case TokenKind::ELSE: - return "ELSE"; case TokenKind::FUNCTION: return "FUN"; case TokenKind::RAW_FUNCTION: return "RAW"; case TokenKind::RAW_SOURCE_LINE: return format("RAW_SOURCE_LINE({})", token->getLexme()); + case TokenKind::BLOB: + return "BLOB"; case TokenKind::RETURN: return "RET"; case TokenKind::REPEAT: return "REP"; + case TokenKind::IF: + return "IF"; + case TokenKind::ELSE: + return "ELSE"; case TokenKind::M_EXTERN: return "@EXTERN"; From 5e65c66d3a56a4475f723e762be92041615cf656 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rafa=C5=82=20Grodzi=C5=84ski?= Date: Tue, 5 Aug 2025 12:45:44 +0900 Subject: [PATCH 05/14] Renamed to blob --- src/Compiler/ModuleBuilder.cpp | 8 ++++---- src/Compiler/ModuleBuilder.h | 4 ++-- src/Logger.cpp | 10 +++++----- src/Logger.h | 4 ++-- src/Parser/Parser.cpp | 8 ++++---- src/Parser/Parser.h | 2 +- src/Parser/Statement/Statement.h | 2 +- src/Parser/Statement/StatementBlob.cpp | 14 ++++++++++++++ .../Statement/{StatementType.h => StatementBlob.h} | 5 ++--- src/Parser/Statement/StatementType.cpp | 14 -------------- 10 files changed, 35 insertions(+), 36 deletions(-) create mode 100644 src/Parser/Statement/StatementBlob.cpp rename src/Parser/Statement/{StatementType.h => StatementBlob.h} (71%) delete mode 100644 src/Parser/Statement/StatementType.cpp diff --git a/src/Compiler/ModuleBuilder.cpp b/src/Compiler/ModuleBuilder.cpp index 1f877e8..18008d0 100644 --- a/src/Compiler/ModuleBuilder.cpp +++ b/src/Compiler/ModuleBuilder.cpp @@ -16,7 +16,7 @@ #include "Parser/Statement/StatementFunction.h" #include "Parser/Statement/StatementRawFunction.h" -#include "Parser/Statement/StatementType.h" +#include "Parser/Statement/StatementBlob.h" #include "Parser/Statement/StatementVariable.h" #include "Parser/Statement/StatementAssignment.h" #include "Parser/Statement/StatementReturn.h" @@ -69,8 +69,8 @@ void ModuleBuilder::buildStatement(shared_ptr statement) { case StatementKind::RAW_FUNCTION: buildRawFunction(dynamic_pointer_cast(statement)); break; - case StatementKind::TYPE: - buildType(dynamic_pointer_cast(statement)); + case StatementKind::BLOB: + buildType(dynamic_pointer_cast(statement)); break; case StatementKind::VARIABLE: buildVarDeclaration(dynamic_pointer_cast(statement)); @@ -164,7 +164,7 @@ void ModuleBuilder::buildRawFunction(shared_ptr statement) return; } -void ModuleBuilder::buildType(shared_ptr statement) { +void ModuleBuilder::buildType(shared_ptr statement) { llvm::StructType *structType = llvm::StructType::create(*context, statement->getIdentifier()); vector elements; structType->setBody(elements, false); diff --git a/src/Compiler/ModuleBuilder.h b/src/Compiler/ModuleBuilder.h index 71dcd9c..fef55a3 100644 --- a/src/Compiler/ModuleBuilder.h +++ b/src/Compiler/ModuleBuilder.h @@ -29,7 +29,7 @@ enum class ExpressionBinaryOperation; class Statement; class StatementFunction; class StatementRawFunction; -class StatementType; +class StatementBlob; class StatementVariable; class StatementAssignment; class StatementReturn; @@ -71,7 +71,7 @@ private: void buildStatement(shared_ptr statement); void buildFunction(shared_ptr statement); void buildRawFunction(shared_ptr statement); - void buildType(shared_ptr statement); + void buildType(shared_ptr statement); void buildVarDeclaration(shared_ptr statement); void buildAssignment(shared_ptr statement); void buildBlock(shared_ptr statement); diff --git a/src/Logger.cpp b/src/Logger.cpp index 9747083..6ea6f3f 100644 --- a/src/Logger.cpp +++ b/src/Logger.cpp @@ -12,7 +12,7 @@ #include "Parser/Statement/StatementVariable.h" #include "Parser/Statement/StatementFunction.h" #include "Parser/Statement/StatementRawFunction.h" -#include "Parser/Statement/StatementType.h" +#include "Parser/Statement/StatementBlob.h" #include "Parser/Statement/StatementBlock.h" #include "Parser/Statement/StatementAssignment.h" #include "Parser/Statement/StatementReturn.h" @@ -241,8 +241,8 @@ string Logger::toString(shared_ptr statement) { return toString(dynamic_pointer_cast(statement)); case StatementKind::RAW_FUNCTION: return toString(dynamic_pointer_cast(statement)); - case StatementKind::TYPE: - return toString(dynamic_pointer_cast(statement)); + case StatementKind::BLOB: + return toString(dynamic_pointer_cast(statement)); case StatementKind::BLOCK: return toString(dynamic_pointer_cast(statement)); case StatementKind::ASSIGNMENT: @@ -303,10 +303,10 @@ string Logger::toString(shared_ptr statement) { return text; } -string Logger::toString(shared_ptr statement) { +string Logger::toString(shared_ptr statement) { string text; - text += format("TYPE(\"{}\"):\n", statement->getIdentifier()); + text += format("BLOB(\"{}\"):\n", statement->getIdentifier()); return text; } diff --git a/src/Logger.h b/src/Logger.h index 81521a9..5ebcd86 100644 --- a/src/Logger.h +++ b/src/Logger.h @@ -12,7 +12,7 @@ class StatementMetaExternFunction; class StatementVariable; class StatementFunction; class StatementRawFunction; -class StatementType; +class StatementBlob; class StatementBlock; class StatementAssignment; class StatementReturn; @@ -45,7 +45,7 @@ private: static string toString(shared_ptr statement); static string toString(shared_ptr statement); static string toString(shared_ptr statement); - static string toString(shared_ptr statement); + static string toString(shared_ptr statement); static string toString(shared_ptr statement); static string toString(shared_ptr statement); static string toString(shared_ptr statement); diff --git a/src/Parser/Parser.cpp b/src/Parser/Parser.cpp index 4bcacba..21fdc61 100644 --- a/src/Parser/Parser.cpp +++ b/src/Parser/Parser.cpp @@ -18,7 +18,7 @@ #include "Parser/Statement/StatementFunction.h" #include "Parser/Statement/StatementRawFunction.h" -#include "Parser/Statement/StatementType.h" +#include "Parser/Statement/StatementBlob.h" #include "Parser/Statement/StatementVariable.h" #include "Parser/Statement/StatementAssignment.h" #include "Parser/Statement/StatementReturn.h" @@ -81,7 +81,7 @@ shared_ptr Parser::nextStatement() { if (statement != nullptr || errors.size() > errorsCount) return statement; - statement = matchStatementType(); + statement = matchStatementBlob(); if (statement != nullptr || errors.size() > errorsCount) return statement; @@ -491,7 +491,7 @@ shared_ptr Parser::matchStatementRawFunction() { return make_shared(name, constraints, arguments, returnType, rawSource); } -shared_ptr Parser::matchStatementType() { +shared_ptr Parser::matchStatementBlob() { ParseeResultsGroup resultsGroup; string identifier; @@ -535,7 +535,7 @@ shared_ptr Parser::matchStatementType() { return nullptr; } - return make_shared(identifier, variables); + return make_shared(identifier, variables); } shared_ptr Parser::matchStatementBlock(vector terminalTokenKinds) { diff --git a/src/Parser/Parser.h b/src/Parser/Parser.h index 3116875..bd1dea2 100644 --- a/src/Parser/Parser.h +++ b/src/Parser/Parser.h @@ -31,7 +31,7 @@ private: shared_ptr matchStatementVariable(); shared_ptr matchStatementFunction(); shared_ptr matchStatementRawFunction(); - shared_ptr matchStatementType(); + shared_ptr matchStatementBlob(); shared_ptr matchStatementBlock(vector terminalTokenKinds); shared_ptr matchStatementAssignment(); diff --git a/src/Parser/Statement/Statement.h b/src/Parser/Statement/Statement.h index 578bed3..e13b25a 100644 --- a/src/Parser/Statement/Statement.h +++ b/src/Parser/Statement/Statement.h @@ -15,7 +15,7 @@ enum class StatementKind { ASSIGNMENT, REPEAT, META_EXTERN_FUNCTION, - TYPE + BLOB }; class Statement { diff --git a/src/Parser/Statement/StatementBlob.cpp b/src/Parser/Statement/StatementBlob.cpp new file mode 100644 index 0000000..c0a9479 --- /dev/null +++ b/src/Parser/Statement/StatementBlob.cpp @@ -0,0 +1,14 @@ +#include "StatementBlob.h" + +#include "Parser/ValueType.h" + +StatementBlob::StatementBlob(string identifier, vector>> variables): +Statement(StatementKind::BLOB), identifier(identifier), variables(variables) { } + +string StatementBlob::getIdentifier() { + return identifier; +} + +vector>> StatementBlob::getVariables() { + return variables; +} \ No newline at end of file diff --git a/src/Parser/Statement/StatementType.h b/src/Parser/Statement/StatementBlob.h similarity index 71% rename from src/Parser/Statement/StatementType.h rename to src/Parser/Statement/StatementBlob.h index 5e3e242..2f1851b 100644 --- a/src/Parser/Statement/StatementType.h +++ b/src/Parser/Statement/StatementBlob.h @@ -3,16 +3,15 @@ #include "Statement.h" -class StatementVariable; class ValueType; -class StatementType: public Statement { +class StatementBlob: public Statement { private: string identifier; vector>> variables; public: - StatementType(string identifier, vector>> variables); + StatementBlob(string identifier, vector>> variables); string getIdentifier(); vector>> getVariables(); }; diff --git a/src/Parser/Statement/StatementType.cpp b/src/Parser/Statement/StatementType.cpp deleted file mode 100644 index 184b5a7..0000000 --- a/src/Parser/Statement/StatementType.cpp +++ /dev/null @@ -1,14 +0,0 @@ -#include "StatementType.h" - -#include "Parser/ValueType.h" - -StatementType::StatementType(string identifier, vector>> variables): -Statement(StatementKind::TYPE), identifier(identifier), variables(variables) { } - -string StatementType::getIdentifier() { - return identifier; -} - -vector>> StatementType::getVariables() { - return variables; -} \ No newline at end of file From 76f03ef8e36bc210c0d10d091ad57ee12f07dc46 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rafa=C5=82=20Grodzi=C5=84ski?= Date: Thu, 7 Aug 2025 09:39:45 +0900 Subject: [PATCH 06/14] wip --- samples/test.brc | 2 + src/Parser/Parsee/Parsee.cpp | 19 ++++ src/Parser/Parsee/Parsee.h | 14 ++- src/Parser/Parsee/ParseeGroup.cpp | 10 +- src/Parser/Parsee/ParseeGroup.h | 6 +- src/Parser/Parser.cpp | 164 +++++++++++++++++++----------- src/Parser/Parser.h | 7 +- 7 files changed, 152 insertions(+), 70 deletions(-) diff --git a/samples/test.brc b/samples/test.brc index b30ff0c..0205e7f 100644 --- a/samples/test.brc +++ b/samples/test.brc @@ -1,4 +1,6 @@ User blob + num1 s32 + num2 u8 ; main fun -> u32 diff --git a/src/Parser/Parsee/Parsee.cpp b/src/Parser/Parsee/Parsee.cpp index 3ec80d9..b3a5d21 100644 --- a/src/Parser/Parsee/Parsee.cpp +++ b/src/Parser/Parsee/Parsee.cpp @@ -1,5 +1,16 @@ #include "Parsee.h" +#include "ParseeGroup.h" + +Parsee Parsee::repeatedGroupParsee(ParseeGroup repeatedGroup, bool isRequired, bool shouldReturn, bool shouldFailOnNoMatch) { + Parsee parsee; + parsee.kind = ParseeKind::REPEATED_GROUP; + parsee.repeatedGroup = repeatedGroup; + parsee.isRequired = isRequired; + parsee.shouldFailOnNoMatch = shouldFailOnNoMatch; + return parsee; +} + Parsee Parsee::tokenParsee(TokenKind tokenKind, bool isRequired, bool shouldReturn) { Parsee parsee; parsee.kind = ParseeKind::TOKEN; @@ -27,6 +38,10 @@ Parsee Parsee::expressionParsee(bool isRequired) { Parsee::Parsee() { } +optional Parsee::getRepeatedGroup() { + return repeatedGroup; +} + ParseeKind Parsee::getKind() { return kind; } @@ -41,4 +56,8 @@ bool Parsee::getIsRequired() { bool Parsee::getShouldReturn() { return shouldReturn; +} + +bool Parsee::getShouldFailOnNoMatch() { + return shouldFailOnNoMatch; } \ No newline at end of file diff --git a/src/Parser/Parsee/Parsee.h b/src/Parser/Parsee/Parsee.h index 6dfdf0e..bf6e10d 100644 --- a/src/Parser/Parsee/Parsee.h +++ b/src/Parser/Parsee/Parsee.h @@ -2,10 +2,17 @@ #define PARSEE_H #include +#include + +#include "ParseeGroup.h" enum class TokenKind; +//class ParseeGroup; + +using namespace std; enum class ParseeKind { + REPEATED_GROUP, TOKEN, VALUE_TYPE, EXPRESSION @@ -14,20 +21,25 @@ enum class ParseeKind { class Parsee { private: ParseeKind kind; + optional repeatedGroup; TokenKind tokenKind; bool isRequired; bool shouldReturn; + bool shouldFailOnNoMatch; Parsee(); public: + static Parsee repeatedGroupParsee(ParseeGroup repeatedGroup, bool isRequired, bool shouldReturn, bool shouldFailOnNoMatch); static Parsee tokenParsee(TokenKind tokenKind, bool isRequired, bool shouldReturn); - static Parsee valueTypeParsee(bool isRequired); + static Parsee valueTypeParsee(bool isRequired); static Parsee expressionParsee(bool isRequired); ParseeKind getKind(); + optional getRepeatedGroup(); TokenKind getTokenKind(); bool getIsRequired(); bool getShouldReturn(); + bool getShouldFailOnNoMatch(); }; #endif \ No newline at end of file diff --git a/src/Parser/Parsee/ParseeGroup.cpp b/src/Parser/Parsee/ParseeGroup.cpp index ead5352..d580679 100644 --- a/src/Parser/Parsee/ParseeGroup.cpp +++ b/src/Parser/Parsee/ParseeGroup.cpp @@ -2,19 +2,19 @@ #include "Parsee.h" -ParseeGroup::ParseeGroup(vector parsees, optional repeatedGroup): +ParseeGroup::ParseeGroup(vector parsees)://, optional repeatedGroup): parsees(parsees) { - if (repeatedGroup) { + /*if (repeatedGroup) { this->repeatedGroup = *repeatedGroup; } else { this->repeatedGroup = {}; - } + }*/ } vector ParseeGroup::getParsees() { return parsees; } -optional> ParseeGroup::getRepeatedGroup() { +/*optional> ParseeGroup::getRepeatedGroup() { return repeatedGroup; -} \ No newline at end of file +}*/ \ No newline at end of file diff --git a/src/Parser/Parsee/ParseeGroup.h b/src/Parser/Parsee/ParseeGroup.h index 4e4cc82..1f6681b 100644 --- a/src/Parser/Parsee/ParseeGroup.h +++ b/src/Parser/Parsee/ParseeGroup.h @@ -11,12 +11,12 @@ using namespace std; class ParseeGroup { private: vector parsees; - optional> repeatedGroup; + //optional> repeatedGroup; public: - ParseeGroup(vector parsees, optional repeatedGroup); + ParseeGroup(vector parsees);//, optional repeatedGroup); vector getParsees(); - optional> getRepeatedGroup(); + //optional> getRepeatedGroup(); }; #endif \ No newline at end of file diff --git a/src/Parser/Parser.cpp b/src/Parser/Parser.cpp index 21fdc61..6c48ab1 100644 --- a/src/Parser/Parser.cpp +++ b/src/Parser/Parser.cpp @@ -131,8 +131,8 @@ shared_ptr Parser::matchStatementMetaExternFunction() { Parsee::tokenParsee(TokenKind::M_EXTERN, true, false), Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true), Parsee::tokenParsee(TokenKind::FUNCTION, true, false) - }, - {} + }/*, + {}*/ ) ); @@ -153,7 +153,7 @@ shared_ptr Parser::matchStatementMetaExternFunction() { Parsee::tokenParsee(TokenKind::NEW_LINE, false, false), Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true), Parsee::valueTypeParsee(true) - }, + }/*, ParseeGroup( { Parsee::tokenParsee(TokenKind::COMMA, true, false), @@ -162,7 +162,7 @@ shared_ptr Parser::matchStatementMetaExternFunction() { Parsee::valueTypeParsee(true) }, {} - ) + )*/ ) ); switch (resultsGroup.getKind()) { @@ -187,8 +187,8 @@ shared_ptr Parser::matchStatementMetaExternFunction() { Parsee::tokenParsee(TokenKind::RIGHT_ARROW, true, false), Parsee::tokenParsee(TokenKind::NEW_LINE, false, false), Parsee::valueTypeParsee(true) - }, - {} + }/*, + {}*/ ) ); @@ -213,8 +213,8 @@ shared_ptr Parser::matchStatementVariable() { Parsee::valueTypeParsee(true), Parsee::tokenParsee(TokenKind::LEFT_ARROW, true, false), Parsee::expressionParsee(true) - }, - {} + }/*, + {}*/ ) ); @@ -243,8 +243,8 @@ shared_ptr Parser::matchStatementFunction() { { Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true), Parsee::tokenParsee(TokenKind::FUNCTION, true, false) - }, - {} + }/*, + {}*/ ) ); @@ -268,7 +268,8 @@ shared_ptr Parser::matchStatementFunction() { Parsee::tokenParsee(TokenKind::NEW_LINE, false, false), Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true), Parsee::valueTypeParsee(true) - }, + }/*, + {} ParseeGroup( { Parsee::tokenParsee(TokenKind::COMMA, true, false), @@ -277,7 +278,7 @@ shared_ptr Parser::matchStatementFunction() { Parsee::valueTypeParsee(true) }, {} - ) + )*/ ) ); switch (resultsGroup.getKind()) { @@ -305,8 +306,8 @@ shared_ptr Parser::matchStatementFunction() { Parsee::tokenParsee(TokenKind::RIGHT_ARROW, true, false), Parsee::tokenParsee(TokenKind::NEW_LINE, false, false), Parsee::valueTypeParsee(true) - }, - {} + }/*, + {}*/ ) ); @@ -358,8 +359,8 @@ shared_ptr Parser::matchStatementRawFunction() { { Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true), Parsee::tokenParsee(TokenKind::RAW_FUNCTION, true, false) - }, - {} + }/*, + {}*/ ) ); @@ -383,8 +384,8 @@ shared_ptr Parser::matchStatementRawFunction() { Parsee::tokenParsee(TokenKind::LESS, true, false), Parsee::tokenParsee(TokenKind::STRING, true, true), Parsee::tokenParsee(TokenKind::GREATER, true, false) - }, - {} + }/*, + {}*/ ) ); @@ -413,7 +414,7 @@ shared_ptr Parser::matchStatementRawFunction() { Parsee::tokenParsee(TokenKind::NEW_LINE, false, false), Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true), Parsee::valueTypeParsee(true) - }, + }/*, ParseeGroup( { Parsee::tokenParsee(TokenKind::COMMA, true, false), @@ -422,7 +423,7 @@ shared_ptr Parser::matchStatementRawFunction() { Parsee::valueTypeParsee(true) }, {} - ) + )*/ ) ); switch (resultsGroup.getKind()) { @@ -450,8 +451,8 @@ shared_ptr Parser::matchStatementRawFunction() { Parsee::tokenParsee(TokenKind::RIGHT_ARROW, true, false), Parsee::tokenParsee(TokenKind::NEW_LINE, false, false), Parsee::valueTypeParsee(true) - }, - {} + }/*, + {}*/ ) ); @@ -501,21 +502,40 @@ shared_ptr Parser::matchStatementBlob() { ParseeGroup( { Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true), - Parsee::tokenParsee(TokenKind::TYPE, true, false) - }, + Parsee::tokenParsee(TokenKind::BLOB, true, false), + Parsee::tokenParsee(TokenKind::NEW_LINE, true, false), + Parsee::repeatedGroupParsee( + ParseeGroup( + { + Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true), + Parsee::valueTypeParsee(true), + Parsee::tokenParsee(TokenKind::NEW_LINE, true, false) + }/*, + {}*/ + ), false, true, false + ), + Parsee::tokenParsee(TokenKind::SEMICOLON, true, false) + }/*, {} + ParseeGroup( + { + Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true), + Parsee::valueTypeParsee(true) + }, + {} + )*/ ) ); switch (resultsGroup.getKind()) { case ParseeResultsGroupKind::SUCCESS: identifier = resultsGroup.getResults().at(0).getToken()->getLexme(); - /*for (int i=1; i> arg; arg.first = resultsGroup.getResults().at(i).getToken()->getLexme(); arg.second = resultsGroup.getResults().at(i+1).getValueType(); variables.push_back(arg); - }*/ + } break; case ParseeResultsGroupKind::NO_MATCH: case ParseeResultsGroupKind::FAILURE: @@ -570,8 +590,8 @@ shared_ptr Parser::matchStatementAssignment() { ParseeGroup( { Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true), - }, - {} + }/*, + {}*/ ) ); @@ -587,8 +607,8 @@ shared_ptr Parser::matchStatementAssignment() { Parsee::tokenParsee(TokenKind::LEFT_SQUARE_BRACKET, true, false), Parsee::expressionParsee(true), Parsee::tokenParsee(TokenKind::RIGHT_SQUARE_BRACKET, true, false), - }, - {} + }/*, + {}*/ ) ); @@ -608,8 +628,8 @@ shared_ptr Parser::matchStatementAssignment() { { Parsee::tokenParsee(TokenKind::LEFT_ARROW, true, false), Parsee::expressionParsee(true) - }, - {} + }/*, + {}*/ ) ); @@ -633,8 +653,8 @@ shared_ptr Parser::matchStatementReturn() { { Parsee::tokenParsee(TokenKind::RETURN, true, false), Parsee::expressionParsee(false) - }, - {} + }/*, + {}*/ ) ); @@ -1021,20 +1041,24 @@ shared_ptr Parser::matchExpressionBlock(vector terminalTo ParseeResultsGroup Parser::parseeResultsGroupForParseeGroup(ParseeGroup group) { int errorsCount = errors.size(); int startIndex = currentIndex; - vector results; + vector parseeResults; bool mustFulfill = false; for (Parsee &parsee : group.getParsees()) { - optional result; + optional> subResults; switch (parsee.getKind()) { + case ParseeKind::REPEATED_GROUP: + //ParseeResultsGroup results = parseeResultsGroupForParseeGroup(*parsee.getRepeatedGroup()); + subResults = repeatedGroupParseeResults(*parsee.getRepeatedGroup()); + break; case ParseeKind::TOKEN: - result = tokenParseeResult(currentIndex, parsee.getTokenKind()); + subResults = tokenParseeResults(currentIndex, parsee.getTokenKind()); break; case ParseeKind::VALUE_TYPE: - result = valueTypeParseeResult(currentIndex); + subResults = valueTypeParseeResults(currentIndex); break; case ParseeKind::EXPRESSION: - result = expressionParseeResult(currentIndex); + subResults = expressionParseeResults(currentIndex); break; } @@ -1043,33 +1067,39 @@ ParseeResultsGroup Parser::parseeResultsGroupForParseeGroup(ParseeGroup group) { return ParseeResultsGroup::failure(); // if doesn't match on optional group - if (!result && parsee.getIsRequired() && !mustFulfill) { + if (!subResults && parsee.getIsRequired() && !mustFulfill) { currentIndex = startIndex; //return vector(); return ParseeResultsGroup::noMatch(); } // return matching token? - if (result && parsee.getShouldReturn()) - results.push_back(*result); + if (subResults && parsee.getShouldReturn()) { + //parseeResults.push_back(*result); + for (ParseeResult &subResult : *subResults) + parseeResults.push_back(subResult); + } // decide if we're decoding the expected sequence if (!parsee.getIsRequired() && currentIndex > startIndex) mustFulfill = true; // invalid sequence detected? - if (!result && parsee.getIsRequired() && mustFulfill) { + if (!subResults && parsee.getIsRequired() && mustFulfill) { markError(parsee.getTokenKind(), {}); //return {}; return ParseeResultsGroup::failure(); } // got to the next token if we got a match - if (result) - currentIndex += (*result).getTokensCount(); + if (subResults) { + for (ParseeResult &subResult : *subResults ) + currentIndex += subResult.getTokensCount(); + //currentIndex += (*result).getTokensCount(); + } } - if (group.getRepeatedGroup()) { + /*if (group.getRepeatedGroup()) { ParseeResultsGroup subResultsGroup; do { subResultsGroup = parseeResultsGroupForParseeGroup(*group.getRepeatedGroup()); @@ -1079,19 +1109,37 @@ ParseeResultsGroup Parser::parseeResultsGroupForParseeGroup(ParseeGroup group) { for (ParseeResult &subResult : subResultsGroup.getResults()) results.push_back(subResult); } while (subResultsGroup.getKind() == ParseeResultsGroupKind::SUCCESS); - } + }*/ - return ParseeResultsGroup::success(results); + return ParseeResultsGroup::success(parseeResults); } -optional Parser::tokenParseeResult(int index, TokenKind tokenKind) { +optional> Parser::repeatedGroupParseeResults(ParseeGroup group) { + int startIndex = currentIndex; + vector results; + + ParseeResultsGroup resultsGroup; + do { + resultsGroup = parseeResultsGroupForParseeGroup(group); + if (resultsGroup.getKind() == ParseeResultsGroupKind::FAILURE) + return {}; + + for (ParseeResult &result : resultsGroup.getResults()) + results.push_back(result); + } while (resultsGroup.getKind() == ParseeResultsGroupKind::SUCCESS); + + currentIndex = startIndex; + return results; +} + +optional> Parser::tokenParseeResults(int index, TokenKind tokenKind) { shared_ptr token = tokens.at(index); if (token->isOfKind({tokenKind})) - return ParseeResult::tokenResult(token); + return vector({ParseeResult::tokenResult(token)}); return {}; } -optional Parser::valueTypeParseeResult(int index) { +optional> Parser::valueTypeParseeResults(int index) { int startIndex = index; if (!tokens.at(index)->isOfKind({TokenKind::TYPE})) @@ -1103,11 +1151,11 @@ optional Parser::valueTypeParseeResult(int index) { if (tokens.at(index)->isOfKind({TokenKind::LESS})) { index++; - optional subResult = valueTypeParseeResult(index); - if (!subResult) + optional> subResults = valueTypeParseeResults(index); + if (!subResults || (*subResults).empty()) return {}; - subType = (*subResult).getValueType(); - index += (*subResult).getTokensCount(); + subType = (*subResults)[0].getValueType(); + index += (*subResults)[0].getTokensCount(); if (tokens.at(index)->isOfKind({TokenKind::COMMA})) { index++; @@ -1129,10 +1177,10 @@ optional Parser::valueTypeParseeResult(int index) { } shared_ptr valueType = ValueType::valueTypeForToken(typeToken, subType, typeArg); - return ParseeResult::valueTypeResult(valueType, index - startIndex); + return vector({ParseeResult::valueTypeResult(valueType, index - startIndex)}); } -optional Parser::expressionParseeResult(int index) { +optional> Parser::expressionParseeResults(int index) { int startIndex = currentIndex; int errorsCount = errors.size(); shared_ptr expression = nextExpression(); @@ -1141,7 +1189,7 @@ optional Parser::expressionParseeResult(int index) { int tokensCount = currentIndex - startIndex; currentIndex = startIndex; - return ParseeResult::expressionResult(expression, tokensCount); + return vector({ParseeResult::expressionResult(expression, tokensCount)}); } bool Parser::tryMatchingTokenKinds(vector kinds, bool shouldMatchAll, bool shouldAdvance) { diff --git a/src/Parser/Parser.h b/src/Parser/Parser.h index bd1dea2..5ef35a6 100644 --- a/src/Parser/Parser.h +++ b/src/Parser/Parser.h @@ -57,9 +57,10 @@ private: shared_ptr matchExpressionBlock(vector terminalTokenKinds); ParseeResultsGroup parseeResultsGroupForParseeGroup(ParseeGroup group); - optional tokenParseeResult(int index, TokenKind tokenKind); - optional valueTypeParseeResult(int index); - optional expressionParseeResult(int index); + optional> repeatedGroupParseeResults(ParseeGroup group); + optional> tokenParseeResults(int index, TokenKind tokenKind); + optional> valueTypeParseeResults(int index); + optional> expressionParseeResults(int index); bool tryMatchingTokenKinds(vector kinds, bool shouldMatchAll, bool shouldAdvance); void markError(optional expectedTokenKind, optional message); From 8dcdcc7061da2c818dfc2043cbb507f49b2f0bd2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rafa=C5=82=20Grodzi=C5=84ski?= Date: Thu, 7 Aug 2025 18:35:43 +0900 Subject: [PATCH 07/14] Correctly parse blob --- src/Parser/Parsee/Parsee.cpp | 1 + src/Parser/Parser.cpp | 78 +++++++++++++----------------------- src/Parser/Parser.h | 8 ++-- 3 files changed, 32 insertions(+), 55 deletions(-) diff --git a/src/Parser/Parsee/Parsee.cpp b/src/Parser/Parsee/Parsee.cpp index b3a5d21..455c736 100644 --- a/src/Parser/Parsee/Parsee.cpp +++ b/src/Parser/Parsee/Parsee.cpp @@ -7,6 +7,7 @@ Parsee Parsee::repeatedGroupParsee(ParseeGroup repeatedGroup, bool isRequired, b parsee.kind = ParseeKind::REPEATED_GROUP; parsee.repeatedGroup = repeatedGroup; parsee.isRequired = isRequired; + parsee.shouldReturn = shouldReturn; parsee.shouldFailOnNoMatch = shouldFailOnNoMatch; return parsee; } diff --git a/src/Parser/Parser.cpp b/src/Parser/Parser.cpp index 6c48ab1..1a9df82 100644 --- a/src/Parser/Parser.cpp +++ b/src/Parser/Parser.cpp @@ -510,20 +510,14 @@ shared_ptr Parser::matchStatementBlob() { Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true), Parsee::valueTypeParsee(true), Parsee::tokenParsee(TokenKind::NEW_LINE, true, false) - }/*, - {}*/ - ), false, true, false + } + ), + false, + true, + false ), Parsee::tokenParsee(TokenKind::SEMICOLON, true, false) - }/*, - {} - ParseeGroup( - { - Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true), - Parsee::valueTypeParsee(true) - }, - {} - )*/ + } ) ); @@ -544,16 +538,16 @@ shared_ptr Parser::matchStatementBlob() { } // consume new line - if (!tryMatchingTokenKinds({TokenKind::NEW_LINE}, true, true)) { + /*if (!tryMatchingTokenKinds({TokenKind::NEW_LINE}, true, true)) { markError(TokenKind::NEW_LINE, {}); return nullptr; - } + }*/ // closing semicolon - if(!tryMatchingTokenKinds({TokenKind::SEMICOLON}, false, true)) { + /*if(!tryMatchingTokenKinds({TokenKind::SEMICOLON}, false, true)) { markError(TokenKind::SEMICOLON, {}); return nullptr; - } + }*/ return make_shared(identifier, variables); } @@ -1045,10 +1039,9 @@ ParseeResultsGroup Parser::parseeResultsGroupForParseeGroup(ParseeGroup group) { bool mustFulfill = false; for (Parsee &parsee : group.getParsees()) { - optional> subResults; + optional, int>> subResults; switch (parsee.getKind()) { case ParseeKind::REPEATED_GROUP: - //ParseeResultsGroup results = parseeResultsGroupForParseeGroup(*parsee.getRepeatedGroup()); subResults = repeatedGroupParseeResults(*parsee.getRepeatedGroup()); break; case ParseeKind::TOKEN: @@ -1069,14 +1062,12 @@ ParseeResultsGroup Parser::parseeResultsGroupForParseeGroup(ParseeGroup group) { // if doesn't match on optional group if (!subResults && parsee.getIsRequired() && !mustFulfill) { currentIndex = startIndex; - //return vector(); return ParseeResultsGroup::noMatch(); } // return matching token? if (subResults && parsee.getShouldReturn()) { - //parseeResults.push_back(*result); - for (ParseeResult &subResult : *subResults) + for (ParseeResult &subResult : (*subResults).first) parseeResults.push_back(subResult); } @@ -1087,34 +1078,18 @@ ParseeResultsGroup Parser::parseeResultsGroupForParseeGroup(ParseeGroup group) { // invalid sequence detected? if (!subResults && parsee.getIsRequired() && mustFulfill) { markError(parsee.getTokenKind(), {}); - //return {}; return ParseeResultsGroup::failure(); } // got to the next token if we got a match - if (subResults) { - for (ParseeResult &subResult : *subResults ) - currentIndex += subResult.getTokensCount(); - //currentIndex += (*result).getTokensCount(); - } + if (subResults) + currentIndex += (*subResults).second; } - /*if (group.getRepeatedGroup()) { - ParseeResultsGroup subResultsGroup; - do { - subResultsGroup = parseeResultsGroupForParseeGroup(*group.getRepeatedGroup()); - if (subResultsGroup.getKind() == ParseeResultsGroupKind::FAILURE) - return ParseeResultsGroup::failure(); - - for (ParseeResult &subResult : subResultsGroup.getResults()) - results.push_back(subResult); - } while (subResultsGroup.getKind() == ParseeResultsGroupKind::SUCCESS); - }*/ - return ParseeResultsGroup::success(parseeResults); } -optional> Parser::repeatedGroupParseeResults(ParseeGroup group) { +optional, int>> Parser::repeatedGroupParseeResults(ParseeGroup group) { int startIndex = currentIndex; vector results; @@ -1128,18 +1103,19 @@ optional> Parser::repeatedGroupParseeResults(ParseeGroup gr results.push_back(result); } while (resultsGroup.getKind() == ParseeResultsGroupKind::SUCCESS); + int tokensCount = currentIndex - startIndex; currentIndex = startIndex; - return results; + return pair(results, tokensCount); } -optional> Parser::tokenParseeResults(int index, TokenKind tokenKind) { +optional, int>> Parser::tokenParseeResults(int index, TokenKind tokenKind) { shared_ptr token = tokens.at(index); if (token->isOfKind({tokenKind})) - return vector({ParseeResult::tokenResult(token)}); + return pair(vector({ParseeResult::tokenResult(token)}), 1); return {}; } -optional> Parser::valueTypeParseeResults(int index) { +optional, int>> Parser::valueTypeParseeResults(int index) { int startIndex = index; if (!tokens.at(index)->isOfKind({TokenKind::TYPE})) @@ -1151,11 +1127,11 @@ optional> Parser::valueTypeParseeResults(int index) { if (tokens.at(index)->isOfKind({TokenKind::LESS})) { index++; - optional> subResults = valueTypeParseeResults(index); - if (!subResults || (*subResults).empty()) + optional, int>> subResults = valueTypeParseeResults(index); + if (!subResults || (*subResults).first.empty()) return {}; - subType = (*subResults)[0].getValueType(); - index += (*subResults)[0].getTokensCount(); + subType = (*subResults).first[0].getValueType(); + index += (*subResults).second; if (tokens.at(index)->isOfKind({TokenKind::COMMA})) { index++; @@ -1177,10 +1153,10 @@ optional> Parser::valueTypeParseeResults(int index) { } shared_ptr valueType = ValueType::valueTypeForToken(typeToken, subType, typeArg); - return vector({ParseeResult::valueTypeResult(valueType, index - startIndex)}); + return pair(vector({ParseeResult::valueTypeResult(valueType, index - startIndex)}), index - startIndex); } -optional> Parser::expressionParseeResults(int index) { +optional, int>> Parser::expressionParseeResults(int index) { int startIndex = currentIndex; int errorsCount = errors.size(); shared_ptr expression = nextExpression(); @@ -1189,7 +1165,7 @@ optional> Parser::expressionParseeResults(int index) { int tokensCount = currentIndex - startIndex; currentIndex = startIndex; - return vector({ParseeResult::expressionResult(expression, tokensCount)}); + return pair(vector({ParseeResult::expressionResult(expression, tokensCount)}), tokensCount); } bool Parser::tryMatchingTokenKinds(vector kinds, bool shouldMatchAll, bool shouldAdvance) { diff --git a/src/Parser/Parser.h b/src/Parser/Parser.h index 5ef35a6..4d36593 100644 --- a/src/Parser/Parser.h +++ b/src/Parser/Parser.h @@ -57,10 +57,10 @@ private: shared_ptr matchExpressionBlock(vector terminalTokenKinds); ParseeResultsGroup parseeResultsGroupForParseeGroup(ParseeGroup group); - optional> repeatedGroupParseeResults(ParseeGroup group); - optional> tokenParseeResults(int index, TokenKind tokenKind); - optional> valueTypeParseeResults(int index); - optional> expressionParseeResults(int index); + optional, int>> repeatedGroupParseeResults(ParseeGroup group); + optional, int>> tokenParseeResults(int index, TokenKind tokenKind); + optional, int>> valueTypeParseeResults(int index); + optional, int>> expressionParseeResults(int index); bool tryMatchingTokenKinds(vector kinds, bool shouldMatchAll, bool shouldAdvance); void markError(optional expectedTokenKind, optional message); From 39be17e6a1750ec21c0bfc19d0678090a1d4be6c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rafa=C5=82=20Grodzi=C5=84ski?= Date: Thu, 7 Aug 2025 21:34:14 +0900 Subject: [PATCH 08/14] Fixed logger and module builder --- src/Compiler/ModuleBuilder.cpp | 16 ++++++++++++---- src/Compiler/ModuleBuilder.h | 2 +- src/Logger.cpp | 2 ++ src/Parser/Parser.cpp | 12 ------------ 4 files changed, 15 insertions(+), 17 deletions(-) diff --git a/src/Compiler/ModuleBuilder.cpp b/src/Compiler/ModuleBuilder.cpp index 18008d0..cb0fa73 100644 --- a/src/Compiler/ModuleBuilder.cpp +++ b/src/Compiler/ModuleBuilder.cpp @@ -70,7 +70,7 @@ void ModuleBuilder::buildStatement(shared_ptr statement) { buildRawFunction(dynamic_pointer_cast(statement)); break; case StatementKind::BLOB: - buildType(dynamic_pointer_cast(statement)); + buildBlob(dynamic_pointer_cast(statement)); break; case StatementKind::VARIABLE: buildVarDeclaration(dynamic_pointer_cast(statement)); @@ -164,10 +164,18 @@ void ModuleBuilder::buildRawFunction(shared_ptr statement) return; } -void ModuleBuilder::buildType(shared_ptr statement) { +void ModuleBuilder::buildBlob(shared_ptr statement) { llvm::StructType *structType = llvm::StructType::create(*context, statement->getIdentifier()); - vector elements; - structType->setBody(elements, false); + + // Generate types for body + vector types; + for (pair> &variable: statement->getVariables()) { + llvm::Type *type = typeForValueType(variable.second); + if (type == nullptr) + return; + types.push_back(type); + } + structType->setBody(types, false); if (!setStruct(statement->getIdentifier(), structType)) return; } diff --git a/src/Compiler/ModuleBuilder.h b/src/Compiler/ModuleBuilder.h index fef55a3..d63b0a7 100644 --- a/src/Compiler/ModuleBuilder.h +++ b/src/Compiler/ModuleBuilder.h @@ -71,7 +71,7 @@ private: void buildStatement(shared_ptr statement); void buildFunction(shared_ptr statement); void buildRawFunction(shared_ptr statement); - void buildType(shared_ptr statement); + void buildBlob(shared_ptr statement); void buildVarDeclaration(shared_ptr statement); void buildAssignment(shared_ptr statement); void buildBlock(shared_ptr statement); diff --git a/src/Logger.cpp b/src/Logger.cpp index 6ea6f3f..134009e 100644 --- a/src/Logger.cpp +++ b/src/Logger.cpp @@ -307,6 +307,8 @@ string Logger::toString(shared_ptr statement) { string text; text += format("BLOB(\"{}\"):\n", statement->getIdentifier()); + for (pair> &variable : statement->getVariables()) + text += format("{}: {}\n", variable.first, toString(variable.second)); return text; } diff --git a/src/Parser/Parser.cpp b/src/Parser/Parser.cpp index 1a9df82..2507a37 100644 --- a/src/Parser/Parser.cpp +++ b/src/Parser/Parser.cpp @@ -537,18 +537,6 @@ shared_ptr Parser::matchStatementBlob() { break; } - // consume new line - /*if (!tryMatchingTokenKinds({TokenKind::NEW_LINE}, true, true)) { - markError(TokenKind::NEW_LINE, {}); - return nullptr; - }*/ - - // closing semicolon - /*if(!tryMatchingTokenKinds({TokenKind::SEMICOLON}, false, true)) { - markError(TokenKind::SEMICOLON, {}); - return nullptr; - }*/ - return make_shared(identifier, variables); } From e4c956cdd6006bc9cf0784acb23ef54a0482a512 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rafa=C5=82=20Grodzi=C5=84ski?= Date: Fri, 8 Aug 2025 12:34:28 +0900 Subject: [PATCH 09/14] Using the groupParsee --- samples/test.brc | 11 +- src/Logger.cpp | 5 +- src/Parser/Parsee/Parsee.cpp | 27 +- src/Parser/Parsee/Parsee.h | 11 +- src/Parser/Parsee/ParseeGroup.cpp | 14 +- src/Parser/Parsee/ParseeGroup.h | 5 +- src/Parser/Parser.cpp | 595 ++++++++++++------------------ src/Parser/Parser.h | 1 + 8 files changed, 292 insertions(+), 377 deletions(-) diff --git a/samples/test.brc b/samples/test.brc index 0205e7f..3d1cfa0 100644 --- a/samples/test.brc +++ b/samples/test.brc @@ -1,10 +1,19 @@ +@extern putchar fun: character u32 -> u32 + User blob num1 s32 num2 u8 ; +rawAdd raw<"=r,r,r">: num1 u32, num2 u32 -> u32 + add $1, $2 + mov $0, $1 +; + main fun -> u32 - user User <- 0 + n1 u32 <- 5 + n2 u32 <- 4 + n3 u32 <- rawAdd(n1, n2) ret 0 ; \ No newline at end of file diff --git a/src/Logger.cpp b/src/Logger.cpp index 134009e..a8559ec 100644 --- a/src/Logger.cpp +++ b/src/Logger.cpp @@ -326,7 +326,10 @@ string Logger::toString(shared_ptr statement) { } string Logger::toString(shared_ptr statement) { - return format("{} <- {}", statement->getName(), toString(statement->getExpression())); + if (statement->getIndexExpression() != nullptr) + return format("{}[{}] <- {}", statement->getName(), toString(statement->getIndexExpression()), toString(statement->getExpression())); + else + return format("{} <- {}", statement->getName(), toString(statement->getExpression())); } string Logger::toString(shared_ptr statement) { diff --git a/src/Parser/Parsee/Parsee.cpp b/src/Parser/Parsee/Parsee.cpp index 455c736..55ebf35 100644 --- a/src/Parser/Parsee/Parsee.cpp +++ b/src/Parser/Parsee/Parsee.cpp @@ -2,6 +2,16 @@ #include "ParseeGroup.h" +Parsee Parsee::groupParsee(ParseeGroup group, bool isRequired, bool shouldReturn, bool shouldFailOnNoMatch) { + Parsee parsee; + parsee.kind = ParseeKind::GROUP; + parsee.group = group; + parsee.isRequired = isRequired; + parsee.shouldReturn = shouldReturn; + parsee.shouldFailOnNoMatch = shouldFailOnNoMatch; + return parsee; +} + Parsee Parsee::repeatedGroupParsee(ParseeGroup repeatedGroup, bool isRequired, bool shouldReturn, bool shouldFailOnNoMatch) { Parsee parsee; parsee.kind = ParseeKind::REPEATED_GROUP; @@ -12,33 +22,40 @@ Parsee Parsee::repeatedGroupParsee(ParseeGroup repeatedGroup, bool isRequired, b return parsee; } -Parsee Parsee::tokenParsee(TokenKind tokenKind, bool isRequired, bool shouldReturn) { +Parsee Parsee::tokenParsee(TokenKind tokenKind, bool isRequired, bool shouldReturn, bool shouldFailOnNoMatch) { Parsee parsee; parsee.kind = ParseeKind::TOKEN; parsee.tokenKind = tokenKind; parsee.isRequired = isRequired; parsee.shouldReturn = shouldReturn; + parsee.shouldFailOnNoMatch = shouldFailOnNoMatch; return parsee; } -Parsee Parsee::valueTypeParsee(bool isRequired) { +Parsee Parsee::valueTypeParsee(bool isRequired, bool shouldReturn, bool shouldFailOnNoMatch) { Parsee parsee; parsee.kind = ParseeKind::VALUE_TYPE; parsee.isRequired = isRequired; - parsee.shouldReturn = true; + parsee.shouldReturn = shouldReturn; + parsee.shouldFailOnNoMatch = shouldFailOnNoMatch; return parsee; } -Parsee Parsee::expressionParsee(bool isRequired) { +Parsee Parsee::expressionParsee(bool isRequired, bool shouldReturn, bool shouldFailOnNoMatch) { Parsee parsee; parsee.kind = ParseeKind::EXPRESSION; parsee.isRequired = isRequired; - parsee.shouldReturn = true; + parsee.shouldReturn = shouldReturn; + parsee.shouldFailOnNoMatch = shouldFailOnNoMatch; return parsee; } Parsee::Parsee() { } +optional Parsee::getGroup() { + return group; +} + optional Parsee::getRepeatedGroup() { return repeatedGroup; } diff --git a/src/Parser/Parsee/Parsee.h b/src/Parser/Parsee/Parsee.h index bf6e10d..d194867 100644 --- a/src/Parser/Parsee/Parsee.h +++ b/src/Parser/Parsee/Parsee.h @@ -7,11 +7,11 @@ #include "ParseeGroup.h" enum class TokenKind; -//class ParseeGroup; using namespace std; enum class ParseeKind { + GROUP, REPEATED_GROUP, TOKEN, VALUE_TYPE, @@ -21,6 +21,7 @@ enum class ParseeKind { class Parsee { private: ParseeKind kind; + optional group; optional repeatedGroup; TokenKind tokenKind; bool isRequired; @@ -29,12 +30,14 @@ private: Parsee(); public: + static Parsee groupParsee(ParseeGroup group, bool isRequired, bool shouldReturn, bool shouldFailOnNoMatch); static Parsee repeatedGroupParsee(ParseeGroup repeatedGroup, bool isRequired, bool shouldReturn, bool shouldFailOnNoMatch); - static Parsee tokenParsee(TokenKind tokenKind, bool isRequired, bool shouldReturn); - static Parsee valueTypeParsee(bool isRequired); - static Parsee expressionParsee(bool isRequired); + static Parsee tokenParsee(TokenKind tokenKind, bool isRequired, bool shouldReturn, bool shouldFailOnNoMatch); + static Parsee valueTypeParsee(bool isRequired, bool shouldReturn, bool shouldFailOnNoMatch); + static Parsee expressionParsee(bool isRequired, bool shouldReturn, bool shouldFailOnNoMatch); ParseeKind getKind(); + optional getGroup(); optional getRepeatedGroup(); TokenKind getTokenKind(); bool getIsRequired(); diff --git a/src/Parser/Parsee/ParseeGroup.cpp b/src/Parser/Parsee/ParseeGroup.cpp index d580679..401c4f9 100644 --- a/src/Parser/Parsee/ParseeGroup.cpp +++ b/src/Parser/Parsee/ParseeGroup.cpp @@ -2,19 +2,9 @@ #include "Parsee.h" -ParseeGroup::ParseeGroup(vector parsees)://, optional repeatedGroup): -parsees(parsees) { - /*if (repeatedGroup) { - this->repeatedGroup = *repeatedGroup; - } else { - this->repeatedGroup = {}; - }*/ - } +ParseeGroup::ParseeGroup(vector parsees): +parsees(parsees) { } vector ParseeGroup::getParsees() { return parsees; } - -/*optional> ParseeGroup::getRepeatedGroup() { - return repeatedGroup; -}*/ \ No newline at end of file diff --git a/src/Parser/Parsee/ParseeGroup.h b/src/Parser/Parsee/ParseeGroup.h index 1f6681b..0f26087 100644 --- a/src/Parser/Parsee/ParseeGroup.h +++ b/src/Parser/Parsee/ParseeGroup.h @@ -2,7 +2,6 @@ #define PARSEE_GROUP_H #include -#include class Parsee; @@ -11,12 +10,10 @@ using namespace std; class ParseeGroup { private: vector parsees; - //optional> repeatedGroup; public: - ParseeGroup(vector parsees);//, optional repeatedGroup); + ParseeGroup(vector parsees); vector getParsees(); - //optional> getRepeatedGroup(); }; #endif \ No newline at end of file diff --git a/src/Parser/Parser.cpp b/src/Parser/Parser.cpp index 2507a37..ce3e639 100644 --- a/src/Parser/Parser.cpp +++ b/src/Parser/Parser.cpp @@ -118,89 +118,70 @@ shared_ptr Parser::nextInBlockStatement() { } shared_ptr Parser::matchStatementMetaExternFunction() { - ParseeResultsGroup resultsGroup; - string identifier; vector>> arguments; shared_ptr returnType = ValueType::NONE; - // identifier - resultsGroup = parseeResultsGroupForParseeGroup( + ParseeResultsGroup resultsGroup = parseeResultsGroupForParseeGroup( ParseeGroup( { - Parsee::tokenParsee(TokenKind::M_EXTERN, true, false), - Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true), - Parsee::tokenParsee(TokenKind::FUNCTION, true, false) - }/*, - {}*/ - ) - ); - - switch (resultsGroup.getKind()) { - case ParseeResultsGroupKind::SUCCESS: - identifier = resultsGroup.getResults().at(0).getToken()->getLexme(); - break; - case ParseeResultsGroupKind::NO_MATCH: - case ParseeResultsGroupKind::FAILURE: - return nullptr; - } - - // arguments - resultsGroup = parseeResultsGroupForParseeGroup( - ParseeGroup( - { - Parsee::tokenParsee(TokenKind::COLON, true, false), - Parsee::tokenParsee(TokenKind::NEW_LINE, false, false), - Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true), - Parsee::valueTypeParsee(true) - }/*, - ParseeGroup( - { - Parsee::tokenParsee(TokenKind::COMMA, true, false), - Parsee::tokenParsee(TokenKind::NEW_LINE, false, false), - Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true), - Parsee::valueTypeParsee(true) - }, - {} - )*/ - ) - ); - switch (resultsGroup.getKind()) { - case ParseeResultsGroupKind::SUCCESS: - for (int i=0; i> arg; - arg.first = resultsGroup.getResults().at(i).getToken()->getLexme(); - arg.second = resultsGroup.getResults().at(i+1).getValueType(); - arguments.push_back(arg); + // identifier + Parsee::tokenParsee(TokenKind::M_EXTERN, true, false, false), + Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true, false), + Parsee::tokenParsee(TokenKind::FUNCTION, true, false, false), + // arguments + Parsee::groupParsee( + ParseeGroup( + { + // first argument + Parsee::tokenParsee(TokenKind::COLON, true, false, false), + Parsee::tokenParsee(TokenKind::NEW_LINE, false, false, false), + Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true, true), + Parsee::valueTypeParsee(true, true, true), + // additional arguments + Parsee::repeatedGroupParsee( + ParseeGroup( + { + Parsee::tokenParsee(TokenKind::COMMA, true, false, false), + Parsee::tokenParsee(TokenKind::NEW_LINE, false, false, false), + Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true, true), + Parsee::valueTypeParsee(true, true, true) + } + ), false, true, false + ) + } + ), false, true, false + ), + // return type + Parsee::groupParsee( + ParseeGroup( + { + Parsee::tokenParsee(TokenKind::RIGHT_ARROW, true, false, false), + Parsee::tokenParsee(TokenKind::NEW_LINE, false, false, false), + Parsee::valueTypeParsee(true, true, true) + } + ), false, true, false + ) } - break; - case ParseeResultsGroupKind::NO_MATCH: - break; - case ParseeResultsGroupKind::FAILURE: - return nullptr; - } - - // return type - resultsGroup = parseeResultsGroupForParseeGroup( - ParseeGroup( - { - Parsee::tokenParsee(TokenKind::RIGHT_ARROW, true, false), - Parsee::tokenParsee(TokenKind::NEW_LINE, false, false), - Parsee::valueTypeParsee(true) - }/*, - {}*/ ) ); - switch (resultsGroup.getKind()) { - case ParseeResultsGroupKind::SUCCESS: - returnType = resultsGroup.getResults().at(0).getValueType(); - break; - case ParseeResultsGroupKind::NO_MATCH: - break; - case ParseeResultsGroupKind::FAILURE: - return nullptr; + if (resultsGroup.getKind() != ParseeResultsGroupKind::SUCCESS) + return nullptr; + + int i = 0; + // identifier + identifier = resultsGroup.getResults().at(i++).getToken()->getLexme(); + // arguments + while (i < resultsGroup.getResults().size()-1 && resultsGroup.getResults().at(i).getKind() == ParseeResultKind::TOKEN) { + pair> argument; + argument.first = resultsGroup.getResults().at(i++).getToken()->getLexme(); + argument.second = resultsGroup.getResults().at(i++).getValueType(); + arguments.push_back(argument); } + // return type + if (i < resultsGroup.getResults().size()) + returnType = resultsGroup.getResults().at(i).getValueType(); return make_shared(identifier, arguments, returnType); } @@ -209,12 +190,11 @@ shared_ptr Parser::matchStatementVariable() { ParseeResultsGroup resultsGroup = parseeResultsGroupForParseeGroup( ParseeGroup( { - Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true), - Parsee::valueTypeParsee(true), - Parsee::tokenParsee(TokenKind::LEFT_ARROW, true, false), - Parsee::expressionParsee(true) - }/*, - {}*/ + Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true, false), + Parsee::valueTypeParsee(true, true, false), + Parsee::tokenParsee(TokenKind::LEFT_ARROW, true, false, true), + Parsee::expressionParsee(true, true, true) + } ) ); @@ -229,106 +209,79 @@ shared_ptr Parser::matchStatementVariable() { } shared_ptr Parser::matchStatementFunction() { - bool hasError = false; - ParseeResultsGroup resultsGroup; - - string name; + string identifier; vector>> arguments; shared_ptr returnType = ValueType::NONE; shared_ptr statementBlock; - // identifier - resultsGroup = parseeResultsGroupForParseeGroup( + ParseeResultsGroup resultsGroup = parseeResultsGroupForParseeGroup( ParseeGroup( { - Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true), - Parsee::tokenParsee(TokenKind::FUNCTION, true, false) - }/*, - {}*/ + // identifier + Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true, false), + Parsee::tokenParsee(TokenKind::FUNCTION, true, false, false), + // arguments + Parsee::groupParsee( + ParseeGroup( + { + // first argument + Parsee::tokenParsee(TokenKind::COLON, true, false, false), + Parsee::tokenParsee(TokenKind::NEW_LINE, false, false, false), + Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true, true), + Parsee::valueTypeParsee(true, true, true), + // additional arguments + Parsee::repeatedGroupParsee( + ParseeGroup( + { + Parsee::tokenParsee(TokenKind::COMMA, true, false, false), + Parsee::tokenParsee(TokenKind::NEW_LINE, false, false, false), + Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true, true), + Parsee::valueTypeParsee(true, true, true) + } + ), false, true, false + ) + } + ), false, true, false + ), + // return type + Parsee::groupParsee( + ParseeGroup( + { + Parsee::tokenParsee(TokenKind::RIGHT_ARROW, true, false, false), + Parsee::tokenParsee(TokenKind::NEW_LINE, false, false, false), + Parsee::valueTypeParsee(true, true, true) + } + ), false, true, false + ), + // new line + Parsee::tokenParsee(TokenKind::NEW_LINE, true, false, true) + } ) ); switch (resultsGroup.getKind()) { - case ParseeResultsGroupKind::SUCCESS: - name = resultsGroup.getResults().at(0).getToken()->getLexme(); + case ParseeResultsGroupKind::SUCCESS: { + int i = 0; + // identifier + identifier = resultsGroup.getResults().at(i++).getToken()->getLexme(); + // arguments + while (i < resultsGroup.getResults().size()-1 && resultsGroup.getResults().at(i).getKind() == ParseeResultKind::TOKEN) { + pair> argument; + argument.first = resultsGroup.getResults().at(i++).getToken()->getLexme(); + argument.second = resultsGroup.getResults().at(i++).getValueType(); + arguments.push_back(argument); + } + // return type + if (i < resultsGroup.getResults().size()) + returnType = resultsGroup.getResults().at(i).getValueType(); + } break; case ParseeResultsGroupKind::NO_MATCH: return nullptr; case ParseeResultsGroupKind::FAILURE: - hasError = true; break; } - // arguments - if (!hasError) { - resultsGroup = parseeResultsGroupForParseeGroup( - ParseeGroup( - { - Parsee::tokenParsee(TokenKind::COLON, true, false), - Parsee::tokenParsee(TokenKind::NEW_LINE, false, false), - Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true), - Parsee::valueTypeParsee(true) - }/*, - {} - ParseeGroup( - { - Parsee::tokenParsee(TokenKind::COMMA, true, false), - Parsee::tokenParsee(TokenKind::NEW_LINE, false, false), - Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true), - Parsee::valueTypeParsee(true) - }, - {} - )*/ - ) - ); - switch (resultsGroup.getKind()) { - case ParseeResultsGroupKind::SUCCESS: - for (int i=0; i> arg; - arg.first = resultsGroup.getResults().at(i).getToken()->getLexme(); - arg.second = resultsGroup.getResults().at(i+1).getValueType(); - arguments.push_back(arg); - } - break; - case ParseeResultsGroupKind::NO_MATCH: - break; - case ParseeResultsGroupKind::FAILURE: - hasError = true; - break; - } - } - - // return type - if (!hasError) { - resultsGroup = parseeResultsGroupForParseeGroup( - ParseeGroup( - { - Parsee::tokenParsee(TokenKind::RIGHT_ARROW, true, false), - Parsee::tokenParsee(TokenKind::NEW_LINE, false, false), - Parsee::valueTypeParsee(true) - }/*, - {}*/ - ) - ); - - switch (resultsGroup.getKind()) { - case ParseeResultsGroupKind::SUCCESS: - returnType = resultsGroup.getResults().at(0).getValueType(); - break; - case ParseeResultsGroupKind::NO_MATCH: - break; - case ParseeResultsGroupKind::FAILURE: - hasError = true; - break; - } - } - - // consume new line - if (!tryMatchingTokenKinds({TokenKind::NEW_LINE}, true, true)) { - markError(TokenKind::NEW_LINE, {}); - return nullptr; - } - // block statementBlock = matchStatementBlock({TokenKind::SEMICOLON, TokenKind::END}); if (statementBlock == nullptr) @@ -340,140 +293,99 @@ shared_ptr Parser::matchStatementFunction() { return nullptr; } - return make_shared(name, arguments, returnType, dynamic_pointer_cast(statementBlock)); + return make_shared(identifier, arguments, returnType, dynamic_pointer_cast(statementBlock)); } shared_ptr Parser::matchStatementRawFunction() { - bool hasError = false; - ParseeResultsGroup resultsGroup; - - string name; + string identifier; string constraints; vector>> arguments; shared_ptr returnType = ValueType::NONE; string rawSource; - // identifier - resultsGroup = parseeResultsGroupForParseeGroup( + ParseeResultsGroup resultsGroup = parseeResultsGroupForParseeGroup( ParseeGroup( { - Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true), - Parsee::tokenParsee(TokenKind::RAW_FUNCTION, true, false) - }/*, - {}*/ + // identifier + Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true, false), + Parsee::tokenParsee(TokenKind::RAW_FUNCTION, true, false, false), + // constraints + Parsee::groupParsee( + ParseeGroup( + { + Parsee::tokenParsee(TokenKind::LESS, true, false, true), + Parsee::tokenParsee(TokenKind::STRING, true, true, true), + Parsee::tokenParsee(TokenKind::GREATER, true, false, true) + } + ), true, true, true + ), + // arguments + Parsee::groupParsee( + ParseeGroup( + { + // first argument + Parsee::tokenParsee(TokenKind::COLON, true, false, false), + Parsee::tokenParsee(TokenKind::NEW_LINE, false, false, false), + Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true, true), + Parsee::valueTypeParsee(true, true, true), + // additional arguments + Parsee::repeatedGroupParsee( + ParseeGroup( + { + Parsee::tokenParsee(TokenKind::COMMA, true, false, false), + Parsee::tokenParsee(TokenKind::NEW_LINE, false, false, false), + Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true, true), + Parsee::valueTypeParsee(true, true, true) + } + ), false, true, false + ) + } + ), false, true, false + ), + // return type + Parsee::groupParsee( + ParseeGroup( + { + Parsee::tokenParsee(TokenKind::RIGHT_ARROW, true, false, false), + Parsee::tokenParsee(TokenKind::NEW_LINE, false, false, false), + Parsee::valueTypeParsee(true, true, true) + } + ), false, true, false + ), + // new line + Parsee::tokenParsee(TokenKind::NEW_LINE, true, false, true) + } ) ); switch (resultsGroup.getKind()) { - case ParseeResultsGroupKind::SUCCESS: - name = resultsGroup.getResults().at(0).getToken()->getLexme(); + case ParseeResultsGroupKind::SUCCESS: { + int i = 0; + // identifier + identifier = resultsGroup.getResults().at(i++).getToken()->getLexme(); + // constraints + constraints = resultsGroup.getResults().at(i++).getToken()->getLexme(); + // remove enclosing quotes + if (constraints.length() >= 2) + constraints = constraints.substr(1, constraints.length() - 2); + // arguments + while (i < resultsGroup.getResults().size()-1 && resultsGroup.getResults().at(i).getKind() == ParseeResultKind::TOKEN) { + pair> argument; + argument.first = resultsGroup.getResults().at(i++).getToken()->getLexme(); + argument.second = resultsGroup.getResults().at(i++).getValueType(); + arguments.push_back(argument); + } + // return type + if (i < resultsGroup.getResults().size()) + returnType = resultsGroup.getResults().at(i).getValueType(); + } break; case ParseeResultsGroupKind::NO_MATCH: return nullptr; - break; case ParseeResultsGroupKind::FAILURE: - hasError = true; break; } - // constraints - if (!hasError) { - resultsGroup = parseeResultsGroupForParseeGroup( - ParseeGroup( - { - Parsee::tokenParsee(TokenKind::LESS, true, false), - Parsee::tokenParsee(TokenKind::STRING, true, true), - Parsee::tokenParsee(TokenKind::GREATER, true, false) - }/*, - {}*/ - ) - ); - - switch (resultsGroup.getKind()) { - case ParseeResultsGroupKind::SUCCESS: - constraints = resultsGroup.getResults().at(0).getToken()->getLexme(); - // remove enclosing quotes - if (constraints.length() >= 2) - constraints = constraints.substr(1, constraints.length() - 2); - break; - case ParseeResultsGroupKind::NO_MATCH: - return nullptr; - break; - case ParseeResultsGroupKind::FAILURE: - hasError = true; - break; - } - } - - // arguments - if (!hasError) { - resultsGroup = parseeResultsGroupForParseeGroup( - ParseeGroup( - { - Parsee::tokenParsee(TokenKind::COLON, true, false), - Parsee::tokenParsee(TokenKind::NEW_LINE, false, false), - Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true), - Parsee::valueTypeParsee(true) - }/*, - ParseeGroup( - { - Parsee::tokenParsee(TokenKind::COMMA, true, false), - Parsee::tokenParsee(TokenKind::NEW_LINE, false, false), - Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true), - Parsee::valueTypeParsee(true) - }, - {} - )*/ - ) - ); - switch (resultsGroup.getKind()) { - case ParseeResultsGroupKind::SUCCESS: - for (int i=0; i> arg; - arg.first = resultsGroup.getResults().at(i).getToken()->getLexme(); - arg.second = resultsGroup.getResults().at(i+1).getValueType(); - arguments.push_back(arg); - } - break; - case ParseeResultsGroupKind::NO_MATCH: - break; - case ParseeResultsGroupKind::FAILURE: - hasError = true; - break; - } - } - - // return type - if (!hasError) { - resultsGroup = parseeResultsGroupForParseeGroup( - ParseeGroup( - { - Parsee::tokenParsee(TokenKind::RIGHT_ARROW, true, false), - Parsee::tokenParsee(TokenKind::NEW_LINE, false, false), - Parsee::valueTypeParsee(true) - }/*, - {}*/ - ) - ); - - switch (resultsGroup.getKind()) { - case ParseeResultsGroupKind::SUCCESS: - returnType = resultsGroup.getResults().at(0).getValueType(); - break; - case ParseeResultsGroupKind::NO_MATCH: - break; - case ParseeResultsGroupKind::FAILURE: - hasError = true; - break; - } - } - - // consume new line - if (!tryMatchingTokenKinds({TokenKind::NEW_LINE}, true, true)) { - markError(TokenKind::NEW_LINE, {}); - return nullptr; - } - // source while (tryMatchingTokenKinds({TokenKind::RAW_SOURCE_LINE}, true, false)) { if (!rawSource.empty()) @@ -484,12 +396,13 @@ shared_ptr Parser::matchStatementRawFunction() { tryMatchingTokenKinds({TokenKind::NEW_LINE}, true, true); } + // closing semicolon if(!tryMatchingTokenKinds({TokenKind::SEMICOLON}, false, true)) { markError(TokenKind::SEMICOLON, {}); return nullptr; } - return make_shared(name, constraints, arguments, returnType, rawSource); + return make_shared(identifier, constraints, arguments, returnType, rawSource); } shared_ptr Parser::matchStatementBlob() { @@ -501,22 +414,19 @@ shared_ptr Parser::matchStatementBlob() { resultsGroup = parseeResultsGroupForParseeGroup( ParseeGroup( { - Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true), - Parsee::tokenParsee(TokenKind::BLOB, true, false), - Parsee::tokenParsee(TokenKind::NEW_LINE, true, false), + Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true, false), + Parsee::tokenParsee(TokenKind::BLOB, true, false, false), + Parsee::tokenParsee(TokenKind::NEW_LINE, true, false, true), Parsee::repeatedGroupParsee( ParseeGroup( { - Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true), - Parsee::valueTypeParsee(true), - Parsee::tokenParsee(TokenKind::NEW_LINE, true, false) + Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true, false), + Parsee::valueTypeParsee(true, true, true), + Parsee::tokenParsee(TokenKind::NEW_LINE, true, false, true) } - ), - false, - true, - false + ), false, true, false ), - Parsee::tokenParsee(TokenKind::SEMICOLON, true, false) + Parsee::tokenParsee(TokenKind::SEMICOLON, true, false, true) } ) ); @@ -560,71 +470,43 @@ shared_ptr Parser::matchStatementBlock(vector terminalToke } shared_ptr Parser::matchStatementAssignment() { - int startIndex = currentIndex; - ParseeResultsGroup resultsGroup; - string identifier; shared_ptr indexExpression; shared_ptr expression; - // identifier - resultsGroup = parseeResultsGroupForParseeGroup( + ParseeResultsGroup resultsGroup = parseeResultsGroupForParseeGroup( ParseeGroup( { - Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true), - }/*, - {}*/ + // identifier + Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true, false), + // index expression + Parsee::groupParsee( + ParseeGroup( + { + Parsee::tokenParsee(TokenKind::LEFT_SQUARE_BRACKET, true, false, false), + Parsee::expressionParsee(true, true, true), + Parsee::tokenParsee(TokenKind::RIGHT_SQUARE_BRACKET, true, false, true) + } + ), false, true, false + ), + // expression + Parsee::tokenParsee(TokenKind::LEFT_ARROW, true, false, false), + Parsee::expressionParsee(true, true, true) + } ) ); if (resultsGroup.getKind() != ParseeResultsGroupKind::SUCCESS) return nullptr; - identifier = resultsGroup.getResults().at(0).getToken()->getLexme(); - + int i = 0; + // identifier + identifier = resultsGroup.getResults().at(i++).getToken()->getLexme(); // index expression - resultsGroup = parseeResultsGroupForParseeGroup( - ParseeGroup( - { - Parsee::tokenParsee(TokenKind::LEFT_SQUARE_BRACKET, true, false), - Parsee::expressionParsee(true), - Parsee::tokenParsee(TokenKind::RIGHT_SQUARE_BRACKET, true, false), - }/*, - {}*/ - ) - ); - - switch (resultsGroup.getKind()) { - case ParseeResultsGroupKind::SUCCESS: - indexExpression = resultsGroup.getResults().at(0).getExpression(); - break; - case ParseeResultsGroupKind::NO_MATCH: - break; - case ParseeResultsGroupKind::FAILURE: - return nullptr; - } - + if (i < resultsGroup.getResults().size()-1) + indexExpression = resultsGroup.getResults().at(i++).getExpression(); // expression - resultsGroup = parseeResultsGroupForParseeGroup( - ParseeGroup( - { - Parsee::tokenParsee(TokenKind::LEFT_ARROW, true, false), - Parsee::expressionParsee(true) - }/*, - {}*/ - ) - ); - - switch (resultsGroup.getKind()) { - case ParseeResultsGroupKind::SUCCESS: - expression = resultsGroup.getResults().at(0).getExpression(); - break; - case ParseeResultsGroupKind::NO_MATCH: - currentIndex = startIndex; - return nullptr; - case ParseeResultsGroupKind::FAILURE: - return nullptr; - } + expression = resultsGroup.getResults().at(i).getExpression(); return make_shared(identifier, indexExpression, expression); } @@ -633,10 +515,9 @@ shared_ptr Parser::matchStatementReturn() { ParseeResultsGroup resultsGroup = parseeResultsGroupForParseeGroup( ParseeGroup( { - Parsee::tokenParsee(TokenKind::RETURN, true, false), - Parsee::expressionParsee(false) - }/*, - {}*/ + Parsee::tokenParsee(TokenKind::RETURN, true, false, false), + Parsee::expressionParsee(false, true, false) + } ) ); @@ -1024,11 +905,13 @@ ParseeResultsGroup Parser::parseeResultsGroupForParseeGroup(ParseeGroup group) { int errorsCount = errors.size(); int startIndex = currentIndex; vector parseeResults; - bool mustFulfill = false; for (Parsee &parsee : group.getParsees()) { optional, int>> subResults; switch (parsee.getKind()) { + case ParseeKind::GROUP: + subResults = groupParseeResults(*parsee.getGroup()); + break; case ParseeKind::REPEATED_GROUP: subResults = repeatedGroupParseeResults(*parsee.getRepeatedGroup()); break; @@ -1047,24 +930,20 @@ ParseeResultsGroup Parser::parseeResultsGroupForParseeGroup(ParseeGroup group) { if (errors.size() > errorsCount) return ParseeResultsGroup::failure(); - // if doesn't match on optional group - if (!subResults && parsee.getIsRequired() && !mustFulfill) { + // if doesn't match a required but non-failing parsee + if (!subResults && parsee.getIsRequired() && !parsee.getShouldFailOnNoMatch()) { currentIndex = startIndex; return ParseeResultsGroup::noMatch(); } - // return matching token? + // should return a matching result? if (subResults && parsee.getShouldReturn()) { for (ParseeResult &subResult : (*subResults).first) parseeResults.push_back(subResult); } - // decide if we're decoding the expected sequence - if (!parsee.getIsRequired() && currentIndex > startIndex) - mustFulfill = true; - // invalid sequence detected? - if (!subResults && parsee.getIsRequired() && mustFulfill) { + if (!subResults && parsee.getShouldFailOnNoMatch()) { markError(parsee.getTokenKind(), {}); return ParseeResultsGroup::failure(); } @@ -1077,6 +956,22 @@ ParseeResultsGroup Parser::parseeResultsGroupForParseeGroup(ParseeGroup group) { return ParseeResultsGroup::success(parseeResults); } +optional, int>> Parser::groupParseeResults(ParseeGroup group) { + int startIndex = currentIndex; + vector results; + + ParseeResultsGroup resultsGroup = parseeResultsGroupForParseeGroup(group); + if (resultsGroup.getKind() == ParseeResultsGroupKind::FAILURE) + return {}; + + for (ParseeResult &result : resultsGroup.getResults()) + results.push_back(result); + + int tokensCount = currentIndex - startIndex; + currentIndex = startIndex; + return pair(results, tokensCount); +} + optional, int>> Parser::repeatedGroupParseeResults(ParseeGroup group) { int startIndex = currentIndex; vector results; diff --git a/src/Parser/Parser.h b/src/Parser/Parser.h index 4d36593..5c5f176 100644 --- a/src/Parser/Parser.h +++ b/src/Parser/Parser.h @@ -57,6 +57,7 @@ private: shared_ptr matchExpressionBlock(vector terminalTokenKinds); ParseeResultsGroup parseeResultsGroupForParseeGroup(ParseeGroup group); + optional, int>> groupParseeResults(ParseeGroup group); optional, int>> repeatedGroupParseeResults(ParseeGroup group); optional, int>> tokenParseeResults(int index, TokenKind tokenKind); optional, int>> valueTypeParseeResults(int index); From 885094eef6e50c0f918ebeadde6d5133d6a26eab Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rafa=C5=82=20Grodzi=C5=84ski?= Date: Fri, 8 Aug 2025 13:11:06 +0900 Subject: [PATCH 10/14] Var without initializer --- samples/test.brc | 10 ++++------ src/Compiler/ModuleBuilder.cpp | 13 +++++++++---- src/Logger.cpp | 5 ++++- src/Parser/Parser.cpp | 12 +++++++++--- 4 files changed, 26 insertions(+), 14 deletions(-) diff --git a/samples/test.brc b/samples/test.brc index 3d1cfa0..d5b647e 100644 --- a/samples/test.brc +++ b/samples/test.brc @@ -1,19 +1,17 @@ -@extern putchar fun: character u32 -> u32 +//@extern putchar fun: character u32 -> u32 User blob num1 s32 num2 u8 ; -rawAdd raw<"=r,r,r">: num1 u32, num2 u32 -> u32 +/*rawAdd raw<"=r,r,r">: num1 u32, num2 u32 -> u32 add $1, $2 mov $0, $1 -; +;*/ main fun -> u32 - n1 u32 <- 5 - n2 u32 <- 4 - n3 u32 <- rawAdd(n1, n2) + us User ret 0 ; \ No newline at end of file diff --git a/src/Compiler/ModuleBuilder.cpp b/src/Compiler/ModuleBuilder.cpp index cb0fa73..598f78d 100644 --- a/src/Compiler/ModuleBuilder.cpp +++ b/src/Compiler/ModuleBuilder.cpp @@ -203,14 +203,19 @@ void ModuleBuilder::buildVarDeclaration(shared_ptr statement) if (!setAlloca(statement->getName(), alloca)) return; } else { - llvm::Value *value = valueForExpression(statement->getExpression()); - if (value == nullptr) - return; llvm::AllocaInst *alloca = builder->CreateAlloca(typeForValueType(statement->getValueType(), 0), nullptr, statement->getName()); if (!setAlloca(statement->getName(), alloca)) return; - builder->CreateStore(value, alloca); + + // set initial value + if (statement->getExpression() != nullptr) { + llvm::Value *value = nullptr; + value = valueForExpression(statement->getExpression()); + if (value == nullptr) + return; + builder->CreateStore(value, alloca); + } } } diff --git a/src/Logger.cpp b/src/Logger.cpp index a8559ec..5ffe5ee 100644 --- a/src/Logger.cpp +++ b/src/Logger.cpp @@ -271,7 +271,10 @@ string Logger::toString(shared_ptr statement) { } string Logger::toString(shared_ptr statement) { - return format("{}({}|{})", statement->getName(), toString(statement->getValueType()), toString(statement->getExpression())); + if (statement->getExpression() != nullptr) + return format("{}({}|{})", statement->getName(), toString(statement->getValueType()), toString(statement->getExpression())); + else + return format("{}({})", statement->getName(), toString(statement->getValueType())); } string Logger::toString(shared_ptr statement) { diff --git a/src/Parser/Parser.cpp b/src/Parser/Parser.cpp index ce3e639..05f8484 100644 --- a/src/Parser/Parser.cpp +++ b/src/Parser/Parser.cpp @@ -192,8 +192,14 @@ shared_ptr Parser::matchStatementVariable() { { Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true, false), Parsee::valueTypeParsee(true, true, false), - Parsee::tokenParsee(TokenKind::LEFT_ARROW, true, false, true), - Parsee::expressionParsee(true, true, true) + Parsee::groupParsee( + ParseeGroup( + { + Parsee::tokenParsee(TokenKind::LEFT_ARROW, true, false, false), + Parsee::expressionParsee(true, true, true) + } + ), false, true, false + ) } ) ); @@ -203,7 +209,7 @@ shared_ptr Parser::matchStatementVariable() { string identifier = resultsGroup.getResults().at(0).getToken()->getLexme(); shared_ptr valueType = resultsGroup.getResults().at(1).getValueType(); - shared_ptr expression = resultsGroup.getResults().at(2).getExpression(); + shared_ptr expression = resultsGroup.getResults().size() > 2 ? resultsGroup.getResults().at(2).getExpression() : nullptr; return make_shared(identifier, valueType, expression); } From b8d6ba9033ab80c017989d6b8e0f0bd56b3e918c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rafa=C5=82=20Grodzi=C5=84ski?= Date: Mon, 11 Aug 2025 21:29:20 +0900 Subject: [PATCH 11/14] Build struct member assignment --- samples/test.brc | 1 + src/Compiler/ModuleBuilder.cpp | 76 +++++++++++++++----- src/Compiler/ModuleBuilder.h | 6 +- src/Parser/Statement/StatementAssignment.cpp | 8 +++ src/Parser/Statement/StatementAssignment.h | 10 +++ 5 files changed, 81 insertions(+), 20 deletions(-) diff --git a/samples/test.brc b/samples/test.brc index d5b647e..2862269 100644 --- a/samples/test.brc +++ b/samples/test.brc @@ -12,6 +12,7 @@ User blob main fun -> u32 us User + us<- 5 ret 0 ; \ No newline at end of file diff --git a/src/Compiler/ModuleBuilder.cpp b/src/Compiler/ModuleBuilder.cpp index 598f78d..8c1f0f0 100644 --- a/src/Compiler/ModuleBuilder.cpp +++ b/src/Compiler/ModuleBuilder.cpp @@ -168,15 +168,17 @@ void ModuleBuilder::buildBlob(shared_ptr statement) { llvm::StructType *structType = llvm::StructType::create(*context, statement->getIdentifier()); // Generate types for body + vector memberNames; vector types; for (pair> &variable: statement->getVariables()) { + memberNames.push_back(variable.first); llvm::Type *type = typeForValueType(variable.second); if (type == nullptr) return; types.push_back(type); } structType->setBody(types, false); - if (!setStruct(statement->getIdentifier(), structType)) + if (!registerStruct(statement->getIdentifier(), structType, memberNames)) return; } @@ -226,18 +228,37 @@ void ModuleBuilder::buildAssignment(shared_ptr statement) { llvm::Value *value = valueForExpression(statement->getExpression()); - if (statement->getIndexExpression()) { - llvm::Value *indexValue = valueForExpression(statement->getIndexExpression()); - llvm::Value *index[] = { - builder->getInt32(0), - indexValue - }; - llvm::ArrayType *type = (llvm::ArrayType *)alloca->getAllocatedType(); - llvm::Value *elementPtr = builder->CreateGEP(type, alloca, index, format("{}[]", statement->getName())); + switch (statement->getAssignmentKind()) { + case StatementAssignmentKind::VARIABLE: { + builder->CreateStore(value, alloca); + break; + } + case StatementAssignmentKind::DATA: { + llvm::Value *indexValue = valueForExpression(statement->getIndexExpression()); + llvm::Value *index[] = { + builder->getInt32(0), + indexValue + }; + llvm::ArrayType *type = (llvm::ArrayType *)alloca->getAllocatedType(); + llvm::Value *elementPtr = builder->CreateGEP(type, alloca, index, format("{}[]", statement->getName())); - builder->CreateStore(value, elementPtr); - } else { - builder->CreateStore(value, alloca); + builder->CreateStore(value, elementPtr); + break; + } + case StatementAssignmentKind::BLOB: { + llvm::StructType *structType = (llvm::StructType *)alloca->getAllocatedType(); + string structName = string(structType->getName()); + optional memberIndex = getMemberIndex(structName, statement->getMemberName()); + if (!memberIndex) + return; + llvm::Value *index[] = { + builder->getInt32(0), + builder->getInt32(*memberIndex) + }; + llvm::Value *elementPtr = builder->CreateGEP(structType, alloca, index); + builder->CreateStore(value, elementPtr); + break; + } } } @@ -701,21 +722,23 @@ llvm::InlineAsm *ModuleBuilder::getRawFun(string name) { return nullptr; } -bool ModuleBuilder::setStruct(string name, llvm::StructType *structType) { - if (scopes.top().structTypeMap[name] != nullptr) { - markError(0, 0, format("Type \"{}\" already defined in scope", name)); +bool ModuleBuilder::registerStruct(string structName, llvm::StructType *structType, vector memberNames) { + if (scopes.top().structTypeMap[structName] != nullptr) { + markError(0, 0, format("Blob \"{}\" already defined in scope",structName)); return false; } - scopes.top().structTypeMap[name] = structType; + scopes.top().structTypeMap[structName] = structType; + scopes.top().structMembersMap[structName] = memberNames; + return true; } -llvm::StructType *ModuleBuilder::getStructType(string name) { +llvm::StructType *ModuleBuilder::getStructType(string structName) { stack scopes = this->scopes; while (!scopes.empty()) { - llvm::StructType *structType = scopes.top().structTypeMap[name]; + llvm::StructType *structType = scopes.top().structTypeMap[structName]; if (structType != nullptr) return structType; scopes.pop(); @@ -724,6 +747,23 @@ llvm::StructType *ModuleBuilder::getStructType(string name) { return nullptr; } +optional ModuleBuilder::getMemberIndex(string structName, string memberName) { + stack scopes = this->scopes; + + while (!scopes.empty()) { + if (scopes.top().structMembersMap.contains(structName)) { + vector memberNames = scopes.top().structMembersMap[structName]; + for (int i=0; i valueType, int count) { if (valueType == nullptr) { markError(0, 0, "Missing type"); diff --git a/src/Compiler/ModuleBuilder.h b/src/Compiler/ModuleBuilder.h index d63b0a7..dcf55b3 100644 --- a/src/Compiler/ModuleBuilder.h +++ b/src/Compiler/ModuleBuilder.h @@ -45,6 +45,7 @@ typedef struct { map funMap; map rawFunMap; map structTypeMap; + map> structMembersMap; } Scope; class ModuleBuilder { @@ -104,8 +105,9 @@ private: bool setRawFun(string name, llvm::InlineAsm *rawFun); llvm::InlineAsm *getRawFun(string name); - bool setStruct(string name, llvm::StructType *structType); - llvm::StructType *getStructType(string name); + bool registerStruct(string structName, llvm::StructType *structType, vector memberNames); + llvm::StructType *getStructType(string structName); + optional getMemberIndex(string structName, string memberName); llvm::Type *typeForValueType(shared_ptr valueType, int count = 0); diff --git a/src/Parser/Statement/StatementAssignment.cpp b/src/Parser/Statement/StatementAssignment.cpp index ae0d24f..c63e13d 100644 --- a/src/Parser/Statement/StatementAssignment.cpp +++ b/src/Parser/Statement/StatementAssignment.cpp @@ -3,6 +3,10 @@ StatementAssignment::StatementAssignment(string name, shared_ptr indexExpression, shared_ptr expression): Statement(StatementKind::ASSIGNMENT), name(name), indexExpression(indexExpression), expression(expression) { } +StatementAssignmentKind StatementAssignment::getAssignmentKind() { + return assignmentKind; +} + string StatementAssignment::getName() { return name; } @@ -13,4 +17,8 @@ shared_ptr StatementAssignment::getIndexExpression() { shared_ptr StatementAssignment::getExpression() { return expression; +} + +string StatementAssignment::getMemberName() { + return memberName; } \ No newline at end of file diff --git a/src/Parser/Statement/StatementAssignment.h b/src/Parser/Statement/StatementAssignment.h index 0bb7f63..bc541ae 100644 --- a/src/Parser/Statement/StatementAssignment.h +++ b/src/Parser/Statement/StatementAssignment.h @@ -2,15 +2,25 @@ class Expression; +enum class StatementAssignmentKind { + VARIABLE, + DATA, + BLOB +}; + class StatementAssignment: public Statement { private: + StatementAssignmentKind assignmentKind; string name; shared_ptr indexExpression; shared_ptr expression; + string memberName; public: StatementAssignment(string name, shared_ptr indexExpressio, shared_ptr expression); + StatementAssignmentKind getAssignmentKind(); string getName(); shared_ptr getIndexExpression(); shared_ptr getExpression(); + string getMemberName(); }; \ No newline at end of file From ad3c5a99f11c8f48252a7961d55ab68993085893 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rafa=C5=82=20Grodzi=C5=84ski?= Date: Mon, 11 Aug 2025 23:08:36 +0900 Subject: [PATCH 12/14] Assign struct member --- samples/test.brc | 3 +- src/Compiler/ModuleBuilder.cpp | 8 +- src/Lexer/Lexer.cpp | 5 + src/Lexer/Token.h | 1 + src/Logger.cpp | 16 +++- src/Parser/Parser.cpp | 98 +++++++++++++++----- src/Parser/Statement/StatementAssignment.cpp | 42 +++++++-- src/Parser/Statement/StatementAssignment.h | 17 ++-- 8 files changed, 141 insertions(+), 49 deletions(-) diff --git a/samples/test.brc b/samples/test.brc index 2862269..823e89e 100644 --- a/samples/test.brc +++ b/samples/test.brc @@ -12,7 +12,8 @@ User blob main fun -> u32 us User - us<- 5 + us.num1 <- 5 + us.num2 <- 4 ret 0 ; \ No newline at end of file diff --git a/src/Compiler/ModuleBuilder.cpp b/src/Compiler/ModuleBuilder.cpp index 8c1f0f0..09cae8f 100644 --- a/src/Compiler/ModuleBuilder.cpp +++ b/src/Compiler/ModuleBuilder.cpp @@ -222,11 +222,11 @@ void ModuleBuilder::buildVarDeclaration(shared_ptr statement) } void ModuleBuilder::buildAssignment(shared_ptr statement) { - llvm::AllocaInst *alloca = getAlloca(statement->getName()); + llvm::AllocaInst *alloca = getAlloca(statement->getIdentifier()); if (alloca == nullptr) return; - llvm::Value *value = valueForExpression(statement->getExpression()); + llvm::Value *value = valueForExpression(statement->getValueExpression()); switch (statement->getAssignmentKind()) { case StatementAssignmentKind::VARIABLE: { @@ -240,7 +240,7 @@ void ModuleBuilder::buildAssignment(shared_ptr statement) { indexValue }; llvm::ArrayType *type = (llvm::ArrayType *)alloca->getAllocatedType(); - llvm::Value *elementPtr = builder->CreateGEP(type, alloca, index, format("{}[]", statement->getName())); + llvm::Value *elementPtr = builder->CreateGEP(type, alloca, index, format("{}[]", statement->getIdentifier())); builder->CreateStore(value, elementPtr); break; @@ -255,7 +255,7 @@ void ModuleBuilder::buildAssignment(shared_ptr statement) { builder->getInt32(0), builder->getInt32(*memberIndex) }; - llvm::Value *elementPtr = builder->CreateGEP(structType, alloca, index); + llvm::Value *elementPtr = builder->CreateGEP(structType, alloca, index, format("{}.{}", statement->getIdentifier(), statement->getMemberName())); builder->CreateStore(value, elementPtr); break; } diff --git a/src/Lexer/Lexer.cpp b/src/Lexer/Lexer.cpp index 56fccf4..843cb4f 100644 --- a/src/Lexer/Lexer.cpp +++ b/src/Lexer/Lexer.cpp @@ -161,6 +161,10 @@ shared_ptr Lexer::nextToken() { if (token != nullptr) return token; + token = match(TokenKind::DOT, ".", false); + if (token != nullptr) + return token; + // arithmetic token = match(TokenKind::PLUS, "+", false); if (token != nullptr) @@ -573,6 +577,7 @@ bool Lexer::isSeparator(int index) { case ' ': case '\t': case '\n': + case '.': return true; default: return false; diff --git a/src/Lexer/Token.h b/src/Lexer/Token.h index 5e6ad36..e7b5b75 100644 --- a/src/Lexer/Token.h +++ b/src/Lexer/Token.h @@ -28,6 +28,7 @@ enum class TokenKind { SEMICOLON, LEFT_ARROW, RIGHT_ARROW, + DOT, FUNCTION, RAW_FUNCTION, diff --git a/src/Logger.cpp b/src/Logger.cpp index 5ffe5ee..76a3b37 100644 --- a/src/Logger.cpp +++ b/src/Logger.cpp @@ -74,6 +74,8 @@ string Logger::toString(shared_ptr token) { return "←"; case TokenKind::RIGHT_ARROW: return "→"; + case TokenKind::DOT: + return "."; case TokenKind::BOOL: return "BOOL(" + token->getLexme() + ")"; @@ -165,6 +167,8 @@ string Logger::toString(TokenKind tokenKind) { return "←"; case TokenKind::RIGHT_ARROW: return "→"; + case TokenKind::DOT: + return "."; case TokenKind::BOOL: return "LITERAL(BOOLEAN)"; @@ -329,10 +333,14 @@ string Logger::toString(shared_ptr statement) { } string Logger::toString(shared_ptr statement) { - if (statement->getIndexExpression() != nullptr) - return format("{}[{}] <- {}", statement->getName(), toString(statement->getIndexExpression()), toString(statement->getExpression())); - else - return format("{} <- {}", statement->getName(), toString(statement->getExpression())); + switch (statement->getAssignmentKind()) { + case StatementAssignmentKind::VARIABLE: + return format("{} <- {}", statement->getIdentifier(), toString(statement->getValueExpression())); + case StatementAssignmentKind::DATA: + return format("{}[{}] <- {}", statement->getIdentifier(), toString(statement->getIndexExpression()), toString(statement->getValueExpression())); + case StatementAssignmentKind::BLOB: + return format("{}.{} <- {}", statement->getIdentifier(), statement->getMemberName(), toString(statement->getValueExpression())); + } } string Logger::toString(shared_ptr statement) { diff --git a/src/Parser/Parser.cpp b/src/Parser/Parser.cpp index 05f8484..3e939dd 100644 --- a/src/Parser/Parser.cpp +++ b/src/Parser/Parser.cpp @@ -476,25 +476,14 @@ shared_ptr Parser::matchStatementBlock(vector terminalToke } shared_ptr Parser::matchStatementAssignment() { - string identifier; - shared_ptr indexExpression; - shared_ptr expression; + ParseeResultsGroup resultsGroup; - ParseeResultsGroup resultsGroup = parseeResultsGroupForParseeGroup( + // variable + resultsGroup = parseeResultsGroupForParseeGroup( ParseeGroup( { // identifier Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true, false), - // index expression - Parsee::groupParsee( - ParseeGroup( - { - Parsee::tokenParsee(TokenKind::LEFT_SQUARE_BRACKET, true, false, false), - Parsee::expressionParsee(true, true, true), - Parsee::tokenParsee(TokenKind::RIGHT_SQUARE_BRACKET, true, false, true) - } - ), false, true, false - ), // expression Parsee::tokenParsee(TokenKind::LEFT_ARROW, true, false, false), Parsee::expressionParsee(true, true, true) @@ -502,19 +491,78 @@ shared_ptr Parser::matchStatementAssignment() { ) ); - if (resultsGroup.getKind() != ParseeResultsGroupKind::SUCCESS) - return nullptr; + switch (resultsGroup.getKind()) { + case ParseeResultsGroupKind::SUCCESS: { + string identifier = resultsGroup.getResults().at(0).getToken()->getLexme(); + shared_ptr valueExpression = resultsGroup.getResults().at(1).getExpression(); + return StatementAssignment::variableAssignment(identifier, valueExpression); + } + case ParseeResultsGroupKind::NO_MATCH: + break; + case ParseeResultsGroupKind::FAILURE: + return nullptr; + } - int i = 0; - // identifier - identifier = resultsGroup.getResults().at(i++).getToken()->getLexme(); - // index expression - if (i < resultsGroup.getResults().size()-1) - indexExpression = resultsGroup.getResults().at(i++).getExpression(); - // expression - expression = resultsGroup.getResults().at(i).getExpression(); + // data + resultsGroup = parseeResultsGroupForParseeGroup( + ParseeGroup( + { + // identifier + Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true, false), + // index expression + Parsee::tokenParsee(TokenKind::LEFT_SQUARE_BRACKET, true, false, false), + Parsee::expressionParsee(true, true, true), + Parsee::tokenParsee(TokenKind::RIGHT_SQUARE_BRACKET, true, false, true), + // expression + Parsee::tokenParsee(TokenKind::LEFT_ARROW, true, false, false), + Parsee::expressionParsee(true, true, true) + } + ) + ); - return make_shared(identifier, indexExpression, expression); + switch (resultsGroup.getKind()) { + case ParseeResultsGroupKind::SUCCESS: { + string identifier = resultsGroup.getResults().at(0).getToken()->getLexme(); + shared_ptr indexExpression = indexExpression = resultsGroup.getResults().at(1).getExpression(); + shared_ptr valueExpression = resultsGroup.getResults().at(2).getExpression(); + return StatementAssignment::dataAssignment(identifier, indexExpression, valueExpression); + } + case ParseeResultsGroupKind::NO_MATCH: + break; + case ParseeResultsGroupKind::FAILURE: + return nullptr; + } + + // blob + resultsGroup = parseeResultsGroupForParseeGroup( + ParseeGroup( + { + // identifier + Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true, false), + // member name + Parsee::tokenParsee(TokenKind::DOT, true, false, false), + Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true, true), + // expression + Parsee::tokenParsee(TokenKind::LEFT_ARROW, true, false, false), + Parsee::expressionParsee(true, true, true) + } + ) + ); + + switch (resultsGroup.getKind()) { + case ParseeResultsGroupKind::SUCCESS: { + string identifier = resultsGroup.getResults().at(0).getToken()->getLexme(); + string memberName = resultsGroup.getResults().at(1).getToken()->getLexme(); + shared_ptr valueExpression = resultsGroup.getResults().at(2).getExpression(); + return StatementAssignment::blobAssignment(identifier, memberName, valueExpression); + } + case ParseeResultsGroupKind::NO_MATCH: + break; + case ParseeResultsGroupKind::FAILURE: + return nullptr; + } + + return nullptr; } shared_ptr Parser::matchStatementReturn() { diff --git a/src/Parser/Statement/StatementAssignment.cpp b/src/Parser/Statement/StatementAssignment.cpp index c63e13d..51722a7 100644 --- a/src/Parser/Statement/StatementAssignment.cpp +++ b/src/Parser/Statement/StatementAssignment.cpp @@ -1,24 +1,50 @@ #include "StatementAssignment.h" -StatementAssignment::StatementAssignment(string name, shared_ptr indexExpression, shared_ptr expression): -Statement(StatementKind::ASSIGNMENT), name(name), indexExpression(indexExpression), expression(expression) { } +StatementAssignment::StatementAssignment(): +Statement(StatementKind::ASSIGNMENT) { } + +shared_ptr StatementAssignment::variableAssignment(string identifier, shared_ptr valueExpression) { + shared_ptr statement = make_shared(); + statement->assignmentKind = StatementAssignmentKind::VARIABLE; + statement->identifier = identifier; + statement->valueExpression = valueExpression; + return statement; +} + +shared_ptr StatementAssignment::dataAssignment(string identifier, shared_ptr indexExpression, shared_ptr valueExpression) { + shared_ptr statement = make_shared(); + statement->assignmentKind = StatementAssignmentKind::DATA; + statement->identifier = identifier; + statement->indexExpression = indexExpression; + statement->valueExpression = valueExpression; + return statement; +} + +shared_ptr StatementAssignment::blobAssignment(string identifier, string memberName, shared_ptr valueExpression) { + shared_ptr statement = make_shared(); + statement->assignmentKind = StatementAssignmentKind::BLOB; + statement->identifier = identifier; + statement->memberName = memberName; + statement->valueExpression = valueExpression; + return statement; +} StatementAssignmentKind StatementAssignment::getAssignmentKind() { return assignmentKind; } -string StatementAssignment::getName() { - return name; +string StatementAssignment::getIdentifier() { + return identifier; } shared_ptr StatementAssignment::getIndexExpression() { return indexExpression; } -shared_ptr StatementAssignment::getExpression() { - return expression; -} - string StatementAssignment::getMemberName() { return memberName; +} + +shared_ptr StatementAssignment::getValueExpression() { + return valueExpression; } \ No newline at end of file diff --git a/src/Parser/Statement/StatementAssignment.h b/src/Parser/Statement/StatementAssignment.h index bc541ae..2d5892c 100644 --- a/src/Parser/Statement/StatementAssignment.h +++ b/src/Parser/Statement/StatementAssignment.h @@ -11,16 +11,19 @@ enum class StatementAssignmentKind { class StatementAssignment: public Statement { private: StatementAssignmentKind assignmentKind; - string name; + string identifier; shared_ptr indexExpression; - shared_ptr expression; string memberName; - -public: - StatementAssignment(string name, shared_ptr indexExpressio, shared_ptr expression); + shared_ptr valueExpression; + + public: + StatementAssignment(); + static shared_ptr variableAssignment(string identifier, shared_ptr expression); + static shared_ptr dataAssignment(string identifier, shared_ptr indexExpression, shared_ptr valueExpression); + static shared_ptr blobAssignment(string identifier, string memberName, shared_ptr valueExpression); StatementAssignmentKind getAssignmentKind(); - string getName(); + string getIdentifier(); shared_ptr getIndexExpression(); - shared_ptr getExpression(); string getMemberName(); + shared_ptr getValueExpression(); }; \ No newline at end of file From d159b81c465f81b9e738598a6755c878f08f2cb1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rafa=C5=82=20Grodzi=C5=84ski?= Date: Tue, 12 Aug 2025 13:01:48 +0900 Subject: [PATCH 13/14] Read member --- samples/test.brc | 2 + src/Compiler/ModuleBuilder.cpp | 46 ++++++---- src/Compiler/ModuleBuilder.h | 2 +- src/Logger.cpp | 13 +-- src/Parser/Expression/ExpressionVariable.cpp | 39 ++++++++- src/Parser/Expression/ExpressionVariable.h | 20 ++++- src/Parser/Parser.cpp | 88 ++++++++++++++++---- src/Parser/Statement/StatementAssignment.h | 4 +- 8 files changed, 170 insertions(+), 44 deletions(-) diff --git a/samples/test.brc b/samples/test.brc index 823e89e..7e1eaf1 100644 --- a/samples/test.brc +++ b/samples/test.brc @@ -15,5 +15,7 @@ main fun -> u32 us.num1 <- 5 us.num2 <- 4 + num3 s32 <- us.num1 + 13 + ret 0 ; \ No newline at end of file diff --git a/src/Compiler/ModuleBuilder.cpp b/src/Compiler/ModuleBuilder.cpp index 09cae8f..2074995 100644 --- a/src/Compiler/ModuleBuilder.cpp +++ b/src/Compiler/ModuleBuilder.cpp @@ -365,7 +365,7 @@ llvm::Value *ModuleBuilder::valueForExpression(shared_ptr expression case ExpressionKind::IF_ELSE: return valueForIfElse(dynamic_pointer_cast(expression)); case ExpressionKind::VAR: - return valueForVar(dynamic_pointer_cast(expression)); + return valueForVariable(dynamic_pointer_cast(expression)); case ExpressionKind::CALL: return valueForCall(dynamic_pointer_cast(expression)); default: @@ -435,6 +435,8 @@ llvm::Value *ModuleBuilder::valueForBinary(shared_ptr expressi return valueForBinarySignedInteger(expression->getOperation(), leftValue, rightValue); } else if (type == typeR32) { return valueForBinaryReal(expression->getOperation(), leftValue, rightValue); + } else { // FIXME (we have missing value types) + return valueForBinarySignedInteger(expression->getOperation(), leftValue, rightValue); } markError(0, 0, "Unexpected operation"); @@ -606,23 +608,39 @@ llvm::Value *ModuleBuilder::valueForIfElse(shared_ptr expressi } } -llvm::Value *ModuleBuilder::valueForVar(shared_ptr expression) { - llvm::AllocaInst *alloca = getAlloca(expression->getName()); +llvm::Value *ModuleBuilder::valueForVariable(shared_ptr expression) { + llvm::AllocaInst *alloca = getAlloca(expression->getIdentifier()); if (alloca == nullptr) return nullptr; - if (expression->getIndexExpression()) { - llvm::Value *indexValue = valueForExpression(expression->getIndexExpression()); - llvm::Value *index[] = { - builder->getInt32(0), - indexValue - }; - llvm::ArrayType *type = (llvm::ArrayType *)alloca->getAllocatedType(); - llvm::Value *elementPtr = builder->CreateGEP(type, alloca, index, format("{}[]", expression->getName())); + switch (expression->getVariableKind()) { + case ExpressionVariableKind::SIMPLE: { + return builder->CreateLoad(alloca->getAllocatedType(), alloca, expression->getIdentifier()); + } + case ExpressionVariableKind::DATA: { + llvm::Value *indexValue = valueForExpression(expression->getIndexExpression()); + llvm::Value *index[] = { + builder->getInt32(0), + indexValue + }; + llvm::ArrayType *type = (llvm::ArrayType *)alloca->getAllocatedType(); + llvm::Value *elementPtr = builder->CreateGEP(type, alloca, index, format("{}[]", expression->getIdentifier())); - return builder->CreateLoad(type->getArrayElementType(), elementPtr); - } else { - return builder->CreateLoad(alloca->getAllocatedType(), alloca, expression->getName()); + return builder->CreateLoad(type->getArrayElementType(), elementPtr); + } + case ExpressionVariableKind::BLOB: { + llvm::StructType *structType = (llvm::StructType *)alloca->getAllocatedType(); + string structName = string(structType->getName()); + optional memberIndex = getMemberIndex(structName, expression->getMemberName()); + if (!memberIndex) + return nullptr; + llvm::Value *index[] = { + builder->getInt32(0), + builder->getInt32(*memberIndex) + }; + llvm::Value *elementPtr = builder->CreateGEP(structType, alloca, index, format("{}.{}", expression->getIdentifier(), expression->getMemberName())); + return builder->CreateLoad(structType->getElementType(*memberIndex), elementPtr); + } } } diff --git a/src/Compiler/ModuleBuilder.h b/src/Compiler/ModuleBuilder.h index dcf55b3..43d3eb7 100644 --- a/src/Compiler/ModuleBuilder.h +++ b/src/Compiler/ModuleBuilder.h @@ -93,7 +93,7 @@ private: llvm::Value *valueForBinaryReal(ExpressionBinaryOperation operation, llvm::Value *leftValue, llvm::Value *rightValue); llvm::Value *valueForUnary(shared_ptr expression); llvm::Value *valueForIfElse(shared_ptr expression); - llvm::Value *valueForVar(shared_ptr expression); + llvm::Value *valueForVariable(shared_ptr expression); llvm::Value *valueForCall(shared_ptr expression); bool setAlloca(string name, llvm::AllocaInst *alloca); diff --git a/src/Logger.cpp b/src/Logger.cpp index 76a3b37..3e5aeeb 100644 --- a/src/Logger.cpp +++ b/src/Logger.cpp @@ -454,11 +454,14 @@ string Logger::toString(shared_ptr expression) { } string Logger::toString(shared_ptr expression) { - string text = format("VAR({}", expression->getName()); - if (expression->getIndexExpression() != nullptr) - text += format("|{}", toString(expression->getIndexExpression())); - text += ")"; - return text; + switch (expression->getVariableKind()) { + case ExpressionVariableKind::SIMPLE: + return format("VAR({})", expression->getIdentifier()); + case ExpressionVariableKind::DATA: + return format("VAR({}|{})", expression->getIdentifier(), toString(expression->getIndexExpression())); + case ExpressionVariableKind::BLOB: + return format("VAR({}.{})", expression->getIdentifier(), expression->getMemberName()); + } } string Logger::toString(shared_ptr expression) { diff --git a/src/Parser/Expression/ExpressionVariable.cpp b/src/Parser/Expression/ExpressionVariable.cpp index 61a03e2..6bb7423 100644 --- a/src/Parser/Expression/ExpressionVariable.cpp +++ b/src/Parser/Expression/ExpressionVariable.cpp @@ -1,12 +1,43 @@ #include "ExpressionVariable.h" -ExpressionVariable::ExpressionVariable(string name, shared_ptr indexExpression): -Expression(ExpressionKind::VAR, nullptr), name(name), indexExpression(indexExpression) { } +shared_ptr ExpressionVariable::simpleVariable(string identifier) { + shared_ptr expression = make_shared(); + expression->variableKind = ExpressionVariableKind::SIMPLE; + expression->identifier = identifier; + return expression; +} -string ExpressionVariable::getName() { - return name; +shared_ptr ExpressionVariable::dataVariable(string identifier, shared_ptr indexExpression) { + shared_ptr expression = make_shared(); + expression->variableKind = ExpressionVariableKind::DATA; + expression->identifier = identifier; + expression->indexExpression = indexExpression; + return expression; +} + +shared_ptr ExpressionVariable::blobVariable(string identifier, string memberName) { + shared_ptr expression = make_shared(); + expression->variableKind = ExpressionVariableKind::BLOB; + expression->identifier = identifier; + expression->memberName = memberName; + return expression; +} + +ExpressionVariable::ExpressionVariable(): +Expression(ExpressionKind::VAR, nullptr) { } + +ExpressionVariableKind ExpressionVariable::getVariableKind() { + return variableKind; +} + +string ExpressionVariable::getIdentifier() { + return identifier; } shared_ptr ExpressionVariable::getIndexExpression() { return indexExpression; } + +string ExpressionVariable::getMemberName() { + return memberName; +} \ No newline at end of file diff --git a/src/Parser/Expression/ExpressionVariable.h b/src/Parser/Expression/ExpressionVariable.h index 5835d9a..7a1f255 100644 --- a/src/Parser/Expression/ExpressionVariable.h +++ b/src/Parser/Expression/ExpressionVariable.h @@ -1,12 +1,26 @@ #include "Parser/Expression/Expression.h" +enum class ExpressionVariableKind { + SIMPLE, + DATA, + BLOB +}; + class ExpressionVariable: public Expression { private: - string name; + ExpressionVariableKind variableKind; + string identifier; shared_ptr indexExpression; + string memberName; public: - ExpressionVariable(string name, shared_ptr indexExpression); - string getName(); + static shared_ptr simpleVariable(string identifer); + static shared_ptr dataVariable(string identifier, shared_ptr indexExpression); + static shared_ptr blobVariable(string identifier, string memberName); + + ExpressionVariable(); + ExpressionVariableKind getVariableKind(); + string getIdentifier(); shared_ptr getIndexExpression(); + string getMemberName(); }; \ No newline at end of file diff --git a/src/Parser/Parser.cpp b/src/Parser/Parser.cpp index 3e939dd..f67480e 100644 --- a/src/Parser/Parser.cpp +++ b/src/Parser/Parser.cpp @@ -478,7 +478,7 @@ shared_ptr Parser::matchStatementBlock(vector terminalToke shared_ptr Parser::matchStatementAssignment() { ParseeResultsGroup resultsGroup; - // variable + // simple resultsGroup = parseeResultsGroupForParseeGroup( ParseeGroup( { @@ -523,7 +523,7 @@ shared_ptr Parser::matchStatementAssignment() { switch (resultsGroup.getKind()) { case ParseeResultsGroupKind::SUCCESS: { string identifier = resultsGroup.getResults().at(0).getToken()->getLexme(); - shared_ptr indexExpression = indexExpression = resultsGroup.getResults().at(1).getExpression(); + shared_ptr indexExpression = resultsGroup.getResults().at(1).getExpression(); shared_ptr valueExpression = resultsGroup.getResults().at(2).getExpression(); return StatementAssignment::dataAssignment(identifier, indexExpression, valueExpression); } @@ -813,23 +813,81 @@ shared_ptr Parser::matchExpressionArrayLiteral() { } shared_ptr Parser::matchExpressionVariable() { - if (!tryMatchingTokenKinds({TokenKind::IDENTIFIER}, true, false)) - return nullptr; - shared_ptr idToken = tokens.at(currentIndex++); - shared_ptr indexExpression; + ParseeResultsGroup resultsGroup; - if (tryMatchingTokenKinds({TokenKind::LEFT_SQUARE_BRACKET}, true, true)) { - indexExpression = nextExpression(); - if (indexExpression == nullptr) - return nullptr; + // data + resultsGroup = parseeResultsGroupForParseeGroup( + ParseeGroup( + { + // identifier + Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true, false), + // index expression + Parsee::tokenParsee(TokenKind::LEFT_SQUARE_BRACKET, true, false, false), + Parsee::expressionParsee(true, true, true), + Parsee::tokenParsee(TokenKind::RIGHT_SQUARE_BRACKET, true, false, true) + } + ) + ); - if (!tryMatchingTokenKinds({TokenKind::RIGHT_SQUARE_BRACKET}, true, true)) { - markError(TokenKind::RIGHT_SQUARE_BRACKET, {}); - return nullptr; + switch (resultsGroup.getKind()) { + case ParseeResultsGroupKind::SUCCESS: { + string identifier = resultsGroup.getResults().at(0).getToken()->getLexme(); + shared_ptr indexExpression = indexExpression = resultsGroup.getResults().at(1).getExpression(); + return ExpressionVariable::dataVariable(identifier, indexExpression); } + case ParseeResultsGroupKind::NO_MATCH: + break; + case ParseeResultsGroupKind::FAILURE: + return nullptr; } - - return make_shared(idToken->getLexme(), indexExpression); + + // blob + resultsGroup = parseeResultsGroupForParseeGroup( + ParseeGroup( + { + // identifier + Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true, false), + // member name + Parsee::tokenParsee(TokenKind::DOT, true, false, false), + Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true, true) + } + ) + ); + + switch (resultsGroup.getKind()) { + case ParseeResultsGroupKind::SUCCESS: { + string identifier = resultsGroup.getResults().at(0).getToken()->getLexme(); + string memberName = resultsGroup.getResults().at(1).getToken()->getLexme(); + return ExpressionVariable::blobVariable(identifier, memberName); + } + case ParseeResultsGroupKind::NO_MATCH: + break; + case ParseeResultsGroupKind::FAILURE: + return nullptr; + } + + // simple + resultsGroup = parseeResultsGroupForParseeGroup( + ParseeGroup( + { + // identifier + Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true, false) + } + ) + ); + + switch (resultsGroup.getKind()) { + case ParseeResultsGroupKind::SUCCESS: { + string identifier = resultsGroup.getResults().at(0).getToken()->getLexme(); + return ExpressionVariable::simpleVariable(identifier); + } + case ParseeResultsGroupKind::NO_MATCH: + break; + case ParseeResultsGroupKind::FAILURE: + return nullptr; + } + + return nullptr; } shared_ptr Parser::matchExpressionCall() { diff --git a/src/Parser/Statement/StatementAssignment.h b/src/Parser/Statement/StatementAssignment.h index 2d5892c..110ee4c 100644 --- a/src/Parser/Statement/StatementAssignment.h +++ b/src/Parser/Statement/StatementAssignment.h @@ -16,9 +16,9 @@ private: string memberName; shared_ptr valueExpression; - public: +public: StatementAssignment(); - static shared_ptr variableAssignment(string identifier, shared_ptr expression); + static shared_ptr variableAssignment(string identifier, shared_ptr valueExpression); static shared_ptr dataAssignment(string identifier, shared_ptr indexExpression, shared_ptr valueExpression); static shared_ptr blobAssignment(string identifier, string memberName, shared_ptr valueExpression); StatementAssignmentKind getAssignmentKind(); From c0188e16bcd92eeedcbeb01d36f2ff95781db7a0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rafa=C5=82=20Grodzi=C5=84ski?= Date: Tue, 12 Aug 2025 13:11:34 +0900 Subject: [PATCH 14/14] Changed naming --- src/Compiler/ModuleBuilder.cpp | 4 ++-- src/Logger.cpp | 4 ++-- src/Parser/Expression/Expression.h | 2 +- src/Parser/Expression/ExpressionVariable.cpp | 8 ++++---- src/Parser/Expression/ExpressionVariable.h | 6 +++--- src/Parser/Parser.cpp | 14 +++++++------- src/Parser/Statement/StatementAssignment.cpp | 14 +++++++------- src/Parser/Statement/StatementAssignment.h | 9 +++++---- 8 files changed, 31 insertions(+), 30 deletions(-) diff --git a/src/Compiler/ModuleBuilder.cpp b/src/Compiler/ModuleBuilder.cpp index 2074995..723671e 100644 --- a/src/Compiler/ModuleBuilder.cpp +++ b/src/Compiler/ModuleBuilder.cpp @@ -229,7 +229,7 @@ void ModuleBuilder::buildAssignment(shared_ptr statement) { llvm::Value *value = valueForExpression(statement->getValueExpression()); switch (statement->getAssignmentKind()) { - case StatementAssignmentKind::VARIABLE: { + case StatementAssignmentKind::SIMPLE: { builder->CreateStore(value, alloca); break; } @@ -364,7 +364,7 @@ llvm::Value *ModuleBuilder::valueForExpression(shared_ptr expression return valueForUnary(dynamic_pointer_cast(expression)); case ExpressionKind::IF_ELSE: return valueForIfElse(dynamic_pointer_cast(expression)); - case ExpressionKind::VAR: + case ExpressionKind::VARIABLE: return valueForVariable(dynamic_pointer_cast(expression)); case ExpressionKind::CALL: return valueForCall(dynamic_pointer_cast(expression)); diff --git a/src/Logger.cpp b/src/Logger.cpp index 3e5aeeb..196f552 100644 --- a/src/Logger.cpp +++ b/src/Logger.cpp @@ -334,7 +334,7 @@ string Logger::toString(shared_ptr statement) { string Logger::toString(shared_ptr statement) { switch (statement->getAssignmentKind()) { - case StatementAssignmentKind::VARIABLE: + case StatementAssignmentKind::SIMPLE: return format("{} <- {}", statement->getIdentifier(), toString(statement->getValueExpression())); case StatementAssignmentKind::DATA: return format("{}[{}] <- {}", statement->getIdentifier(), toString(statement->getIndexExpression()), toString(statement->getValueExpression())); @@ -384,7 +384,7 @@ string Logger::toString(shared_ptr expression) { return toString(dynamic_pointer_cast(expression)); case ExpressionKind::IF_ELSE: return toString(dynamic_pointer_cast(expression)); - case ExpressionKind::VAR: + case ExpressionKind::VARIABLE: return toString(dynamic_pointer_cast(expression)); case ExpressionKind::GROUPING: return toString(dynamic_pointer_cast(expression)); diff --git a/src/Parser/Expression/Expression.h b/src/Parser/Expression/Expression.h index a335052..9fc4f46 100644 --- a/src/Parser/Expression/Expression.h +++ b/src/Parser/Expression/Expression.h @@ -15,7 +15,7 @@ enum class ExpressionKind { UNARY, BINARY, IF_ELSE, - VAR, + VARIABLE, CALL, BLOCK }; diff --git a/src/Parser/Expression/ExpressionVariable.cpp b/src/Parser/Expression/ExpressionVariable.cpp index 6bb7423..242fa89 100644 --- a/src/Parser/Expression/ExpressionVariable.cpp +++ b/src/Parser/Expression/ExpressionVariable.cpp @@ -1,13 +1,13 @@ #include "ExpressionVariable.h" -shared_ptr ExpressionVariable::simpleVariable(string identifier) { +shared_ptr ExpressionVariable::simple(string identifier) { shared_ptr expression = make_shared(); expression->variableKind = ExpressionVariableKind::SIMPLE; expression->identifier = identifier; return expression; } -shared_ptr ExpressionVariable::dataVariable(string identifier, shared_ptr indexExpression) { +shared_ptr ExpressionVariable::data(string identifier, shared_ptr indexExpression) { shared_ptr expression = make_shared(); expression->variableKind = ExpressionVariableKind::DATA; expression->identifier = identifier; @@ -15,7 +15,7 @@ shared_ptr ExpressionVariable::dataVariable(string identifie return expression; } -shared_ptr ExpressionVariable::blobVariable(string identifier, string memberName) { +shared_ptr ExpressionVariable::blob(string identifier, string memberName) { shared_ptr expression = make_shared(); expression->variableKind = ExpressionVariableKind::BLOB; expression->identifier = identifier; @@ -24,7 +24,7 @@ shared_ptr ExpressionVariable::blobVariable(string identifie } ExpressionVariable::ExpressionVariable(): -Expression(ExpressionKind::VAR, nullptr) { } +Expression(ExpressionKind::VARIABLE, nullptr) { } ExpressionVariableKind ExpressionVariable::getVariableKind() { return variableKind; diff --git a/src/Parser/Expression/ExpressionVariable.h b/src/Parser/Expression/ExpressionVariable.h index 7a1f255..99c9868 100644 --- a/src/Parser/Expression/ExpressionVariable.h +++ b/src/Parser/Expression/ExpressionVariable.h @@ -14,9 +14,9 @@ private: string memberName; public: - static shared_ptr simpleVariable(string identifer); - static shared_ptr dataVariable(string identifier, shared_ptr indexExpression); - static shared_ptr blobVariable(string identifier, string memberName); + static shared_ptr simple(string identifer); + static shared_ptr data(string identifier, shared_ptr indexExpression); + static shared_ptr blob(string identifier, string memberName); ExpressionVariable(); ExpressionVariableKind getVariableKind(); diff --git a/src/Parser/Parser.cpp b/src/Parser/Parser.cpp index f67480e..2720985 100644 --- a/src/Parser/Parser.cpp +++ b/src/Parser/Parser.cpp @@ -495,7 +495,7 @@ shared_ptr Parser::matchStatementAssignment() { case ParseeResultsGroupKind::SUCCESS: { string identifier = resultsGroup.getResults().at(0).getToken()->getLexme(); shared_ptr valueExpression = resultsGroup.getResults().at(1).getExpression(); - return StatementAssignment::variableAssignment(identifier, valueExpression); + return StatementAssignment::simple(identifier, valueExpression); } case ParseeResultsGroupKind::NO_MATCH: break; @@ -525,7 +525,7 @@ shared_ptr Parser::matchStatementAssignment() { string identifier = resultsGroup.getResults().at(0).getToken()->getLexme(); shared_ptr indexExpression = resultsGroup.getResults().at(1).getExpression(); shared_ptr valueExpression = resultsGroup.getResults().at(2).getExpression(); - return StatementAssignment::dataAssignment(identifier, indexExpression, valueExpression); + return StatementAssignment::data(identifier, indexExpression, valueExpression); } case ParseeResultsGroupKind::NO_MATCH: break; @@ -554,7 +554,7 @@ shared_ptr Parser::matchStatementAssignment() { string identifier = resultsGroup.getResults().at(0).getToken()->getLexme(); string memberName = resultsGroup.getResults().at(1).getToken()->getLexme(); shared_ptr valueExpression = resultsGroup.getResults().at(2).getExpression(); - return StatementAssignment::blobAssignment(identifier, memberName, valueExpression); + return StatementAssignment::blob(identifier, memberName, valueExpression); } case ParseeResultsGroupKind::NO_MATCH: break; @@ -832,8 +832,8 @@ shared_ptr Parser::matchExpressionVariable() { switch (resultsGroup.getKind()) { case ParseeResultsGroupKind::SUCCESS: { string identifier = resultsGroup.getResults().at(0).getToken()->getLexme(); - shared_ptr indexExpression = indexExpression = resultsGroup.getResults().at(1).getExpression(); - return ExpressionVariable::dataVariable(identifier, indexExpression); + shared_ptr indexExpression = resultsGroup.getResults().at(1).getExpression(); + return ExpressionVariable::data(identifier, indexExpression); } case ParseeResultsGroupKind::NO_MATCH: break; @@ -858,7 +858,7 @@ shared_ptr Parser::matchExpressionVariable() { case ParseeResultsGroupKind::SUCCESS: { string identifier = resultsGroup.getResults().at(0).getToken()->getLexme(); string memberName = resultsGroup.getResults().at(1).getToken()->getLexme(); - return ExpressionVariable::blobVariable(identifier, memberName); + return ExpressionVariable::blob(identifier, memberName); } case ParseeResultsGroupKind::NO_MATCH: break; @@ -879,7 +879,7 @@ shared_ptr Parser::matchExpressionVariable() { switch (resultsGroup.getKind()) { case ParseeResultsGroupKind::SUCCESS: { string identifier = resultsGroup.getResults().at(0).getToken()->getLexme(); - return ExpressionVariable::simpleVariable(identifier); + return ExpressionVariable::simple(identifier); } case ParseeResultsGroupKind::NO_MATCH: break; diff --git a/src/Parser/Statement/StatementAssignment.cpp b/src/Parser/Statement/StatementAssignment.cpp index 51722a7..5dfeee0 100644 --- a/src/Parser/Statement/StatementAssignment.cpp +++ b/src/Parser/Statement/StatementAssignment.cpp @@ -1,17 +1,14 @@ #include "StatementAssignment.h" -StatementAssignment::StatementAssignment(): -Statement(StatementKind::ASSIGNMENT) { } - -shared_ptr StatementAssignment::variableAssignment(string identifier, shared_ptr valueExpression) { +shared_ptr StatementAssignment::simple(string identifier, shared_ptr valueExpression) { shared_ptr statement = make_shared(); - statement->assignmentKind = StatementAssignmentKind::VARIABLE; + statement->assignmentKind = StatementAssignmentKind::SIMPLE; statement->identifier = identifier; statement->valueExpression = valueExpression; return statement; } -shared_ptr StatementAssignment::dataAssignment(string identifier, shared_ptr indexExpression, shared_ptr valueExpression) { +shared_ptr StatementAssignment::data(string identifier, shared_ptr indexExpression, shared_ptr valueExpression) { shared_ptr statement = make_shared(); statement->assignmentKind = StatementAssignmentKind::DATA; statement->identifier = identifier; @@ -20,7 +17,7 @@ shared_ptr StatementAssignment::dataAssignment(string ident return statement; } -shared_ptr StatementAssignment::blobAssignment(string identifier, string memberName, shared_ptr valueExpression) { +shared_ptr StatementAssignment::blob(string identifier, string memberName, shared_ptr valueExpression) { shared_ptr statement = make_shared(); statement->assignmentKind = StatementAssignmentKind::BLOB; statement->identifier = identifier; @@ -29,6 +26,9 @@ shared_ptr StatementAssignment::blobAssignment(string ident return statement; } +StatementAssignment::StatementAssignment(): +Statement(StatementKind::ASSIGNMENT) { } + StatementAssignmentKind StatementAssignment::getAssignmentKind() { return assignmentKind; } diff --git a/src/Parser/Statement/StatementAssignment.h b/src/Parser/Statement/StatementAssignment.h index 110ee4c..9b639ca 100644 --- a/src/Parser/Statement/StatementAssignment.h +++ b/src/Parser/Statement/StatementAssignment.h @@ -3,7 +3,7 @@ class Expression; enum class StatementAssignmentKind { - VARIABLE, + SIMPLE, DATA, BLOB }; @@ -17,10 +17,11 @@ private: shared_ptr valueExpression; public: + static shared_ptr simple(string identifier, shared_ptr valueExpression); + static shared_ptr data(string identifier, shared_ptr indexExpression, shared_ptr valueExpression); + static shared_ptr blob(string identifier, string memberName, shared_ptr valueExpression); + StatementAssignment(); - static shared_ptr variableAssignment(string identifier, shared_ptr valueExpression); - static shared_ptr dataAssignment(string identifier, shared_ptr indexExpression, shared_ptr valueExpression); - static shared_ptr blobAssignment(string identifier, string memberName, shared_ptr valueExpression); StatementAssignmentKind getAssignmentKind(); string getIdentifier(); shared_ptr getIndexExpression();