solstice/v2
Archived
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

comments, use Nothing instead of voidptr

Browse Source
This commit is contained in:
Maxwell
2026-02-21 14:18:48 +11:00
parent cb13200545
commit f325b8deef
9 changed files with 84 additions and 44 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
src/include/nothing.h Normal file
View File

@@ -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

2
src/lexer/SolsLiteral.h
View File

@@ -3,7 +3,9 @@
#include <inttypes.h>
#include <stdarg.h>
#include "../include/error.h"
#include "../include/nothing.h"
typedef char* charptr;

6
src/lexer/SolsToken.c
View File

@@ -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, {});
}

16
src/lexer/SolsToken.h
View File

@@ -1,10 +1,13 @@
#ifndef SOLSTOKEN_H
#define SOLSTOKEN_H
#include <stdarg.h>
#include "../include/error.h"
#include "../include/nothing.h"
#include "SolsType.h"
#include "SolsLiteral.h"
#include "../include/error.h"
#include <stdarg.h>
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

8
src/lexer/SolsType.c
View File

@@ -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) {

18
src/lexer/SolsType.h
View File

@@ -2,7 +2,9 @@
#define SOLSTYPE_H
#include <stdlib.h>
#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);

42
src/lexer/lexer.c
View File

@@ -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) {

23
src/lexer/lexer.h
View File

@@ -6,6 +6,7 @@
#include <string.h>
#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

3
src/main.c
View File

@@ -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;
}