Revert "started writing lexer after making string lib"

This reverts commit c0c35e4d17.
started writing lexer after making string lib
2026-04-13 20:00:55 +10:00 · 2026-04-13 20:00:38 +10:00 · 2026-04-13 19:59:48 +10:00 · 2026-04-13 13:00:51 +10:00 · 2026-04-13 09:30:17 +10:00 · 2026-04-12 21:16:59 +10:00
34 changed files with 527 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/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
-
-* `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
-```
+Docs are avaliable at https://sols.dev/docs/
--- 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) bool {}
+
+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/lexer/.DS_Store
+++ b/src/lexer/.DS_Store
--- a/src/lexer/lexer.sols
+++ b/src/lexer/lexer.sols
@@ -0,0 +1,97 @@
+use collections
+use string
+
+//
+// Token type enum.
+//
+// Each token can be one of these types.
+//
+enum SolsToken {
+    Identifier, Literal, Type,
+    
+    Dot, OpenCurly, CloseCurly, OpenParen, CloseParen, Comma,
+
+    OpAdd, OpSub, OpMul, OpDiv, OpAddTo, OpSubTo, OpMulTo, OpDivTo, OpIncrement, OpDecrement, OpSet,
+    OpGreater, OpLesser, OpEqual, OpInequal, OpEqGreater, OpEqLesser,
+
+    KwDef, KwLambda, KwReturn, KwUse, KwStruct, KwEnum, KwConstructor,
+    KwDestructor, KwDuplicator, KwPrivate, KwProtected, KwPuts, KwIf,
+    KwWhile, KwNew, KwGround,
+
+    LineEnd,
+
+}
+
+//
+// Token type map.
+//
+// If a token matches one of the strings in this hashmap, 
+// its type gets set to the token type for that string.
+//
+KEYWORDS = Hashmap()
+KEYWORDS.set("puts", SolsToken.KwPuts)
+KEYWORDS.set("if", SolsToken.KwIf)
+KEYWORDS.set("while", SolsToken.KwWhile)
+KEYWORDS.set("def", SolsToken.KwDef)
+KEYWORDS.set("lambda", SolsToken.KwLambda)
+KEYWORDS.set("return", SolsToken.KwReturn)
+KEYWORDS.set("use", SolsToken.KwUse)
+KEYWORDS.set("struct", SolsToken.KwStruct)
+KEYWORDS.set("enum", SolsToken.KwEnum)
+KEYWORDS.set("constructor", SolsToken.KwConstructor)
+KEYWORDS.set("destructor", SolsToken.KwDestructor)
+KEYWORDS.set("duplicator", SolsToken.KwDuplicator)
+KEYWORDS.set("private", SolsToken.KwPrivate)
+KEYWORDS.set("protected", SolsToken.KwProtected)
+KEYWORDS.set("ground", SolsToken.KwGround)
+KEYWORDS.set("new", SolsToken.KwNew)
+KEYWORDS.set("{", SolsToken.OpenCurly)
+KEYWORDS.set("}", SolsToken.CloseCurly)
+KEYWORDS.set("(", SolsToken.OpenParen)
+KEYWORDS.set(")", SolsToken.CloseParen)
+KEYWORDS.set("+", SolsToken.OpAdd)
+KEYWORDS.set("-", SolsToken.OpSub)
+KEYWORDS.set("*", SolsToken.OpMul)
+KEYWORDS.set("/", SolsToken.OpDiv)
+KEYWORDS.set("=", SolsToken.OpSet)
+KEYWORDS.set("+=", SolsToken.OpAddTo)
+KEYWORDS.set("-=", SolsToken.OpSubTo)
+KEYWORDS.set("*=", SolsToken.OpMulTo)
+KEYWORDS.set("/=", SolsToken.OpDivTo)
+KEYWORDS.set("++", SolsToken.OpIncrement)
+KEYWORDS.set("--", SolsToken.OpDecrement)
+KEYWORDS.set("==", SolsToken.OpEqual)
+KEYWORDS.set("!=", SolsToken.OpInequal)
+KEYWORDS.set(">", SolsToken.OpGreater)
+KEYWORDS.set("<", SolsToken.OpLesser)
+KEYWORDS.set(">=", SolsToken.OpEqGreater)
+KEYWORDS.set("<=", SolsToken.OpEqLesser)
+KEYWORDS.set("\n", SolsToken.LineEnd)
+KEYWORDS.set(";", SolsToken.LineEnd)
+KEYWORDS.set(",", SolsToken.Comma)
+
+struct SolsLexer {
+    sourceCode = "x = 123"
+    current = 0
+
+    private def getTokenType(string input) SolsToken {
+        return KEYWORDS.get(input)
+    }
+
+    def lex() {
+        inString = false
+
+        lineNum = 1
+        lineStart = 0
+        currentLine = ""
+
+        while lineStart < string_Length() {
+            
+        }
+    }
+}
+
+
+
+lexer = new SolsLexer
+puts lexer.getTokenType("if")
--- 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/main.sols
+++ b/src/main.sols
--- 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,32 @@
+struct Person {
+    protected name = ""
+    private age = 0
+
+    def greet() string {
+        return "Hello, " + self.name + "!"
+    }
+
+    def dance() string {
+        return "Dancing..."
+    }
+
+    constructor(string name, int age) {
+        self.name = name
+        self.age = age
+    }
+
+    destructor {
+        // We don't need to do anything here.
+    }
+
+}
+
+max = Person("Max", 16)
+
+puts max
+puts max.greet()
+puts max.name
+// puts max.age (causes compile time error, age is private)
+// max.name = "Maximilian" (causes compile time error, name is protected)
+
+max.dance()
--- 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,45 @@
+" Vim highlight file for Solstice (.sols)
+
+if exists("b:current_syntax")
+  finish
+endif
+
+" Keywords
+syn keyword solsKeyword puts if while def lambda return use struct ground
+syn keyword solsBool    true false
+
+" Types
+syn keyword solsType int double string char bool fun template object
+
+" Strings and chars
+syn region solsString start=/"/ skip=/\\"/ end=/"/
+syn region solsChar   start=/'/ skip=/\\'/ end=/'/
+
+" Numbers
+syn match solsFloat   /\<[0-9]\+\.[0-9]*\>/
+syn match solsInt     /\<[0-9]\+\>/
+
+" Operators
+syn match solsOperator /+\|-\|\*\|\/\|=\|!\|>\|<\|+=\|-=\|\*=\|\/=\|++\|--\|==\|!=\|>=\|<=/
+
+" Delimiters
+syn match solsDelimiter /[{}(),;]/
+
+" Comments
+syn match  solsComment /\/\/.*$/
+syn match  solsComment /#.*$/
+
+" Highlight links
+hi def link solsKeyword   Keyword
+hi def link solsBool      Boolean
+hi def link solsType      Type
+hi def link solsString    String
+hi def link solsChar      Character
+hi def link solsFloat     Float
+hi def link solsInt       Number
+hi def link solsOperator  Operator
+hi def link solsDelimiter Delimiter
+hi def link solsComment   Comment
+
+let b:current_syntax = "solstice"
+
Author	SHA1	Message	Date
SpookyDervish	7c0490668e	Revert "started writing lexer after making string lib" This reverts commit `c0c35e4d17`.	2026-04-13 20:00:55 +10:00
SpookyDervish	e5da1d255b	started writing lexer after making string lib	2026-04-13 20:00:38 +10:00
SpookyDervish	c0c35e4d17	started writing lexer after making string lib	2026-04-13 19:59:48 +10:00
SpookyDervish	f67c045845	need to fix some solstice bugs before i can start on lexer	2026-04-13 13:00:51 +10:00
SpookyDervish	98c8775208	clear out c code	2026-04-13 09:30:17 +10:00
Maxwell Jeffress	f384e19c06	private and protected fields	2026-04-12 21:16:59 +10:00
Maxwell Jeffress	d24462f844	Don't evaluate left of '='	2026-04-12 19:35:56 +10:00
Maxwell Jeffress	4351821d30	Destructor example	2026-04-11 20:42:14 +10:00
Maxwell Jeffress	78f974e189	Destructors	2026-04-11 20:41:54 +10:00
Maxwell Jeffress	1dedb30a87	Constructors	2026-04-11 17:05:20 +10:00
Maxwell Jeffress	2e7b5b7480	Call methods inside objects	2026-04-11 12:03:10 +10:00
Maxwell Jeffress	1cf995f7ac	Fixes for structs	2026-04-10 19:38:26 +10:00
Maxwell Jeffress	605d0a87b1	Update highlighting	2026-04-10 19:37:41 +10:00
Maxwell Jeffress	16569d7355	Struct member writing	2026-04-10 14:57:01 +10:00
Maxwell Jeffress	fd08b7cdb7	Struct field access (slightly buggy)	2026-04-10 10:14:23 +10:00
Maxwell Jeffress	5841a7a999	Parse object member access	2026-04-10 10:00:24 +10:00
Maxwell Jeffress	a2fc138ba1	'new' keyword	2026-04-09 19:00:40 +10:00
Maxwell Jeffress	9b55b509f5	Fix struct interaction with type system	2026-04-09 17:13:51 +10:00
Maxwell Jeffress	f694f50d70	Fix struct parsing	2026-04-09 17:13:13 +10:00
Maxwell Jeffress	5b61a11f00	Codegen for structs	2026-04-09 16:04:53 +10:00
Maxwell Jeffress	00d6ed83fb	Parse structs	2026-04-09 15:39:17 +10:00
Maxwell Jeffress	6988f314b0	Parse exprs in parens	2026-04-09 11:43:00 +10:00
Maxwell Jeffress	70dc5eb5a0	Parse expressions in parens (3 + 2) * 4	2026-04-09 10:38:58 +10:00
Maxwell Jeffress	1e3bd6c601	Division no longer becomes subtraction	2026-04-09 10:17:37 +10:00
Maxwell Jeffress	f66464a7cc	Stuff	2026-04-09 10:01:30 +10:00
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
				`@@ -0,0 +1 @@`
				`au BufRead,BufNewFile *.sols setfiletype solstice`