Fix a load of stuff

Add unistd.sols to libraries
Start work on WASM compatibility, lambda fix
2026-03-07 16:26:54 +11:00 · 2026-03-07 16:26:20 +11:00 · 2026-03-06 09:24:16 +11:00 · 2026-03-05 19:32:31 +11:00 · 2026-03-04 12:25:59 +11:00 · 2026-03-03 08:00:00 +11:00
57 changed files with 6949 additions and 604 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -1 +1,3 @@
-hg
+solstice
 build
 .*_solsbuild
--- a/.project.fish
+++ b/.project.fish
@@ -0,0 +1,5 @@
 # source .project.fish
 alias run "make && ./solstice"
 alias clean "make clean"
 alias cleanrun "make clean && make && ./solstice"
--- a/46
+++ b/46
@@ -0,0 +1,46 @@
 CXX = gcc
 CXXFLAGS = -Wall -Wextra -pedantic -O3 -ggdb
 LDFLAGS = -lgroundvm
 BUILD_DIR = build
 SRC_DIR = src
 LIBS_DIR = libs
 PREFIX ?= /usr/local
 BINDIR = $(PREFIX)/bin
 LIBDIR = /usr/lib
 SRCS = $(SRC_DIR)/main.c $(SRC_DIR)/codegen/SolsScope.c $(SRC_DIR)/codegen/codegen.c $(SRC_DIR)/lexer/SolsLiteral.c $(SRC_DIR)/lexer/SolsToken.c $(SRC_DIR)/lexer/SolsType.c $(SRC_DIR)/lexer/lexer.c $(SRC_DIR)/parser/SolsNode.c $(SRC_DIR)/parser/parser.c $(SRC_DIR)/typeparser/typeparser.c 
 OBJS = $(patsubst $(SRC_DIR)/%.c, $(BUILD_DIR)/%.o, $(SRCS))
 TARGET = solstice
 all: $(TARGET)
 $(TARGET): $(OBJS)
 	$(CXX) $(OBJS) -o $(TARGET) $(LDFLAGS)
 $(BUILD_DIR)/%.o: $(SRC_DIR)/%.c | $(BUILD_DIR)
 	$(CXX) $(CXXFLAGS) -c $< -o $@
 install: $(TARGET)
 	mkdir -p /usr/lib/solstice
 	install -d $(BINDIR)
 	install -m 755 $(TARGET) $(BINDIR)/$(TARGET)
 	install -d $(LIBDIR)
 	cp -r libs/* $(LIBDIR)/solstice
 $(BUILD_DIR)/solstice.tar.gz: $(TARGET) $(LIBS_DIR)
 	mkdir -p $(BUILD_DIR)/pkg/bin $(BUILD_DIR)/pkg/lib/
 	cp $(TARGET) $(BUILD_DIR)/pkg/bin/solstice
 	cp -r $(LIBS_DIR) $(BUILD_DIR)/pkg/lib/solstice
 	tar -czvf $(BUILD_DIR)/solstice.tar.gz $(BUILD_DIR)/pkg
 package: $(BUILD_DIR)/solstice.tar.gz
 $(BUILD_DIR):
 	mkdir -p $(BUILD_DIR) $(BUILD_DIR)/codegen $(BUILD_DIR)/lexer $(BUILD_DIR)/parser $(BUILD_DIR)/typeparser
 clean:
 	rm -rf $(BUILD_DIR) $(TARGET)
 .PHONY: all clean
--- a/README.md
+++ b/README.md
@@ -1,49 +1,21 @@
-# High Ground
+![](https://chookspace.com/max/solstice/raw/branch/master/logo/solstice.png)
-High Ground is a programming language based on Ground.
+# Solstice
-It is the reference language designed to teach you how to build your own Ground-based language.
+Solstice is a programming language based on Ground.
 ## Compiling
 First, ensure CGround is installed on your system with `sudo make install`. Then, compile with
 ```
-g++ src/main.cpp -o hg -lgroundvm
+make
 ```
 ## Usage
-High Ground files use the `.hg` extension. Run files as you would with any other interpreted language.
+Solstice files use the `.sols` extension. Run files as you would with any other interpreted language.
-## Using High Ground
+## Docs
-### Types
+Docs are avaliable at https://sols.dev/docs/
 * `int`: Ground int (64 bit integer) eg 3, 7, 31432
 * `double`: Ground double (Double precision floating point) eg 3.141, 2.7
 * `string`: Ground string (char*) eg "Hello, World"
 * `char`: Ground char (char) eg 'a'
 * `bool`: Ground bool (either true or false)
 ### Printing
 Prefix an expression with `puts` to print it to the console.
 ```
 puts "Hello, world!"
 puts 3.141
 puts 7
 puts 'a'
 puts true
 ```
 ### Math
 Add numbers with `+` (more operations coming soon)
 ```
 puts 1 + 1
 puts 3.14 + 2.7
 puts 532 + 314 + 89432
 ```
--- a/chookspace/index.html
+++ b/chookspace/index.html
@@ -0,0 +1,14 @@
 <!DOCTYPE html>
 <html lang="en">
    <head>
        <meta charset="UTF-8">
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
        <title>Redirecting to sols.dev</title>
    </head>
    <body>
        <p>Redirecting to sols.dev, if that doesn't work <a href="https://sols.dev">click here</a>.</p>
        <script>
            window.location.href = "https://sols.dev";
        </script>
    </body>
 </html>
--- a/libs/conversions.sols
+++ b/libs/conversions.sols
@@ -0,0 +1,15 @@
 def stringToInt(string in) int {
    result = 0
    ground {
        stoi $in &result
    }
    return result
 }
 def intToString(int in) string {
    result = ""
    ground {
        tostring $in &result
    }
    return result
 }
--- a/libs/file.sols
+++ b/libs/file.sols
@@ -0,0 +1,6 @@
 def file_Read(string file) string {}
 def file_Write(string file, string content) {}
 ground {
    extern "fileio"
 }
--- a/libs/io.sols
+++ b/libs/io.sols
@@ -0,0 +1,23 @@
 def input(string msg) string {
    retval = ""
    ground {
        print $msg
        input &retval
    }
    return retval
 }
 def print(string msg) string {
    ground {
        print $msg
    }
    return msg
 }
 def println(string msg) string {
    ground {
        println $msg
    }
    return msg
 }
--- a/libs/request.sols
+++ b/libs/request.sols
@@ -0,0 +1,12 @@
 def request_Get(string url) string {}
 def request_Post(string url, string data) string {}
 def ws_Connect(string url) int {}
 def ws_Send(int connId, string data) int {}
 def ws_SendBinary(int connId, string data) int {}
 def ws_Receive(int connId) string {}
 def ws_ReceiveTimeout(int connId, int timeout) string {}
 def ws_Close(int connId) bool {}
 ground {
    extern "request"
 }
--- a/libs/unistd.sols
+++ b/libs/unistd.sols
@@ -0,0 +1,43 @@
 def unistd_Crypt(string key, string value) string {}
 def unistd_GetHostId() string {}
 def unistd_SetHotId(int hostid) int {}
 def unistd_GetHostname() string {}
 def unistd_SetHostname(string name) int {}
 def unistd_Alarm(int seconds) int {}
 def unistd_Pause() int {}
 unistd_F_OK = 0
 unistd_R_OK = 0
 unistd_W_OK = 0
 unistd_X_OK = 0
 def unistd_Access(string path, int mode) int {}
 def unistd_Chdir(string path) int {}
 def unistd_Chown(string path, int owner, int group) int {}
 def unistd_Link(string oldpath, string newpath) int {}
 def unistd_Rmdir(string path) int {}
 def unistd_Symlink(string target, string linkpath) int {}
 def unistd_Exit(int status) int {}
 def unistd_Fork() int {}
 def unistd_GetPid() int {}
 def unistd_GetPPid() int {}
 def unistd_GetSid(int pid) int {}
 def unistd_Nice(int inc) int {}
 def unistd_SetSid() int {}
 def unistd_Sleep(int seconds) int {}
 def unistd_GetGid() int {}
 def unistd_GetEGid() int {}
 def unistd_GetUid() int {}
 def unistd_GetEUid() int {}
 def unistd_GetLogin() string {}
 def unistd_SetEUid(int euid) int {}
 def unistd_SetEGid(int egid) int {}
 def unistd_SetREUid(int ruid, int euid) int {}
 def unistd_SetREGid(int rgid, int egid) int {}
 ground {
    extern "unistd"
 }
--- a/logo/solstice.png
+++ b/logo/solstice.png
--- a/logo/solstice.svg
+++ b/logo/solstice.svg
@@ -0,0 +1,78 @@
 <?xml version="1.0" encoding="UTF-8" standalone="no"?>
 <!-- Created with Inkscape (http://www.inkscape.org/) -->
 <svg
   width="210mm"
   height="297mm"
   viewBox="0 0 210 297"
   version="1.1"
   id="svg1"
   inkscape:version="1.4.2 (ebf0e940d0, 2025-05-08)"
   sodipodi:docname="solstice.svg"
   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
   xmlns:xlink="http://www.w3.org/1999/xlink"
   xmlns="http://www.w3.org/2000/svg"
   xmlns:svg="http://www.w3.org/2000/svg">
  <sodipodi:namedview
     id="namedview1"
     pagecolor="#ffffff"
     bordercolor="#000000"
     borderopacity="0.25"
     inkscape:showpageshadow="2"
     inkscape:pageopacity="0.0"
     inkscape:pagecheckerboard="0"
     inkscape:deskcolor="#d1d1d1"
     inkscape:document-units="mm"
     inkscape:zoom="1.8101934"
     inkscape:cx="341.39999"
     inkscape:cy="633.35776"
     inkscape:window-width="1908"
     inkscape:window-height="1028"
     inkscape:window-x="0"
     inkscape:window-y="0"
     inkscape:window-maximized="1"
     inkscape:current-layer="layer1" />
  <defs
     id="defs1">
    <linearGradient
       id="linearGradient8"
       inkscape:collect="always">
      <stop
         style="stop-color:#64ffe1;stop-opacity:1;"
         offset="0"
         id="stop8" />
      <stop
         style="stop-color:#a3b9f5;stop-opacity:1;"
         offset="0.5"
         id="stop10" />
      <stop
         style="stop-color:#d1b8fb;stop-opacity:1;"
         offset="0.75"
         id="stop11" />
      <stop
         style="stop-color:#f3cdff;stop-opacity:1;"
         offset="1"
         id="stop9" />
    </linearGradient>
    <linearGradient
       inkscape:collect="always"
       xlink:href="#linearGradient8"
       id="linearGradient9"
       x1="-42.253399"
       y1="135.74071"
       x2="-41.225731"
       y2="239.96782"
       gradientUnits="userSpaceOnUse"
       gradientTransform="matrix(0.73239966,-0.77274564,0.76516532,0.73965537,-4.0932457,-8.6853091)" />
  </defs>
  <g
     inkscape:label="Layer 1"
     inkscape:groupmode="layer"
     id="layer1">
    <path
       id="path1"
       style="fill:url(#linearGradient9);fill-opacity:1;stroke:#ffffff;stroke-width:0.281629;stroke-opacity:0"
       d="m 100.38267,124.7767 a 31.775753,32.090549 0 0 0 -22.257004,9.893 31.775753,32.090549 0 0 0 0.979215,45.36846 l -0.0038,0.004 45.917939,44.38672 43.95132,-46.37229 -45.91795,-44.38673 -0.004,0.004 a 31.775753,32.090549 0 0 0 -22.66587,-8.8969 z" />
  </g>
 </svg>
--- a/src/codegen/SolsScope.c
+++ b/src/codegen/SolsScope.c
@@ -0,0 +1,49 @@
 #include "SolsScope.h"
 #include "../include/uthash.h"
 #include "../lexer/SolsType.h"
 void addVariableToScope(SolsScope* scope, const char* name, SolsType type) {
    SolsVariable* s = malloc(sizeof(SolsVariable));
    strncpy(s->id, name, sizeof(s->id) - 1);
    s->id[sizeof(s->id) - 1] = '\0';
    s->typeinfo = type;
    HASH_ADD_STR(scope->variables, id, s);
 }
 SolsVariable* findSolsVariable(SolsScope* scope, const char* name) {
    if (scope == NULL || scope->variables == NULL || name == NULL) {
        return NULL;
    }
    SolsVariable* s;
    HASH_FIND_STR(scope->variables, name, s);
    return s;
 }
 SolsScope copySolsScope(SolsScope* scope) {
    SolsScope newScope = {
        .variables = NULL,
        .tmpCounter = scope->tmpCounter,
        .returnType = scope->returnType
    };
    SolsVariable *var, *tmp;
    HASH_ITER(hh, scope->variables, var, tmp) {
        addVariableToScope(&newScope, var->id, var->typeinfo);
    }
    return newScope;
 }
 void destroySolsScope(SolsScope* scope) {
    SolsVariable *var, *tmp;
    HASH_ITER(hh, scope->variables, var, tmp) {
        HASH_DEL(scope->variables, var);
        free(var);
    }
 }
--- a/src/codegen/SolsScope.h
+++ b/src/codegen/SolsScope.h
@@ -0,0 +1,32 @@
 #ifndef SOLSSCOPE_H
 #define SOLSSCOPE_H
 #include "../include/uthash.h"
 #include "../lexer/SolsType.h"
 // Stores type information for variables in a UTHash table.
 typedef struct SolsVariable {
    char id[256];
    UT_hash_handle hh;
    SolsType typeinfo;
 } SolsVariable;
 typedef struct SolsScope {
    SolsVariable* variables;    
    size_t tmpCounter;
    SolsType returnType;
 } SolsScope;
 // Adds a variable to the SolsScope.
 void addVariableToScope(SolsScope* scope, const char* name, SolsType type);
 // Finds a variable in the SolsScope.
 SolsVariable* findSolsVariable(SolsScope* scope, const char* name);
 // Deep copies a SolsScope, usually for being inside a code block
 SolsScope copySolsScope(SolsScope* scope);
 // Destroys everything in the SolsScope
 void destroySolsScope(SolsScope* scope);
 #endif
--- a/src/codegen/codegen.c
+++ b/src/codegen/codegen.c
--- a/src/codegen/codegen.h
+++ b/src/codegen/codegen.h
@@ -0,0 +1,34 @@
 #ifndef CODEGEN_H
 #define CODEGEN_H
 #include <groundvm.h>
 #include "SolsScope.h"
 #include "../parser/SolsNode.h"
 Result(GroundProgram, charptr);
 // Generates a GroundProgram (from the Ground VM header) from
 // a provided SolsNode. 
 // Returns:
 //    Success: Generated GroundProgram
 //    Failure: charptr detailing what happened
 ResultType(GroundProgram, charptr) generateCode(SolsNode* node, SolsScope* scope);
 // Gets the type of a node generated by the parser for the type checker.
 ResultType(SolsType, charptr) getNodeType(SolsNode* node, SolsScope* scope);
 // Macro to help with code generation (and soon error handling)
 #define generate(nodetype) {\
    ResultType(GroundProgram, charptr) __result = generate##nodetype##Node(node, scope);\
    if (__result.error) {\
        return Error(GroundProgram, charptr, __result.as.error);\
    }\
    for (size_t i = 0; i < __result.as.success.size; i++) {\
        groundAddInstructionToProgram(&program, __result.as.success.instructions[i]);\
    }\
    break;\
 }
 #endif
--- a/src/include/ansii.h
+++ b/src/include/ansii.h
@@ -0,0 +1,67 @@
 // ansii.h - made by SpookyDervish
 // version 1.0.0
 // do with this whatever you want
 //
 // example usage with printf: printf(ESC_BOLD ESC_RED_FG "hi\n");
 #ifndef ANSII_H
 #define ANSII_H
 #define ESC_RESET    		 	"\x1b[0m"
 #define ESC_BOLD     		 	"\x1b[1m"
 #define ESC_DIM    	 		    "\x1b[2m"
 #define ESC_ITALIC   		    "\x1b[3m"
 #define ESC_UNDERLINE		    "\x1b[4m"
 #define ESC_BLINKING  		    "\x1b[5m"
 #define ESC_REVERSE   	 	    "\x1b[7m"
 #define ESC_HIDDEN    		    "\x1b[8m"
 #define ESC_STRIKETHROUGH       "\x1b[8m"
 #define ESC_TERMINAL_BELL       "\a"
 #define ESC_BLACK_FG            "\x1b[30m"
 #define ESC_RED_FG              "\x1b[31m"
 #define ESC_GREEN_FG            "\x1b[32m"
 #define ESC_YELLOW_FG           "\x1b[33m"
 #define ESC_BLUE_FG             "\x1b[34m"
 #define ESC_MAGENTA_FG          "\x1b[35m"
 #define ESC_CYAN_FG             "\x1b[36m"
 #define ESC_WHITE_FG            "\x1b[37m"
 #define ESC_BLACK_FG            "\x1b[30m"
 #define ESC_RED_FG              "\x1b[31m"
 #define ESC_GREEN_FG            "\x1b[32m"
 #define ESC_YELLOW_FG           "\x1b[33m"
 #define ESC_BLUE_FG             "\x1b[34m"
 #define ESC_MAGENTA_FG          "\x1b[35m"
 #define ESC_CYAN_FG             "\x1b[36m"
 #define ESC_WHITE_FG            "\x1b[37m"
 #define ESC_BRIGHT_BLACK_FG     "\x1b[90m"
 #define ESC_BRIGHT_RED_FG       "\x1b[91m"
 #define ESC_BRIGHT_GREEN_FG     "\x1b[92m"
 #define ESC_BRIGHT_YELLOW_FG    "\x1b[93m"
 #define ESC_BRIGHT_BLUE_FG      "\x1b[94m"
 #define ESC_BRIGHT_MAGENTA_FG   "\x1b[95m"
 #define ESC_BRIGHT_CYAN_FG      "\x1b[96m"
 #define ESC_BRIGHT_WHITE_FG     "\x1b[97m"
 #define ESC_BLACK_BG            "\x1b[40m"
 #define ESC_RED_BG              "\x1b[41m"
 #define ESC_GREEN_BG            "\x1b[42m"
 #define ESC_YELLOW_BG           "\x1b[43m"
 #define ESC_BLUE_BG             "\x1b[44m"
 #define ESC_MAGENTA_BG          "\x1b[45m"
 #define ESC_CYAN_BG             "\x1b[46m"
 #define ESC_WHITE_BG            "\x1b[47m"
 #define ESC_BRIGHT_BLACK_BG     "\x1b[100m"
 #define ESC_BRIGHT_RED_BG       "\x1b[101m"
 #define ESC_BRIGHT_GREEN_BG     "\x1b[102m"
 #define ESC_BRIGHT_YELLOW_BG    "\x1b[103m"
 #define ESC_BRIGHT_BLUE_BG      "\x1b[104m"
 #define ESC_BRIGHT_MAGENTA_BG   "\x1b[105m"
 #define ESC_BRIGHT_CYAN_BG      "\x1b[106m"
 #define ESC_BRIGHT_WHITE_BG     "\x1b[107m"
 #define ESC_DEFAULT_FG          "\x1b[39m"
 #endif // !ANSII_H
--- a/src/include/error.h
+++ b/src/include/error.h
@@ -0,0 +1,83 @@
 #include <stdlib.h>
 #include <stdbool.h>
 #ifndef ERROR_H
 #define ERROR_H
 /*
 * error.h - First class errors for C
 * Have you ever wanted to have a Rust-like error experience in C?
 * Look no further than this library! Using a couple simple macros,
 * we can emulate their complicated enum system, and I'd argue that
 * we do it better. Besides, it's in a better programming language.
 *
 * Enjoy!
 *
 * Licenced to you under the MIT license - see below.
 */
 /*
 * Example usage:
 *
 * #include "error.h"
 * #include <stdio.h>
 * 
 * // You can't write char*, you have to define it with a typedef
 * typedef char* charptr;
 * 
 * Result(int, charptr) myFn(int x) {
 *    if (x > 5) {
 *        return Error(int, charptr, "Your number is too big");
 *    }
 *    return Success(int, charptr, x);
 * }
 * 
 * int main() {
 *    ResultType(int, charptr) res = myFn(10);
 *    if (res.error) {
 *        printf("Uh oh, error is: %s\n", res.as.error);
 *    } else {
 *        printf("Got a result! It is %d\n", res.as.success);
 *    }
 * }
 *
 */
 /*
 * Copyright 2026 Maxwell Jeffress
 * 
 * Permission is hereby granted, free of charge, to any person obtaining 
 * a copy of this software and associated documentation files (the “Software”), 
 * to deal in the Software without restriction, including without limitation 
 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 
 * and/or sell copies of the Software, and to permit persons to whom the 
 * Software is furnished to do so, subject to the following conditions:
 * 
 * The above copyright notice and this permission notice shall be included 
 * in all copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS 
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 
 * DEALINGS IN THE SOFTWARE.
 */
 // Creates a new struct with the a (success) and b (error) types. 
 // If Result(a, b) has already been called with the same paramaters, please
 // use ResultType(a, b) instead.
 #define Result(a, b) struct __ResultType_##a##_##b { bool error; union {a success; b error;} as; }
 // Uses an existing Result(a, b) struct.
 #define ResultType(a, b) struct __ResultType_##a##_##b
 // Creates a __ResultType_a_b struct, with .error as false and .as.success as res.
 #define Success(a, b, res) (ResultType(a, b)) { .error = false, .as.success = res }
 // Creates a __ResultType_a_b struct, with .error as true and .as.error as res.
 #define Error(a, b, res) (ResultType(a, b)) { .error = true, .as.error = res }
 #endif
