Update README.md

Reviewed-on: max/ground#18

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "libraries"]
+	path = libraries
+	url = https://chookspace.com/ground/libraries

README.md

@@ -2,7 +2,7 @@
 
 ## What is Ground?
 
-Ground is an interpreter which processes and interprets Ground instructions. It is quite fast, and the syntax is simple.
+Ground is a sigma interpreter which processes and interprets Ground instructions. It is quite fast, and the syntax is simple.
 
 ## What are the main features of Ground?
 

docs/highlight.py

@@ -0,0 +1,70 @@
+import sys
+
+if len(sys.argv) < 2:
+    exit(1)
+
+fileName = sys.argv[1]
+thefile = open(fileName).readlines()
+
+def isnumber(num):
+    try:
+        float(num)
+        return True
+    except ValueError:
+        return False
+
+allstr = ""
+color = ""
+keywords = ["if", "jump", "end", "stdin", "stdout", "stdlnout", "set", "gettype", "exists", "setlist", "setlistat", "getlistat", "getlistsize", "listappend", "getstrsize", "getstrcharat", "add", "subtract", "multiply", "divide", "equal", "inequal", "not", "greater", "lesser", "stoi", "stod", "tostring", "fun", "return", "endfun", "pusharg", "call", "use", "extern", "error"]
+
+for line in thefile:
+    allstr += line + " <br> "
+
+lines = len(allstr.split("<br>"))-1
+a = allstr.split()
+
+for i in range(lines):
+    instr = False
+    incom = False
+    words = len(allstr.split("<br>")[i].split())
+    for j in range(words):
+        tempword = allstr.split("<br>")[i].split()[j]
+        if allstr.split("<br>")[i].split()[0][0] == "#":
+            color = "\033[37m"
+        elif allstr.split("<br>")[i].split()[0][0] == "@":
+            color = "\033[32m"
+        elif tempword in keywords:
+            color = "\033[95m"
+        elif isnumber(tempword) or tempword == "true" or tempword == "false":
+            color = "\033[96m"
+        elif tempword[0] == "#":
+            incom = True
+            color = "\033[37m"
+        elif tempword[0] == "&":
+            color = "\033[93m"
+        elif tempword[0] == "$":
+            color = "\033[33m"
+        elif tempword[0] == "%":
+            color = "\033[32m"
+        elif tempword[0] == "-":
+            color = "\033[34m"
+        elif tempword[0] == "!":
+            color = "\033[94m"
+        elif tempword[0] == "*":
+            color = "\033[93m"
+        elif tempword[0] == "\"":
+            color = "\033[92m"
+            instr = not instr
+        elif tempword[0] == "\'" and tempword[len(tempword)-1] == "\'":
+            color = "\033[92m"
+        elif instr:
+            color = "\033[92m"
+        elif incom:
+            color = "\033[37m"
+        else:
+            color = "\033[91m"
+        
+        print(f'{color}{tempword}', end=" ")
+    print()
+    
+print("\033[00m", end="")

docs/syntax.md

@@ -84,23 +84,23 @@ Usage: `end $intvalue`
 
 ### I/O
 
-#### stdin
+#### input (or stdin)
 
 Allows input from the console.
 
-Usage: `stdin &var`
+Usage: `input &var`
 
-#### stdout
+#### print (or stdout)
 
 Allows output to the console.
 
-Usage: `stdout $value`
+Usage: `print $value`
 
-#### stdlnout
+#### println (or stdlnout)
 
 Allows output to the console, appending a new line at the end.
 
-Usage: `stdlnout $value`
+Usage: `println $value`
 
 ### Variables and Lists
 
@@ -110,6 +110,20 @@ Allows you to set a variable to a value.
 
 Usage: `set &var $value`
 
+#### gettype
+
+Gets the type of a variable. Outputs a string which can be "int", "double", "bool", "string", "char".
+
+Usage: `gettype $value &var`
+
+#### exists
+
+Checks if a variable exists with a direct reference. If the variable exists, outputs true. Otherwise outputs false.
+
+Usage `exists &var1 &var2`
+
+Note: You can also replace &var1 with a list or line reference to check if it also exists
+
 #### setlist
 
 Allows you to initialize a list.
