comments, use Nothing instead of voidptr

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

src/lexer/SolsLiteral.h

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

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

src/lexer/SolsToken.h

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

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

src/lexer/SolsType.h

@@ -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);
+// Returns:
-ResultType(voidptr, charptr) addChildToSolsType(SolsType* type, SolsType child, const char* name);
+//    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);

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

src/lexer/lexer.h

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

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