--- a/src/include/estr.h
+++ b/src/include/estr.h
@@ -0,0 +1,52 @@
 #include <stddef.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
 #ifndef ESTR_H
 #define ESTR_H
 /*
    estr.h - Easy string manipulation
    This library has macros to allow easier manipulation of strings. No longer shall
    you have to malloc and realloc away to keep adding to your strings.
    Usage:
    Estr myString = CREATE_ESTR("my awesome string");
    APPEND_ESTR(myString, " is so cool");
    printf("%s\n", myString.str);
 */
 #define CREATE_ESTR(instr) \
    (Estr) { \
        .str = instr,\
        .size = strlen(instr),\
        .shouldBeFreed = 0, \
        .destroyed = 0 \
    }
 #define APPEND_ESTR(estr, instr) { \
    estr.size = estr.size + strlen(instr); \
    char* tmp_ptr = malloc(estr.size + 1); \
    if (tmp_ptr == NULL) printf("WARNING: Could not realloc estr " #estr "\n"); \
    else { \
        snprintf(tmp_ptr, estr.size + 1, "%s%s", estr.str, instr); \
        if (estr.shouldBeFreed > 0) free(estr.str); \
        estr.shouldBeFreed = 1; \
        estr.str = tmp_ptr; \
    } \
 }
 #define DESTROY_ESTR(estr) if (estr.shouldBeFreed > 0 && estr.destroyed < 1) free(estr.str); 
 typedef struct Estr {
    char* str;
    size_t size;
    int8_t shouldBeFreed;
    int8_t destroyed;
 } Estr; 
 #endif // ESTR_H
--- a/src/include/nothing.h
+++ 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
--- a/src/include/uthash.h
+++ b/src/include/uthash.h
--- a/src/lexer/SolsLiteral.c
+++ b/src/lexer/SolsLiteral.c
@@ -0,0 +1,51 @@
 #include "SolsLiteral.h"
 #include <stdarg.h>
 #include <string.h>
 ResultType(SolsLiteral, charptr) createSolsLiteral(SolsLiteralType type, ...) {
    va_list args;
    va_start(args, type);
    SolsLiteral literal = {
        .type = type
    };
    switch (type) {
        case SLT_INT: {
            literal.as.intv = va_arg(args, int64_t);
            break;
        }
        case SLT_DOUBLE: {
            literal.as.doublev = va_arg(args, double);
            break;
        }
        case SLT_BOOL: {
            literal.as.boolv = (bool) va_arg(args, int);
            break;
        }
        case SLT_CHAR: {
            literal.as.charv = (char) va_arg(args, int);
            break;
        }
        case SLT_STRING: {
            char* input = va_arg(args, char*);
            if (input == NULL) {
                va_end(args);
                return Error(SolsLiteral, charptr, "Unexpected NULL value (in createSolsLiteral() function)");
            }
            literal.as.stringv = malloc(strlen(input) + 1);
            if (literal.as.stringv == NULL) {
                va_end(args);
                return Error(SolsLiteral, charptr, "Couldn't allocate memory (in createSolsLiteral() function)");
            }
            strcpy(literal.as.stringv, input);
            break;
        }
    }
    va_end(args);
    return Success(SolsLiteral, charptr, literal);
 }
 void freeSolsLiteral(SolsLiteral* lit) {
    if (lit->type == SLT_STRING && lit->as.stringv != NULL) {
        free(lit->as.stringv);
    } 
 }
--- a/src/lexer/SolsLiteral.h
+++ b/src/lexer/SolsLiteral.h
@@ -0,0 +1,46 @@
 #ifndef SOLSLITERAL_H
 #define SOLSLITERAL_H
 #include <inttypes.h>
 #include <stdarg.h>
 #include "../include/error.h"
 #include "../include/nothing.h"
 typedef char* charptr;
 typedef enum SolsLiteralType {
    SLT_INT, SLT_STRING, SLT_DOUBLE, SLT_BOOL, SLT_CHAR
 } SolsLiteralType;
 // Stores literal values which will be added to the Ground code.
 // Not much explaining needed here.
 typedef struct SolsLiteral {
    SolsLiteralType type;
    union {
        int64_t intv;
        char* stringv;
        double doublev;
        bool boolv;
        char charv;
    } as;
 } SolsLiteral;
 Result(SolsLiteral, charptr);
 // Creates a SolsLiteral, based on the type provided.
 // SolsLiteralType -> C type:
 //    SLT_INT -> int64_t
 //    SLT_STRING -> char*
 //    SLT_DOUBLE -> double
 //    SLT_BOOL -> bool
 //    SL_CHAR -> char
 // An error will only be returned if there is an issue copying a provided char*.
 // There is no way to detect incorrectly provided types, so ensure that the right type
 // is provided!!!!
 ResultType(SolsLiteral, charptr) createSolsLiteral(SolsLiteralType type, ...);
 // Frees a SolsLiteral. Primarily concerned with freeing .as.stringv
 void freeSolsLiteral(SolsLiteral* lit);
 #endif
--- a/src/lexer/SolsToken.c
+++ b/src/lexer/SolsToken.c
@@ -0,0 +1,93 @@
 #include "SolsToken.h"
 #include "SolsLiteral.h"
 #include "../include/error.h"
 #include <stdarg.h>
 #include <string.h>
 ResultType(SolsToken, charptr) createSolsToken(SolsTokenType type, ...) {
    va_list args;
    va_start(args, type);
    SolsToken token = {
        .type = type
    };
    if (type == STT_IDENTIFIER) {
        char* name = va_arg(args, char*);
        if (name == NULL) {
            va_end(args);
            return Error(SolsToken, charptr, "String passed is NULL (in createSolsToken() function)");
        }
        token.as.idName = malloc(strlen(name) + 1);
        if (token.as.idName == NULL) {
            va_end(args);
            return Error(SolsToken, charptr, "Couldn't allocate memory (in createSolsToken() function)");
        }
        strcpy(token.as.idName, name);
    }
    if (type == STT_KW_GROUND) {
        char* ground = va_arg(args, char*);
        if (ground == NULL) {
            va_end(args);
            return Error(SolsToken, charptr, "String passed is NULL (in createSolsToken() function)");
        }
        token.as.inlineGround = malloc(strlen(ground) + 1);
        if (token.as.inlineGround == NULL) {
            va_end(args);
            return Error(SolsToken, charptr, "Couldn't allocate memory (in createSolsToken() function)");
        }
        strcpy(token.as.inlineGround, ground);
    }
    if (type == STT_LITERAL) {
        token.as.literal = va_arg(args, SolsLiteral);
    }
    if (type == STT_TYPE) {
        token.as.type = va_arg(args, SolsType);
    }
    va_end(args);
    return Success(SolsToken, charptr, token);
 }
 void freeSolsToken(SolsToken* token) {
    if (token->type == STT_IDENTIFIER && token->as.idName != NULL) {
        free(token->as.idName);
    }
    if (token->type == STT_KW_GROUND && token->as.inlineGround != NULL) {
        free(token->as.inlineGround);
    }
    if (token->type == STT_LITERAL) {
        freeSolsLiteral(&token->as.literal);
    }
    if (token->type == STT_TYPE) {
        freeSolsType(&token->as.type);
    }
 }
 ResultType(SolsTokens, charptr) createSolsTokens() {
    SolsTokens tokens = {
        .at = malloc(sizeof(SolsToken) * 32),
        .capacity = 32,
        .count = 0
    };
    if (tokens.at == NULL) {
        return Error(SolsTokens, charptr, "Failed to allocate memory (in createSolsTokens() function)");
    }
    return Success(SolsTokens, charptr, tokens);
 }
 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(Nothing, charptr, "Failed to allocate memory (in addTokenToSolsTokens() function)");
        }
        tokens->at = tmp;
    }
    tokens->at[tokens->count] = token;
    tokens->count++;
    return Success(Nothing, charptr, {});
 }
--- a/src/lexer/SolsToken.h
+++ b/src/lexer/SolsToken.h
@@ -0,0 +1,83 @@
 #ifndef SOLSTOKEN_H
 #define SOLSTOKEN_H
 #include <stdarg.h>
 #include "../include/error.h"
 #include "../include/nothing.h"
 #include "SolsType.h"
 #include "SolsLiteral.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_LAMBDA, STT_KW_RETURN, STT_KW_USE, STT_KW_STRUCT, STT_KW_PUTS, STT_KW_IF, STT_KW_WHILE, STT_KW_NEW, STT_KW_GROUND, STT_LINE_END, STT_COMMA
 } SolsTokenType;
 typedef char* charptr;
 // Stores information about the line that the token/node is on, for printing if an error
 // occurs.
 // .num is the line number, .content is the line's contents.
 typedef struct LineInfo {
    size_t num;
    char* content;
 } LineInfo;
 // Represents a token lexed by the lex() function.
 // Most token types exclusively use the .type field, however some tokens require storing
 // more data, inside the .as union.
 // Those tokens are:
 //    STT_LITERAL: A literal value. Uses field .as.literal
 //    STT_TYPE: A type descriptor. Uses field .as.type
 //    STT_IDENTIFIER: An identifier. Uses field .as.idName
 //    STT_KW_GROUND: Ground code embedded inside Solstice. Uses field .as.inlineGround
 typedef struct SolsToken {
    SolsTokenType type;
    union {
        SolsLiteral literal;
        SolsType type;
        char* idName;
        char* inlineGround;
    } as;
    LineInfo line;
 } SolsToken;
 Result(SolsToken, charptr);
 // Creates a SolsToken. If the type passed in is STT_LITERAL, STT_TYPE, STT_IDENTIFIER or
 // STT_KW_GROUND, the function expects another argument, corresponding to the data type
 // the token holds. See the SolsToken struct for more information.
 // Returns:
 //    Success: The created SolsToken
 //    Failure: char* detailing what went wrong (usually memory failure)
 ResultType(SolsToken, charptr) createSolsToken(SolsTokenType type, ...);
 // Frees a SolsToken, specifically the .as field elements.
 void freeSolsToken(SolsToken* token);
 // Represents a Solstice program, seperated into tokens.
 // .at is a pointer to the tokens
 // .count is how many tokens are currently being stored 
 // .capacity is how many tokens worth of memory is allocated
 typedef struct SolsTokens {
    SolsToken* at;
    size_t count;
    size_t capacity;
 } 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.
 // Returns:
 //    Success: Nothing
 //    Failure: char* detailing what went wrong (usually memory failure)
 ResultType(Nothing, charptr) addTokenToSolsTokens(SolsTokens* tokens, SolsToken token);
 #endif