@@ -238,9 +252,9 @@ Some symbols specific to this category:
 
 * `!function`: A function reference
 
-* `-type`: A type reference. Can be one of the following: "-string", "-char", "-int", "-double", "-bool"
+* `-type`: A type reference. Can be one of the following: "-string", "-char", "-int", "-double", "-bool", or a custom struct (see "Custom data structures" below)
 
-#### fun 
+#### fun
 
 Defines a function. All code between `fun` and `endfun` will be included in the function.
 
@@ -272,19 +286,46 @@ Calls a function, with all the arguments in the argument list. The return value
 
 Usage: `call !function &var
 
+### Custom Data Structures
+
+#### struct
+
+Begins creation of a custom data structure, which can contain values and functions. Similar to a class or struct in other programming languages.
+
+In between the `struct` and `endstruct` lines, you can insert the following:
+
+* `init` statements, to initialize values
+* `fun`/`endfun` statements, to add member functions to the struct
+
+When calling a function from inside a struct, all members of the struct are avaliable to read from and write to.
+
+Usage: `struct -structName`
+
+#### endstruct
+
+Ends creation of a custom data structure.
+
+Usage: `endstruct`
+
+#### init
+
+Initialises a variable with the default value of a type.
+
+Usage: `init &var -type`
+
 ### Interacting with Libraries
 
-#### use (Experimental, please report bugs!)
+#### use
 
-Attempts to import another Ground program. Gets inserted wherever the use statement is. Any code (including code outside function declarations) will be executed. 
+Attempts to import another Ground program. Gets inserted wherever the use statement is. Any code (including code outside function declarations) will be executed. All functions from the library will be given a prefix, meaning functions will be registered as `!libName:functionName`.
 
 Note: Ground will check the directory where the program is being run from when trying to find imported programs. If that fails, it will check the directory set in the $GROUND_LIBS environment variable set by your system. The '.grnd' extension is appended automatically.
 
 Usage: `use $stringvalue`
 
-#### extern (Experimental, please report bugs!)
+#### extern
 
-Attempts to import a shared object library written for Ground. All functions in the external library will be usable with `call`.
+Attempts to import a shared object library written for Ground. All functions in the external library will be usable with `call`. All functions from the library will be given a prefix, meaning functions will be registered as `!libName:functionName`.
 
 Note: Ground will check the directory set in the $GROUND_LIBS environment variable set by your system. The '.so' (Linux), '.dylib' (macOS), or '.dll' (Windows) extension is appended automatically.
 

docs/tutorial.md

@@ -0,0 +1,349 @@
+# Ground Tutorial
+
+Get up and running with Ground in no time!
+
+## First Steps
+
+First, create a file ending in `.grnd` and open it in your favourite text editor. Then, write the following:
+
+```
+println "Hello, World!"
+```
+
+(I think you know what this does.)
+
+(If you don't, it prints something to the console, and adds a new line at the end.)
+
+You can test it on the console using the Ground interpreter:
+
+```bash
+ground myFile.grnd
+```
+
+But that's boring! You want to be able to do more in Ground. So, let's ask the user for something. We can write:
+
+```
+input &var
+println $var
+```
+
+This will wait for the user to type something into the console and press enter, and will save it to the variable `var`. Then, we print out the variable `var`.
+
+But how do variables work in Ground?
+
+## Variables
+
+In Ground, variables are used to store values. (Yeah, I know, very original.) However, variables work a bit differently. What you need to know right now are called "value references" and "direct references".
+
+### Value References
+
+A value reference gets the value of a variable, and inserts it into the statement currently being executed.
+
+For example, let's assume I have a variable called `myVar`, and it has the value `"Hello from the variable!"`. If you want to access that value, you use a value reference. To use a value reference, write the variable name, but prefixed with the `$` sign.
+
+Let's try printing out `myVar`:
+
+```
+println $myVar
+```
+
+Sidenote: Value references are inserted before each line of code is ran.
+
+You should see "Hello from the variable!" on the console, assuming you defined `myVar` beforehand. But how do you define a variable?
+
+### Direct References
+
+Direct references allow you to write to a variable. To use one, prefix your desired variable name with an `&` symbol.
+
+Ground works differently to many programming languages in that you can't write things like `myVar = 10`. Everything uses an instruction (which I'll explain in a moment). So in Ground, you'd write:
+
+```
+set &myVar 10
+```
+
+to set `myVar` to 10. Simple, right?
+
+### Summary
+* Value references let you get the variable of a value, and are prefixed with `$`.
+* Direct references let you write to variables, and are prefixed with `&`.
+
+As an example:
+
+```
+set &myVar "Hello from the variable!"
+println $myVar
+```
+
+will set `myVar` to "Hello from the variable!", and print it to the console.
+
+## Instructions
+
+Now, I assume you want to do more than setting variables and printing them, right? Luckily for you, Ground has (at the time of writing) 35 instructions to build whatever you can think of (not to mention libraries, but that's a later topic).
+
+First, here's how you use them:
+
+### Using instructions
+
+Each line of Ground code contains an instruction and arguments. For example:
+
+```
+add 9 10 &result
+```
+
+This uses the `add` keyword (which adds two things together) to add 9 and 10, and outputs the result (which would be 19) to the direct reference provided (`result`).
+
+So each instruction works sort of like a function in most other languages.
+
+Now you know how they work, here's a list of cool instructions:
+
+### Cool instructions
+
+So here's a list of some instructions keywords to know about at present:
+
+### Mathy stuff
+
+`add`, `subtract`, `multiply`, `divide`
+
+These instructions all take two numbers, and operate on them (add adds, subtract subtracts, and so on), and then output the result to the provided direct reference. You can use them all like:
+
+```
+add 5 6 &addition
+```
+
+```
+multiply 10 30 &myVar
+```
+
+(and so on.)
+
+Tip: `add` works on strings for concatenation! (for those who don't know, a string is a series of characters surrounded with `"`'s)
+
+### User interaction
+
+`input` (or `stdin`)
+
+This instruction takes input from the console, and saves it to the given direct reference. For example:
+
+```
+input &myVar
+```
+
+`print` (or `stdout`) and `println` (or `stdlnout`)
+
+These instructions print out values to the console. `println` also prints a new line character after your statement. For example:
+
+```
+println "Hi there! This has a new line at the end"
+print "Heyo! This doesn't have a new line at the end."
+```
+
+### Other variable stuff
+
+`set`
+
+Sets a variable to something.
+
+For example:
+
+```
+set &myVar "Hi there!"
+```
+
+`gettype`
+
+Gets the type of a variable, in the form of a string. As an example:
+
+```
+gettype $someSortOfValue &type
+```
+
+If you accessed `$type`, you'd get one of the following:
+
+"int", "double", "bool", "string", "char".
+
+More on types later!
+
+## Commenting
+
+Comments are done with a `#`. Anything after the `#` on the line is ignored.
+
+## Control Flow
+
+Now, I assume you want to be able to use logic in your programs, right? Ground simplifies control flow to the bare minimum.
+
+### Labels
+
+A label is a point in your Ground code you can jump to. To set one, instead of writing an instruction, you can do something like this:
+
+```
+@myLabel
+```
+
+This will allow you to jump back to that point in code at any time.
+
+### Jumping around
+
+Jump to labels with the `jump` instruction.
+
+```
+# Infinite loop!
+@myLabel
+jump %myLabel
+```
+
+But what does `%myLabel` mean? This is the third reference type: a line reference. It tells Ground which line to look at.
+
+You can also use `if`, however `if` works differently:
+
+```
+@myLabel
+if $myCondition %myLabel
+```
+
+This essentialy says "if `myCondition` is true, then jump to `myLabel`". But how do you compute conditions?
+
+### More instructions!
+
+Here are some useful instructions to compute a condition:
+
+`equal`, `inequal`
+
+These compare two values, and puts a boolean in a variable once they're compared.
+
+Example:
+
+```
+# Prints out true
+equal "Hello!" "Hello!" &condition
+println $condition
+
+# Prints out false
+equal 10 20 &condition
+println $condition
+
+# Prints out true
+inequal "Hi there!" "Hello there!" &condition
+println $condition
+```
+
+`equal` and `inequal` work on most regular values.
+
+`greater`, `lesser`
+
+These instructions check if the first provided value is greater or lesser than the second provided value. As an example:
+
+```
+# Prints out true
+greater 10 5 &condition
+println $condition
+```
+
+### So how do I use these?
+
+Labels, `if`, and `jump` can be used to create what would be if and while statements in other languages. Here's a loop that counts to 10:
+
+```
+set &counter 0
+
+@loopStart
+
+# Add one to our counter and print it out
+add $counter 1 &counter
+println $counter
+
+# Check if we've hit 10 yet
+equal $counter 10 &condition
+
+# If we have, go to the end of the loop
+if $condition %loopEnd
+
+# Otherwise, go back to the start
+jump %loopStart
+@loopEnd
+```
+
+And here's a conditional if statement that checks if a user guessed the right password:
+
+```
+# Ask the user what the password is
+print "Password: "
+input &password
+
+# Check if they got it right
+equal $password "supersecurepassword" &condition
+if $condition %rightPassword
+jump %wrongPassword
+
+@rightPassword
+println "Correct!"
+jump %end
+
+@wrongPassword
+println "Incorrect!"
+jump %end
+
+@end
+```
+
+## Building a meaningful program
+
+Now we have all the building blocks to create a simple program!
+
+Let's write a program that loops until the user tells us the right answer to a question. Here's how we do it:
+
+First let's create a label so we can loop back to the start of our program:
+
+```
+@begin
+```
+
+Then we ask the user for their answer:
+
+```
+print "Do you like cheese?"
+input &userInput
+```
+
+After this, we can check for the desired answer:
+```
+equal $userInput "yes" &condition
+if $condition %success
+```
+
+Now, if the user answers "yes" to our question, they will be sent to the `%success` label. But we need to handle what happens if they don't say what we want them to.
+
+So we can tell them that they said the wrong thing, and jump back to the start of the program.
+
+```
+println "That's a pity"
+jump %begin
+```
+
+At last, we should handle what happens when we get the input we want:
+
+```
+@success
+println "Yay!"
+```
+
+Try running that program!
+
+Here's the full text of what we wrote:
+
+```
+@begin
+print "Do you like cheese?"
+input &userInput
+equal $userInput "yes" &condition
+if $condition %success
+
+println "That's a pity"
+jump %begin
+
+@success
+println "Yay!"
+```
+
+## Next Steps
+
+Now you've completed the basic tutorial! This will probably be expanded in future, but for now you can look at [the syntax guide](https://chookspace.com/ground/ground/src/branch/master/docs/syntax.md) for more features to use.

