From f325b8deefb0c7b8944d522a31f3e6d7a9b40737 Mon Sep 17 00:00:00 2001 From: Maxwell Jeffress Date: Sat, 21 Feb 2026 14:18:48 +1100 Subject: [PATCH] comments, use Nothing instead of voidptr --- src/include/nothing.h | 10 ++++++++++ src/lexer/SolsLiteral.h | 2 ++ src/lexer/SolsToken.c | 6 +++--- src/lexer/SolsToken.h | 16 +++++++++++++--- src/lexer/SolsType.c | 8 ++++---- src/lexer/SolsType.h | 18 +++++++++++++----- src/lexer/lexer.c | 42 ++++++++++++++++++++--------------------- src/lexer/lexer.h | 23 ++++++++++++++++------ src/main.c | 3 +-- 9 files changed, 84 insertions(+), 44 deletions(-) create mode 100644 src/include/nothing.h diff --git a/src/include/nothing.h b/src/include/nothing.h new file mode 100644 index 0000000..cfa91b7 --- /dev/null +++ b/src/include/nothing.h @@ -0,0 +1,10 @@ +// nothing.h - ever needed to return nothing (but not void)? +// boy do I have the solution for you + +#ifndef NOTHING_H +#define NOTHING_H + +// Behold, it is nothing! +typedef struct Nothing {} Nothing; + +#endif diff --git a/src/lexer/SolsLiteral.h b/src/lexer/SolsLiteral.h index d35df40..7c97ac9 100644 --- a/src/lexer/SolsLiteral.h +++ b/src/lexer/SolsLiteral.h @@ -3,7 +3,9 @@ #include #include + #include "../include/error.h" +#include "../include/nothing.h" typedef char* charptr; diff --git a/src/lexer/SolsToken.c b/src/lexer/SolsToken.c index 5cf7943..2c805f0 100644 --- a/src/lexer/SolsToken.c +++ b/src/lexer/SolsToken.c @@ -74,16 +74,16 @@ ResultType(SolsTokens, charptr) createSolsTokens() { return Success(SolsTokens, charptr, tokens); } -ResultType(voidptr, charptr) addTokenToSolsTokens(SolsTokens* tokens, SolsToken token) { +ResultType(Nothing, charptr) addTokenToSolsTokens(SolsTokens* tokens, SolsToken token) { if (tokens->capacity < tokens->count + 1) { tokens->capacity *= 2; SolsToken* tmp = realloc(tokens->at, sizeof(SolsToken) * tokens->capacity); if (tmp == NULL) { - return Error(voidptr, charptr, "Failed to allocate memory (in addTokenToSolsTokens() function)"); + return Error(Nothing, charptr, "Failed to allocate memory (in addTokenToSolsTokens() function)"); } tokens->at = tmp; } tokens->at[tokens->count] = token; tokens->count++; - return Success(voidptr, charptr, NULL); + return Success(Nothing, charptr, {}); } diff --git a/src/lexer/SolsToken.h b/src/lexer/SolsToken.h index 0907ae7..636ae59 100644 --- a/src/lexer/SolsToken.h +++ b/src/lexer/SolsToken.h @@ -1,10 +1,13 @@ #ifndef SOLSTOKEN_H #define SOLSTOKEN_H +#include + +#include "../include/error.h" +#include "../include/nothing.h" + #include "SolsType.h" #include "SolsLiteral.h" -#include "../include/error.h" -#include typedef enum SolsTokenType { STT_IDENTIFIER, STT_LITERAL, STT_TYPE, STT_DOT, STT_OPEN_CURLY, STT_CLOSE_CURLY, STT_OPEN_PAREN, STT_CLOSE_PAREN, STT_OP_ADD, STT_OP_SUB, STT_OP_MUL, STT_OP_DIV, STT_OP_ADDTO, STT_OP_SUBTO, STT_OP_MULTO, STT_OP_DIVTO, STT_OP_INCREMENT, STT_OP_DECREMENT, STT_OP_SET, STT_OP_GREATER, STT_OP_LESSER, STT_OP_EQUAL, STT_OP_INEQUAL, STT_OP_EQGREATER, STT_OP_EQLESSER, STT_KW_DEF, STT_KW_STRUCT, STT_KW_PUTS, STT_KW_IF, STT_KW_WHILE, STT_KW_NEW, STT_KW_GROUND @@ -51,11 +54,18 @@ typedef struct SolsTokens { } SolsTokens; Result(SolsTokens, charptr); + // Creates a SolsTokens holder. +// Returns: +// Success: Constructed SolsTokens +// Failure: char* detailing what went wrong (usually memory failure) ResultType(SolsTokens, charptr) createSolsTokens(); // Adds a token to SolsTokens. Used by the lex() function. -ResultType(voidptr, charptr) addTokenToSolsTokens(SolsTokens* tokens, SolsToken token); +// Returns: +// Success: Nothing +// Failure: char* detailing what went wrong (usually memory failure) +ResultType(Nothing, charptr) addTokenToSolsTokens(SolsTokens* tokens, SolsToken token); #endif diff --git a/src/lexer/SolsType.c b/src/lexer/SolsType.c index a3025e7..9648565 100644 --- a/src/lexer/SolsType.c +++ b/src/lexer/SolsType.c @@ -46,12 +46,12 @@ ResultType(SolsType, charptr) copySolsType(SolsType* type) { return Success(SolsType, charptr, ret); } -ResultType(voidptr, charptr) addChildToSolsType(SolsType* type, SolsType child, const char* name) { +ResultType(Nothing, charptr) addChildToSolsType(SolsType* type, SolsType child, const char* name) { if (type->children.capacity < type->children.count + 1) { type->children.capacity *= 2; SolsTypeField* ptr = realloc(type->children.at, sizeof(SolsTypeField) * type->children.capacity); if (ptr == NULL) { - return Error(voidptr, charptr, "Couldn't allocate memory (in addChildToSolsType() function)"); + return Error(Nothing, charptr, "Couldn't allocate memory (in addChildToSolsType() function)"); } type->children.at = ptr; } @@ -59,7 +59,7 @@ ResultType(voidptr, charptr) addChildToSolsType(SolsType* type, SolsType child, if (copied.error) { Estr err = CREATE_ESTR(copied.as.error); APPEND_ESTR(err, " (in addChildToSolsType() function)"); - return Error(voidptr, charptr, err.str); + return Error(Nothing, charptr, err.str); } type->children.at[type->children.count].type = copied.as.success; if (name == NULL) { @@ -70,7 +70,7 @@ ResultType(voidptr, charptr) addChildToSolsType(SolsType* type, SolsType child, } type->children.count++; - return Success(voidptr, charptr, NULL); + return Success(Nothing, charptr, {}); } void freeSolsType(SolsType* type) { diff --git a/src/lexer/SolsType.h b/src/lexer/SolsType.h index fba3602..8954955 100644 --- a/src/lexer/SolsType.h +++ b/src/lexer/SolsType.h @@ -2,7 +2,9 @@ #define SOLSTYPE_H #include + #include "../include/error.h" +#include "../include/nothing.h" typedef enum SolsTypeType { STT_INT, STT_STRING, STT_DOUBLE, STT_BOOL, STT_CHAR, STT_FUN, STT_TEMPLATE, STT_OBJECT @@ -10,8 +12,6 @@ typedef enum SolsTypeType { // Definition of charptr for Result() and ResultType() macros typedef char* charptr; -// Definition of voidptr for Result() and ResultType() macros -typedef void* voidptr; struct SolsTypeField; @@ -62,14 +62,22 @@ typedef struct SolsTypeField { } SolsTypeField; +Result(SolsType, charptr); + // Creates a SolsType, with the provided type type. // Use the "addChildToSolsType()" function to add children, in case this type has children. -Result(SolsType, charptr); +// Returns: +// Success: The constructed SolsType +// Failure: char* detailing what went wrong (usually memory failure) ResultType(SolsType, charptr) createSolsType(SolsTypeType in); +Result(Nothing, charptr); + // Adds a child SolsType to a given SolsType. -Result(voidptr, charptr); -ResultType(voidptr, charptr) addChildToSolsType(SolsType* type, SolsType child, const char* name); +// Returns: +// Success: Nothing +// Failure: char* detailing what went wrong (usually memory failure) +ResultType(Nothing, charptr) addChildToSolsType(SolsType* type, SolsType child, const char* name); // Makes a deep copy of a SolsType. ResultType(SolsType, charptr) copySolsType(SolsType* type); diff --git a/src/lexer/lexer.c b/src/lexer/lexer.c index c420408..fdde2b8 100644 --- a/src/lexer/lexer.c +++ b/src/lexer/lexer.c @@ -334,16 +334,16 @@ char* createParsingError(size_t lineNum, char* line, char* why) { return error.str; } -ResultType(voidptr, charptr) lex(SolsLexer* lexer) { +ResultType(Nothing, charptr) lex(SolsLexer* lexer) { if (lexer->input == NULL) { - return Error(voidptr, charptr, "Lexer is not initialised"); + return Error(Nothing, charptr, "Lexer is not initialised"); } ResultType(SolsTokens, charptr) tokens = createSolsTokens(); if (tokens.error) { Estr e = CREATE_ESTR(tokens.as.error); APPEND_ESTR(e, " (in createSolsTokens() function)"); - return Error(voidptr, charptr, e.str); + return Error(Nothing, charptr, e.str); } lexer->output = tokens.as.success; @@ -377,7 +377,7 @@ ResultType(voidptr, charptr) lex(SolsLexer* lexer) { chr = lexerConsume(lexer); for (;;) { chr = lexerConsume(lexer); - if (chr.error) return Success(voidptr, charptr, NULL); + if (chr.error) return Success(Nothing, charptr, {}); if (chr.as.success == '\n') { chr = lexerConsume(lexer); break; @@ -386,7 +386,7 @@ ResultType(voidptr, charptr) lex(SolsLexer* lexer) { } else if (!peek.error && peek.as.success == '*') { for (;;) { chr = lexerConsume(lexer); - if (chr.error) return Success(voidptr, charptr, NULL); + if (chr.error) return Success(Nothing, charptr, {}); if (chr.as.success == '*') { peek = lexerPeek(lexer, 1); if (!peek.error && peek.as.success == '/') { @@ -400,7 +400,7 @@ ResultType(voidptr, charptr) lex(SolsLexer* lexer) { if (chr.as.success == '#' && !inString) { for (;;) { chr = lexerConsume(lexer); - if (chr.error) return Success(voidptr, charptr, NULL); + if (chr.error) return Success(Nothing, charptr, {}); if (chr.as.success == '\n') { chr = lexerConsume(lexer); break; @@ -446,7 +446,7 @@ ResultType(voidptr, charptr) lex(SolsLexer* lexer) { if (strcmp(buf.str, "") != 0) { ResultType(SolsToken, charptr) result = identifyToken(buf.str); if (result.error) { - return Error(voidptr, charptr, createParsingError(lineNum, currentLine.str, result.as.error)); + return Error(Nothing, charptr, createParsingError(lineNum, currentLine.str, result.as.error)); } addTokenToSolsTokens(&lexer->output, result.as.success); DESTROY_ESTR(buf); @@ -455,7 +455,7 @@ ResultType(voidptr, charptr) lex(SolsLexer* lexer) { char tmp[] = {chr.as.success, '\0'}; ResultType(SolsToken, charptr) result = identifyToken(tmp); if (result.error) { - return Error(voidptr, charptr, createParsingError(lineNum, currentLine.str, result.as.error)); + return Error(Nothing, charptr, createParsingError(lineNum, currentLine.str, result.as.error)); } addTokenToSolsTokens(&lexer->output, result.as.success); break; @@ -467,7 +467,7 @@ ResultType(voidptr, charptr) lex(SolsLexer* lexer) { if (strcmp(buf.str, "") != 0) { ResultType(SolsToken, charptr) result = identifyToken(buf.str); if (result.error) { - return Error(voidptr, charptr, createParsingError(lineNum, currentLine.str, result.as.error)); + return Error(Nothing, charptr, createParsingError(lineNum, currentLine.str, result.as.error)); } addTokenToSolsTokens(&lexer->output, result.as.success); DESTROY_ESTR(buf); @@ -478,7 +478,7 @@ ResultType(voidptr, charptr) lex(SolsLexer* lexer) { char tmp[] = {chr.as.success, '\0'}; ResultType(SolsToken, charptr) result = identifyToken(tmp); if (result.error) { - return Error(voidptr, charptr, createParsingError(lineNum, currentLine.str, result.as.error)); + return Error(Nothing, charptr, createParsingError(lineNum, currentLine.str, result.as.error)); } addTokenToSolsTokens(&lexer->output, result.as.success); } @@ -486,7 +486,7 @@ ResultType(voidptr, charptr) lex(SolsLexer* lexer) { char tmp[] = {chr.as.success, '=', '\0'}; ResultType(SolsToken, charptr) result = identifyToken(tmp); if (result.error) { - return Error(voidptr, charptr, createParsingError(lineNum, currentLine.str, result.as.error)); + return Error(Nothing, charptr, createParsingError(lineNum, currentLine.str, result.as.error)); } addTokenToSolsTokens(&lexer->output, result.as.success); lexerConsume(lexer); @@ -495,7 +495,7 @@ ResultType(voidptr, charptr) lex(SolsLexer* lexer) { char tmp[] = {chr.as.success, chr.as.success, '\0'}; ResultType(SolsToken, charptr) result = identifyToken(tmp); if (result.error) { - return Error(voidptr, charptr, createParsingError(lineNum, currentLine.str, result.as.error)); + return Error(Nothing, charptr, createParsingError(lineNum, currentLine.str, result.as.error)); } addTokenToSolsTokens(&lexer->output, result.as.success); lexerConsume(lexer); @@ -513,7 +513,7 @@ ResultType(voidptr, charptr) lex(SolsLexer* lexer) { if (strcmp(buf.str, "") != 0) { ResultType(SolsToken, charptr) result = identifyToken(buf.str); if (result.error) { - return Error(voidptr, charptr, createParsingError(lineNum, currentLine.str, result.as.error)); + return Error(Nothing, charptr, createParsingError(lineNum, currentLine.str, result.as.error)); } addTokenToSolsTokens(&lexer->output, result.as.success); DESTROY_ESTR(buf); @@ -524,7 +524,7 @@ ResultType(voidptr, charptr) lex(SolsLexer* lexer) { char tmp[] = {chr.as.success, '\0'}; ResultType(SolsToken, charptr) result = identifyToken(tmp); if (result.error) { - return Error(voidptr, charptr, createParsingError(lineNum, currentLine.str, result.as.error)); + return Error(Nothing, charptr, createParsingError(lineNum, currentLine.str, result.as.error)); } addTokenToSolsTokens(&lexer->output, result.as.success); } @@ -532,7 +532,7 @@ ResultType(voidptr, charptr) lex(SolsLexer* lexer) { char tmp[] = {chr.as.success, '=', '\0'}; ResultType(SolsToken, charptr) result = identifyToken(tmp); if (result.error) { - return Error(voidptr, charptr, createParsingError(lineNum, currentLine.str, result.as.error)); + return Error(Nothing, charptr, createParsingError(lineNum, currentLine.str, result.as.error)); } addTokenToSolsTokens(&lexer->output, result.as.success); lexerConsume(lexer); @@ -545,7 +545,7 @@ ResultType(voidptr, charptr) lex(SolsLexer* lexer) { case '.': { ResultType(char, Nothing) peek = lexerPeek(lexer, 1); if (peek.error) { - return Error(voidptr, charptr, createParsingError(lineNum, currentLine.str, "Expecting token after '.'")); + return Error(Nothing, charptr, createParsingError(lineNum, currentLine.str, "Expecting token after '.'")); } if (isdigit(peek.as.success)) { char tmp[] = {peek.as.success, '\0'}; @@ -555,7 +555,7 @@ ResultType(voidptr, charptr) lex(SolsLexer* lexer) { if (strcmp(buf.str, "") != 0) { ResultType(SolsToken, charptr) result = identifyToken(buf.str); if (result.error) { - return Error(voidptr, charptr, createParsingError(lineNum, currentLine.str, result.as.error)); + return Error(Nothing, charptr, createParsingError(lineNum, currentLine.str, result.as.error)); } addTokenToSolsTokens(&lexer->output, result.as.success); DESTROY_ESTR(buf); @@ -572,7 +572,7 @@ ResultType(voidptr, charptr) lex(SolsLexer* lexer) { if (strcmp(buf.str, "") != 0) { ResultType(SolsToken, charptr) result = identifyToken(buf.str); if (result.error) { - return Error(voidptr, charptr, createParsingError(lineNum, currentLine.str, result.as.error)); + return Error(Nothing, charptr, createParsingError(lineNum, currentLine.str, result.as.error)); } addTokenToSolsTokens(&lexer->output, result.as.success); DESTROY_ESTR(buf); @@ -610,16 +610,16 @@ ResultType(voidptr, charptr) lex(SolsLexer* lexer) { if (strcmp(buf.str, "") != 0) { ResultType(SolsToken, charptr) result = identifyToken(buf.str); if (result.error) { - return Error(voidptr, charptr, createParsingError(lineNum, currentLine.str, result.as.error)); + return Error(Nothing, charptr, createParsingError(lineNum, currentLine.str, result.as.error)); } DESTROY_ESTR(buf); } if (inString) { - return Error(voidptr, charptr, createParsingError(lineNum, currentLine.str, "Unterminated string")); + return Error(Nothing, charptr, createParsingError(lineNum, currentLine.str, "Unterminated string")); } - return Success(voidptr, charptr, NULL); + return Success(Nothing, charptr, {}); } ResultType(Nothing, charptr) processTypeSignature(SolsLexer* lexer) { diff --git a/src/lexer/lexer.h b/src/lexer/lexer.h index 16bcfb6..96d5f8e 100644 --- a/src/lexer/lexer.h +++ b/src/lexer/lexer.h @@ -6,6 +6,7 @@ #include #include "../include/error.h" +#include "../include/nothing.h" #include "SolsType.h" #include "SolsToken.h" @@ -22,31 +23,41 @@ typedef struct SolsLexer { size_t current; } SolsLexer; -// An empty struct lmao -typedef struct Nothing {} Nothing; - Result(SolsLexer, charptr); // Creates a lexer for use by the lex() function. +// Returns: +// Success: Constructed SolsLexer +// Failure: char* detailing what went wrong (usually memory failure) ResultType(SolsLexer, charptr) createLexer(char* input); // Uses the provided lexer to scan the code, and create tokens. -ResultType(voidptr, charptr) lex(SolsLexer* lexer); +// Returne: +// Success: Nothing +// Failure: char* detailing what went wrong (usually user failure or memory failure) +ResultType(Nothing, charptr) lex(SolsLexer* lexer); Result(char, Nothing); // Peeks at the next token in the lexer. +// Returns: +// Success: The token with offset ahead +// Failure: Nothing (requested character is out of bounds) ResultType(char, Nothing) lexerPeek(SolsLexer* lexer, size_t ahead); // Consumes the next token in the lexer. +// Success: The token that has just been consumed +// Failure: Nothing (requested character is out of bounds) ResultType(char, Nothing) lexerConsume(SolsLexer* lexer); // Helper function to classify tokens +// Returns: +// Success: A SolsToken which has all information needed from the token. +// Failure: char* detailing what went wrong (usually memory failure) ResultType(SolsToken, charptr) identifyToken(const char* token); -Result(Nothing, charptr); - // Helper function to lex type signatures into tokens +// FIXME this function is a work in progress ResultType(Nothing, charptr) processTypeSignature(SolsLexer* lexer); #endif diff --git a/src/main.c b/src/main.c index 21a87fe..4d85232 100644 --- a/src/main.c +++ b/src/main.c @@ -48,12 +48,11 @@ int main(int argc, char** argv) { printf("Error while creating lexer: %s", lexer.as.error); exit(1); } - ResultType(voidptr, charptr) lexed = lex(&lexer.as.success); + ResultType(Nothing, charptr) lexed = lex(&lexer.as.success); if (lexed.error) { printf("%s", lexed.as.error); exit(1); } - return 0; }