--- a/src/lexer/SolsType.c
+++ b/src/lexer/SolsType.c
@@ -0,0 +1,176 @@
 #include "SolsType.h"
 #include "lexer.h"
 #include "../include/error.h"
 #include "../include/estr.h"
 #include <groundvm.h>
 #include <string.h>
 ResultType(SolsType, charptr) createSolsType(SolsTypeType in) {
    SolsTypeField* ptr = malloc(sizeof(SolsTypeField) * 32);
    if (ptr == NULL) {
        return Error(SolsType, charptr, "Couldn't allocate memory (in createSolsType() function)");
    }
    SolsType type = { .type = in, .children.capacity = 32, .children.at = ptr };
    return Success(SolsType, charptr, type);
 }
 ResultType(SolsType, charptr) copySolsType(SolsType* type) {
    SolsType ret = { .type = type->type, .children.count = type->children.count, .children.capacity = type->children.capacity};
    // Allocate memory
    SolsTypeField* ptr = malloc(sizeof(SolsTypeField) * type->children.capacity);
    if (ptr == NULL) {
        return Error(SolsType, charptr, "Couldn't allocate memory (in copySolsType() function)");
    }
    ret.children.at = ptr;
    // Deep copy values
    for (size_t i = 0; i < type->children.count; i++) {
        // Copy the SolsType value
        ResultType(SolsType, charptr) copied = copySolsType(&type->children.at[i].type);
        if (copied.error) {
            Estr err = CREATE_ESTR(copied.as.error);
            APPEND_ESTR(err, " (in addChildToSolsType() function)");
            return Error(SolsType, charptr, err.str);
        }
        ret.children.at[i].type = copied.as.success;
        // Copy the name
        if (type->children.at[i].name == NULL) {
            ret.children.at[i].name = NULL;
        } else {
            ret.children.at[i].name = malloc(strlen(type->children.at[i].name) + 1);
            if (ret.children.at[i].name == NULL) {
                return Error(SolsType, charptr, "Couldn't allocate memory (in copySolsType() function)");
            }
            strcpy(ret.children.at[i].name, type->children.at[i].name);
        }
    }
    return Success(SolsType, charptr, ret);
 }
 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(Nothing, charptr, "Couldn't allocate memory (in addChildToSolsType() function)");
        }
        type->children.at = ptr;
    }
    ResultType(SolsType, charptr) copied = copySolsType(&child);
    if (copied.error) {
        Estr err = CREATE_ESTR(copied.as.error);
        APPEND_ESTR(err, " (in addChildToSolsType() function)");
        return Error(Nothing, charptr, err.str);
    }
    type->children.at[type->children.count].type = copied.as.success;
    if (name == NULL) {
        type->children.at[type->children.count].name = NULL;
    } else {
        type->children.at[type->children.count].name = malloc(strlen(name) + 1);
        strcpy(type->children.at[type->children.count].name, name);
    }
    type->children.count++;
    return Success(Nothing, charptr, {});
 }
 void freeSolsType(SolsType* type) {
    for (size_t i = 0; i < type->children.count; i++) {
        // Free the name
        if (type->children.at[i].name != NULL) {
            free(type->children.at[i].name);
        }
        // Free the child SolsTypes
        freeSolsType(&type->children.at[i].type);
    }
    // Free the field itself
    free(type->children.at);
    type->children.at = NULL;
    // Set count and capacity to zero
    type->children.count = 0;
    type->children.capacity = 0;
 }
 bool compareTypes(SolsType* left, SolsType* right) {
    if (left->type != right->type) {
        return false;
    }
    switch (left->type) {
        case STT_OBJECT: {
            if (left->children.count != right->children.count) {
                return false;
            }
            for (size_t i = 0; i < left->children.count; i++) {
                if (strcmp(left->children.at[i].name, right->children.at[i].name) != 0) {
                    return false;
                }
                if (compareTypes(&left->children.at[i].type, &right->children.at[i].type) == false) {
                    return false;
                }
            }
            return true;
        }
        case STT_TEMPLATE: {
            if (left->children.count != right->children.count) {
                return false;
            }
            for (size_t i = 0; i < left->children.count; i++) {
                if (strcmp(left->children.at[i].name, right->children.at[i].name) != 0) {
                    return false;
                }
                if (compareTypes(&left->children.at[i].type, &right->children.at[i].type) == false) {
                    return false;
                }
            }
            return true;
        }
        case STT_FUN: {
            if (left->children.count != right->children.count) {
                return false;
            }
            for (size_t i = 0; i < left->children.count; i++) {
                if (compareTypes(&left->children.at[i].type, &right->children.at[i].type) == false) {
                    return false;
                }
            }
            return true;
        }
        default: return true;
    }
 }
 ResultType(GroundArg, charptr) createGroundArgFromSolsType(SolsType* type) {
    switch (type->type) {
        case STT_INT: {
            return Success(GroundArg, charptr, groundCreateReference(TYPEREF, "int"));
        }
        case STT_DOUBLE: {
            return Success(GroundArg, charptr, groundCreateReference(TYPEREF, "double"));
        }
        case STT_STRING: {
            return Success(GroundArg, charptr, groundCreateReference(TYPEREF, "string"));
        }
        case STT_BOOL: {
            return Success(GroundArg, charptr, groundCreateReference(TYPEREF, "bool"));
        }
        case STT_CHAR: {
            return Success(GroundArg, charptr, groundCreateReference(TYPEREF, "char"));
        }
        case STT_FUN: {
            return Success(GroundArg, charptr, groundCreateReference(TYPEREF, "function"));
        }
        case STT_TEMPLATE: {
            return Success(GroundArg, charptr, groundCreateReference(TYPEREF, "struct"));
        }
        case STT_OBJECT: {
            // FIXME Do this later
            return Error(GroundArg, charptr, "FIXME");
        }
    }
    return Error(GroundArg, charptr, "How did we get here?");
 }
--- a/src/lexer/SolsType.h
+++ b/src/lexer/SolsType.h
@@ -0,0 +1,105 @@
 #ifndef SOLSTYPE_H
 #define SOLSTYPE_H
 #include <stdlib.h>
 #include <groundvm.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
 } SolsTypeType;
 // Definition of charptr for Result() and ResultType() macros
 typedef char* charptr;
 struct SolsTypeField;
 // Holds type information for a struct, object or function.
 // Say, for example, your type signature looks like this:
 //    object(string x, fun(int) y)
 // This is stored like this:
 //    SolsType {
 //        type: STT_OBJECT
 //        children: [
 //            {
 //                type: {
 //                    type: STT_STRING
 //                }
 //                name: "x"
 //            }
 //            {
 //                type: {
 //                    type: STT_FUN
 //                    children: [
 //                        {
 //                            type: {
 //                                type: STT_INT
 //                            }
 //                        }
 //                    ]
 //                }
 //                name: "y"
 //            }
 //        ]
 //    }
 //
 //    (Sorry for the long explaination, but it's worth it so you know how the type system works.)
 //
 typedef struct SolsType {
    SolsTypeType type;
    // For use when type is identified with a name
    char* identifierType;
    // For use in functions
    struct SolsType* returnType;
    // For use by fun, template, object
    struct {
        struct SolsTypeField* at;
        size_t count;
        size_t capacity;
    } children;
 } SolsType;
 // Assists with holding child types in the SolsType struct.
 typedef struct SolsTypeField {
    SolsType type;
    char* name;
 } 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.
 // 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. 
 // 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);
 Result(GroundArg, charptr);
 // Represents a SolsType as a GroundArg (in typeref form)
 ResultType(GroundArg, charptr) createGroundArgFromSolsType(SolsType* type);
 // Frees a SolsType
 void freeSolsType(SolsType* type);
 // Compares two SolsTypes
 bool compareTypes(SolsType* left, SolsType* right);
 #endif