extlibs/file.cpp

@@ -1,43 +0,0 @@
-#include "ground_lib.h"
-
-#include <fstream>
-#include <filesystem>
-
-GroundValue readFile(GroundValue* args, int arg_count) {
-    VALIDATE_ARGS_1(GROUND_STRING);
-
-    std::ifstream ffile(GET_STRING(args[0]));
-
-    std::string tmp;
-    std::string out;
-
-    while (std::getline(ffile, tmp)) {
-        out += tmp + "\n";
-    }
-    
-    return ground_string_val(out);
-}
-
-GroundValue writeFile(GroundValue* args, int arg_count) {
-    VALIDATE_ARGS_2(GROUND_STRING, GROUND_STRING);
-
-    std::ofstream file(GET_STRING(args[0]));
-    if (file.good()) {
-        file << GET_STRING(args[1]);
-    } else {
-        std::cout << "File isn't good for writing in" << std::endl;
-        return GROUND_BOOL_VAL(false);
-    }
-    
-    return GROUND_BOOL_VAL(true);
-}
-
-GROUND_LIBRARY_INTERFACE()
-
-GROUND_LIBRARY_INIT()
-    REGISTER_GROUND_FUNCTION(readFile);
-    REGISTER_GROUND_FUNCTION(writeFile);
-GROUND_LIBRARY_INIT_END()
-
-GROUND_LIBRARY_CLEANUP()
-GROUND_LIBRARY_CLEANUP_END()

