From f5068fe861bd05ca6a84ea35a7b453e138e903d5 Mon Sep 17 00:00:00 2001 From: Maxwell Jeffress Date: Thu, 26 Feb 2026 11:46:29 +1100 Subject: [PATCH] Add stuff --- src/codegen/SolsScope.h | 1 + src/codegen/codegen.c | 65 +++++++++++++++++++++++++++++++++++++++++ src/main.c | 3 +- src/parser/parser.c | 64 ++++++++++++++++++++++++++++++++++++++++ test.sols | 2 +- 5 files changed, 133 insertions(+), 2 deletions(-) diff --git a/src/codegen/SolsScope.h b/src/codegen/SolsScope.h index 764e469..0fd2eeb 100644 --- a/src/codegen/SolsScope.h +++ b/src/codegen/SolsScope.h @@ -13,6 +13,7 @@ typedef struct SolsVariable { typedef struct SolsScope { SolsVariable* variables; + size_t tmpCounter; } SolsScope; // Adds a variable to the SolsScope. diff --git a/src/codegen/codegen.c b/src/codegen/codegen.c index 02ad544..0f9fed3 100644 --- a/src/codegen/codegen.c +++ b/src/codegen/codegen.c @@ -30,6 +30,40 @@ ResultType(SolsType, charptr) getNodeType(SolsNode* node, SolsScope* scope) { } return Success(SolsType, charptr, type.as.success); } + case SNT_OP_ADD: { + if (node->children.count < 2) { + return Error(SolsType, charptr, "Not enough children to determine type"); + } + + ResultType(SolsType, charptr) leftType = getNodeType(&node->children.at[0], scope); + if (leftType.error) { + return Error(SolsType, charptr, leftType.as.error); + } + ResultType(SolsType, charptr) rightType = getNodeType(&node->children.at[1], scope); + if (rightType.error) { + return Error(SolsType, charptr, rightType.as.error); + } + + if (!(leftType.as.success.type == STT_INT || leftType.as.success.type == STT_DOUBLE || leftType.as.success.type == STT_STRING)) { + return Error(SolsType, charptr, "Cannot add left type"); + } + if (!(rightType.as.success.type == STT_INT || rightType.as.success.type == STT_DOUBLE || rightType.as.success.type == STT_STRING)) { + return Error(SolsType, charptr, "Cannot add right type"); + } + + if (leftType.as.success.type == rightType.as.success.type) { + return Success(SolsType, charptr, leftType.as.success); + } + + if ((leftType.as.success.type == STT_INT && rightType.as.success.type == STT_DOUBLE) || (leftType.as.success.type == STT_DOUBLE && rightType.as.success.type == STT_INT)) { + ResultType(SolsType, charptr) type = createSolsType(STT_DOUBLE); + if (type.error) { + return Error(SolsType, charptr, type.as.error); + } + return Success(SolsType, charptr, type.as.success); + } + return Error(SolsType, charptr, "Cannot add these types together"); + } case SNT_LITERAL: { switch (node->as.literal.type) { case SLT_INT: { @@ -115,6 +149,36 @@ static inline ResultType(GroundProgram, charptr) generateSetNode(SolsNode* node, return Success(GroundProgram, charptr, gp); } +static inline ResultType(GroundProgram, charptr) generateAddNode(SolsNode* node, SolsScope* scope) { + if (node->children.count < 2) { + return Error(GroundProgram, charptr, "add requires arguments"); + } + + // Use this function for type checking + ResultType(SolsType, charptr) type = getNodeType(node, scope); + if (type.error) { + return Error(GroundProgram, charptr, type.as.error); + } + + GroundProgram gp = groundCreateProgram(); + GroundInstruction add = groundCreateInstruction(ADD); + groundAddReferenceToInstruction(&add, node->children.at[0].accessArg); + groundAddReferenceToInstruction(&add, node->children.at[1].accessArg); + + char* tmpId = malloc(sizeof(char) * 64); + if (tmpId == NULL) { + return Error(GroundProgram, charptr, "Failed to allocate memory for temporary identifier in add"); + } + snprintf(tmpId, 64, "__SOLS_TMP_ADD_%zu", scope->tmpCounter++); + + groundAddReferenceToInstruction(&add, groundCreateReference(DIRREF, tmpId)); + + node->accessArg = groundCreateReference(VALREF, tmpId); + + groundAddInstructionToProgram(&gp, add); + return Success(GroundProgram, charptr, gp); +} + ResultType(GroundProgram, charptr) generateCode(SolsNode* node, SolsScope* scope) { GroundProgram program = groundCreateProgram(); @@ -135,6 +199,7 @@ ResultType(GroundProgram, charptr) generateCode(SolsNode* node, SolsScope* scope case SNT_PUTS: generate(Puts); case SNT_LITERAL: generate(Literal); case SNT_OP_SET: generate(Set); + case SNT_OP_ADD: generate(Add); } return Success(GroundProgram, charptr, program); } diff --git a/src/main.c b/src/main.c index 0bb9b8e..3717f8d 100644 --- a/src/main.c +++ b/src/main.c @@ -73,7 +73,8 @@ int main(int argc, char** argv) { } SolsScope scope = { - .variables = NULL + .variables = NULL, + .tmpCounter = 0 }; // Do codegen on root node diff --git a/src/parser/parser.c b/src/parser/parser.c index 174ed54..8e66d6e 100644 --- a/src/parser/parser.c +++ b/src/parser/parser.c @@ -214,6 +214,69 @@ static inline ResultType(Nothing, charptr) parseSet(SolsParser* parser) { return Success(Nothing, charptr, {}); } +static inline ResultType(Nothing, charptr) parseAdd(SolsParser* parser) { + if (parser->currentParent->children.count < 1) { + return Error(Nothing, charptr, "Expecting something before '+'"); + } + + // Collect tokens for node + ResultType(SolsTokens, charptr) tokens = createSolsTokens(); + if (tokens.error) { + return Error(Nothing, charptr, tokens.as.error); + } + + // Get the previous node + SolsNode idNode = parser->currentParent->children.at[parser->currentParent->children.count - 1]; + + ResultType(SolsToken, Nothing) peek = parserPeek(parser, 0); + if (peek.error) return Error(Nothing, charptr, "ruh roh"); + + for (;;) { + ResultType(SolsToken, Nothing) peek = parserPeek(parser, 1); + if (peek.error) break; + if (getPrecedence(&peek.as.success) <= STP_ADD) { + break; + } + parserConsume(parser); + addTokenToSolsTokens(&tokens.as.success, peek.as.success); + } + + // Create node + ResultType(SolsNode, charptr) node = createSolsNode(SNT_OP_ADD); + if (node.error) return Error(Nothing, charptr, node.as.error); + node.as.success.line = peek.as.success.line; + + // Parse selected tokens + ResultType(SolsParser, charptr) putsParser = createSolsParser(&tokens.as.success); + if (putsParser.error) return Error(Nothing, charptr, putsParser.as.error); + putsParser.as.success.currentParent = &putsParser.as.success.output; + ResultType(Nothing, charptr) parsed = parse(&putsParser.as.success); + + // Add any error messages from parsing + if (parsed.error) { + addToParserErrors(parser, parsed.as.error); + return Success(Nothing, charptr, {}); + } + + if (putsParser.as.success.output.children.count < 1) { + return Error(Nothing, charptr, "Expecting token after '+'"); + } + + // Copy idnode into set node + addChildToSolsNode(&node.as.success, idNode); + + // Copy nodes into the set node + for (size_t i = 0; i < putsParser.as.success.output.children.count; i++) { + addChildToSolsNode(&node.as.success, putsParser.as.success.output.children.at[i]); + } + + // Put the set node where the idNode was + parser->currentParent->children.count--; + addChildToSolsNode(parser->currentParent, node.as.success); + + return Success(Nothing, charptr, {}); +} + static inline ResultType(Nothing, charptr) parseLiteral(SolsParser* parser) { ResultType(SolsToken, Nothing) peek = parserPeek(parser, 0); if (peek.error) { @@ -317,6 +380,7 @@ ResultType(Nothing, charptr) parse(SolsParser* parser) { case STT_LITERAL: PARSER_HANDLE(Literal); case STT_KW_PUTS: PARSER_HANDLE(Puts); case STT_OP_SET: PARSER_HANDLE(Set); + case STT_OP_ADD: PARSER_HANDLE(Add); } } if (parser->errors.count > 0) { diff --git a/test.sols b/test.sols index 51d482f..95fbc70 100644 --- a/test.sols +++ b/test.sols @@ -1,5 +1,5 @@ // heheheha comment x = 5 -puts x +puts x + 3