--- a/src/lexer/lexer.c
+++ b/src/lexer/lexer.c
@@ -0,0 +1,844 @@
 #include "lexer.h"
 #include "SolsLiteral.h"
 #include "SolsToken.h"
 #include "../include/error.h"
 #include "../include/estr.h"
 #include "../include/ansii.h"
 #include <ctype.h>
 struct _SolsTokenTypeMap SolsTokenTypeMap[] = {
    {"puts", STT_KW_PUTS},
    {"if", STT_KW_IF},
    {"while", STT_KW_WHILE},
    {"def", STT_KW_DEF},
    {"lambda", STT_KW_LAMBDA},
    {"return", STT_KW_RETURN},
    {"use", STT_KW_USE},
    {"struct", STT_KW_STRUCT},
    {"ground", STT_KW_GROUND},
    {"{", 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_SET},
    {"+=", STT_OP_ADDTO},
    {"-=", STT_OP_SUBTO},
    {"*=", STT_OP_MULTO},
    {"/=", STT_OP_DIVTO},
    {"++", STT_OP_INCREMENT},
    {"--", STT_OP_DECREMENT},
    {"==", STT_OP_EQUAL},
    {"!=", STT_OP_INEQUAL},
    {">", STT_OP_GREATER},
    {"<", STT_OP_LESSER},
    {">=", STT_OP_EQGREATER},
    {"<=", STT_OP_EQLESSER},
    {"\n", STT_LINE_END},
    {";", STT_LINE_END},
    {",", STT_COMMA},
    // Shh, this is our little secret
    // Your reward for actually reading the source code
    // Enable this by adding -DSUPER_SILLY_MODE to your 
    // compile flags (not recommended for production)
    #ifdef SUPER_SILLY_MODE
    {"plus", STT_OP_ADD},
    {"minus", STT_OP_SUB},
    {"times", STT_OP_MUL},
    {"dividedby", STT_OP_DIV},
    {"then", STT_OPEN_CURLY},
    {"do", STT_OPEN_CURLY},
    {"end", STT_CLOSE_CURLY},
    {"is", STT_OP_SET},
    {"equals", STT_OP_EQUAL},
    {"greaterthan", STT_OP_GREATER},
    {"lesserthan", STT_OP_LESSER},
    {"increment", STT_OP_INCREMENT},
    {"decrement", STT_OP_DECREMENT},
    {"adds", STT_OP_ADDTO},
    {"subtracts", STT_OP_SUBTO},
    {"multiplies", STT_OP_MULTO},
    {"divides", STT_OP_DIVTO},
    #endif
 };
 ResultType(SolsTokenType, Nothing) getTokenType(const char* input) {
    size_t mapsize = sizeof(SolsTokenTypeMap) / sizeof(struct _SolsTokenTypeMap);
    for (size_t i = 0; i < mapsize; i++) {
        if (strcmp(input, SolsTokenTypeMap[i].str) == 0) {
            return Success(SolsTokenType, Nothing, SolsTokenTypeMap[i].type);
        }
    }
    return Error(SolsTokenType, Nothing, {});
 }
 static ResultType(Nothing, charptr) handleGround(SolsLexer* lexer, SolsToken* token, size_t* lineNum, Estr* currentLine, char currentChr, bool* skipDelimiter) {
    bool foundBrace = false;
    if (currentChr == '{') {
        foundBrace = true;
        *skipDelimiter = true;
    } else {
        while (true) {
            ResultType(char, Nothing) peek = lexerPeek(lexer, 1);
            if (peek.error) break;
            if (isspace(peek.as.success)) {
                char c = lexerConsume(lexer).as.success;
                if (c == '\n') {
                    (*lineNum)++;
                    DESTROY_ESTR((*currentLine));
                    *currentLine = CREATE_ESTR("");
                    size_t lineStart = lexer->current;
                    for (size_t i = lineStart; i < lexer->inputsize; i++) {
                        if (lexer->input[i] == '\n') break;
                        char buf_tmp[] = {lexer->input[i], '\0'};
                        APPEND_ESTR((*currentLine), buf_tmp);
                    }
                }
            } else if (peek.as.success == '{') {
                lexerConsume(lexer);
                foundBrace = true;
                break;
            } else {
                break;
            }
        }
    }
    if (!foundBrace) {
        return Error(Nothing, charptr, "Expected '{' after 'ground'");
    }
    Estr groundBuf = CREATE_ESTR("");
    int depth = 1;
    while (depth > 0) {
        ResultType(char, Nothing) next = lexerConsume(lexer);
        if (next.error) {
            DESTROY_ESTR(groundBuf);
            return Error(Nothing, charptr, "Unterminated 'ground' block");
        }
        if (next.as.success == '{') depth++;
        if (next.as.success == '}') {
            depth--;
            if (depth == 0) break;
        }
        char tmp[] = {next.as.success, '\0'};
        APPEND_ESTR(groundBuf, tmp);
        if (next.as.success == '\n') {
            (*lineNum)++;
            DESTROY_ESTR((*currentLine));
            *currentLine = CREATE_ESTR("");
            size_t lineStart = lexer->current;
            for (size_t i = lineStart; i < lexer->inputsize; i++) {
                if (lexer->input[i] == '\n') break;
                char buf_tmp[] = {lexer->input[i], '\0'};
                APPEND_ESTR((*currentLine), buf_tmp);
            }
        }
    }
    token->as.inlineGround = malloc(strlen(groundBuf.str) + 1);
    if (token->as.inlineGround == NULL) {
        DESTROY_ESTR(groundBuf);
        return Error(Nothing, charptr, "Memory allocation failed (in handleGround() function)");
    }
    strcpy(token->as.inlineGround, groundBuf.str);
    DESTROY_ESTR(groundBuf);
    return Success(Nothing, charptr, {});
 }
 static ResultType(Nothing, charptr) identifyAndAdd(SolsLexer* lexer, Estr* buf, size_t* lineNum, Estr* currentLine, char currentChr, bool* skipDelimiter) {
    if (strcmp(buf->str, "") == 0) return Success(Nothing, charptr, {});
    ResultType(SolsToken, charptr) result = identifyToken(buf->str);
    if (result.error) {
        return Error(Nothing, charptr, result.as.error);
    }
    result.as.success.line.num = *lineNum;
    result.as.success.line.content = malloc(strlen(currentLine->str) + 1);
    if (result.as.success.line.content == NULL) {
        return Error(Nothing, charptr, "Couldn't allocate memory to store line information in token (in identifyAndAdd() function)");
    }
    strcpy(result.as.success.line.content, currentLine->str);
    if (result.as.success.type == STT_KW_GROUND) {
        ResultType(Nothing, charptr) res = handleGround(lexer, &result.as.success, lineNum, currentLine, currentChr, skipDelimiter);
        if (res.error) return res;
    }
    addTokenToSolsTokens(&lexer->output, result.as.success);
    DESTROY_ESTR((*buf));
    *buf = CREATE_ESTR("");
    return Success(Nothing, charptr, {});
 }
 ResultType(SolsLexer, charptr) createLexer(char* input) {
    // Copy input into the new lexer struct
    char* inputcopy = malloc(strlen(input) + 1);
    if (inputcopy == NULL) {
        return Error(SolsLexer, charptr, "Couldn't copy string into lexer (in createLexer() function)");
    }
    strcpy(inputcopy, input);
    // Create SolsTokens
    ResultType(SolsTokens, charptr) tokens = createSolsTokens();
    if (tokens.error) {
        Estr e = CREATE_ESTR(tokens.as.error);
        APPEND_ESTR(e, " (in createLexer() function)");
        return Error(SolsLexer, charptr, e.str);
    }
    // Construct and return lexer
    SolsLexer lexer = {
        .input = inputcopy,
        .inputsize = strlen(inputcopy),
        .output = tokens.as.success,
        .current = 0,
    };
    return Success(SolsLexer, charptr, lexer);
 }
 ResultType(char, Nothing) lexerPeek(SolsLexer* lexer, size_t ahead) {
    // Reduce by 1 so peeking at the next token with 1 works
    ahead--;
    // Bounds and null checking
    if (lexer->input == NULL) {
        return Error(char, Nothing, {});
    }
    if (lexer->current + ahead >= lexer->inputsize) {
        return Error(char, Nothing, {});
    }
    // Char is within bounds, return it
    return Success(char, Nothing, lexer->input[lexer->current + ahead]);
 }
 ResultType(char, Nothing) lexerConsume(SolsLexer* lexer) {
    // Bounds and null checking
    if (lexer->input == NULL) {
        return Error(char, Nothing, {});
    }
    if (lexer->current + 1 > lexer->inputsize) {
        return Error(char, Nothing, {});
    }
    // Char is within bounds, return and increment
    return Success(char, Nothing, lexer->input[lexer->current++]);
 }
 ResultType(SolsToken, charptr) identifyToken(const char* token) {
    // Process strings
    if (token[0] == '"') {
        if (token[strlen(token) - 1] == '"') {
            // Cut out the quotes
            char* tokencopy = malloc(strlen(token) + 1);
            strncpy(tokencopy, token + 1, strlen(token) - 2);
            tokencopy[strlen(token) - 2] = '\0';
            // Create a literal
            ResultType(SolsLiteral, charptr) literal = createSolsLiteral(SLT_STRING, tokencopy);
            // Free our copy of the string, createSolsLiteral creates a copy
            free(tokencopy);
            if (literal.error) {
                Estr str = CREATE_ESTR(literal.as.error);
                APPEND_ESTR(str, " (in identifyToken() function)");
                return Error(SolsToken, charptr, str.str);
            }
            // Construct and return the token
            SolsToken tok = {
                .type = STT_LITERAL,
                .as.literal = literal.as.success
            };
            return Success(SolsToken, charptr, tok);
        }
        return Error(SolsToken, charptr, "Unterminated string (in identifyToken() function)");
    }
    // Process characters
    if (token[0] == '\'') {
        if (strlen(token) != 3) {
            return Error(SolsToken, charptr, "Characters can only hold one character at a time (try using \"this\" for strings?)");
        }
        if (token[2] == '\'') {
            ResultType(SolsLiteral, charptr) literal = createSolsLiteral(SLT_CHAR, token[1]);
            if (literal.error) {
                Estr str = CREATE_ESTR(literal.as.error);
                APPEND_ESTR(str, " (in identifyToken() function)");
                return Error(SolsToken, charptr, str.str);
            }
            SolsToken tok = {
                .type = STT_LITERAL,
                .as.literal = literal.as.success
            };
            return Success(SolsToken, charptr, tok);
        } else {
            return Error(SolsToken, charptr, "Unterminated character (in identifyToken() function)");
        }
    }
    // Process integers and floats
    if (isdigit(token[0]) || (token[0] == '-' && strlen(token) > 1 && (isdigit(token[1]) || token[1] == '.'))) {
        size_t len = strlen(token);
        bool isInt = true;
        bool isDouble = false;
        for (size_t i = 1; i < len; i++) {
            if (isInt && token[i] == '.') {
                isInt = false;
                isDouble = true;
                continue;
            }
            if (!isdigit(token[i])) {
                isInt = false;
                isDouble = false;
            }
        }
        if (isInt) {
            int64_t newInt = atoll(token);
            ResultType(SolsLiteral, charptr) literal = createSolsLiteral(SLT_INT, newInt);
            if (literal.error) {
                Estr str = CREATE_ESTR(literal.as.error);
                APPEND_ESTR(str, " (in identifyToken() function)");
                return Error(SolsToken, charptr, str.str);
            }
            SolsToken tok = {
                .type = STT_LITERAL,
                .as.literal = literal.as.success
            };
            return Success(SolsToken, charptr, tok);
        }
        if (isDouble) {
            double newDouble = atof(token);
            ResultType(SolsLiteral, charptr) literal = createSolsLiteral(SLT_DOUBLE, newDouble);
            if (literal.error) {
                Estr str = CREATE_ESTR(literal.as.error);
                APPEND_ESTR(str, " (in identifyToken() function)");
                return Error(SolsToken, charptr, str.str);
            }
            SolsToken tok = {
                .type = STT_LITERAL,
                .as.literal = literal.as.success
            };
            return Success(SolsToken, charptr, tok);
        }
    }
    // Handle boolean (true/false)
    if (strcmp(token, "true") == 0) {
        ResultType(SolsLiteral, charptr) literal = createSolsLiteral(SLT_BOOL, true);
        if (literal.error) {
            Estr str = CREATE_ESTR(literal.as.error);
            APPEND_ESTR(str, " (in identifyToken() function)");
            return Error(SolsToken, charptr, str.str);
        }
        SolsToken tok = {
            .type = STT_LITERAL,
            .as.literal = literal.as.success
        };
        return Success(SolsToken, charptr, tok);
    }
    if (strcmp(token, "false") == 0) {
        ResultType(SolsLiteral, charptr) literal = createSolsLiteral(SLT_BOOL, false);
        if (literal.error) {
            Estr str = CREATE_ESTR(literal.as.error);
            APPEND_ESTR(str, " (in identifyToken() function)");
            return Error(SolsToken, charptr, str.str);
        }
        SolsToken tok = {
            .type = STT_LITERAL,
            .as.literal = literal.as.success
        };
        return Success(SolsToken, charptr, tok);
    }
    // Process base types
    if (strcmp(token, "int") == 0) {
        ResultType(SolsType, charptr) type = createSolsType(STT_INT);
        if (type.error) {
            Estr e = CREATE_ESTR(type.as.error);
            APPEND_ESTR(e, " (in identifyToken() function)");
            return Error(SolsToken, charptr, e.str);
        }
        SolsToken tok = {
            .type = STT_TYPE,
            .as.type = type.as.success
        };
        return Success(SolsToken, charptr, tok);
    }
    if (strcmp(token, "double") == 0) {
        ResultType(SolsType, charptr) type = createSolsType(STT_DOUBLE);
        if (type.error) {
            Estr e = CREATE_ESTR(type.as.error);
            APPEND_ESTR(e, " (in identifyToken() function)");
            return Error(SolsToken, charptr, e.str);
        }
        SolsToken tok = {
            .type = STT_TYPE,
            .as.type = type.as.success
        };
        return Success(SolsToken, charptr, tok);
    }
    if (strcmp(token, "string") == 0) {
        ResultType(SolsType, charptr) type = createSolsType(STT_STRING);
        if (type.error) {
            Estr e = CREATE_ESTR(type.as.error);
            APPEND_ESTR(e, " (in identifyToken() function)");
            return Error(SolsToken, charptr, e.str);
        }
        SolsToken tok = {
            .type = STT_TYPE,
            .as.type = type.as.success
        };
        return Success(SolsToken, charptr, tok);
    }
    if (strcmp(token, "char") == 0) {
        ResultType(SolsType, charptr) type = createSolsType(STT_CHAR);
        if (type.error) {
            Estr e = CREATE_ESTR(type.as.error);
            APPEND_ESTR(e, " (in identifyToken() function)");
            return Error(SolsToken, charptr, e.str);
        }
        SolsToken tok = {
            .type = STT_TYPE,
            .as.type = type.as.success
        };
        return Success(SolsToken, charptr, tok);
    }
    if (strcmp(token, "bool") == 0) {
        ResultType(SolsType, charptr) type = createSolsType(STT_BOOL);
        if (type.error) {
            Estr e = CREATE_ESTR(type.as.error);
            APPEND_ESTR(e, " (in identifyToken() function)");
            return Error(SolsToken, charptr, e.str);
        }
        SolsToken tok = {
            .type = STT_TYPE,
            .as.type = type.as.success
        };
        return Success(SolsToken, charptr, tok);
    }
    // Find if it's a reserved keyword/operator
    ResultType(SolsTokenType, Nothing) result = getTokenType(token);
    if (!result.error) {
        return Success(SolsToken, charptr, {result.as.success});
    }
    // No appropriate token found, it's an identifier (I hope)
    SolsToken id = {
        .type = STT_IDENTIFIER,
        .as.idName = malloc(strlen(token) + 1)
    };
    if (id.as.idName == NULL) {
        return Error(SolsToken, charptr, "Couldn't allocate memory to copy string (in identifyToken() function)");
    }
    strcpy(id.as.idName, token);
    return Success(SolsToken, charptr, id);
 }
 char* createLexingError(size_t lineNum, char* line, char* why) {
    Estr error = CREATE_ESTR(ESC_RESET ESC_BOLD ESC_RED_FG "Lexing Error " ESC_RESET ESC_YELLOW_FG "on line ");
    char buf[256];
    snprintf(buf, sizeof(buf), "%zu", lineNum);
    APPEND_ESTR(error, buf);
    APPEND_ESTR(error, ":\n\n" ESC_RESET ESC_BLUE_FG "    ");
    APPEND_ESTR(error, line);
    APPEND_ESTR(error, "\n\n");
    APPEND_ESTR(error, ESC_RESET ESC_MAGENTA_FG "-> ");
    APPEND_ESTR(error, why);
    APPEND_ESTR(error, "\n");
    return error.str;
 }
 ResultType(Nothing, charptr) lex(SolsLexer* lexer) {
    if (lexer->input == NULL) {
        return Error(Nothing, charptr, "Lexer is not initialised");
    }
    Estr buf = CREATE_ESTR("");
    bool inString = false;
    size_t lineNum = 1;
    size_t lineStart = 0;
    Estr currentLine = CREATE_ESTR("");
    for (; lineStart < lexer->inputsize; lineStart++) {
        if (lexer->input[lineStart] == '\n') {
            break;
        }
        char tmp[] = {lexer->input[lineStart], '\0'};
        APPEND_ESTR(currentLine, tmp);
    }
    bool skipDelimiter = false;
    for (;;) {
        ResultType(char, Nothing) chr = lexerConsume(lexer);
        if (chr.error) {
            break;
        }
        skipDelimiter = false;
        if (chr.as.success == '/' && !inString) {
            ResultType(char, Nothing) peek = lexerPeek(lexer, 1);
            if (!peek.error && peek.as.success == '/') {
                // Consume characters until \n or EOF
                while (true) {
                    ResultType(char, Nothing) next = lexerPeek(lexer, 1);
                    if (next.error || next.as.success == '\n') break;
                    lexerConsume(lexer);
                }
                continue;
            } else if (!peek.error && peek.as.success == '*') {
                // Skip the *
                lexerConsume(lexer);
                // Consume characters until */ or EOF
                while (true) {
                    ResultType(char, Nothing) next = lexerConsume(lexer);
                    if (next.error) break;
                    if (next.as.success == '\n') {
                        lineNum++;
                        DESTROY_ESTR(currentLine);
                        currentLine = CREATE_ESTR("");
                        lineStart = lexer->current;
                        for (size_t i = lineStart; i < lexer->inputsize; i++) {
                            if (lexer->input[i] == '\n') break;
                            char tmp[] = {lexer->input[i], '\0'};
                            APPEND_ESTR(currentLine, tmp);
                        }
                    }
                    if (next.as.success == '*') {
                        ResultType(char, Nothing) peek2 = lexerPeek(lexer, 1);
                        if (!peek2.error && peek2.as.success == '/') {
                            lexerConsume(lexer); // skip /
                            break;
                        }
                    }
                }
                continue;
            }
        }
        if (chr.as.success == '#' && !inString) {
            while (true) {
                ResultType(char, Nothing) next = lexerPeek(lexer, 1);
                if (next.error || next.as.success == '\n') break;
                lexerConsume(lexer);
            }
            continue;
        }
        if (chr.as.success == '\n') {
            lineNum++;
            DESTROY_ESTR(currentLine);
            currentLine = CREATE_ESTR("");
            lineStart = lexer->current;
            for (size_t i = lineStart; i < lexer->inputsize; i++) {
                if (lexer->input[i] == '\n') {
                    break;
                }
                char buf_tmp[] = {lexer->input[i], '\0'};
                APPEND_ESTR(currentLine, buf_tmp);
            }
        }
        if (inString) {
            char str[2] = { chr.as.success, '\0' };
            APPEND_ESTR(buf, str);
            if (chr.as.success == '"') {
                inString = false;
            }
            continue;
        }
        switch (chr.as.success) {
            case '"': {
                inString = true;
                APPEND_ESTR(buf, "\"");
                break;
            }
            // These characters require themselves added seperately from the previous token.
            case '{': 
            case '}':
            case '(':
            case ')':
            case ',':
            case ':':
            case ';':
            case '\n':
            {
                ResultType(Nothing, charptr) res = identifyAndAdd(lexer, &buf, &lineNum, &currentLine, chr.as.success, &skipDelimiter);
                if (res.error) {
                    char* err = createLexingError(lineNum, currentLine.str, res.as.error);
                    DESTROY_ESTR(buf);
                    DESTROY_ESTR(currentLine);
                    return Error(Nothing, charptr, err);
                }
                if (skipDelimiter) break;
                char tmp[] = {chr.as.success, '\0'};
                ResultType(SolsToken, charptr) result = identifyToken(tmp);
                if (result.error) {
                    char* err = createLexingError(lineNum, currentLine.str, result.as.error);
                    DESTROY_ESTR(buf);
                    DESTROY_ESTR(currentLine);
                    return Error(Nothing, charptr, err);
                }
                result.as.success.line.num = lineNum;
                result.as.success.line.content = malloc(strlen(currentLine.str) + 1);
                if (result.as.success.line.content == NULL) {
                    char* err = createLexingError(lineNum, currentLine.str, "Couldn't allocate memory to store line information in token (in lex() function)");
                    DESTROY_ESTR(buf);
                    DESTROY_ESTR(currentLine);
                    return Error(Nothing, charptr, err);
                }
                strcpy(result.as.success.line.content, currentLine.str);
                addTokenToSolsTokens(&lexer->output, result.as.success);
                break;
            }
            // These characters may be repeated, or followed by an equals sign.
            case '+':
            case '-': {
                ResultType(Nothing, charptr) res = identifyAndAdd(lexer, &buf, &lineNum, &currentLine, chr.as.success, &skipDelimiter);
                if (res.error) {
                    char* err = createLexingError(lineNum, currentLine.str, res.as.error);
                    DESTROY_ESTR(buf);
                    DESTROY_ESTR(currentLine);
                    return Error(Nothing, charptr, err);
                }
                // skipDelimiter is unlikely here but handled just in case
                if (skipDelimiter) break;
                ResultType(char, Nothing) next = lexerPeek(lexer, 1);
                if (next.error || (next.as.success != chr.as.success && next.as.success != '=')) {
                    char tmp[] = {chr.as.success, '\0'};
                    ResultType(SolsToken, charptr) result = identifyToken(tmp);
                    if (result.error) {
                        char* err = createLexingError(lineNum, currentLine.str, result.as.error);
                        DESTROY_ESTR(buf);
                        DESTROY_ESTR(currentLine);
                        return Error(Nothing, charptr, err);
                    }
                    result.as.success.line.num = lineNum;
                    result.as.success.line.content = malloc(strlen(currentLine.str) + 1);
                    if (result.as.success.line.content == NULL) {
                        char* err = createLexingError(lineNum, currentLine.str, "Couldn't allocate memory to store line information in token (in lex() function)");
                        DESTROY_ESTR(buf);
                        DESTROY_ESTR(currentLine);
                        return Error(Nothing, charptr, err);
                    }
                    strcpy(result.as.success.line.content, currentLine.str);
                    addTokenToSolsTokens(&lexer->output, result.as.success);
                }
                if (next.as.success == '=') {
                    char tmp[] = {chr.as.success, '=', '\0'};
                    ResultType(SolsToken, charptr) result = identifyToken(tmp);
                    if (result.error) {
                        char* err = createLexingError(lineNum, currentLine.str, result.as.error);
                        DESTROY_ESTR(buf);
                        DESTROY_ESTR(currentLine);
                        return Error(Nothing, charptr, err);
                    }
                    result.as.success.line.num = lineNum;
                    result.as.success.line.content = malloc(strlen(currentLine.str) + 1);
                    if (result.as.success.line.content == NULL) {
                        char* err = createLexingError(lineNum, currentLine.str, "Couldn't allocate memory to store line information in token (in lex() function)");
                        DESTROY_ESTR(buf);
                        DESTROY_ESTR(currentLine);
                        return Error(Nothing, charptr, err);
                    }
                    strcpy(result.as.success.line.content, currentLine.str);
                    addTokenToSolsTokens(&lexer->output, result.as.success);
                    lexerConsume(lexer);
                }
                if (next.as.success == chr.as.success) {
                    char tmp[] = {chr.as.success, chr.as.success, '\0'};
                    ResultType(SolsToken, charptr) result = identifyToken(tmp);
                    if (result.error) {
                        char* err = createLexingError(lineNum, currentLine.str, result.as.error);
                        DESTROY_ESTR(buf);
                        DESTROY_ESTR(currentLine);
                        return Error(Nothing, charptr, err);
                    }
                    result.as.success.line.num = lineNum;
                    result.as.success.line.content = malloc(strlen(currentLine.str) + 1);
                    if (result.as.success.line.content == NULL) {
                        char* err = createLexingError(lineNum, currentLine.str, "Couldn't allocate memory to store line information in token (in lex() function)");
                        DESTROY_ESTR(buf);
                        DESTROY_ESTR(currentLine);
                        return Error(Nothing, charptr, err);
                    }
                    strcpy(result.as.success.line.content, currentLine.str);
                    addTokenToSolsTokens(&lexer->output, result.as.success);
                    lexerConsume(lexer);
                }
                break;                
            }
            // These characters may be followed by an equals sign, or nothing else.
            case '=':
            case '!':
            case '>':
            case '<':
            case '*':
            case '/': {
                ResultType(Nothing, charptr) res = identifyAndAdd(lexer, &buf, &lineNum, &currentLine, chr.as.success, &skipDelimiter);
                if (res.error) {
                    char* err = createLexingError(lineNum, currentLine.str, res.as.error);
                    DESTROY_ESTR(buf);
                    DESTROY_ESTR(currentLine);
                    return Error(Nothing, charptr, err);
                }
                if (skipDelimiter) break;
                ResultType(char, Nothing) next = lexerPeek(lexer, 1);
                if (next.error || next.as.success != '=') {
                    char tmp[] = {chr.as.success, '\0'};
                    ResultType(SolsToken, charptr) result = identifyToken(tmp);
                    if (result.error) {
                        char* err = createLexingError(lineNum, currentLine.str, result.as.error);
                        DESTROY_ESTR(buf);
                        DESTROY_ESTR(currentLine);
                        return Error(Nothing, charptr, err);
                    }
                    result.as.success.line.num = lineNum;
                    result.as.success.line.content = malloc(strlen(currentLine.str) + 1);
                    if (result.as.success.line.content == NULL) {
                        char* err = createLexingError(lineNum, currentLine.str, "Couldn't allocate memory to store line information in token (in lex() function)");
                        DESTROY_ESTR(buf);
                        DESTROY_ESTR(currentLine);
                        return Error(Nothing, charptr, err);
                    }
                    strcpy(result.as.success.line.content, currentLine.str);
                    addTokenToSolsTokens(&lexer->output, result.as.success);
                }
                if (next.as.success == '=') {
                    char tmp[] = {chr.as.success, '=', '\0'};
                    ResultType(SolsToken, charptr) result = identifyToken(tmp);
                    if (result.error) {
                        char* err = createLexingError(lineNum, currentLine.str, result.as.error);
                        DESTROY_ESTR(buf);
                        DESTROY_ESTR(currentLine);
                        return Error(Nothing, charptr, err);
                    }
                    result.as.success.line.num = lineNum;
                    result.as.success.line.content = malloc(strlen(currentLine.str) + 1);
                    if (result.as.success.line.content == NULL) {
                        char* err = createLexingError(lineNum, currentLine.str, "Couldn't allocate memory to store line information in token (in lex() function)");
                        DESTROY_ESTR(buf);
                        DESTROY_ESTR(currentLine);
                        return Error(Nothing, charptr, err);
                    }
                    strcpy(result.as.success.line.content, currentLine.str);
                    addTokenToSolsTokens(&lexer->output, result.as.success);
                    lexerConsume(lexer);
                }
                break;
            }
            // '.' requires checking whether it's a number or an identifier after
            case '.': {
                ResultType(char, Nothing) peek = lexerPeek(lexer, 1);
                // If the next character is a digit, then this is a literal, not a member access dot.
                if (!peek.error && isdigit(peek.as.success)) {
                    APPEND_ESTR(buf, ".");
                } else {
                    ResultType(Nothing, charptr) res = identifyAndAdd(lexer, &buf, &lineNum, &currentLine, chr.as.success, &skipDelimiter);
                    if (res.error) {
                        char* err = createLexingError(lineNum, currentLine.str, res.as.error);
                        DESTROY_ESTR(buf);
                        DESTROY_ESTR(currentLine);
                        return Error(Nothing, charptr, err);
                    }
                    if (!skipDelimiter) {
                        addTokenToSolsTokens(&lexer->output, (SolsToken) {.type = STT_DOT});
                    }
                }
                break;
            }
            // This whitespace splits the program and does not get appended as it's own token.
            case '\t':
            case ' ': {
                ResultType(Nothing, charptr) res = identifyAndAdd(lexer, &buf, &lineNum, &currentLine, chr.as.success, &skipDelimiter);
                if (res.error) {
                    char* err = createLexingError(lineNum, currentLine.str, res.as.error);
                    DESTROY_ESTR(buf);
                    DESTROY_ESTR(currentLine);
                    return Error(Nothing, charptr, err);
                }
                break;
            }
            default: {
                char newchar[] = {chr.as.success, '\0'};
                APPEND_ESTR(buf, newchar);
                break;
            }
        }
        // Check whether we need to parse types
        if (strcmp(buf.str, "fun") == 0) {
            if (!lexerPeek(lexer, 1).error && lexerPeek(lexer, 1).as.success == '(') {
                // do stuff
            }
        }
        if (strcmp(buf.str, "template") == 0 ) {
            if (!lexerPeek(lexer, 1).error && lexerPeek(lexer, 1).as.success == '(') {
            }
        }
        if (strcmp(buf.str, "object") == 0 ) {
            if (!lexerPeek(lexer, 1).error && lexerPeek(lexer, 1).as.success == '(') {
            }
        }
    }
    ResultType(Nothing, charptr) res = identifyAndAdd(lexer, &buf, &lineNum, &currentLine, '\0', &skipDelimiter);
    if (res.error) {
        char* err = createLexingError(lineNum, currentLine.str, res.as.error);
        DESTROY_ESTR(buf);
        DESTROY_ESTR(currentLine);
        return Error(Nothing, charptr, err);
    }
    if (inString) {
        char* err = createLexingError(lineNum, currentLine.str, "Unterminated string");
        DESTROY_ESTR(buf);
        DESTROY_ESTR(currentLine);
        return Error(Nothing, charptr, err);
    }
    DESTROY_ESTR(buf);
    DESTROY_ESTR(currentLine);
    return Success(Nothing, charptr, (Nothing){});
 }
 ResultType(Nothing, charptr) processTypeSignature(SolsLexer* lexer) {
    return Error(Nothing, charptr, "WIP (in processTypeSignature() function)");
 }