extlibs/ground_lib.h

@@ -1,193 +0,0 @@
-#ifndef GROUND_LIB_H
-#define GROUND_LIB_H
-
-#include <cstring>
-#include <string>
-#include <vector>
-#include <iostream>
-
-// Ground types - must match the interpreter
-typedef enum {
-    GROUND_INT,
-    GROUND_DOUBLE, 
-    GROUND_BOOL,
-    GROUND_STRING,
-    GROUND_CHAR
-} GroundType;
-
-typedef struct {
-    GroundType type;
-    union {
-        int int_val;
-        double double_val;
-        int bool_val;
-        char* string_val;
-        char char_val;
-    } data;
-} GroundValue;
-
-// Helper macros for creating GroundValue objects
-#define GROUND_INT_VAL(x) ({ GroundValue v; v.type = GROUND_INT; v.data.int_val = (x); v; })
-#define GROUND_DOUBLE_VAL(x) ({ GroundValue v; v.type = GROUND_DOUBLE; v.data.double_val = (x); v; })
-#define GROUND_BOOL_VAL(x) ({ GroundValue v; v.type = GROUND_BOOL; v.data.bool_val = (x) ? 1 : 0; v; })
-#define GROUND_CHAR_VAL(x) ({ GroundValue v; v.type = GROUND_CHAR; v.data.char_val = (x); v; })
-
-// Helper function for creating string values
-inline GroundValue ground_string_val(const std::string& str) {
-    GroundValue v;
-    v.type = GROUND_STRING;
-    char* result_str = new char[str.length() + 1];
-    std::strcpy(result_str, str.c_str());
-    v.data.string_val = result_str;
-    return v;
-}
-
-// Helper function for creating string values from C strings
-inline GroundValue ground_cstring_val(const char* str) {
-    GroundValue v;
-    v.type = GROUND_STRING;
-    if (str) {
-        size_t len = std::strlen(str);
-        char* result_str = new char[len + 1];
-        std::strcpy(result_str, str);
-        v.data.string_val = result_str;
-    } else {
-        v.data.string_val = nullptr;
-    }
-    return v;
-}
-
-// Helper macros for type checking
-#define IS_INT(v) ((v).type == GROUND_INT)
-#define IS_DOUBLE(v) ((v).type == GROUND_DOUBLE)
-#define IS_BOOL(v) ((v).type == GROUND_BOOL)
-#define IS_STRING(v) ((v).type == GROUND_STRING)
-#define IS_CHAR(v) ((v).type == GROUND_CHAR)
-
-// Helper macros for extracting values
-#define GET_INT(v) ((v).data.int_val)
-#define GET_DOUBLE(v) ((v).data.double_val)
-#define GET_BOOL(v) ((v).data.bool_val != 0)
-#define GET_STRING(v) ((v).data.string_val)
-#define GET_CHAR(v) ((v).data.char_val)
-
-// Helper macros for argument validation
-#define REQUIRE_ARGS(count) \
-    if (arg_count < (count)) { \
-        std::cerr << "Error: Expected at least " << (count) << " arguments, got " << arg_count << std::endl; \
-        return GROUND_BOOL_VAL(false); \
-    }
-
-#define REQUIRE_TYPE(arg_index, expected_type) \
-    if (args[arg_index].type != expected_type) { \
-        std::cerr << "Error: Argument " << (arg_index + 1) << " must be of type " << #expected_type << std::endl; \
-        return GROUND_BOOL_VAL(false); \
-    }
-
-// Convenience macro for checking both arg count and types
-#define VALIDATE_ARGS_1(type1) \
-    REQUIRE_ARGS(1); \
-    REQUIRE_TYPE(0, type1);
-
-#define VALIDATE_ARGS_2(type1, type2) \
-    REQUIRE_ARGS(2); \
-    REQUIRE_TYPE(0, type1); \
-    REQUIRE_TYPE(1, type2);
-
-#define VALIDATE_ARGS_3(type1, type2, type3) \
-    REQUIRE_ARGS(3); \
-    REQUIRE_TYPE(0, type1); \
-    REQUIRE_TYPE(1, type2); \
-    REQUIRE_TYPE(2, type3);
-
-// Function registration helpers
-class GroundLibrary {
-private:
-    std::vector<std::string> function_names;
-    std::vector<void*> function_pointers;
-    
-public:
-    void register_function(const std::string& name, void* ptr) {
-        function_names.push_back(name);
-        function_pointers.push_back(ptr);
-    }
-    
-    const char** get_function_names() {
-        static std::vector<const char*> names;
-        names.clear();
-        for (const auto& name : function_names) {
-            names.push_back(name.c_str());
-        }
-        names.push_back(nullptr);  // Null terminator
-        return names.data();
-    }
-    
-    void* get_function(const char* name) {
-        for (size_t i = 0; i < function_names.size(); i++) {
-            if (function_names[i] == name) {
-                return function_pointers[i];
-            }
-        }
-        return nullptr;
-    }
-};
-
-// Global library instance
-extern GroundLibrary ground_lib_registry;
-
-// Macro to register functions easily
-#define REGISTER_GROUND_FUNCTION(func_name) \
-    ground_lib_registry.register_function(#func_name, (void*)func_name)
-
-// Macro to define the library interface
-#define GROUND_LIBRARY_INTERFACE() \
-    GroundLibrary ground_lib_registry; \
-    extern "C" { \
-        const char** ground_get_functions() { \
-            return ground_lib_registry.get_function_names(); \
-        } \
-        void* ground_get_function(const char* name) { \
-            return ground_lib_registry.get_function(name); \
-        } \
-    }
-
-// Optional initialization macro
-#define GROUND_LIBRARY_INIT() \
-    extern "C" { \
-        void ground_lib_init() {
-
-#define GROUND_LIBRARY_INIT_END() \
-        } \
-    }
-
-// Optional cleanup macro
-#define GROUND_LIBRARY_CLEANUP() \
-    extern "C" { \
-        void ground_lib_cleanup() {
-
-#define GROUND_LIBRARY_CLEANUP_END() \
-        } \
-    }
-
-// Utility function to print GroundValue for debugging
-inline void debug_print_ground_value(const GroundValue& v) {
-    switch (v.type) {
-        case GROUND_INT:
-            std::cout << "INT: " << v.data.int_val << std::endl;
-            break;
-        case GROUND_DOUBLE:
-            std::cout << "DOUBLE: " << v.data.double_val << std::endl;
-            break;
-        case GROUND_BOOL:
-            std::cout << "BOOL: " << (v.data.bool_val ? "true" : "false") << std::endl;
-            break;
-        case GROUND_STRING:
-            std::cout << "STRING: " << (v.data.string_val ? v.data.string_val : "(null)") << std::endl;
-            break;
-        case GROUND_CHAR:
-            std::cout << "CHAR: '" << v.data.char_val << "'" << std::endl;
-            break;
-    }
-}
-
-#endif // GROUND_LIB_H

extlibs/request.cpp

@@ -1,45 +0,0 @@
-#include "ground_lib.h"
-
-#include <cpr/cpr.h>
-#include <cpr/interface.h>
-#include <fstream>
-
-GroundValue simpleRequest(GroundValue* args, int arg_count) {
-    VALIDATE_ARGS_1(GROUND_STRING);
-
-    cpr::Response r = cpr::Get(cpr::Url(GET_STRING(args[0])));
-
-    if (!(r.status_code >= 200 && r.status_code < 300)) {
-        return ground_string_val("Error code " + std::to_string(r.status_code));    
-    }
-    
-    return ground_string_val(r.text);
-}
-
-GroundValue saveContents(GroundValue* args, int arg_count) {
-    VALIDATE_ARGS_2(GROUND_STRING, GROUND_STRING);
-
-    std::ofstream file(GET_STRING(args[1]), std::ios::binary);
-
-    if (file.good()) {
-        cpr::Response r = cpr::Download(file, cpr::Url{GET_STRING(args[0])});
-
-        if (r.status_code >= 200 && r.status_code < 300) {
-            return GROUND_BOOL_VAL(false);
-        }
-    } else {
-        return GROUND_BOOL_VAL(false);
-    }
-
-    return GROUND_BOOL_VAL(true);
-}
-
-GROUND_LIBRARY_INTERFACE()
-
-GROUND_LIBRARY_INIT()
-    REGISTER_GROUND_FUNCTION(simpleRequest);
-    REGISTER_GROUND_FUNCTION(saveContents);
-GROUND_LIBRARY_INIT_END()
-
-GROUND_LIBRARY_CLEANUP()
-GROUND_LIBRARY_CLEANUP_END()

tests/error.grnd

@@ -0,0 +1,23 @@
+fun -int !divten -int &divisor
+    divide 10 $divisor &out
+    # Skip the rest of the function because we have an error
+    println "aw yeag we devided by zero"
+    return $out
+endfun
+
+fun -string !wrapperFn -int &dingle
+    pusharg $dingle
+    !divten &result
+    # Skip the rest of the function because we have an error
+    println "big error incoming"
+    tostring $result &out
+    return $out
+endfun
+
+catch "divisionByZeroError" &success
+pusharg 0
+!wrapperFn &result
+
+# There's a catch in this scope, stop here and continue execution
+
+println $success

tests/exists.grnd

@@ -0,0 +1,20 @@
+set &testVar "dingus"
+exists &testVar &exist
+stdlnout $exist
+
+setlist *myList "item"
+exists *myList &exist
+stdlnout $exist
+
+@dingus
+exists %dingus &exist
+stdlnout $exist
+
+exists &doesNotExist &exist
+stdlnout $exist
+
+exists *doesNotExist &exist
+stdlnout $exist
+
+exists %doesNotExist &exist
+stdlnout $exist

tests/functions.grnd

@@ -14,6 +14,36 @@ fun -bool !jumpy
     return true
 endfun
 
-call !jumpy &tmp
+!jumpy &tmp
 
 stdlnout "I called a function"
+
+# This function returns a list
+
+fun -list !dingus
+    stdlnout "Testing lists in functions"
+    setlist *dingle "heheheha" "hahahahe" "hmmm"
+    return *dingle
+endfun
+
+call !dingus *outlist
+
+getlistsize *outlist &size
+set &counter 0
+@loopstart
+equal $size $counter &cond
+if $cond %loopend
+getlistat *outlist $counter &tmp
+stdlnout $tmp
+add 1 $counter &counter
+jump %loopstart
+@loopend
+
+fun -int !doSomething -int &a -string &b
+    println $a
+    println $b
+    return 0
+endfun
+
+pusharg 432 "dingle"
+!doSomething &ret

tests/gettype.grnd

@@ -0,0 +1,5 @@
+set &myVar "dingus"
+
+gettype $myVar &type
+
+stdlnout $type

tests/lists.grnd

@@ -1,5 +1,6 @@
 # A cool list
 setlist *favWords "hello" "there" "general" "kenobi"
+stdlnout *favWords
 
 set &count 0
 set &passedThrough true

tests/struct.grnd

@@ -0,0 +1,29 @@
+struct -point
+    init &xpos -int
+    init &ypos -int
+
+    fun -int !init -int &x -int &y
+        set &xpos $x
+        set &ypos $y
+        return 0
+    endfun
+
+    fun -string !toString
+        tostring $xpos &xposstr
+        tostring $ypos &yposstr
+        add "x: " $xposstr &str
+        add $str ", y: " &str
+        add $str $yposstr &str
+        return $str
+    endfun
+endstruct
+
+init &myPoint -point
+
+pusharg 30 15
+!myPoint.init &out
+println $myPoint.xpos
+
+!myPoint.toString &out
+
+println $out

tests/to1000.grnd

@@ -1,5 +1,6 @@
 set &var 0
+@jump
 add 1 $var &var
 stdlnout $var
-greater 1000 $var &cond
-if $cond %2
+greater 10000 $var &cond
+if $cond %jump

tests/use/use.grnd

@@ -1,5 +1,5 @@
 use "library"
 
-call !dingus &var
+call !library:dingus &var
 
 stdlnout $var