--- a/src/lexer/lexer.h
+++ b/src/lexer/lexer.h
@@ -0,0 +1,76 @@
 #ifndef LEXER_H
 #define LEXER_H
 #include <stdlib.h>
 #include <stdbool.h>
 #include <string.h>
 #include "../include/error.h"
 #include "../include/nothing.h"
 #include "SolsType.h"
 #include "SolsToken.h"
 #include "SolsLiteral.h"
 // A map containing all corresponding strs and token types.
 // Use the getTokenType() function to search this
 extern struct _SolsTokenTypeMap {char* str; SolsTokenType type;} SolsTokenTypeMap[];
 // Represents the current state of the lexer.
 // .input is the Solstice program as written by the user.
 // .output is the lexed Solstice program, which is constructed by the lex() function.
 // .current represents the current character from .input being lexed. 
 typedef struct SolsLexer {
    char* input;
    size_t inputsize;
    SolsTokens output;
    size_t current;
 } SolsLexer;
 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.
 // 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(SolsTokenType, Nothing);
 // Helper function to convert a char* into a SolsTokenType using the SolsTokenTypeMap.
 // Returns:
 //    Success: The corresponding SolsTokenType
 //    Failure: Nothing (meaning the token is likely an identifier)
 ResultType(SolsTokenType, Nothing) getTokenType(const char* input);
 // Helper function to lex type signatures into tokens
 // FIXME this function is a work in progress
 ResultType(Nothing, charptr) processTypeSignature(SolsLexer* lexer);
 #endif
--- a/src/main.c
+++ b/src/main.c
@@ -0,0 +1,266 @@
 #include "lexer/SolsType.h"
 #include "lexer/lexer.h"
 #include "typeparser/typeparser.h"
 #include "parser/parser.h"
 #include "codegen/codegen.h"
 #include "include/error.h"
 #include "include/estr.h"
 #include <stdio.h>
 #ifdef _WIN32
 #include <direct.h>
 #else
 #include <sys/stat.h>
 #endif
 #include <groundvm.h>
 typedef enum SolsAction {
    SA_PRINT, SA_EXEC, SA_BYTECODE, SA_COMPILE, SA_EXIT, SA_EXITOK
 } SolsAction;
 typedef struct Args {
    SolsAction action;
    char* inputFile;
    char* outputFile;
 } Args;
 Args parseArgs(int argc, char** argv) {
    Args args = {
        .action = SA_EXEC,
        .inputFile = NULL,
        .outputFile = NULL
    };
    for (int i = 0; i < argc; i++) {
        if (strcmp("-h", argv[i]) == 0 || strcmp("--help", argv[i]) == 0) {
            printf("Solstice programming language\n");
            printf("Usage: %s <file> [-h] [--help] [-p] [--print] [-b <file>] [--bytecode <file>] [-c <file>] [--compile <file>]\n", argv[0]);
            printf("Args:\n");
            printf("  <file>:                         Solstice source file\n");
            printf("  -h or --help:                   Prints this help message and exits\n");
            printf("  -p or --print:                  Prints textual version of Ground bytecode to console\n");
            printf("  -b <file> or --bytecode <file>: Generates Ground bytecode (.grbc) and saves it to the provided filename\n");
            printf("  -c <file> or --compile <file>:  Compiles Ground to Linux x86_64 assembly, outputs a binary to the provided filename (experimental)\n");
            printf("  If no extra arguments are provided, the generated Ground bytecode will be executed.\n");
            args.action = SA_EXIT;
            return args;
        }
        else if (strcmp("-p", argv[i]) == 0 || strcmp("--print", argv[i]) == 0) {
            args.action = SA_PRINT;
        }
        else if (strcmp("-b", argv[i]) == 0 || strcmp("--bytecode", argv[i]) == 0) {
            if (args.action != SA_EXEC) {
                printf("Expecting only one action\n");
                args.action = SA_EXIT;
                return args;
            }
            args.action = SA_BYTECODE;
            if (i + 1 >= argc) {
                printf("Expecting file name after %s\n", argv[i]);
                args.action = SA_EXIT;
                return args;
            }
            i++;
            args.outputFile = argv[i]; 
        }
        else if (strcmp("-c", argv[i]) == 0 || strcmp("--compile", argv[i]) == 0) {
            if (args.action != SA_EXEC) {
                printf("Expecting only one action\n");
                args.action = SA_EXIT;
                return args;
            }
            args.action = SA_COMPILE;
            if (i + 1 >= argc) {
                printf("Expecting file name after %s\n", argv[i]);
                args.action = SA_EXIT;
                return args;
            }
            i++;
            args.outputFile = argv[i]; 
        }
        else {
            args.inputFile = argv[i];
        }
    }
    if (args.inputFile == NULL) {
        printf("Usage: %s <file> [-h] [--help] [-p] [--print] [-b <file>] [--bytecode <file>] [-c <file>] [--compile <file>]\n", argv[0]);
        args.action = SA_EXIT;
        return args;
    }
    return args;
 }
 char* getFileContents(const char* filename) {
    // https://stackoverflow.com/questions/3747086/reading-the-whole-text-file-into-a-char-array-in-c
    FILE* fp;
    long lSize;
    char* file;
    fp = fopen(filename, "rb");
    if (!fp) {
        perror(filename);
        return NULL;
    }
    fseek(fp, 0L, SEEK_END);
    lSize = ftell(fp);
    rewind(fp);
    file = calloc(1, lSize + 1);
    if (!file) {
        fclose(fp);
        return NULL;
    }
    if (1!=fread(file, lSize, 1, fp)) {
        fclose(fp);
        free(file);
        return NULL;
    }
    // we done
    fclose(fp);
    return file;
 }
 int main(int argc, char** argv) {
    Args args = parseArgs(argc, argv);
    if (args.action == SA_EXIT) {
        return 1;
    }
    if (args.action == SA_EXITOK) {
        return 0;
    }
    char* fileContents = getFileContents(args.inputFile);
    if (fileContents == NULL) {
        printf("Couldn't read that file :(\n");
        return 1;
    }
    // Lex file
    ResultType(SolsLexer, charptr) lexer = createLexer(fileContents);
    if (lexer.error) {
        printf("Error while creating lexer: %s", lexer.as.error);
        return 1;
    }
    ResultType(Nothing, charptr) lexed = lex(&lexer.as.success);
    if (lexed.error) {
        printf("%s\n", lexed.as.error);
        return 1;
    }
    // Detect and parse types
    ResultType(SolsTokens, charptr) typed = addTypeInfo(&lexer.as.success.output);
    if (typed.error) {
        printf("%s\n", typed.as.error);
        return 1;
    }
    // Parse file
    ResultType(SolsParser, charptr) parser = createSolsParser(&typed.as.success);
    if (parser.error) {
        printf("Error while creating parser: %s\n", parser.as.error);
        return 1;
    }
    ResultType(Nothing, charptr) parsed = parse(&parser.as.success);
    if (parsed.error) {
        printf("%s\n", parsed.as.error);
        return 1;
    }
    SolsScope scope = {
        .variables = NULL,
        .tmpCounter = 0,
        .returnType = createSolsType(STT_INT).as.success
    };
    // Do codegen on root node
    ResultType(GroundProgram, charptr) codegen = generateCode(&parser.as.success.output, &scope);
    if (codegen.error) {
        printf("%s\n", codegen.as.error);
        return 1;
    }
    switch (args.action) {
        case SA_PRINT: {
            groundPrintProgram(&codegen.as.success);
            break;
        }
        case SA_EXEC: {
            GroundValue retval = groundRunProgram(&codegen.as.success);
            if (retval.type == INT) {
                return retval.data.intVal;
            } else {
                return 0;
            }
            break;
        }
        case SA_BYTECODE: {
            serializeProgramToFile(args.outputFile, &codegen.as.success);
            break;
        }
        case SA_COMPILE: {
            char* compiled = groundCompileProgram(&codegen.as.success);
            // Make work directory
            Estr dir = CREATE_ESTR(".solsbuild_");
            APPEND_ESTR(dir, args.outputFile);
            #ifdef _WIN32
            int dirstatus = _mkdir(estr.str);
            #else
            int dirstatus = mkdir(dir.str, 0755);
            #endif
            if (dirstatus != 0) {
                printf("Couldn't create temporary work directory\n");
                return 1;
            }
            // Write generated asm to .s
            Estr tmpasm = CREATE_ESTR(dir.str);
            APPEND_ESTR(tmpasm, "/generated.s");
            FILE* file = fopen(tmpasm.str, "w");
            if (file == NULL) {
                printf("Couldn't write to temporary assembly file");
            }
            fprintf(file, "%s", compiled);
            fclose(file);
            // Assemble with nasm
            Estr nasmcmd = CREATE_ESTR("nasm -f elf64 -o ");
            APPEND_ESTR(nasmcmd, dir.str);
            APPEND_ESTR(nasmcmd, "/generated.o ");
            APPEND_ESTR(nasmcmd, tmpasm.str);
            int nasmstatus = system(nasmcmd.str);
            if (nasmstatus != 0) {
                printf("command \"%s\" exited with code %d\n", nasmcmd.str, nasmstatus);
                return 1;
            }
            // Link with ld 
            Estr ldcmd = CREATE_ESTR("ld -o ");
            APPEND_ESTR(ldcmd, args.outputFile);
            APPEND_ESTR(ldcmd, " ");
            APPEND_ESTR(ldcmd, dir.str);
            APPEND_ESTR(ldcmd, "/generated.o");
            int ldstatus = system(ldcmd.str);
            if (ldstatus != 0) {
                printf("command \"%s\" exited with code %d\n", ldcmd.str, ldstatus);
                return 1;
            }
            // Yay we compiled it
            break;
        }
    }
    return 0;
 }
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -1,563 +0,0 @@
 #include <cctype>
 #include <cstdint>
 #include <groundvm.h>
 #include <vector>
 #include <string>
 #include <fstream>
 #include <iostream>
 #include <sstream>
 #include <optional>
 #include <variant>
 #define parseOneToken(token) Parser({token.value()}).parse().children[0]
 namespace HighGround {
    int tmpIdIterator = 0;
    namespace Parser {
        enum class HGNodeType {
            Add, Subtract, Equal, Set, While, If, Value, Identifier, None, Root, CodeBlock, CodeBlockStart, CodeBlockEnd, Puts
        };
        enum class HGDataType {
            Int, String, Double, Bool, Char, None
        };
        class HGNode;
        class HGGroundCodeBlock {
            public:
            std::vector<GroundInstruction> code;
            HGGroundCodeBlock() = default;
        };
        class HGData {
            typedef std::variant<int64_t, std::string, double, bool, char> varData; 
            varData data;
            public:
            HGDataType type = HGDataType::Int;
            HGData() = default;
            HGData(int64_t in) : data(in), type(HGDataType::Int) {}
            HGData(double in) : data(in), type(HGDataType::Double) {}
            HGData(std::string in) : data(in), type(HGDataType::String) {}
            HGData(char in) : data(in), type(HGDataType::Char) {}
            HGData(bool in) : data(in), type(HGDataType::Bool) {}
            std::optional<int64_t> getInt() {
                if (type == HGDataType::Int) {
                    return std::get<int64_t>(data);
                } else {
                    return {};
                }
            }
            std::optional<double> getDouble() {
                if (type == HGDataType::Double) {
                    return std::get<double>(data);
                } else {
                    return {};
                }
            }
            std::optional<std::string> getString() {
                if (type == HGDataType::String) {
                    return std::get<std::string>(data);
                } else {
                    return {};
                }
            }
            std::optional<char> getChar() {
                if (type == HGDataType::Char) {
                    return std::get<char>(data);
                } else {
                    return {};
                }
            }
            std::optional<bool> getBool() {
                if (type == HGDataType::Bool) {
                    return std::get<bool>(data);
                } else {
                    return {};
                }
            }
        };
        class HGNode {
            HGNodeType nodeType = HGNodeType::None;
            HGData data;
            public:
            std::vector<HGNode> children;
            std::string outputId;
            HGNode(HGNodeType nodeType) : nodeType(nodeType) {}
            HGNode(HGNodeType nodeType, HGData data) : nodeType(nodeType), data(data) {}
            HGNode() = default;
            void addNode(HGNode in) {
                children.push_back(in);
            }
            void setValue(HGData in) {
                data = in;
            }
            const std::vector<HGGroundCodeBlock> generateCode() {
                std::vector<HGGroundCodeBlock> code;
                for (auto& child : children) {
                    auto childCode = child.generateCode();
                    code.insert(code.end(), childCode.begin(), childCode.end());
                }
                switch (nodeType) {
                    case HGNodeType::Value: {
                        outputId = "tmp_" + std::to_string(tmpIdIterator++);
                        HGGroundCodeBlock codeBlock;
                        GroundInstruction gi = groundCreateInstruction(SET);
                        groundAddReferenceToInstruction(&gi, groundCreateReference(DIRREF, outputId.data()));
                        switch (data.type) {
                            case HGDataType::Int: {
                                auto dataopt = data.getInt();
                                if (dataopt) {
                                    groundAddValueToInstruction(&gi, groundCreateValue(INT, dataopt.value()));
                                }
                                break;
                            }
                            case HGDataType::Double: {
                                auto dataopt = data.getDouble();
                                if (dataopt) {
                                    groundAddValueToInstruction(&gi, groundCreateValue(DOUBLE, dataopt.value()));
                                }
                                break;
                            }
                            case HGDataType::String: {
                                auto dataopt = data.getString();
                                if (dataopt) {
                                    groundAddValueToInstruction(&gi, groundCreateValue(STRING, dataopt.value().c_str()));
                                }
                                break;
                            }
                            case HGDataType::Char: {
                                auto dataopt = data.getChar();
                                if (dataopt) {
                                    groundAddValueToInstruction(&gi, groundCreateValue(CHAR, dataopt.value()));
                                }
                                break;
                            }
                            case HGDataType::Bool: {
                                auto dataopt = data.getBool();
                                if (dataopt) {
                                    groundAddValueToInstruction(&gi, groundCreateValue(BOOL, dataopt.value()));
                                }
                                break;
                            }
                        }
                        codeBlock.code.push_back(gi);
                        code.push_back(codeBlock);
                        break;
                    }
                    case HGNodeType::Add: {
                        HGGroundCodeBlock codeBlock;
                        outputId = "tmp_" + std::to_string(tmpIdIterator++);
                        GroundInstruction gi = groundCreateInstruction(ADD); 
                        if (children.size() < 2) {
                            std::cout << "Need more stuff to add\n";
                        }
                        groundAddReferenceToInstruction(&gi, groundCreateReference(VALREF, children[0].outputId.data()));
                        groundAddReferenceToInstruction(&gi, groundCreateReference(VALREF, children[1].outputId.data()));
                        groundAddReferenceToInstruction(&gi, groundCreateReference(DIRREF, outputId.data()));
                        codeBlock.code.push_back(gi);
                        code.push_back(codeBlock);
                        break;
                    }
                    case HGNodeType::Puts: {
                        HGGroundCodeBlock codeBlock;
                        GroundInstruction gi = groundCreateInstruction(PRINTLN);                   
                        if (children.size() < 1) {
                            std::cout << "Need more stuff to puts\n";
                        }
                        groundAddReferenceToInstruction(&gi, groundCreateReference(VALREF, children[0].outputId.data()));
                        codeBlock.code.push_back(gi);
                        code.push_back(codeBlock);
                        break;
                    }
                    default: {}
                }
                return code;
            }
        };
        class Parser {
            std::vector<std::string> tokensToParse;
            size_t current;
            size_t size;
            std::optional<std::string> peek(int ahead = 1) {
                if (current + ahead < size) {
                    return tokensToParse[current + ahead];
                } else {
                    return {};
                }
            }
            std::optional<std::string> consume() {
                if (current < size) {
                    return tokensToParse[current++];
                } else {
                    return {};
                }
            }
            bool isInt(std::string in) {
                for (const char& c : in) {
                    if (!std::isdigit(c)) {
                        return false;
                    }
                }
                return true;
            }
            bool isDouble(std::string in) {
                bool foundDot = false;
                for (const char& c : in) {
                    if (!std::isdigit(c)) {
                        if (!foundDot && c == '.') {
                            foundDot = true;
                            continue;
                        }
                        return false;
                    }
                }
                return true;
            }
            bool isString(std::string in) {
                if (in.size() > 1 && in[0] == '"' && in.back() == '"') {
                    return true;
                }
                return false;
            }
            bool isChar(std::string in) {
                if (in.size() == 3 && in[0] == '\'' && in.back() == '\'') {
                    return true;
                }
                return false;
            }
            bool isBool(std::string in) {
                if (in == "true" || in == "false") {
                    return true;
                }
                return false;
            }
            HGDataType getDataType(std::string in) {
                if (isInt(in)) {
                    return HGDataType::Int;
                }
                if (isDouble(in)) {
                    return HGDataType::Double;
                }
                if (isString(in)) {
                    return HGDataType::String;
                }
                if (isChar(in)) {
                    return HGDataType::Char;
                }
                if (isBool(in)) {
                    return HGDataType::Bool;
                }
                return HGDataType::None;
            }
            HGNodeType getNodeType(std::string in) {
                if (getDataType(in) != HGDataType::None) {
                    return HGNodeType::Value;
                }
                if (in == "+") {
                    return HGNodeType::Add;
                }
                if (in == "puts") {
                    return HGNodeType::Puts;
                }
                if (in == "if") {
                    return HGNodeType::If;
                }
                if (in == "{") {
                    return HGNodeType::CodeBlockStart;
                }
                if (in == "}") {
                    return HGNodeType::CodeBlockEnd;
                }
                return HGNodeType::None;
            }
            public:
            Parser(std::vector<std::string> in) : tokensToParse(in) {}
            HGNode parse() {
                current = 0;
                size = tokensToParse.size();
                HGNode rootNode(HGNodeType::Root);
                while (auto tokenopt = consume()) {
                    std::string token = tokenopt.value();
                    switch (getNodeType(token)) {
                        case HGNodeType::Value: {
                            switch (getDataType(token)) {
                                case HGDataType::Int: {
                                    HGNode intNode(HGNodeType::Value);
                                    intNode.setValue((int64_t) std::stoll(token));
                                    rootNode.addNode(intNode);
                                    break;
                                }
                                case HGDataType::Double: {
                                    HGNode doubleNode(HGNodeType::Value);
                                    doubleNode.setValue(std::stod(token));
                                    rootNode.addNode(doubleNode);
                                    break;
                                }
                                case HGDataType::String: {
                                    HGNode stringNode(HGNodeType::Value);
                                    stringNode.setValue(token.substr(1, token.size() - 2));
                                    rootNode.addNode(stringNode);
                                    break;
                                }
                                case HGDataType::Char: {
                                    HGNode charNode(HGNodeType::Value);
                                    charNode.setValue(token[1]);
                                    rootNode.addNode(charNode);
                                    break;
                                }
                                case HGDataType::Bool: {
                                    HGNode boolNode(HGNodeType::Value);
                                    boolNode.setValue(token == "true");
                                    rootNode.addNode(boolNode);
                                    break;
                                }
                            }
                            break;
                        }
                        case HGNodeType::Add: {
                            HGNode addNode(HGNodeType::Add);
                            addNode.addNode(rootNode.children.back());
                            rootNode.children.pop_back();
                            auto tokenopt = consume();
                            if (tokenopt) {
                                addNode.addNode(parseOneToken(tokenopt));
                            } else {
                                std::cout << "FEED ME MORE TOKENS\n";
                                exit(1);
                            }
                            rootNode.addNode(addNode);
                            break;
                        }
                        case HGNodeType::Puts: {
                            HGNode putsNode(HGNodeType::Puts);
                            std::vector<std::string> tokens;
                            while (auto tokenopt = consume()) {
                                if (tokenopt.value() == "\n") {
                                    break;
                                }
                                tokens.push_back(tokenopt.value());
                            }
                            auto children = Parser(tokens).parse();
                            for (auto& child : children.children) {
                                putsNode.addNode(child);
                            } 
                            rootNode.addNode(putsNode);
                            break;
                        }
                        case HGNodeType::If: {
                            HGNode ifNode(HGNodeType::If);
                            std::vector<std::string> tokens;
                            while (auto tokenopt = consume()) {
                                if (tokenopt.value() == "\n") {
                                    break;
                                }
                                tokens.push_back(tokenopt.value());
                            }
                            auto children = Parser(tokens).parse();
                            if (children.children.size() != 1) {
                                std::cout << "Too many or too little conditions for if\n";
                                exit(1);
                            }
                            ifNode.addNode(children.children[0]);
                            tokens.clear();
                            size_t brackets = 1;
                            auto tokenopt = consume();
                            if (tokenopt) {
                                if (tokenopt.value() == "{") {
                                    tokens.push_back(tokenopt.value());
                                    while (auto tokenopt = consume()) {
                                        tokens.push_back(tokenopt.value());
                                        if (tokenopt.value() == "{") {
                                            brackets++;
                                        }
                                        if (tokenopt.value() == "}") {
                                            brackets--;
                                        }
                                        if (brackets == 0) {
                                            break;
                                        }
                                    }
                                } else {
                                    std::cout << "I want a code block\n";
                                    exit(1);
                                }
                            } else {
                                std::cout << "FEED ME MORE TOKENSSSSS\n";
                                exit(1);
                            }
                            break;
                        }
                        case HGNodeType::CodeBlockStart: {
                            HGNode codeBlockNode(HGNodeType::CodeBlock);
                            // WIP
                            break;
                        }
                    }
                }
                return rootNode;
            }
        };
        GroundProgram assembleProgram(HGNode& rootNode) {
            GroundProgram gp = groundCreateProgram();
            auto code = rootNode.generateCode();
            for (int i = 0; i < code.size(); i++) {
                for (const auto& inst : code[i].code) {
                    groundAddInstructionToProgram(&gp, inst);
                }
            }
            return gp;
        }
    } // namespace Parser
    class Lexer {
        std::string input;
        size_t size;
        size_t current;
        std::optional<char> peek(int ahead = 1) {
            if (current + ahead < size) {
                return input[current + ahead];
            } else {
                return {};
            }
        }
        std::optional<char> consume() {
            if (current < size) {
                return input[current++];
            } else {
                return {};
            }
        }
        public:
        Lexer(std::string in) : input(in), size(in.size()) {};
        std::vector<std::string> lex() {
            current = 0;
            std::vector<std::string> tokens;
            std::string buf;
            while (auto copt = consume()) {
                char c = copt.value();
                switch (c) {
                    // tokens which are not followed by anything
                    case '\n':
                    case '(':
                    case ')':
                    case '}': 
                    {
                        if (!buf.empty()) {
                            tokens.push_back(buf);
                            buf.clear();
                        }
                        tokens.push_back(std::string(1, c));
                        break;
                    }
                    // tokens which may be followed by either themselves
                    // or an equals sign
                    case '+':
                    case '-':
                    {
                        std::string newToken(1, c);
                        auto tokenopt = peek();
                        if (tokenopt) {
                            char token = tokenopt.value();
                            if (token == c || token == '=') {
                                newToken += token;
                                consume();
                            }
                        }
                        if (!buf.empty()) {
                            tokens.push_back(buf);
                            buf.clear();
                        }
                        tokens.push_back(newToken);
                        break;
                    }
                    // tokens which may be followed by an equals sign
                    case '*':
                    case '/':
                    case '=':
                    {
                        std::string newToken(1, c);
                        auto tokenopt = peek();
                        if (tokenopt) {
                            char token = tokenopt.value();
                            if (token == '=') {
                                newToken += token;
                                consume();
                            }
                        }
                        if (!buf.empty()) {
                            tokens.push_back(buf);
                            buf.clear();
                        }
                        tokens.push_back(newToken);
                        break;
                    }
                    // tokens which need a newline inserted for them
                    case '{':
                    {
                        if (!buf.empty()) {
                            tokens.push_back(buf);
                            buf.clear();
                        }
                        tokens.push_back(std::string(1, c));
                        tokens.push_back("\n");
                    }
                    // tokens which do not need to be included
                    case ' ':
                    {
                        if (!buf.empty()) {
                            tokens.push_back(buf);
                            buf.clear();
                        }
                        break;
                    }
                    default: 
                    {
                        buf += c;
                    }
                }
            }
            if (!buf.empty()) {
                tokens.push_back(buf);
            }
            return tokens;
        }
    };
 } // namespace HighGround
 int main(int argc, char** argv) {
    if (argc < 2) {
        std::cout << "Usage: " << argv[0] << " (file)\n"; 
        exit(1);
    }
    std::ifstream file(argv[1]);
    std::ostringstream ss;
    ss << file.rdbuf();
    auto lexed = HighGround::Lexer(ss.str()).lex();
    auto parsed = HighGround::Parser::Parser(lexed).parse();
    GroundProgram program = HighGround::Parser::assembleProgram(parsed);
    groundRunProgram(&program);
 }
--- a/src/parser/SolsNode.c
+++ b/src/parser/SolsNode.c
@@ -0,0 +1,70 @@
 #include "SolsNode.h"
 #include <stdarg.h>
 #include <stdio.h>
 #include "../include/error.h"
 #include "../lexer/SolsLiteral.h"
 #include "../lexer/SolsType.h"
 ResultType(SolsNode, charptr) createSolsNode(SolsNodeType type, ...) {
    va_list args;
    va_start(args, type);
    SolsNode node = {
        .type = type,
        .children.capacity = 32,
        .children.count = 0,
        .children.at = malloc(sizeof(SolsNode) * 32)
    };
    if (node.children.at == NULL) {
        return Error(SolsNode, charptr, "Failed to allocate memory for children (in createSolsNode() function)");
    }
    switch (type) {
        case SNT_LITERAL: {
            node.as.literal = va_arg(args, SolsLiteral);
            break;
        }
        case SNT_TYPE: {
            node.as.type = va_arg(args, SolsType);
            break;
        }
        case SNT_IDENTIFIER: {
            node.as.idName = va_arg(args, char*);
            break;
        }
        case SNT_GROUND: {
            node.as.inlineGround = va_arg(args, char*);
            break;
        }
        default: break;
    }
    va_end(args);
    return Success(SolsNode, charptr, node);
 }
 ResultType(Nothing, charptr) addChildToSolsNode(SolsNode* parent, SolsNode child) {
    if (parent->children.count + 1 >= parent->children.capacity) {
        parent->children.capacity *= 2;
        SolsNode* tmp = realloc(parent->children.at, sizeof(SolsNode) * parent->children.capacity);
        if (tmp == NULL) {
            return Error(Nothing, charptr, "Failed to increase memory for children (in addChildToSolsNode() function)");
        }
        parent->children.at = tmp;
    }
    parent->children.at[parent->children.count] = deepCopySolsNode(child);
    parent->children.count++;
    return Success(Nothing, charptr, {});
 }
 SolsNode deepCopySolsNode(SolsNode node) {
    SolsNode copy = node;
    copy.children.at = malloc(sizeof(SolsNode) * node.children.capacity);
    for (size_t i = 0; i < node.children.count; i++) {
        copy.children.at[i] = deepCopySolsNode(node.children.at[i]);
    }
    return copy;
 }
--- a/src/parser/SolsNode.h
+++ b/src/parser/SolsNode.h
@@ -0,0 +1,65 @@
 #ifndef SOLSNODE_H
 #define SOLSNODE_H
 #include <stdarg.h>
 #include <groundvm.h>
 #include "../include/error.h"
 #include "../lexer/SolsType.h"
 #include "../lexer/SolsLiteral.h"
 #include "../lexer/SolsToken.h"
 typedef enum SolsNodeType {
    SNT_IDENTIFIER, SNT_LITERAL, SNT_TYPE, SNT_CODE_BLOCK, SNT_OP_ADD, SNT_OP_SUB, SNT_OP_MUL, SNT_OP_DIV, SNT_OP_ADDTO, SNT_OP_SUBTO, SNT_OP_MULTO, SNT_OP_DIVTO, SNT_OP_INCREMENT, SNT_OP_DECREMENT, SNT_OP_SET, SNT_OP_GREATER, SNT_OP_LESSER, SNT_OP_EQUAL, SNT_OP_INEQUAL, SNT_OP_EQGREATER, SNT_OP_EQLESSER, SNT_DEF, SNT_LAMBDA, SNT_FUNCTION_CALL, SNT_RETURN, SNT_USE, SNT_STRUCT, SNT_PUTS, SNT_IF, SNT_WHILE, SNT_NEW, SNT_GROUND, SNT_ROOT
 } SolsNodeType;
 struct SolsNode;
 // Represents an AST node.
 // Most node types use the .type and .children fields, however some nodes require storing
 // more data, inside the .as union.
 // Those tokens are:
 //    SNT_LITERAL: A literal value. Uses field .as.literal
 //    SNT_TYPE: A type descriptor. Uses field .as.type
 //    SNT_IDENTIFIER: An identifier. Uses field .as.idName
 //    SNT_GROUND: Ground code embedded inside Solstice. Uses field .as.inlineGround
 typedef struct SolsNode {
    SolsNodeType type;
    union {
        SolsLiteral literal;
        SolsType type;
        char* idName;
        char* inlineGround;
    } as;
    struct {
        size_t count;
        size_t capacity;
        struct SolsNode* at;
    } children;
    LineInfo line;
    // Used by the code generator, unless value is a literal do not use in parser
    GroundArg accessArg;
 } SolsNode;
 Result(SolsNode, charptr);
 // Creates a SolsNode. If the type passed in is SNT_LITERAL, SNT_TYPE, SNT_IDENTIFIER or
 // SNT_KW_GROUND, the function expects another argument, corresponding to the data type
 // the token holds. See the SolsNode struct for more information.
 // Returns:
 //    Success: The created SolsNode
 //    Failure: char* detailing what went wrong (usually memory failure)
 ResultType(SolsNode, charptr) createSolsNode(SolsNodeType type, ...);
 // Adds a child to a SolsNode.
 // Returns:
 //    Success: Nothing
 //    Failure: char* detailing what went wrong (usually memory failure)
 ResultType(Nothing, charptr) addChildToSolsNode(SolsNode* parent, SolsNode child);
 // Deep copies a SolsNode
 SolsNode deepCopySolsNode(SolsNode node);
 #endif
--- a/src/parser/parser.c
+++ b/src/parser/parser.c
--- a/src/parser/parser.h
+++ b/src/parser/parser.h
@@ -0,0 +1,99 @@
 #ifndef PARSER_H
 #define PARSER_H
 #include "SolsNode.h"
 #include "../lexer/SolsToken.h"
 #include "../include/error.h"
 #include "../include/nothing.h"
 // Defines precedence for different tokens.
 // Lower number means higher priority.
 // Any operation involving same or higher precedence than
 // the current token's precedence should be processed first
 // (i.e. placed further down the tree) 
 typedef enum SolsTokenPrecedence {
    STP_NEWLINE = 0,
    STP_PUTS = 1,
    STP_IF = 1,
    STP_WHILE = 1,
    STP_COMPARE = 2,
    STP_SET = 3,
    STP_FUNCTION = 4,
    STP_ADD = 5,
    STP_MUL = 6,
    STP_OTHER = 7,
 } SolsTokenPrecedence;
 // Gets the precedence of the provided token.
 SolsTokenPrecedence getPrecedence(SolsToken* token);
 // Holds information about the parser.
 // .input is lexed tokens, produced by a lexer.
 // .current is the token currently being parsed.
 // .output is the final product of the parser.
 // .currentParent points to the current node being processed
 // .errors holds any errors generated during parsing
 typedef struct SolsParser {
    SolsTokens* input;
    size_t current;
    SolsNode output;
    SolsNode* currentParent;
    struct {
        size_t count;
        size_t capacity;
        char** at;
    } errors;
 } SolsParser;
 Result(SolsParser, charptr);
 // Creates a SolsParser.
 // Returns:
 //    Success: Constructed SolsParser
 //    Failure: char* detailing what went wrong (usually memory failure)
 ResultType(SolsParser, charptr) createSolsParser(SolsTokens* input);
 // Parses the tokens in the SolsParser into an AST.
 // Returns:
 //    Success: Nothing (output is stored in the passed SolsLexer)
 //    Failure: char* detailing what went wrong (usually user error)
 ResultType(Nothing, charptr) parse(SolsParser* parser);
 Result(SolsNode, Nothing);
 // Parses one singular node and returns it. 
 // Returns:
 //    Success: The parsed SolsNode
 //    Failure: Nothing (out of bounds, or an error)
 Result(SolsToken, Nothing);
 // Peeks at a token at a specific index in the lexer, 0 being the first token.
 // Returns:
 //    Success: The requested token
 //    Failure: Nothing (token is out of bounds)
 ResultType(SolsToken, Nothing) parserLookAt(SolsParser* parser, size_t where);
 // Peeks at future tokens in the parser, 0 meaning current token, 1 the next.
 // Returns:
 //    Success: The requested token
 //    Failure: Nothing (token is out of bounds)
 ResultType(SolsToken, Nothing) parserPeek(SolsParser* parser, int64_t ahead);
 // Consumes the next token in the parser.
 // Returns:
 //    Success: The requested token
 //    Failure: Nothing (we have reached the end of the tokens passed)
 ResultType(SolsToken, Nothing) parserConsume(SolsParser* parser);
 // Macro for cleaner handling of each token type in the parser.
 // Calls functions and returns errors for you! Such amazing
 #define PARSER_HANDLE(tokentype) {\
    ResultType(Nothing, charptr) __result = parse##tokentype(parser);\
    if (__result.error) {\
        createParserError(parser, __result.as.error);\
    }\
    break;\
 }
 #endif
--- a/src/typeparser/typeparser.c
+++ b/src/typeparser/typeparser.c
@@ -0,0 +1,230 @@
 #include "typeparser.h"
 #include "../lexer/SolsToken.h"
 #include "../include/error.h"
 #include <string.h>
 ResultType(SolsType, charptr) parseType(SolsTokens* in, size_t* index) {
    if (*index >= in->count) {
        return Error(SolsType, charptr, "Unexpected end of tokens while parsing type");
    }
    SolsToken* token = &in->at[*index];
    if (token->type == STT_TYPE) {
        // It's already a basic type token
        ResultType(SolsType, charptr) res = copySolsType(&token->as.type);
        (*index)++;
        return res;
    }
    if (token->type == STT_IDENTIFIER) {
        if (strcmp(token->as.idName, "fun") == 0) {
            (*index)++; // skip fun
            if (*index >= in->count || in->at[*index].type != STT_OPEN_PAREN) {
                return Error(SolsType, charptr, "Expected '(' after 'fun' in type signature");
            }
            (*index)++; // skip (
            ResultType(SolsType, charptr) funTypeRes = createSolsType(STT_FUN);
            if (funTypeRes.error) return funTypeRes;
            SolsType funType = funTypeRes.as.success;
            if (*index < in->count && in->at[*index].type != STT_CLOSE_PAREN) {
                for (;;) {
                    ResultType(SolsType, charptr) argType = parseType(in, index);
                    if (argType.error) {
                        freeSolsType(&funType);
                        return argType;
                    }
                    addChildToSolsType(&funType, argType.as.success, NULL);
                    freeSolsType(&argType.as.success); // addChildToSolsType copies it
                    if (*index < in->count && in->at[*index].type == STT_COMMA) {
                        (*index)++; // skip comma
                    } else {
                        break;
                    }
                }
            }
            if (*index >= in->count || in->at[*index].type != STT_CLOSE_PAREN) {
                freeSolsType(&funType);
                return Error(SolsType, charptr, "Expected ')' after function arguments in type signature");
            }
            (*index)++; // skip )
            // Return type
            ResultType(SolsType, charptr) retType = parseType(in, index);
            if (retType.error) {
                freeSolsType(&funType);
                return retType;
            }
            // Allocate memory for returnType pointer
            funType.returnType = malloc(sizeof(SolsType));
            if (funType.returnType == NULL) {
                freeSolsType(&funType);
                freeSolsType(&retType.as.success);
                return Error(SolsType, charptr, "Couldn't allocate memory (in parseType() function)");
            }
            *funType.returnType = retType.as.success;
            return Success(SolsType, charptr, funType);
        }
        if (strcmp(token->as.idName, "object") == 0 || strcmp(token->as.idName, "template") == 0) {
            bool isTemplate = strcmp(token->as.idName, "template") == 0;
            (*index)++; // skip object/template
            if (*index >= in->count || in->at[*index].type != STT_OPEN_PAREN) {
                return Error(SolsType, charptr, "Expected '(' after object/template in type signature");
            }
            (*index)++; // skip (
            ResultType(SolsType, charptr) complexTypeRes = createSolsType(isTemplate ? STT_TEMPLATE : STT_OBJECT);
            if (complexTypeRes.error) return complexTypeRes;
            SolsType complexType = complexTypeRes.as.success;
            if (*index < in->count && in->at[*index].type != STT_CLOSE_PAREN) {
                for (;;) {
                    ResultType(SolsType, charptr) fieldType = parseType(in, index);
                    if (fieldType.error) {
                        freeSolsType(&complexType);
                        return fieldType;
                    }
                    char* fieldName = NULL;
                    if (*index < in->count && in->at[*index].type == STT_IDENTIFIER) {
                        fieldName = in->at[*index].as.idName;
                        (*index)++;
                    }
                    addChildToSolsType(&complexType, fieldType.as.success, fieldName);
                    freeSolsType(&fieldType.as.success);
                    if (*index < in->count && in->at[*index].type == STT_COMMA) {
                        (*index)++; // skip comma
                    } else {
                        break;
                    }
                }
            }
            if (*index >= in->count || in->at[*index].type != STT_CLOSE_PAREN) {
                freeSolsType(&complexType);
                return Error(SolsType, charptr, "Expected ')' in type signature");
            }
            (*index)++; // skip )
            return Success(SolsType, charptr, complexType);
        }
        // Handle user-defined types (as identifiers)
        // For now, let's just create an OBJECT type with identifierType set
        ResultType(SolsType, charptr) userTypeRes = createSolsType(STT_OBJECT);
        if (userTypeRes.error) return userTypeRes;
        SolsType userType = userTypeRes.as.success;
        userType.identifierType = malloc(strlen(token->as.idName) + 1);
        if (userType.identifierType == NULL) {
            freeSolsType(&userType);
            return Error(SolsType, charptr, "Couldn't allocate memory (in parseType() function)");
        }
        strcpy(userType.identifierType, token->as.idName);
        (*index)++;
        return Success(SolsType, charptr, userType);
    }
    return Error(SolsType, charptr, "Unexpected token while parsing type");
 }
 ResultType(SolsTokens, charptr) addTypeInfo(SolsTokens* in) {
    ResultType(SolsTokens, charptr) tokensres = createSolsTokens();
    if (tokensres.error) {
        return tokensres;
    }
    SolsTokens tokens = tokensres.as.success;
    for (size_t i = 0; i < in->count; ) {
        if (in->at[i].type == STT_IDENTIFIER && 
            (strcmp(in->at[i].as.idName, "fun") == 0 || 
             strcmp(in->at[i].as.idName, "object") == 0 || 
             strcmp(in->at[i].as.idName, "template") == 0)) {
            size_t startIndex = i;
            ResultType(SolsType, charptr) typeRes = parseType(in, &i);
            if (typeRes.error) {
                // For now, return error
                return Error(SolsTokens, charptr, typeRes.as.error);
            }
            ResultType(SolsToken, charptr) tokenRes = createSolsToken(STT_TYPE, typeRes.as.success);
            if (tokenRes.error) {
                freeSolsType(&typeRes.as.success);
                return Error(SolsTokens, charptr, tokenRes.as.error);
            }
            // Add line info from original token
            tokenRes.as.success.line.num = in->at[startIndex].line.num;
            if (in->at[startIndex].line.content) {
                tokenRes.as.success.line.content = malloc(strlen(in->at[startIndex].line.content) + 1);
                if (tokenRes.as.success.line.content) {
                    strcpy(tokenRes.as.success.line.content, in->at[startIndex].line.content);
                }
            } else {
                tokenRes.as.success.line.content = NULL;
            }
            addTokenToSolsTokens(&tokens, tokenRes.as.success);
            // SolsToken now owns typeRes.as.success and its buffers.
        } else {
            // Need to deep copy the token because addTokenToSolsTokens just copies the struct
            // and freeSolsToken will free buffers.
            // Wait, if we use the same tokens, it's fine.
            // But 'in' tokens might be freed later.
            // Actually, we are creating a *new* SolsTokens.
            // So we should probably copy the token properly.
            SolsToken original = in->at[i];
            SolsToken copy = {0};
            copy.type = original.type;
            copy.line.num = original.line.num;
            if (original.line.content) {
                copy.line.content = malloc(strlen(original.line.content) + 1);
                if (copy.line.content) strcpy(copy.line.content, original.line.content);
            }
            switch (original.type) {
                case STT_IDENTIFIER:
                    copy.as.idName = malloc(strlen(original.as.idName) + 1);
                    if (copy.as.idName) strcpy(copy.as.idName, original.as.idName);
                    break;
                case STT_KW_GROUND:
                    copy.as.inlineGround = malloc(strlen(original.as.inlineGround) + 1);
                    if (copy.as.inlineGround) strcpy(copy.as.inlineGround, original.as.inlineGround);
                    break;
                case STT_LITERAL:
                    // Literals also need deep copy?
                    // SolsLiteral has stringv.
                    if (original.as.literal.type == SLT_STRING) {
                        copy.as.literal.type = SLT_STRING;
                        copy.as.literal.as.stringv = malloc(strlen(original.as.literal.as.stringv) + 1);
                        if (copy.as.literal.as.stringv) strcpy(copy.as.literal.as.stringv, original.as.literal.as.stringv);
                    } else {
                        copy.as.literal = original.as.literal;
                    }
                    break;
                case STT_TYPE: {
                    ResultType(SolsType, charptr) copiedType = copySolsType(&original.as.type);
                    if (!copiedType.error) {
                        copy.as.type = copiedType.as.success;
                    }
                    break;
                }
                default:
                    copy.as = original.as;
                    break;
            }
            addTokenToSolsTokens(&tokens, copy);
            i++;
        }
    }
    return Success(SolsTokens, charptr, tokens);
 }
--- a/src/typeparser/typeparser.h
+++ b/src/typeparser/typeparser.h
@@ -0,0 +1,11 @@
 #ifndef TYPEPARSER_H
 #define TYPEPARSER_H
 #include "../lexer/SolsToken.h"
 #include "../include/error.h"
 // Scans a SolsTokens and identifies type signatures, like fun(int) string.
 // These are then converted into a single STT_TYPE token.
 ResultType(SolsTokens, charptr) addTypeInfo(SolsTokens* in);
 #endif
--- a/src/wasm_main.c
+++ b/src/wasm_main.c
@@ -0,0 +1,81 @@
 #include <emscripten.h>
 #include <stdio.h>
 #include <string.h>
 #include <setjmp.h>
 #include "lexer/lexer.h"
 #include "typeparser/typeparser.h"
 #include "parser/parser.h"
 #include "codegen/codegen.h"
 #include <groundvm.h>
 static char out_buf[65536];
 static int  out_pos = 0;
 // Defined by Ground
 void wasm_print(const char* str);
 EMSCRIPTEN_KEEPALIVE
 const char* solstice_run(char* source) {
    out_pos = 0;
    out_buf[0] = '\0';
    // 1. Lex
    ResultType(SolsLexer, charptr) lexer = createLexer(source);
    if (lexer.error) {
        snprintf(out_buf, sizeof(out_buf),
            "[lex error] %s", lexer.as.error);
        return out_buf;
    }
    ResultType(Nothing, charptr) lexed = lex(&lexer.as.success);
    if (lexed.error) {
        snprintf(out_buf, sizeof(out_buf), "%s", lexed.as.error);
        return out_buf;
    }
    // 2. Type parse
    ResultType(SolsTokens, charptr) typed = addTypeInfo(&lexer.as.success.output);
    if (typed.error) {
        snprintf(out_buf, sizeof(out_buf), "%s", typed.as.error);
        return out_buf;
    }
    // 3. Parse
    ResultType(SolsParser, charptr) parser = createSolsParser(&typed.as.success);
    if (parser.error) {
        snprintf(out_buf, sizeof(out_buf),
            "[parse error] %s", parser.as.error);
        return out_buf;
    }
    ResultType(Nothing, charptr) parsed = parse(&parser.as.success);
    if (parsed.error) {
        snprintf(out_buf, sizeof(out_buf), "%s", parsed.as.error);
        return out_buf;
    }
    // 4. Codegen
    SolsScope scope = {
        .variables = NULL,
        .tmpCounter = 0,
        .returnType = createSolsType(STT_INT).as.success
    };
    ResultType(GroundProgram, charptr) codegen =
        generateCode(&parser.as.success.output, &scope);
    if (codegen.error) {
        snprintf(out_buf, sizeof(out_buf), "%s", codegen.as.error);
        return out_buf;
    }
    // 5. Run
    GroundValue retval = groundRunProgram(&codegen.as.success);
    if (out_pos == 0) {
        // Program produced no output — report exit code
        snprintf(out_buf, sizeof(out_buf),
            "[exited with code %d]",
            retval.type == INT ? retval.data.intVal : 0);
    }
    return out_buf;
 }
--- a/tests/closure.sols
+++ b/tests/closure.sols
@@ -0,0 +1,9 @@
 def createClosure(int x) fun(int) int {
    return lambda(int y) int {
        return x + y
    }
 }
 myVar = createClosure(5)
 puts myVar(3)
--- a/tests/compare.sols
+++ b/tests/compare.sols
@@ -0,0 +1,55 @@
 if 1 == 1 {
    puts "working"
 }
 if 1 == 2 {
    puts "not working"
 }
 if 1 != 2 {
    puts "working"
 }
 if 1 != 1 {
    puts "not working"
 }
 if 2 > 1 {
    puts "working"
 }
 if 1 > 2 {
    puts "not working"
 }
 if 1 < 2 {
    puts "working"
 }
 if 2 < 1 {
    puts "not working"
 }
 if 2 >= 2 {
    puts "working"
 }
 if 2 >= 1 {
    puts "working"
 }
 if 2 >= 3 {
    puts "not working"
 }
 if 2 <= 2 {
    puts "working"
 }
 if 2 <= 3 {
    puts "working"
 }
 if 3 <= 2 {
    puts "not working"
 }
--- a/tests/convert.sols
+++ b/tests/convert.sols
@@ -0,0 +1,11 @@
 use conversions
 use io
 myString = "312"
 myInt = 435
 myNewString = intToString(myInt)
 myNewInt = stringToInt(myString)
 println(myNewString)
 puts myNewInt
--- a/tests/count.sols
+++ b/tests/count.sols
@@ -0,0 +1,6 @@
 number = 0
 while number != 10 {
    number = number + 1 
    puts number
 }
--- a/tests/data.hg
+++ b/tests/data.hg
@@ -1,5 +0,0 @@
 puts "dingus"
 puts 432
 puts 3.141
 puts 'c'
 puts true
--- a/tests/data.sols
+++ b/tests/data.sols
@@ -0,0 +1,7 @@
 puts "dingus"
 puts 432
 puts 3.141
 puts 'c'
 puts true
 puts "now we have proper string lexing!!!!!11!!@!2!1@1@12!!!112!@"
--- a/tests/fib.sols
+++ b/tests/fib.sols
@@ -0,0 +1,15 @@
 a = 0
 b = 1
 n = 92
 i = 0
 while i != n {
    temp = a + b
    a = b
    b = temp
    i = i + 1
 }
 puts a
--- a/tests/function.sols
+++ b/tests/function.sols
@@ -0,0 +1,6 @@
 def add(int a, int b) int {
    puts "testing"
    return 3
 }
 puts add(1, 2)
--- a/tests/if.sols
+++ b/tests/if.sols
@@ -0,0 +1,7 @@
 if 1 == 1 {
    puts "huzzah"
 }
 if 5 == 10 {
    puts "aww"
 }
--- a/tests/inlineground.sols
+++ b/tests/inlineground.sols
@@ -0,0 +1,7 @@
 result = 0
 ground {
    println "dingus"
    add 3 2 &result
 }
 puts result
--- a/tests/input.sols
+++ b/tests/input.sols
@@ -0,0 +1,15 @@
 use io
 accessNotGranted = true
 while accessNotGranted {
    password = input("Password: ")
    if password == "dingus" {
        accessNotGranted = false
    }
    if password != "dingus" {
        puts "Incorrect password!"
    }
 }
 puts "Welcome!"
--- a/tests/int.sols
+++ b/tests/int.sols
--- a/tests/math.sols
+++ b/tests/math.sols
--- a/tests/print.sols
+++ b/tests/print.sols
@@ -1 +1,3 @@
 use io
 println("dingus")
--- a/tests/set.sols
+++ b/tests/set.sols
@@ -0,0 +1,3 @@
 x = 5
 y = 10
 puts x + y
--- a/tests/struct.sols
+++ b/tests/struct.sols
@@ -0,0 +1,18 @@
 use io
 struct dingus {
    x = 5
    y = "dingus"
 }
 e = new dingus
 puts e
 puts dingus
 puts e.x
 println(e.y)
 e.x = 7
 e.y = "heheheha"
 puts e.x
 println(e.y)
--- a/tests/while.sols
+++ b/tests/while.sols
@@ -0,0 +1,3 @@
 while 1 == 1 {
    puts "yay infinite loop"
 }
--- a/vim/ftdetect/solstice.vim
+++ b/vim/ftdetect/solstice.vim
@@ -0,0 +1 @@
 au BufRead,BufNewFile *.sols setfiletype solstice
--- a/vim/syntax/solstice.vim
+++ b/vim/syntax/solstice.vim
@@ -0,0 +1,41 @@
 " Vim highlight file for Solstice (.sols)
 if exists("b:current_syntax")
  finish
 endif
 " Keywords
 syn keyword solsticeConditional       if
 syn keyword solsticeRepeat            while
 syn keyword solsticeKeyword           def struct return use
 syn keyword solsticeType              int string bool double char
 syn keyword solsticeBoolean           true false
 " Built-in functions
 syn keyword solsticeBuiltin           puts print println input
 " Data Types
 syn match   solsticeNumber            "\d\+\(\.\d\+\)\="
 syn region  solsticeString            start=/"/ end=/"/
 syn match   solsticeCharacter         /'[^']'/
 " Operators
 syn match   solsticeOperator          "==\|!=\|>=\|<=\|++\|--\|+\=\|-\=\|\*=\|\/="
 syn match   solsticeOperator          "[><=+\-*/]"
 " Delimiters
 syn match  solsticeDelimiter         "[{()}]"
 hi def link solsticeConditional       Conditional
 hi def link solsticeRepeat            Repeat
 hi def link solsticeKeyword           Keyword
 hi def link solsticeType              Type
 hi def link solsticeBoolean           Boolean
 hi def link solsticeBuiltin           Function
 hi def link solsticeNumber            Number
 hi def link solsticeString            String
 hi def link solsticeCharacter         Character
 hi def link solsticeOperator          Operator
 hi def link solsticeDelimiter         Delimiter
 let b:current_syntax = "solstice"
Author	SHA1	Message	Date
Maxwell Jeffress	631b587d07	Fix a load of stuff	2026-03-07 16:26:54 +11:00
Maxwell Jeffress	445ba032f5	Add unistd.sols to libraries	2026-03-07 16:26:20 +11:00
Maxwell Jeffress	41a2fa53c6	Start work on WASM compatibility, lambda fix	2026-03-06 09:24:16 +11:00
Maxwell Jeffress	00ef8a7d56	Type parser	2026-03-05 19:32:31 +11:00
Maxwell Jeffress	f1eee4f6a8	Command line argument parsing	2026-03-04 12:25:59 +11:00
Maxwell Jeffress	cfca3c1d7a	Lambdas now capture state	2026-03-03 08:00:00 +11:00
Maxwell Jeffress	40e0aec0d4	Package builder	2026-03-01 16:33:00 +11:00
Maxwell Jeffress	38473f0e01	Friendship ended with C++, C is my new best friend	2026-03-01 16:00:03 +11:00
Maxwell Jeffress	139be30e2d	Fix spelling mistake	2026-01-29 09:07:43 +11:00
Maxwell Jeffress	d576c7cdfc	Wrap websockets in request library	2026-01-28 21:11:54 +11:00
Maxwell Jeffress	2e4dbce100	Fix Makefile	2026-01-28 20:24:15 +11:00
Maxwell Jeffress	ea6bf5925b	Add file and request libs	2026-01-28 20:13:28 +11:00
Maxwell Jeffress	142268c016	Output ground files as executable	2026-01-28 18:58:39 +11:00
Maxwell Jeffress	1c6b145d35	Update Makefile	2026-01-28 17:44:38 +11:00
Maxwell Jeffress	6002bd922b	(BREAKING) "use" keyword, stdlib seperate	2026-01-28 17:03:40 +11:00
Maxwell Jeffress	4b86fee7b5	Object field assignment	2026-01-28 14:56:36 +11:00
Maxwell Jeffress	d12036fe70	Fix type issues with struct access	2026-01-27 21:30:50 +11:00
Maxwell Jeffress	59e273b26e	Member access (no writing yet)	2026-01-27 21:12:09 +11:00
Maxwell Jeffress	e285b2c59f	Use `new` to create an object from a struct	2026-01-27 14:10:57 +11:00
Maxwell Jeffress	e3abe07f4b	Add intToString() and stringToInt() functions	2026-01-27 12:19:26 +11:00
Maxwell Jeffress	010d155f5d	Start work on structs	2026-01-25 17:40:07 +11:00
Maxwell Jeffress	44785185f7	Update syntax highlighting	2026-01-25 13:37:03 +11:00
Maxwell Jeffress	c82f81f668	Compilation with ground->asm	2026-01-21 16:26:17 +11:00
Maxwell Jeffress	9397f410da	Use Chookspace Pages to redirect auto to sols.dev	2026-01-20 12:14:15 +11:00
Maxwell Jeffress	6d5d29f05b	Use inbuilt stdlib instead of hard coded functions	2026-01-12 16:18:59 +11:00
Maxwell Jeffress	48c130351a	Fix indentation	2026-01-12 15:43:18 +11:00
Maxwell Jeffress	6bc483b1db	Inline ground	2026-01-12 15:24:37 +11:00
Maxwell Jeffress	c5b67bff72	Function calling fix	2026-01-12 14:45:07 +11:00
Maxwell Jeffress	ca8db171d9	Type checking for functions	2025-12-29 10:30:07 +11:00
Maxwell Jeffress	c266728ff0	make function calling better	2025-12-28 13:49:05 +11:00
Maxwell Jeffress	b46a66cea7	Partially working function calling	2025-12-28 13:41:05 +11:00
Maxwell Jeffress	337b88c148	Fix function calling bug	2025-12-26 13:50:14 +11:00
Maxwell Jeffress	d8812fa14e	Refactor type system, print all errors in file	2025-12-26 13:28:47 +11:00
Maxwell Jeffress	24ea348858	Fix clang builds	2025-12-25 22:42:25 +11:00
Maxwell Jeffress	9a311c3cb8	Better errors, comments	2025-12-25 22:37:40 +11:00
Maxwell Jeffress	aa5ef0e664	Operator precedence I think	2025-12-24 22:01:16 +11:00
Maxwell Jeffress	7ff306b9e8	Some math (no order of operations yet)	2025-12-24 16:22:51 +11:00
Maxwell Jeffress	ac7f22e1bc	Continue type checker work	2025-12-24 14:31:43 +11:00
Maxwell Jeffress	5ec2f86b70	Start work on static type checking	2025-12-24 13:16:11 +11:00
Maxwell	7dd2b10603	Direct users to solstice website for docs	2025-12-23 23:47:01 +11:00
Maxwell Jeffress	7351604571	Vim syntax highlighting	2025-12-22 20:38:02 +11:00
Maxwell Jeffress	43310c70bf	Clean up temporary variables properly	2025-12-22 19:38:06 +11:00
Maxwell Jeffress	957e0fd95a	Start work on dropping tmp vars after use	2025-12-22 14:26:12 +11:00
Maxwell Jeffress	525b2bc733	Add >, >=, <, <=	2025-12-22 13:49:44 +11:00
Maxwell Jeffress	d2f295f46a	refactor	2025-12-21 12:06:55 +11:00
Maxwell Jeffress	869f71466e	Add argument parser, output files	2025-12-21 11:42:18 +11:00
Maxwell Jeffress	a3a9553189	Function calling and input() builtin	2025-12-20 20:25:48 +11:00
Maxwell Jeffress	3c66df5be0	Add fib test	2025-12-20 16:27:54 +11:00
Maxwell	ce058c8f9c	Update README.md	2025-12-20 15:29:18 +11:00
Maxwell	2aff15a317	Add logo	2025-12-20 15:28:39 +11:00
Maxwell Jeffress	72ec9c1fb6	Fixes, rebrand	2025-12-20 15:09:09 +11:00
Maxwell Jeffress	c04e631180	Half working stuff	2025-12-20 14:47:24 +11:00
Maxwell Jeffress	16a406b52f	Variables	2025-12-20 14:28:39 +11:00
Maxwell Jeffress	0488067ef2	While loop	2025-12-20 07:37:15 +11:00
Maxwell Jeffress	a8e5f6a0f1	Proper string parsing	2025-12-20 06:58:41 +11:00
Maxwell Jeffress	e8bf7b70f7	Fix lexer	2025-12-19 17:01:57 +11:00
Maxwell Jeffress	b5c8b1b7ec	WIP conditionals work	2025-12-19 16:17:57 +11:00
Maxwell Jeffress	99bc0dbdc2	If statements	2025-12-15 11:37:27 +11:00
`@@ -1 +1,3 @@`
		`use io`

	`println("dingus")`	`println("dingus")`
		`@@ -0,0 +1 @@`
							`au BufRead,BufNewFile *.sols setfiletype solstice`