Tweaked build trigger

Bumped patch version
Update README.md
2024-09-22 15:04:27 +10:00 · 2024-09-22 14:45:04 +10:00 · 2024-09-22 14:43:20 +10:00 · 2024-08-11 21:25:11 +10:00 · 2024-08-09 23:25:56 +10:00 · 2024-07-20 16:27:07 +10:00
88 changed files with 6847 additions and 1353 deletions
@@ -0,0 +1,10 @@
+---
+name: Question
+about: Ask a Question
+labels: question
+---
+
+### How can I help?
+
+I'm always here to help with any inquiries you have regarding Toy and its related projects.
+
@@ -1,17 +1,26 @@
-name: Comprehensive Tests
+name: Continuous Integration v1.x

+#trigger when these occur
 on:
  push:
-    branches: [ "main", "dev" ]
+    branches:
+      - v1
  pull_request:
-    branches: [ "main" ]
+    types:
+      - opened
+      - edited
+      - reopened
+    branches:
+      - v1
+  workflow_dispatch:

+#testing the CI workflows under multiple supported conditions
 jobs:
  test-valgrind:
    runs-on: ubuntu-latest

    steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
    - name: install valgrind
      run: sudo apt install valgrind
    - name: make test (valgrind)
@@ -21,7 +30,7 @@ jobs:
    runs-on: ubuntu-latest

    steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
    - name: make test (sanitized)
      run: make test-sanitized
  
@@ -29,6 +38,6 @@ jobs:
    runs-on: windows-latest
    
    steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
      - name: make test (mingw32)
        run: make test
@@ -1,34 +1,59 @@
-#Editor generated files
-*.suo
-*.ncb
-*.user
-compile_commands.json
+# Prerequisites
+*.d

-#Directories
-Release/
-Debug/
-Out/
-release/
-debug/
-out/
-bin/
-.cache/
-.vs/
-
-#Project generated files
-*.db
+# Object files
 *.o
-*.a
-*.so
-*.dll
-*.exe
-*.meta
-*.log
-*.out
-*.stackdump
-*.tb
-*.filters
+*.ko
+*.obj
+*.elf

-#Shell files
-*.bat
-*.sh
+# Linker output
+*.ilk
+*.map
+*.exp
+
+# Precompiled Headers
+*.gch
+*.pch
+
+# Libraries
+*.lib
+*.a
+*.la
+*.lo
+
+# Shared objects (inc. Windows DLLs)
+*.dll
+*.so
+*.so.*
+*.dylib
+
+# Executables
+*.exe
+*.out
+*.app
+*.i*86
+*.x86_64
+*.hex
+
+# Debug files
+*.dSYM/
+*.su
+*.idb
+*.pdb
+
+# Kernel Module Compile Results
+*.mod*
+*.cmd
+.tmp_versions/
+modules.order
+Module.symvers
+Mkfile.old
+dkms.conf
+
+.cproject
+.project
+.settings/
+temp/
+Release/
+out/
@@ -1,6 +1,6 @@
 # License

-Copyright (c) 2020-2023 Kayne Ruse, KR Game Studios
+Copyright (c) 2020-2024 Kayne Ruse, KR Game Studios

 This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software.

@@ -2,19 +2,21 @@
  <image src="toylogo.png" />
 </p>

-# Toy
+# Toy v1
+
+The Toy programming language is an imperative bytecode-intermediate embedded scripting language. It isn't intended to operate on its own, but rather as part of another program, the "host". This process is intended to allow a decent amount of easy customisation by the host's end user, by exposing logic in script files. Alternatively, binary files in a custom format can be used as well.
+
+The host will provide all of the extensions needed on a case-by-case basis. Script files have the `.toy` file extension, while binary files have the `.tb` file extension.

 This is the Toy programming language interpreter, written in C.

-Special thanks to http://craftinginterpreters.com/ for their fantastic book that set me on this path.
-
 # Nifty Features

 * Simple C-like syntax
 * Bytecode intermediate compilation
 * Optional, but robust type system (including `opaque` for arbitrary data)
 * Functions and types are first-class citizens
-* Import external libraries
+* Import native libraries from the host
 * Fancy slice notation for strings, arrays and dictionaries
 * Can re-direct output, error and assertion failure messages
 * Open source under the zlib license
@@ -33,6 +35,8 @@ Run `make install-tools` to install a number of tools, including:

 * VSCode syntax highlighting

+Other tools such as a disassembler are available, as well - simply run `make` in the correct directory.
+
 ## Syntax

 ```
@@ -67,7 +71,16 @@ print tally(); //3

 This source code is covered by the zlib license (see [LICENSE.md](LICENSE.md)).

+# Contributions
+
+@hiperiondev - Disassembler, porting support and feedback  
+@add00 - Library support  
+@gruelingpine185 - Unofficial MacOS support  
+@solar-mist - Minor bugfixes  
+Unnamed Individuals - Feedback
+
 # Patrons via Patreon

 * Seth A. Robinson

+Special thanks to http://craftinginterpreters.com/ for their fantastic book that set me on this path.
@@ -71,12 +71,12 @@
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
    <IgnoreImportLibrary>false</IgnoreImportLibrary>
-    <OutDir>$(SolutionDir)out\$(Configuration)\</OutDir>
-    <IntDir>$(Platform)\$(ProjectName)\$(Configuration)\</IntDir>
+    <OutDir>$(SolutionDir)out\</OutDir>
+    <IntDir>$(Platform)\$(Configuration)\$(ProjectName)\</IntDir>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
-    <OutDir>$(SolutionDir)out\$(Configuration)\</OutDir>
-    <IntDir>$(Platform)\$(ProjectName)\$(Configuration)\</IntDir>
+    <OutDir>$(SolutionDir)out\</OutDir>
+    <IntDir>$(Platform)\$(Configuration)\$(ProjectName)\</IntDir>
  </PropertyGroup>
  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
    <ClCompile>
@@ -110,45 +110,49 @@
  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
    <Link>
      <AdditionalDependencies>Toy.lib;%(AdditionalDependencies)</AdditionalDependencies>
-      <AdditionalLibraryDirectories>$(SolutionDir)out\$(Configuration)</AdditionalLibraryDirectories>
+      <AdditionalLibraryDirectories>$(SolutionDir)out</AdditionalLibraryDirectories>
    </Link>
    <ClCompile>
      <AdditionalIncludeDirectories>$(SolutionDir)/source;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
      <LanguageStandard_C>stdc17</LanguageStandard_C>
-      <PreprocessorDefinitions>LIB_RUNNER_EXPORT</PreprocessorDefinitions>
+      <PreprocessorDefinitions>%(PreprocessorDefinitions)</PreprocessorDefinitions>
    </ClCompile>
  </ItemDefinitionGroup>
  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
    <ClCompile>
      <LanguageStandard_C>stdc17</LanguageStandard_C>
-      <PreprocessorDefinitions>LIB_RUNNER_EXPORT</PreprocessorDefinitions>
+      <PreprocessorDefinitions>%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <AdditionalIncludeDirectories>$(SolutionDir)/source;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
    </ClCompile>
    <Link>
-      <AdditionalLibraryDirectories>$(SolutionDir)out\$(Configuration)</AdditionalLibraryDirectories>
+      <AdditionalLibraryDirectories>$(SolutionDir)out</AdditionalLibraryDirectories>
      <AdditionalDependencies>Toy.lib;%(AdditionalDependencies)</AdditionalDependencies>
    </Link>
  </ItemDefinitionGroup>
-  <ItemGroup>
-    <ClCompile Include="repl\lib_about.c" />
-    <ClCompile Include="repl\lib_random.c" />
-    <ClCompile Include="repl\lib_runner.c" />
-    <ClCompile Include="repl\lib_standard.c" />
-    <ClCompile Include="repl\repl_main.c" />
-    <ClCompile Include="repl\repl_tools.c" />
-  </ItemGroup>
-  <ItemGroup>
-    <ClInclude Include="repl\lib_about.h" />
-    <ClInclude Include="repl\lib_random.h" />
-    <ClInclude Include="repl\lib_runner.h" />
-    <ClInclude Include="repl\lib_standard.h" />
-    <ClInclude Include="repl\repl_tools.h" />
-  </ItemGroup>
  <ItemGroup>
    <ProjectReference Include="Toy.vcxproj">
      <Project>{26360002-cc2a-469a-9b28-ba0c1af41657}</Project>
    </ProjectReference>
  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="repl\drive_system.c" />
+    <ClCompile Include="repl\lib_math.c" />
+    <ClCompile Include="repl\lib_random.c" />
+    <ClCompile Include="repl\lib_runner.c" />
+    <ClCompile Include="repl\lib_standard.c" />
+    <ClCompile Include="repl\lib_toy_version_info.c" />
+    <ClCompile Include="repl\repl_main.c" />
+    <ClCompile Include="repl\repl_tools.c" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="repl\drive_system.h" />
+    <ClInclude Include="repl\lib_math.h" />
+    <ClInclude Include="repl\lib_random.h" />
+    <ClInclude Include="repl\lib_runner.h" />
+    <ClInclude Include="repl\lib_standard.h" />
+    <ClInclude Include="repl\lib_toy_version_info.h" />
+    <ClInclude Include="repl\repl_tools.h" />
+  </ItemGroup>
  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
  <ImportGroup Label="ExtensionTargets">
  </ImportGroup>
@@ -70,12 +70,14 @@
    <LinkIncremental>true</LinkIncremental>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
-    <OutDir>$(SolutionDir)out\$(Configuration)\</OutDir>
-    <IntDir>$(Platform)\$(ProjectName)\$(Configuration)\</IntDir>
+    <OutDir>$(SolutionDir)out\</OutDir>
+    <IntDir>$(Platform)\$(Configuration)\$(ProjectName)\</IntDir>
+    <LinkIncremental>false</LinkIncremental>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
-    <OutDir>$(SolutionDir)out\$(Configuration)\</OutDir>
-    <IntDir>$(Platform)\$(ProjectName)\$(Configuration)\</IntDir>
+    <OutDir>$(SolutionDir)out\</OutDir>
+    <IntDir>$(Platform)\$(Configuration)\$(ProjectName)\</IntDir>
+    <LinkIncremental>false</LinkIncremental>
  </PropertyGroup>
  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
    <ClCompile>
@@ -111,12 +113,32 @@
      <PreprocessorDefinitions>TOY_EXPORT;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <LanguageStandard_C>stdc17</LanguageStandard_C>
    </ClCompile>
+    <PostBuildEvent>
+      <Command>
+      </Command>
+    </PostBuildEvent>
+    <Link>
+      <OutputFile>$(Outdir)$(TargetName)$(TargetExt)</OutputFile>
+    </Link>
+    <Bscmake>
+      <OutputFile>$(Platform)\$(Configuration)\$(TargetName).bsc</OutputFile>
+    </Bscmake>
  </ItemDefinitionGroup>
  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
    <ClCompile>
      <LanguageStandard_C>stdc17</LanguageStandard_C>
      <PreprocessorDefinitions>TOY_EXPORT;%(PreprocessorDefinitions)</PreprocessorDefinitions>
    </ClCompile>
+    <PostBuildEvent>
+      <Command>
+      </Command>
+    </PostBuildEvent>
+    <Link>
+      <OutputFile>$(Outdir)$(TargetName)$(TargetExt)</OutputFile>
+    </Link>
+    <Bscmake>
+      <OutputFile>$(Platform)\$(Configuration)\$(TargetName).bsc</OutputFile>
+    </Bscmake>
  </ItemDefinitionGroup>
  <ItemGroup>
    <ClCompile Include="source\toy_ast_node.c" />
@@ -131,10 +153,12 @@
    <ClCompile Include="source\toy_literal_dictionary.c" />
    <ClCompile Include="source\toy_memory.c" />
    <ClCompile Include="source\toy_parser.c" />
+    <ClCompile Include="source\toy_reffunction.c" />
    <ClCompile Include="source\toy_refstring.c" />
    <ClCompile Include="source\toy_scope.c" />
  </ItemGroup>
  <ItemGroup>
+    <ClInclude Include="source\toy.h" />
    <ClInclude Include="source\toy_ast_node.h" />
    <ClInclude Include="source\toy_builtin.h" />
    <ClInclude Include="source\toy_common.h" />
@@ -149,6 +173,7 @@
    <ClInclude Include="source\toy_memory.h" />
    <ClInclude Include="source\toy_opcodes.h" />
    <ClInclude Include="source\toy_parser.h" />
+    <ClInclude Include="source\toy_reffunction.h" />
    <ClInclude Include="source\toy_refstring.h" />
    <ClInclude Include="source\toy_scope.h" />
    <ClInclude Include="source\toy_token_types.h" />
@@ -1,7 +1,3 @@
-# Optimisation Options
-# export CFLAGS+=-O2 -mtune=native -march=native
-# export CFLAGS+=-fsanitize=address,undefined
-
 export CFLAGS+=-std=c18 -pedantic -Werror

 export TOY_OUTDIR = out
@@ -28,12 +24,16 @@ library: $(TOY_OUTDIR)
 static: $(TOY_OUTDIR)
 	$(MAKE) -j8 -C source static

-library-release: $(TOY_OUTDIR)
+library-release: clean $(TOY_OUTDIR)
 	$(MAKE) -j8 -C source library-release

-static-release: $(TOY_OUTDIR)
+static-release: clean $(TOY_OUTDIR)
 	$(MAKE) -j8 -C source static-release

+#distribution
+dist: export CFLAGS+=-O2 -mtune=native -march=native
+dist: repl-release
+
 #utils
 test: clean $(TOY_OUTDIR)
 	$(MAKE) -C test
@@ -51,6 +51,25 @@ $(TOY_OUTDIR):
 install-tools:
 	cp -rf tools/toylang.vscode-highlighting ~/.vscode/extensions

+#utils
+build-mecha: $(TOY_OUTDIR)
+	g++ -o $(TOY_OUTDIR)/mecha tools/mecha.cpp
+
+build-docs: build-mecha
+	$(TOY_OUTDIR)/mecha $(wildcard source/*.h)
+	$(TOY_OUTDIR)/mecha $(wildcard repl/*.h)
+
+docs:
+	mkdir docs
+
+move-docs: docs
+	mv -u $(wildcard source/*.md) docs
+	mv -u $(wildcard repl/*.md) docs
+
+documentation:
+	$(MAKE) build-docs
+	$(MAKE) move-docs
+
 .PHONY: clean

 clean:
@@ -0,0 +1,99 @@
+#include "drive_system.h"
+
+#include "toy_memory.h"
+#include "toy_literal_dictionary.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+//file system API
+static Toy_LiteralDictionary driveDictionary;
+
+void Toy_initDriveSystem() {
+	Toy_initLiteralDictionary(&driveDictionary);
+}
+
+void Toy_freeDriveSystem() {
+	Toy_freeLiteralDictionary(&driveDictionary);
+}
+
+void Toy_setDrivePath(char* drive, char* path) {
+	Toy_Literal driveLiteral = TOY_TO_STRING_LITERAL(Toy_createRefString(drive));
+	Toy_Literal pathLiteral = TOY_TO_STRING_LITERAL(Toy_createRefString(path));
+
+	Toy_setLiteralDictionary(&driveDictionary, driveLiteral, pathLiteral);
+
+	Toy_freeLiteral(driveLiteral);
+	Toy_freeLiteral(pathLiteral);
+}
+
+Toy_Literal Toy_getDrivePathLiteral(Toy_Interpreter* interpreter, Toy_Literal* drivePathLiteral) {
+	//check argument types
+	if (!TOY_IS_STRING(*drivePathLiteral)) {
+		interpreter->errorOutput("Incorrect argument type passed to Toy_getDrivePathLiteral\n");
+		return TOY_TO_NULL_LITERAL;
+	}
+
+	Toy_RefString* drivePath = Toy_copyRefString(TOY_AS_STRING(*drivePathLiteral));
+
+	//get the drive and path as a string (can't trust that pesky strtok - custom split) TODO: move this to refstring library
+	size_t driveLength = 0;
+	while (Toy_toCString(drivePath)[driveLength] != ':') {
+		if (driveLength >= Toy_lengthRefString(drivePath)) {
+			interpreter->errorOutput("Incorrect drive path format given to Toy_getDrivePathLiteral\n");
+
+			return TOY_TO_NULL_LITERAL;
+		}
+
+		driveLength++;
+	}
+
+	Toy_RefString* drive = Toy_createRefStringLength(Toy_toCString(drivePath), driveLength);
+	Toy_RefString* filePath = Toy_createRefStringLength( &Toy_toCString(drivePath)[driveLength + 1], Toy_lengthRefString(drivePath) - driveLength );
+
+	//get the real drive file path
+	Toy_Literal driveLiteral = TOY_TO_STRING_LITERAL(drive); //NOTE: driveLiteral takes ownership of the refString
+	Toy_Literal pathLiteral = Toy_getLiteralDictionary(&driveDictionary, driveLiteral);
+
+	if (!TOY_IS_STRING(pathLiteral)) {
+		interpreter->errorOutput("Incorrect literal type found for drive: ");
+		Toy_printLiteralCustom(pathLiteral, interpreter->errorOutput);
+		interpreter->errorOutput("\n");
+		Toy_freeLiteral(driveLiteral);
+		Toy_freeLiteral(pathLiteral);
+		Toy_deleteRefString(filePath);
+		Toy_deleteRefString(drivePath);
+
+		return TOY_TO_NULL_LITERAL;
+	}
+
+	//get the final real file path (concat) TODO: move this concat to refstring library
+	Toy_RefString* path = Toy_copyRefString(TOY_AS_STRING(pathLiteral));
+	size_t fileLength = Toy_lengthRefString(path) + Toy_lengthRefString(filePath);
+
+	char* file = TOY_ALLOCATE(char, fileLength + 1); //+1 for null
+	snprintf(file, fileLength, "%s%s", Toy_toCString(path), Toy_toCString(filePath));
+
+	//clean up the drive/path stuff
+    Toy_deleteRefString(drivePath);
+    Toy_deleteRefString(filePath);
+    Toy_deleteRefString(path);
+    Toy_freeLiteral(driveLiteral);
+	Toy_freeLiteral(pathLiteral);
+
+	//check for break-out attempts
+	for (size_t i = 0; i < fileLength - 1; i++) {
+		if (file[i] == '.' && file[i + 1] == '.') {
+			interpreter->errorOutput("Parent directory access not allowed\n");
+			TOY_FREE_ARRAY(char, file, fileLength + 1);
+			return TOY_TO_NULL_LITERAL;
+		}
+	}
+
+	Toy_Literal result = TOY_TO_STRING_LITERAL(Toy_createRefStringLength(file, fileLength));
+
+	TOY_FREE_ARRAY(char, file, fileLength + 1);
+
+	return result;
+}
@@ -0,0 +1,76 @@
+#pragma once
+
+/*!
+# drive_system.h
+
+When accessing the file system through Toy (such as with the runner library), it's best practice to utilize the drive system - this system (tries to) prevent malicious accessing of files outside of the designated folders. It does this by causing an error when a script tries to access a parent directory.
+
+To use the drive system, first you must designate specific folders which can be accessed, like so:
+
+```c
+#include "drive_system.h"
+
+int main(int argc, char* argv[]) {
+	//the drive system uses a LiteralDictionary, which must be initialized with this
+	Toy_initDriveSystem();
+
+	Toy_setDrivePath("scripts", "assets/scripts");
+	Toy_setDrivePath("sprites", "assets/sprites");
+	Toy_setDrivePath("fonts", "assets/fonts");
+
+	//TODO: do you stuff here
+
+	//clean up the drive dictionary when you're done
+	Toy_freeDriveSystem();
+
+	return 0;
+}
+```
+
+This utility is intended mainly for libraries to use - as such, the core of Toy does not utilize it.
+
+### Implementation Details
+
+The drive system uses a Toy's Dictionary structure to store the mappings between keys and values - this dictionary object is a static global which persists for the lifetime of the program.
+!*/
+
+#include "toy_common.h"
+
+#include "toy_literal.h"
+#include "toy_interpreter.h"
+
+/*!
+## Defined Functions
+!*/
+
+/*!
+### void Toy_initDriveSystem()
+
+This function initializes the drive system.
+!*/
+TOY_API void Toy_initDriveSystem();
+
+/*!
+### void Toy_freeDriveSystem()
+
+This function cleans up after the drive system is no longer needed.
+!*/
+TOY_API void Toy_freeDriveSystem();
+
+/*!
+### void Toy_setDrivePath(char* drive, char* path)
+
+This function sets a key-value pair in the drive system. It uses C strings, since its intended to be called directly from `main()`.
+!*/
+TOY_API void Toy_setDrivePath(char* drive, char* path);
+
+/*!
+### Toy_Literal Toy_getDrivePathLiteral(Toy_Interpreter* interpreter, Toy_Literal* drivePathLiteral)
+
+This function, when given a string literal of the correct format, will return a new string literal containing the relative filepath to a specified file.
+
+The correct format is `drive:/path/to/filename`, where `drive` is a drive that was specified with `Toy_setDrivePath()`.
+
+On failure, this function returns a null literal.
+!*/
+TOY_API Toy_Literal Toy_getDrivePathLiteral(Toy_Interpreter* interpreter, Toy_Literal* drivePathLiteral);
@@ -1,6 +0,0 @@
-#pragma once
-
-#include "toy_interpreter.h"
-
-int Toy_hookAbout(Toy_Interpreter* interpreter, Toy_Literal identifier, Toy_Literal alias);
-
@@ -0,0 +1,5 @@
+#pragma once
+
+#include "toy_interpreter.h"
+
+int Toy_hookMath(Toy_Interpreter* interpreter, Toy_Literal identifier, Toy_Literal alias);
@@ -30,11 +30,6 @@ static int nativeCreateRandomGenerator(Toy_Interpreter* interpreter, Toy_Literal
 		Toy_freeLiteral(seedLiteralIdn);
 	}

-	if (TOY_IS_IDENTIFIER(seedLiteral)) {
-		Toy_freeLiteral(seedLiteral);
-		return -1;
-	}
-
 	if (!TOY_IS_INTEGER(seedLiteral)) {
 		interpreter->errorOutput("Incorrect literal type passed to createRandomGenerator");
 		Toy_freeLiteral(seedLiteral);
@@ -70,11 +65,6 @@ static int nativeGenerateRandomNumber(Toy_Interpreter* interpreter, Toy_LiteralA
 		Toy_freeLiteral(generatorLiteralIdn);
 	}

-	if (TOY_IS_IDENTIFIER(generatorLiteral)) {
-		Toy_freeLiteral(generatorLiteral);
-		return -1;
-	}
-
 	if (TOY_GET_OPAQUE_TAG(generatorLiteral) != TOY_OPAQUE_TAG_RANDOM) {
 		interpreter->errorOutput("Unrecognized opaque literal in generateRandomNumber\n");
 		return -1;
@@ -111,11 +101,6 @@ static int nativeFreeRandomGenerator(Toy_Interpreter* interpreter, Toy_LiteralAr
 		Toy_freeLiteral(generatorLiteralIdn);
 	}

-	if (TOY_IS_IDENTIFIER(generatorLiteral)) {
-		Toy_freeLiteral(generatorLiteral);
-		return -1;
-	}
-
 	if (TOY_GET_OPAQUE_TAG(generatorLiteral) != TOY_OPAQUE_TAG_RANDOM) {
 		interpreter->errorOutput("Unrecognized opaque literal in freeRandomGenerator\n");
 		return -1;
@@ -148,7 +133,7 @@ int Toy_hookRandom(Toy_Interpreter* interpreter, Toy_Literal identifier, Toy_Lit
 	//store the library in an aliased dictionary
 	if (!TOY_IS_NULL(alias)) {
 		//make sure the name isn't taken
-		if (Toy_isDelcaredScopeVariable(interpreter->scope, alias)) {
+		if (Toy_isDeclaredScopeVariable(interpreter->scope, alias)) {
 			interpreter->errorOutput("Can't override an existing variable\n");
 			Toy_freeLiteral(alias);
 			return -1;
@@ -2,6 +2,6 @@

 #include "toy_interpreter.h"

-int Toy_hookRandom(Toy_Interpreter* interpreter, Toy_Literal identifier, Toy_Literal alias);
-
 #define TOY_OPAQUE_TAG_RANDOM 200
+
+int Toy_hookRandom(Toy_Interpreter* interpreter, Toy_Literal identifier, Toy_Literal alias);
@@ -4,10 +4,9 @@
 #include "toy_interpreter.h"

 #include "repl_tools.h"
+#include "drive_system.h"

-#include <stdio.h>
 #include <stdlib.h>
-#include <string.h>

 typedef struct Toy_Runner {
 	Toy_Interpreter interpreter;
@@ -33,12 +32,7 @@ static int nativeLoadScript(Toy_Interpreter* interpreter, Toy_LiteralArray* argu
 		Toy_freeLiteral(drivePathLiteralIdn);
 	}

-	if (TOY_IS_IDENTIFIER(drivePathLiteral)) {
-		Toy_freeLiteral(drivePathLiteral);
-		return -1;
-	}
-
-	Toy_Literal filePathLiteral = Toy_getFilePathLiteral(interpreter, &drivePathLiteral);
+	Toy_Literal filePathLiteral = Toy_getDrivePathLiteral(interpreter, &drivePathLiteral);

 	if (TOY_IS_NULL(filePathLiteral)) {
 		Toy_freeLiteral(filePathLiteral);
@@ -108,75 +102,19 @@ static int nativeLoadScriptBytecode(Toy_Interpreter* interpreter, Toy_LiteralArr
 		Toy_freeLiteral(drivePathLiteralIdn);
 	}

-	if (TOY_IS_IDENTIFIER(drivePathLiteral)) {
+	Toy_Literal filePathLiteral = Toy_getDrivePathLiteral(interpreter, &drivePathLiteral);
+
+	if (TOY_IS_NULL(filePathLiteral)) {
+		Toy_freeLiteral(filePathLiteral);
 		Toy_freeLiteral(drivePathLiteral);
 		return -1;
 	}

-	Toy_RefString* drivePath = Toy_copyRefString(TOY_AS_STRING(drivePathLiteral));
-
-	//get the drive and path as a string (can't trust that pesky strtok - custom split) TODO: move this to refstring library
-	size_t driveLength = 0;
-	while (Toy_toCString(drivePath)[driveLength] != ':') {
-		if (driveLength >= Toy_lengthRefString(drivePath)) {
-			interpreter->errorOutput("Incorrect drive path format given to loadScriptBytecode\n");
-			Toy_deleteRefString(drivePath);
-			Toy_freeLiteral(drivePathLiteral);
-			return -1;
-		}
-
-		driveLength++;
-	}
-
-	Toy_RefString* drive = Toy_createRefStringLength(Toy_toCString(drivePath), driveLength);
-	Toy_RefString* path = Toy_createRefStringLength( &Toy_toCString(drivePath)[driveLength + 1], Toy_lengthRefString(drivePath) - driveLength );
-
-	//get the real drive file path
-	Toy_Literal driveLiteral = TOY_TO_STRING_LITERAL(drive); //NOTE: driveLiteral takes ownership of the refString
-	Toy_Literal realDriveLiteral = Toy_getLiteralDictionary(Toy_getDriveDictionary(), driveLiteral);
-
-	if (!TOY_IS_STRING(realDriveLiteral)) {
-		interpreter->errorOutput("Incorrect literal type found for drive: ");
-		Toy_printLiteralCustom(realDriveLiteral, interpreter->errorOutput);
-		interpreter->errorOutput("\n");
-		Toy_freeLiteral(realDriveLiteral);
-		Toy_freeLiteral(driveLiteral);
-		Toy_deleteRefString(path);
-		Toy_deleteRefString(drivePath);
-		Toy_freeLiteral(drivePathLiteral);
-		return -1;
-	}
-
-	//get the final real file path (concat) TODO: move this concat to refstring library
-	Toy_RefString* realDrive = Toy_copyRefString(TOY_AS_STRING(realDriveLiteral));
-	size_t realLength = Toy_lengthRefString(realDrive) + Toy_lengthRefString(path);
-
-	char* filePath = TOY_ALLOCATE(char, realLength + 1); //+1 for null
-	snprintf(filePath, realLength, "%s%s", Toy_toCString(realDrive), Toy_toCString(path));
-
-	//clean up the drivepath stuff
-	Toy_deleteRefString(realDrive);
-	Toy_freeLiteral(realDriveLiteral);
-	Toy_freeLiteral(driveLiteral);
-	Toy_deleteRefString(path);
-	Toy_deleteRefString(drivePath);
 	Toy_freeLiteral(drivePathLiteral);

-	//check for file extensions
-	if (!(filePath[realLength - 4] == '.' && filePath[realLength - 3] == 't' && filePath[realLength - 2] == 'b')) {
-		interpreter->errorOutput("Bad binary file extension (expected .tb)\n");
-		TOY_FREE_ARRAY(char, filePath, realLength);
-		return -1;
-	}
-
-	//check for break-out attempts
-	for (size_t i = 0; i < realLength - 1; i++) {
-		if (filePath[i] == '.' && filePath[i + 1] == '.') {
-			interpreter->errorOutput("Parent directory access not allowed\n");
-			TOY_FREE_ARRAY(char, filePath, realLength);
-			return -1;
-		}
-	}
+	//use raw types - easier
+	const char* filePath = Toy_toCString(TOY_AS_STRING(filePathLiteral));
+	size_t filePathLength = Toy_lengthRefString(TOY_AS_STRING(filePathLiteral));

 	//load the bytecode
 	size_t fileSize = 0;
@@ -203,7 +141,8 @@ static int nativeLoadScriptBytecode(Toy_Interpreter* interpreter, Toy_LiteralArr
 	Toy_Literal runnerLiteral = TOY_TO_OPAQUE_LITERAL(runner, TOY_OPAQUE_TAG_RUNNER);
 	Toy_pushLiteralArray(&interpreter->stack, runnerLiteral);

-	TOY_FREE_ARRAY(char, filePath, realLength);
+	//free the drive path
+	Toy_freeLiteral(filePathLiteral);

 	return 1;
 }
@@ -223,11 +162,6 @@ static int nativeRunScript(Toy_Interpreter* interpreter, Toy_LiteralArray* argum
 		Toy_freeLiteral(runnerIdn);
 	}

-	if (TOY_IS_IDENTIFIER(runnerLiteral)) {
-		Toy_freeLiteral(runnerLiteral);
-		return -1;
-	}
-
 	if (TOY_GET_OPAQUE_TAG(runnerLiteral) != TOY_OPAQUE_TAG_RUNNER) {
 		interpreter->errorOutput("Unrecognized opaque literal in runScript\n");
 		return -1;
@@ -275,12 +209,6 @@ static int nativeGetScriptVar(Toy_Interpreter* interpreter, Toy_LiteralArray* ar
 		Toy_freeLiteral(runnerIdn);
 	}

-	if (TOY_IS_IDENTIFIER(varName) || TOY_IS_IDENTIFIER(runnerLiteral)) {
-		Toy_freeLiteral(varName);
-		Toy_freeLiteral(runnerLiteral);
-		return -1;
-	}
-
 	if (TOY_GET_OPAQUE_TAG(runnerLiteral) != TOY_OPAQUE_TAG_RUNNER) {
 		interpreter->errorOutput("Unrecognized opaque literal in getScriptVar\n");
 		return -1;
@@ -353,12 +281,6 @@ static int nativeCallScriptFn(Toy_Interpreter* interpreter, Toy_LiteralArray* ar
 		Toy_freeLiteral(runnerIdn);
 	}

-	if (TOY_IS_IDENTIFIER(varName) || TOY_IS_IDENTIFIER(runnerLiteral)) {
-		Toy_freeLiteral(varName);
-		Toy_freeLiteral(runnerLiteral);
-		return -1;
-	}
-
 	if (TOY_GET_OPAQUE_TAG(runnerLiteral) != TOY_OPAQUE_TAG_RUNNER) {
 		interpreter->errorOutput("Unrecognized opaque literal in callScriptFn\n");
 		return -1;
@@ -428,11 +350,6 @@ static int nativeResetScript(Toy_Interpreter* interpreter, Toy_LiteralArray* arg
 		Toy_freeLiteral(runnerIdn);
 	}

-	if (TOY_IS_IDENTIFIER(runnerLiteral)) {
-		Toy_freeLiteral(runnerLiteral);
-		return -1;
-	}
-
 	if (TOY_GET_OPAQUE_TAG(runnerLiteral) != TOY_OPAQUE_TAG_RUNNER) {
 		interpreter->errorOutput("Unrecognized opaque literal in resetScript\n");
 		return -1;
@@ -469,11 +386,6 @@ static int nativeFreeScript(Toy_Interpreter* interpreter, Toy_LiteralArray* argu
 		Toy_freeLiteral(runnerIdn);
 	}

-	if (TOY_IS_IDENTIFIER(runnerLiteral)) {
-		Toy_freeLiteral(runnerLiteral);
-		return -1;
-	}
-
 	if (TOY_GET_OPAQUE_TAG(runnerLiteral) != TOY_OPAQUE_TAG_RUNNER) {
 		interpreter->errorOutput("Unrecognized opaque literal in freeScript\n");
 		return -1;
@@ -508,11 +420,6 @@ static int nativeCheckScriptDirty(Toy_Interpreter* interpreter, Toy_LiteralArray
 		Toy_freeLiteral(runnerIdn);
 	}

-	if (TOY_IS_IDENTIFIER(runnerLiteral)) {
-		Toy_freeLiteral(runnerLiteral);
-		return -1;
-	}
-
 	if (TOY_GET_OPAQUE_TAG(runnerLiteral) != TOY_OPAQUE_TAG_RUNNER) {
 		interpreter->errorOutput("Unrecognized opaque literal in checkScriptDirty\n");
 		return -1;
@@ -555,7 +462,7 @@ int Toy_hookRunner(Toy_Interpreter* interpreter, Toy_Literal identifier, Toy_Lit
 	//store the library in an aliased dictionary
 	if (!TOY_IS_NULL(alias)) {
 		//make sure the name isn't taken
-		if (Toy_isDelcaredScopeVariable(interpreter->scope, alias)) {
+		if (Toy_isDeclaredScopeVariable(interpreter->scope, alias)) {
 			interpreter->errorOutput("Can't override an existing variable\n");
 			Toy_freeLiteral(alias);
 			return -1;
@@ -602,87 +509,3 @@ int Toy_hookRunner(Toy_Interpreter* interpreter, Toy_Literal identifier, Toy_Lit
 	return 0;
 }

-//file system API
-static Toy_LiteralDictionary Toy_driveDictionary;
-
-void Toy_initDriveDictionary() {
-	Toy_initLiteralDictionary(&Toy_driveDictionary);
-}
-
-void Toy_freeDriveDictionary() {
-	Toy_freeLiteralDictionary(&Toy_driveDictionary);
-}
-
-Toy_LiteralDictionary* Toy_getDriveDictionary() {
-	return &Toy_driveDictionary;
-}
-
-Toy_Literal Toy_getFilePathLiteral(Toy_Interpreter* interpreter, Toy_Literal* drivePathLiteral) {
-	//check argument types
-	if (!TOY_IS_STRING(*drivePathLiteral)) {
-		interpreter->errorOutput("Incorrect argument type passed to Toy_getFilePathLiteral\n");
-		return TOY_TO_NULL_LITERAL;
-	}
-
-	Toy_RefString* drivePath = Toy_copyRefString(TOY_AS_STRING(*drivePathLiteral));
-
-	//get the drive and path as a string (can't trust that pesky strtok - custom split) TODO: move this to refstring library
-	size_t driveLength = 0;
-	while (Toy_toCString(drivePath)[driveLength] != ':') {
-		if (driveLength >= Toy_lengthRefString(drivePath)) {
-			interpreter->errorOutput("Incorrect drive path format given to Toy_getFilePathLiteral\n");
-
-			return TOY_TO_NULL_LITERAL;
-		}
-
-		driveLength++;
-	}
-
-	Toy_RefString* drive = Toy_createRefStringLength(Toy_toCString(drivePath), driveLength);
-	Toy_RefString* path = Toy_createRefStringLength( &Toy_toCString(drivePath)[driveLength + 1], Toy_lengthRefString(drivePath) - driveLength );
-
-	//get the real drive file path
-	Toy_Literal driveLiteral = TOY_TO_STRING_LITERAL(drive); //NOTE: driveLiteral takes ownership of the refString
-	Toy_Literal realDriveLiteral = Toy_getLiteralDictionary(Toy_getDriveDictionary(), driveLiteral);
-
-	if (!TOY_IS_STRING(realDriveLiteral)) {
-		interpreter->errorOutput("Incorrect literal type found for drive: ");
-		Toy_printLiteralCustom(realDriveLiteral, interpreter->errorOutput);
-		interpreter->errorOutput("\n");
-		Toy_freeLiteral(realDriveLiteral);
-		Toy_freeLiteral(driveLiteral);
-		Toy_deleteRefString(path);
-		Toy_deleteRefString(drivePath);
-
-		return TOY_TO_NULL_LITERAL;
-	}
-
-	//get the final real file path (concat) TODO: move this concat to refstring library
-	Toy_RefString* realDrive = Toy_copyRefString(TOY_AS_STRING(realDriveLiteral));
-	size_t realLength = Toy_lengthRefString(realDrive) + Toy_lengthRefString(path);
-
-	char* filePath = TOY_ALLOCATE(char, realLength + 1); //+1 for null
-	snprintf(filePath, realLength, "%s%s", Toy_toCString(realDrive), Toy_toCString(path));
-
-	//clean up the drivepath stuff
-	Toy_deleteRefString(realDrive);
-	Toy_freeLiteral(realDriveLiteral);
-	Toy_freeLiteral(driveLiteral);
-	Toy_deleteRefString(path);
-	Toy_deleteRefString(drivePath);
-
-	//check for break-out attempts
-	for (size_t i = 0; i < realLength - 1; i++) {
-		if (filePath[i] == '.' && filePath[i + 1] == '.') {
-			interpreter->errorOutput("Parent directory access not allowed\n");
-			TOY_FREE_ARRAY(char, filePath, realLength + 1);
-			return TOY_TO_NULL_LITERAL;
-		}
-	}
-
-	Toy_Literal result = TOY_TO_STRING_LITERAL(Toy_createRefStringLength(filePath, realLength));
-
-	TOY_FREE_ARRAY(char, filePath, realLength + 1);
-
-	return result;
-}
@@ -1,35 +1,7 @@
 #pragma once

-#include "toy_common.h"
 #include "toy_interpreter.h"

-int Toy_hookRunner(Toy_Interpreter* interpreter, Toy_Literal identifier, Toy_Literal alias);
-
 #define TOY_OPAQUE_TAG_RUNNER 100

-//platform/compiler-specific instructions - because MSVC + Box Engine are dumber than a bag of rocks
-#if defined(__linux__) || defined(__MINGW32__) || defined(__GNUC__)
-
-#define LIB_RUNNER_API extern
-
-#elif defined(_MSC_VER)
-
-#ifndef LIB_RUNNER_EXPORT
-#define LIB_RUNNER_API __declspec(dllimport)
-#else
-#define LIB_RUNNER_API __declspec(dllexport)
-#endif
-
-#else
-
-#define LIB_RUNNER_API extern
-
-#endif
-
-//file system API - these need to be set by the host
-LIB_RUNNER_API void Toy_initDriveDictionary();
-LIB_RUNNER_API void Toy_freeDriveDictionary();
-LIB_RUNNER_API Toy_LiteralDictionary* Toy_getDriveDictionary();
-
-//file system API - for use with other libs
-LIB_RUNNER_API Toy_Literal Toy_getFilePathLiteral(Toy_Interpreter* interpreter, Toy_Literal* drivePathLiteral);
+int Toy_hookRunner(Toy_Interpreter* interpreter, Toy_Literal identifier, Toy_Literal alias);
@@ -47,11 +47,6 @@ static int nativeHash(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments)
 		Toy_freeLiteral(selfLiteralIdn);
 	}

-	if (TOY_IS_IDENTIFIER(selfLiteral)) {
-		Toy_freeLiteral(selfLiteral);
-		return -1;
-	}
-
 	Toy_Literal result = TOY_TO_INTEGER_LITERAL(Toy_hashLiteral(selfLiteral));

 	Toy_pushLiteralArray(&interpreter->stack, result);
@@ -77,11 +72,6 @@ static int nativeAbs(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments)
 		Toy_freeLiteral(selfLiteralIdn);
 	}

-	if (TOY_IS_IDENTIFIER(selfLiteral)) {
-		Toy_freeLiteral(selfLiteral);
-		return -1;
-	}
-
 	if (!(TOY_IS_INTEGER(selfLiteral) || TOY_IS_FLOAT(selfLiteral))) {
 		interpreter->errorOutput("Incorrect argument type passed to abs\n");
 		Toy_freeLiteral(selfLiteral);
@@ -120,11 +110,6 @@ static int nativeCeil(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments)
 		Toy_freeLiteral(selfLiteralIdn);
 	}

-	if (TOY_IS_IDENTIFIER(selfLiteral)) {
-		Toy_freeLiteral(selfLiteral);
-		return -1;
-	}
-
 	if (!(TOY_IS_INTEGER(selfLiteral) || TOY_IS_FLOAT(selfLiteral))) {
 		interpreter->errorOutput("Incorrect argument type passed to ceil\n");
 		Toy_freeLiteral(selfLiteral);
@@ -164,11 +149,6 @@ static int nativeFloor(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments
 		Toy_freeLiteral(selfLiteralIdn);
 	}

-	if (TOY_IS_IDENTIFIER(selfLiteral)) {
-		Toy_freeLiteral(selfLiteral);
-		return -1;
-	}
-
 	if (!(TOY_IS_INTEGER(selfLiteral) || TOY_IS_FLOAT(selfLiteral))) {
 		interpreter->errorOutput("Incorrect argument type passed to floor\n");
 		Toy_freeLiteral(selfLiteral);
@@ -208,11 +188,6 @@ static int nativeMax(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments)
 			Toy_freeLiteral(selfLiteralIdn);
 		}

-		if (TOY_IS_IDENTIFIER(selfLiteral)) {
-			Toy_freeLiteral(selfLiteral);
-			return -1;
-		}
-
 		if (!(TOY_IS_INTEGER(selfLiteral) || TOY_IS_FLOAT(selfLiteral))) {
 			interpreter->errorOutput("Incorrect argument type passed to max\n");
 			Toy_freeLiteral(selfLiteral);
@@ -227,11 +202,11 @@ static int nativeMax(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments)

 		//cooerce if needed
 		if (TOY_IS_INTEGER(resultLiteral) && TOY_IS_FLOAT(selfLiteral)) {
-			resultLiteral = TOY_TO_FLOAT_LITERAL( TOY_AS_INTEGER(resultLiteral) );
+			resultLiteral = TOY_TO_FLOAT_LITERAL( (float)TOY_AS_INTEGER(resultLiteral) );
 		}

 		if (TOY_IS_FLOAT(resultLiteral) && TOY_IS_INTEGER(selfLiteral)) {
-			selfLiteral = TOY_TO_FLOAT_LITERAL( TOY_AS_INTEGER(selfLiteral) );
+			selfLiteral = TOY_TO_FLOAT_LITERAL( (float)TOY_AS_INTEGER(selfLiteral) );
 		}

 		//compare
@@ -269,11 +244,6 @@ static int nativeMin(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments)
 			Toy_freeLiteral(selfLiteralIdn);
 		}

-		if (TOY_IS_IDENTIFIER(selfLiteral)) {
-			Toy_freeLiteral(selfLiteral);
-			return -1;
-		}
-
 		if (!(TOY_IS_INTEGER(selfLiteral) || TOY_IS_FLOAT(selfLiteral))) {
 			interpreter->errorOutput("Incorrect argument type passed to min\n");
 			Toy_freeLiteral(selfLiteral);
@@ -288,11 +258,11 @@ static int nativeMin(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments)

 		//cooerce if needed
 		if (TOY_IS_INTEGER(resultLiteral) && TOY_IS_FLOAT(selfLiteral)) {
-			resultLiteral = TOY_TO_FLOAT_LITERAL( TOY_AS_INTEGER(resultLiteral) );
+			resultLiteral = TOY_TO_FLOAT_LITERAL( (float)TOY_AS_INTEGER(resultLiteral) );
 		}

 		if (TOY_IS_FLOAT(resultLiteral) && TOY_IS_INTEGER(selfLiteral)) {
-			selfLiteral = TOY_TO_FLOAT_LITERAL( TOY_AS_INTEGER(selfLiteral) );
+			selfLiteral = TOY_TO_FLOAT_LITERAL( (float)TOY_AS_INTEGER(selfLiteral) );
 		}

 		//compare
@@ -330,11 +300,6 @@ static int nativeRound(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments
 		Toy_freeLiteral(selfLiteralIdn);
 	}

-	if (TOY_IS_IDENTIFIER(selfLiteral)) {
-		Toy_freeLiteral(selfLiteral);
-		return -1;
-	}
-
 	if (!(TOY_IS_INTEGER(selfLiteral) || TOY_IS_FLOAT(selfLiteral))) {
 		interpreter->errorOutput("Incorrect argument type passed to round\n");
 		Toy_freeLiteral(selfLiteral);
@@ -365,6 +330,259 @@ static int nativeRound(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments
 	return 1;
 }

+static int nativeSign(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments) {
+	if (arguments->count != 1) {
+		interpreter->errorOutput("Incorrect number of arguments to sign\n");
+		return -1;
+	}
+
+	//get the self
+	Toy_Literal selfLiteral = Toy_popLiteralArray(arguments);
+
+	//parse to value if needed
+	Toy_Literal selfLiteralIdn = selfLiteral;
+	if (TOY_IS_IDENTIFIER(selfLiteral) && Toy_parseIdentifierToValue(interpreter, &selfLiteral)) {
+		Toy_freeLiteral(selfLiteralIdn);
+	}
+
+	if (!(TOY_IS_INTEGER(selfLiteral) || TOY_IS_FLOAT(selfLiteral))) {
+		interpreter->errorOutput("Incorrect argument type passed to sign\n");
+		Toy_freeLiteral(selfLiteral);
+		return -1;
+	}
+
+	Toy_Literal resultLiteral = TOY_TO_NULL_LITERAL;
+
+	if (TOY_IS_INTEGER(selfLiteral)) {
+		if (TOY_AS_INTEGER(selfLiteral) < 0) {
+			resultLiteral = TOY_TO_INTEGER_LITERAL(-1);
+		}
+		else {
+			resultLiteral = TOY_TO_INTEGER_LITERAL(1);
+		}
+	}
+	if (TOY_IS_FLOAT(selfLiteral)) {
+		if (TOY_AS_FLOAT(selfLiteral) < 0) {
+			resultLiteral = TOY_TO_INTEGER_LITERAL(-1);
+		}
+		else {
+			resultLiteral = TOY_TO_INTEGER_LITERAL(1);
+		}
+	}
+
+	Toy_pushLiteralArray(&interpreter->stack, resultLiteral);
+
+	Toy_freeLiteral(resultLiteral);
+	Toy_freeLiteral(selfLiteral);
+
+	return 1;
+}
+
+static int nativeNormalize(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments) {
+	//NOTE: this is identical to `sign`, except it returns 0 when the argument is 0.
+	if (arguments->count != 1) {
+		interpreter->errorOutput("Incorrect number of arguments to normalize\n");
+		return -1;
+	}
+
+	//get the self
+	Toy_Literal selfLiteral = Toy_popLiteralArray(arguments);
+
+	//parse to value if needed
+	Toy_Literal selfLiteralIdn = selfLiteral;
+	if (TOY_IS_IDENTIFIER(selfLiteral) && Toy_parseIdentifierToValue(interpreter, &selfLiteral)) {
+		Toy_freeLiteral(selfLiteralIdn);
+	}
+
+	if (!(TOY_IS_INTEGER(selfLiteral) || TOY_IS_FLOAT(selfLiteral))) {
+		interpreter->errorOutput("Incorrect argument type passed to normalize\n");
+		Toy_freeLiteral(selfLiteral);
+		return -1;
+	}
+
+	Toy_Literal resultLiteral = TOY_TO_NULL_LITERAL;
+
+	if (TOY_IS_INTEGER(selfLiteral)) {
+		if (TOY_AS_INTEGER(selfLiteral) < 0) {
+			resultLiteral = TOY_TO_INTEGER_LITERAL(-1);
+		}
+		else if (TOY_AS_INTEGER(selfLiteral) > 0) {
+			resultLiteral = TOY_TO_INTEGER_LITERAL(1);
+		}
+		else {
+			resultLiteral = TOY_TO_INTEGER_LITERAL(0);
+		}
+	}
+	if (TOY_IS_FLOAT(selfLiteral)) {
+		if (TOY_AS_FLOAT(selfLiteral) < 0) {
+			resultLiteral = TOY_TO_INTEGER_LITERAL(-1);
+		}
+		else if (TOY_AS_FLOAT(selfLiteral) > 0) {
+			resultLiteral = TOY_TO_INTEGER_LITERAL(1);
+		}
+		else {
+			resultLiteral = TOY_TO_INTEGER_LITERAL(0);
+		}
+	}
+
+	Toy_pushLiteralArray(&interpreter->stack, resultLiteral);
+
+	Toy_freeLiteral(resultLiteral);
+	Toy_freeLiteral(selfLiteral);
+
+	return 1;
+}
+
+static int nativeClamp(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments) {
+	if (arguments->count != 3) {
+		interpreter->errorOutput("Incorrect number of arguments to clamp\n");
+		return -1;
+	}
+
+	//get the arguments
+	Toy_Literal maxLiteral = Toy_popLiteralArray(arguments);
+	Toy_Literal minLiteral = Toy_popLiteralArray(arguments);
+	Toy_Literal valueLiteral = Toy_popLiteralArray(arguments);
+
+	//parse the arguments (if they're identifiers)
+	Toy_Literal valueLiteralIdn = valueLiteral;
+	if (TOY_IS_IDENTIFIER(valueLiteral) && Toy_parseIdentifierToValue(interpreter, &valueLiteral)) {
+		Toy_freeLiteral(valueLiteralIdn);
+	}
+
+	Toy_Literal minLiteralIdn = minLiteral;
+	if (TOY_IS_IDENTIFIER(minLiteral) && Toy_parseIdentifierToValue(interpreter, &minLiteral)) {
+		Toy_freeLiteral(minLiteralIdn);
+	}
+
+	Toy_Literal maxLiteralIdn = maxLiteral;
+	if (TOY_IS_IDENTIFIER(maxLiteral) && Toy_parseIdentifierToValue(interpreter, &maxLiteral)) {
+		Toy_freeLiteral(maxLiteralIdn);
+	}
+
+	//check the types
+	if (!(TOY_IS_INTEGER(valueLiteral) || TOY_IS_FLOAT(valueLiteral))) {
+		interpreter->errorOutput("Incorrect argument type passed to clamp\n");
+		Toy_freeLiteral(valueLiteral);
+		Toy_freeLiteral(minLiteral);
+		Toy_freeLiteral(maxLiteral);
+		return -1;
+	}
+
+	if (!(TOY_IS_INTEGER(minLiteral) || TOY_IS_FLOAT(minLiteral))) {
+		interpreter->errorOutput("Incorrect argument type passed to clamp\n");
+		Toy_freeLiteral(valueLiteral);
+		Toy_freeLiteral(minLiteral);
+		Toy_freeLiteral(maxLiteral);
+		return -1;
+	}
+
+	if (!(TOY_IS_INTEGER(maxLiteral) || TOY_IS_FLOAT(maxLiteral))) {
+		interpreter->errorOutput("Incorrect argument type passed to clamp\n");
+		Toy_freeLiteral(valueLiteral);
+		Toy_freeLiteral(minLiteral);
+		Toy_freeLiteral(maxLiteral);
+		return -1;
+	}
+
+	// cast ints to floats to handle all types of numbers
+	float value = TOY_IS_INTEGER(valueLiteral)? TOY_AS_INTEGER(valueLiteral) : TOY_AS_FLOAT(valueLiteral);
+	float min = TOY_IS_INTEGER(minLiteral)? TOY_AS_INTEGER(minLiteral) : TOY_AS_FLOAT(minLiteral);
+	float max = TOY_IS_INTEGER(maxLiteral)? TOY_AS_INTEGER(maxLiteral) : TOY_AS_FLOAT(maxLiteral);
+
+	//determine which literal to return (this way, we retain the original type)
+	if (min > value) {
+		Toy_pushLiteralArray(&interpreter->stack, minLiteral);
+	}
+
+	else if (max < value) {
+		Toy_pushLiteralArray(&interpreter->stack, maxLiteral);
+	}
+
+	else {
+		Toy_pushLiteralArray(&interpreter->stack, valueLiteral);
+	}
+
+	Toy_freeLiteral(valueLiteral);
+	Toy_freeLiteral(minLiteral);
+	Toy_freeLiteral(maxLiteral);
+
+	return 1;
+}
+
+static int nativeLerp(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments) {
+	if (arguments->count != 3) {
+		interpreter->errorOutput("Incorrect number of arguments to lerp\n");
+		return -1;
+	}
+
+	//get the arguments
+	Toy_Literal amountLiteral = Toy_popLiteralArray(arguments);
+	Toy_Literal endLiteral = Toy_popLiteralArray(arguments);
+	Toy_Literal startLiteral = Toy_popLiteralArray(arguments);
+
+	//parse the arguments (if they're identifiers)
+	Toy_Literal startLiteralIdn = startLiteral;
+	if (TOY_IS_IDENTIFIER(startLiteral) && Toy_parseIdentifierToValue(interpreter, &startLiteral)) {
+		Toy_freeLiteral(startLiteralIdn);
+	}
+
+	Toy_Literal endLiteralIdn = endLiteral;
+	if (TOY_IS_IDENTIFIER(endLiteral) && Toy_parseIdentifierToValue(interpreter, &endLiteral)) {
+		Toy_freeLiteral(endLiteralIdn);
+	}
+
+	Toy_Literal amountLiteralIdn = amountLiteral;
+	if (TOY_IS_IDENTIFIER(amountLiteral) && Toy_parseIdentifierToValue(interpreter, &amountLiteral)) {
+		Toy_freeLiteral(amountLiteralIdn);
+	}
+
+	//check the argument types
+	if (!(TOY_IS_INTEGER(startLiteral) || TOY_IS_FLOAT(startLiteral))) {
+		interpreter->errorOutput("Incorrect argument type passed to lerp\n");
+		Toy_freeLiteral(startLiteral);
+		Toy_freeLiteral(endLiteral);
+		Toy_freeLiteral(amountLiteral);
+		return -1;
+	}
+
+	if (!(TOY_IS_INTEGER(endLiteral) || TOY_IS_FLOAT(endLiteral))) {
+		interpreter->errorOutput("Incorrect argument type passed to lerp\n");
+		Toy_freeLiteral(startLiteral);
+		Toy_freeLiteral(endLiteral);
+		Toy_freeLiteral(amountLiteral);
+		return -1;
+	}
+
+	if (!(TOY_IS_INTEGER(amountLiteral) || TOY_IS_FLOAT(amountLiteral))) {
+		interpreter->errorOutput("Incorrect argument type passed to lerp\n");
+		Toy_freeLiteral(startLiteral);
+		Toy_freeLiteral(endLiteral);
+		Toy_freeLiteral(amountLiteral);
+		return -1;
+	}
+
+	// cast ints to floats to handle all types of numbers
+	float start = TOY_IS_INTEGER(startLiteral)? TOY_AS_INTEGER(startLiteral) : TOY_AS_FLOAT(startLiteral);
+	float end = TOY_IS_INTEGER(endLiteral)? TOY_AS_INTEGER(endLiteral) : TOY_AS_FLOAT(endLiteral);
+	float amount = TOY_IS_INTEGER(amountLiteral)? TOY_AS_INTEGER(amountLiteral) : TOY_AS_FLOAT(amountLiteral);
+
+	//calculate the result
+	float result = start + amount * (end - start);
+
+	//return the result
+	Toy_Literal resultLiteral = TOY_TO_FLOAT_LITERAL(result);
+	Toy_pushLiteralArray(&interpreter->stack, resultLiteral);
+
+	//cleanup
+	Toy_freeLiteral(resultLiteral);
+	Toy_freeLiteral(startLiteral);
+	Toy_freeLiteral(endLiteral);
+	Toy_freeLiteral(amountLiteral);
+	
+	return 1;
+}
+
 static int nativeConcat(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments) {
 	//no arguments
 	if (arguments->count != 2) {
@@ -387,12 +605,6 @@ static int nativeConcat(Toy_Interpreter* interpreter, Toy_LiteralArray* argument
 		Toy_freeLiteral(otherLiteralIdn);
 	}

-	if (TOY_IS_IDENTIFIER(selfLiteral) || TOY_IS_IDENTIFIER(otherLiteral)) {
-		Toy_freeLiteral(selfLiteral);
-		Toy_freeLiteral(otherLiteral);
-		return -1;
-	}
-
 	//for each self type
 	if (TOY_IS_ARRAY(selfLiteral)) {
 		if (!TOY_IS_ARRAY(otherLiteral)) {
@@ -449,7 +661,7 @@ static int nativeConcat(Toy_Interpreter* interpreter, Toy_LiteralArray* argument
 		}

 		//get the combined length for the new string
-		size_t length = TOY_AS_STRING(selfLiteral)->length + TOY_AS_STRING(otherLiteral)->length + 1;
+		size_t length = TOY_AS_STRING(selfLiteral)->length + TOY_AS_STRING(otherLiteral)->length;

 		if (length > TOY_MAX_STRING_LENGTH) {
 			interpreter->errorOutput("Can't concatenate these strings, result is too long (error found in concat)\n");
@@ -459,8 +671,8 @@ static int nativeConcat(Toy_Interpreter* interpreter, Toy_LiteralArray* argument
 		}

 		//allocate the space and generate
-		char* buffer = TOY_ALLOCATE(char, length);
-		snprintf(buffer, length, "%s%s", Toy_toCString(TOY_AS_STRING(selfLiteral)), Toy_toCString(TOY_AS_STRING(otherLiteral)));
+		char* buffer = TOY_ALLOCATE(char, length + 1);
+		snprintf(buffer, length + 1, "%s%s", Toy_toCString(TOY_AS_STRING(selfLiteral)), Toy_toCString(TOY_AS_STRING(otherLiteral)));

 		Toy_Literal result = TOY_TO_STRING_LITERAL(Toy_createRefString(buffer));

@@ -503,12 +715,6 @@ static int nativeContainsKey(Toy_Interpreter* interpreter, Toy_LiteralArray* arg
 		Toy_freeLiteral(keyLiteralIdn);
 	}

-	if (TOY_IS_IDENTIFIER(selfLiteral) || TOY_IS_IDENTIFIER(keyLiteral)) {
-		Toy_freeLiteral(selfLiteral);
-		Toy_freeLiteral(keyLiteral);
-		return -1;
-	}
-
 	//check type
 	if (!(/* TOY_IS_ARRAY(selfLiteral) || */ TOY_IS_DICTIONARY(selfLiteral) )) {
 		interpreter->errorOutput("Incorrect argument type passed to containsKey\n");
@@ -554,12 +760,6 @@ static int nativeContainsValue(Toy_Interpreter* interpreter, Toy_LiteralArray* a
 		Toy_freeLiteral(valueLiteralIdn);
 	}

-	if (TOY_IS_IDENTIFIER(selfLiteral) || TOY_IS_IDENTIFIER(valueLiteral)) {
-		Toy_freeLiteral(selfLiteral);
-		Toy_freeLiteral(valueLiteral);
-		return -1;
-	}
-
 	//check type
 	if (!( TOY_IS_ARRAY(selfLiteral) || TOY_IS_DICTIONARY(selfLiteral) )) {
 		interpreter->errorOutput("Incorrect argument type passed to containsValue\n");
@@ -630,12 +830,6 @@ static int nativeEvery(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments
 		Toy_freeLiteral(fnLiteralIdn);
 	}

-	if (TOY_IS_IDENTIFIER(selfLiteral) || TOY_IS_IDENTIFIER(fnLiteral)) {
-		Toy_freeLiteral(selfLiteral);
-		Toy_freeLiteral(fnLiteral);
-		return -1;
-	}
-
 	//check type
 	if (!( TOY_IS_ARRAY(selfLiteral) || TOY_IS_DICTIONARY(selfLiteral) ) || !( TOY_IS_FUNCTION(fnLiteral) || TOY_IS_FUNCTION_NATIVE(fnLiteral) )) {
 		interpreter->errorOutput("Incorrect argument type passed to every\n");
@@ -752,12 +946,6 @@ static int nativeFilter(Toy_Interpreter* interpreter, Toy_LiteralArray* argument
 		Toy_freeLiteral(fnLiteralIdn);
 	}

-	if (TOY_IS_IDENTIFIER(selfLiteral) || TOY_IS_IDENTIFIER(fnLiteral)) {
-		Toy_freeLiteral(selfLiteral);
-		Toy_freeLiteral(fnLiteral);
-		return -1;
-	}
-
 	//check type
 	if (!( TOY_IS_ARRAY(selfLiteral) || TOY_IS_DICTIONARY(selfLiteral) ) || !( TOY_IS_FUNCTION(fnLiteral) || TOY_IS_FUNCTION_NATIVE(fnLiteral) )) {
 		interpreter->errorOutput("Incorrect argument type passed to filter\n");
@@ -872,12 +1060,6 @@ static int nativeForEach(Toy_Interpreter* interpreter, Toy_LiteralArray* argumen
 		Toy_freeLiteral(fnLiteralIdn);
 	}

-	if (TOY_IS_IDENTIFIER(selfLiteral) || TOY_IS_IDENTIFIER(fnLiteral)) {
-		Toy_freeLiteral(selfLiteral);
-		Toy_freeLiteral(fnLiteral);
-		return -1;
-	}
-
 	//check type
 	if (!( TOY_IS_ARRAY(selfLiteral) || TOY_IS_DICTIONARY(selfLiteral) ) || !( TOY_IS_FUNCTION(fnLiteral) || TOY_IS_FUNCTION_NATIVE(fnLiteral) )) {
 		interpreter->errorOutput("Incorrect argument type passed to forEach\n");
@@ -950,11 +1132,6 @@ static int nativeGetKeys(Toy_Interpreter* interpreter, Toy_LiteralArray* argumen
 		Toy_freeLiteral(selfLiteralIdn);
 	}

-	if (TOY_IS_IDENTIFIER(selfLiteral)) {
-		Toy_freeLiteral(selfLiteral);
-		return -1;
-	}
-
 	//check type
 	if (!TOY_IS_DICTIONARY(selfLiteral)) {
 		interpreter->errorOutput("Incorrect argument type passed to getKeys\n");
@@ -1000,11 +1177,6 @@ static int nativeGetValues(Toy_Interpreter* interpreter, Toy_LiteralArray* argum
 		Toy_freeLiteral(selfLiteralIdn);
 	}

-	if (TOY_IS_IDENTIFIER(selfLiteral)) {
-		Toy_freeLiteral(selfLiteral);
-		return -1;
-	}
-
 	//check type
 	if (!TOY_IS_DICTIONARY(selfLiteral)) {
 		interpreter->errorOutput("Incorrect argument type passed to getValues\n");
@@ -1057,12 +1229,6 @@ static int nativeIndexOf(Toy_Interpreter* interpreter, Toy_LiteralArray* argumen
 		Toy_freeLiteral(valueLiteralIdn);
 	}

-	if (TOY_IS_IDENTIFIER(selfLiteral) || TOY_IS_IDENTIFIER(valueLiteral)) {
-		Toy_freeLiteral(selfLiteral);
-		Toy_freeLiteral(valueLiteral);
-		return -1;
-	}
-
 	//check type
 	if (!TOY_IS_ARRAY(selfLiteral)) {
 		interpreter->errorOutput("Incorrect argument type passed to indexOf\n");
@@ -1110,12 +1276,6 @@ static int nativeMap(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments)
 		Toy_freeLiteral(fnLiteralIdn);
 	}

-	if (TOY_IS_IDENTIFIER(selfLiteral) || TOY_IS_IDENTIFIER(fnLiteral)) {
-		Toy_freeLiteral(selfLiteral);
-		Toy_freeLiteral(fnLiteral);
-		return -1;
-	}
-
 	//check type
 	if (!( TOY_IS_ARRAY(selfLiteral) || TOY_IS_DICTIONARY(selfLiteral) ) || !( TOY_IS_FUNCTION(fnLiteral) || TOY_IS_FUNCTION_NATIVE(fnLiteral) )) {
 		interpreter->errorOutput("Incorrect argument type passed to map\n");
@@ -1225,13 +1385,6 @@ static int nativeReduce(Toy_Interpreter* interpreter, Toy_LiteralArray* argument
 		Toy_freeLiteral(fnLiteralIdn);
 	}

-	if (TOY_IS_IDENTIFIER(selfLiteral) || TOY_IS_IDENTIFIER(defaultLiteral) || TOY_IS_IDENTIFIER(fnLiteral)) {
-		Toy_freeLiteral(selfLiteral);
-		Toy_freeLiteral(defaultLiteral);
-		Toy_freeLiteral(fnLiteral);
-		return -1;
-	}
-
 	//check type
 	if (!( TOY_IS_ARRAY(selfLiteral) || TOY_IS_DICTIONARY(selfLiteral) ) || !( TOY_IS_FUNCTION(fnLiteral) || TOY_IS_FUNCTION_NATIVE(fnLiteral) )) {
 		interpreter->errorOutput("Incorrect argument type passed to reduce\n");
@@ -1327,12 +1480,6 @@ static int nativeSome(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments)
 		Toy_freeLiteral(fnLiteralIdn);
 	}

-	if (TOY_IS_IDENTIFIER(selfLiteral) || TOY_IS_IDENTIFIER(fnLiteral)) {
-		Toy_freeLiteral(selfLiteral);
-		Toy_freeLiteral(fnLiteral);
-		return -1;
-	}
-
 	//check type
 	if (!( TOY_IS_ARRAY(selfLiteral) || TOY_IS_DICTIONARY(selfLiteral) ) || !( TOY_IS_FUNCTION(fnLiteral) || TOY_IS_FUNCTION_NATIVE(fnLiteral) )) {
 		interpreter->errorOutput("Incorrect argument type passed to some\n");
@@ -1471,8 +1618,13 @@ static void recursiveLiteralQuicksortUtil(Toy_Interpreter* interpreter, Toy_Lite
 	swapLiteralsUtil(&ptr[runner], &ptr[literalCount - 1]);

 	//recurse on each end
-	recursiveLiteralQuicksortUtil(interpreter, &ptr[0], runner, fnCompareLiteral);
-	recursiveLiteralQuicksortUtil(interpreter, &ptr[runner + 1], literalCount - runner - 1, fnCompareLiteral);
+	if (runner > 0) {
+		recursiveLiteralQuicksortUtil(interpreter, &ptr[0], runner, fnCompareLiteral);
+	}
+
+	if (runner < literalCount) {
+		recursiveLiteralQuicksortUtil(interpreter, &ptr[runner + 1], literalCount - runner - 1, fnCompareLiteral);
+	}
 }

 static int nativeSort(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments) {
@@ -1497,12 +1649,6 @@ static int nativeSort(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments)
 		Toy_freeLiteral(fnLiteralIdn);
 	}

-	if (TOY_IS_IDENTIFIER(selfLiteral) || TOY_IS_IDENTIFIER(fnLiteral)) {
-		Toy_freeLiteral(selfLiteral);
-		Toy_freeLiteral(fnLiteral);
-		return -1;
-	}
-
 	//check type
 	if (!TOY_IS_ARRAY(selfLiteral) || !( TOY_IS_FUNCTION(fnLiteral) || TOY_IS_FUNCTION_NATIVE(fnLiteral) )) {
 		interpreter->errorOutput("Incorrect argument type passed to sort\n");
@@ -1511,8 +1657,34 @@ static int nativeSort(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments)
 		return -1;
 	}

+	//BUGFIX: check if the array is already sorted
+	bool sorted = true;
+	for (int checker = 0; checker < TOY_AS_ARRAY(selfLiteral)->count - 1 && sorted; checker++) {
+		Toy_LiteralArray arguments;
+		Toy_LiteralArray returns;
+
+		Toy_initLiteralArray(&arguments);
+		Toy_initLiteralArray(&returns);
+
+		Toy_pushLiteralArray(&arguments, TOY_AS_ARRAY(selfLiteral)->literals[checker]);
+		Toy_pushLiteralArray(&arguments, TOY_AS_ARRAY(selfLiteral)->literals[checker + 1]);
+
+		Toy_callLiteralFn(interpreter, fnLiteral, &arguments, &returns);
+
+		Toy_Literal lessThan = Toy_popLiteralArray(&returns);
+
+		Toy_freeLiteralArray(&arguments);
+		Toy_freeLiteralArray(&returns);
+
+		if (!TOY_IS_TRUTHY(lessThan)) {
+			sorted = false;
+		}
+
+		Toy_freeLiteral(lessThan);
+	}
+
 	//call the quicksort util
-	if (TOY_IS_ARRAY(selfLiteral)) {
+	if (!sorted) {
 		recursiveLiteralQuicksortUtil(interpreter, TOY_AS_ARRAY(selfLiteral)->literals, TOY_AS_ARRAY(selfLiteral)->count, fnLiteral);
 	}

@@ -1539,11 +1711,6 @@ static int nativeToLower(Toy_Interpreter* interpreter, Toy_LiteralArray* argumen
 		Toy_freeLiteral(selfLiteralIdn);
 	}

-	if (TOY_IS_IDENTIFIER(selfLiteral)) {
-		Toy_freeLiteral(selfLiteral);
-		return -1;
-	}
-
 	if (!TOY_IS_STRING(selfLiteral)) {
 		interpreter->errorOutput("Incorrect argument type passed to toLower\n");
 		Toy_freeLiteral(selfLiteral);
@@ -1605,17 +1772,6 @@ static int nativeToString(Toy_Interpreter* interpreter, Toy_LiteralArray* argume
 		Toy_freeLiteral(selfLiteralIdn);
 	}

-	if (TOY_IS_IDENTIFIER(selfLiteral)) {
-		Toy_freeLiteral(selfLiteral);
-		return -1;
-	}
-
-	//BUGFIX: probably an undefined variable
-	if (TOY_IS_IDENTIFIER(selfLiteral)) {
-		Toy_freeLiteral(selfLiteral);
-		return -1;
-	}
-
 	//print it to a custom function
 	Toy_printLiteralCustom(selfLiteral, toStringUtil);

@@ -1649,11 +1805,6 @@ static int nativeToUpper(Toy_Interpreter* interpreter, Toy_LiteralArray* argumen
 		Toy_freeLiteral(selfLiteralIdn);
 	}

-	if (TOY_IS_IDENTIFIER(selfLiteral)) {
-		Toy_freeLiteral(selfLiteral);
-		return -1;
-	}
-
 	if (!TOY_IS_STRING(selfLiteral)) {
 		interpreter->errorOutput("Incorrect argument type passed to toUpper\n");
 		Toy_freeLiteral(selfLiteral);
@@ -1714,12 +1865,6 @@ static int nativeTrim(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments)
 		Toy_freeLiteral(selfLiteralIdn);
 	}

-	if (TOY_IS_IDENTIFIER(selfLiteral) || TOY_IS_IDENTIFIER(trimCharsLiteral)) {
-		Toy_freeLiteral(selfLiteral);
-		Toy_freeLiteral(trimCharsLiteral);
-		return -1;
-	}
-
 	if (!TOY_IS_STRING(selfLiteral) || !TOY_IS_STRING(trimCharsLiteral)) {
 		interpreter->errorOutput("Incorrect argument type passed to trim\n");
 		Toy_freeLiteral(trimCharsLiteral);
@@ -1831,12 +1976,6 @@ static int nativeTrimBegin(Toy_Interpreter* interpreter, Toy_LiteralArray* argum
 		Toy_freeLiteral(selfLiteralIdn);
 	}

-	if (TOY_IS_IDENTIFIER(selfLiteral) || TOY_IS_IDENTIFIER(trimCharsLiteral)) {
-		Toy_freeLiteral(selfLiteral);
-		Toy_freeLiteral(trimCharsLiteral);
-		return -1;
-	}
-
 	if (!TOY_IS_STRING(selfLiteral) || !TOY_IS_STRING(trimCharsLiteral)) {
 		interpreter->errorOutput("Incorrect argument type passed to trimBegin\n");
 		Toy_freeLiteral(trimCharsLiteral);
@@ -1925,12 +2064,6 @@ static int nativeTrimEnd(Toy_Interpreter* interpreter, Toy_LiteralArray* argumen
 		Toy_freeLiteral(selfLiteralIdn);
 	}

-	if (TOY_IS_IDENTIFIER(selfLiteral) || TOY_IS_IDENTIFIER(trimCharsLiteral)) {
-		Toy_freeLiteral(selfLiteral);
-		Toy_freeLiteral(trimCharsLiteral);
-		return -1;
-	}
-
 	if (!TOY_IS_STRING(selfLiteral) || !TOY_IS_STRING(trimCharsLiteral)) {
 		interpreter->errorOutput("Incorrect argument type passed to trimEnd\n");
 		Toy_freeLiteral(trimCharsLiteral);
@@ -2011,6 +2144,10 @@ int Toy_hookStandard(Toy_Interpreter* interpreter, Toy_Literal identifier, Toy_L
 		{"max", nativeMax},
 		{"min", nativeMin},
 		{"round", nativeRound},
+		{"sign", nativeSign},
+		{"normalize", nativeNormalize},
+		{"clamp", nativeClamp},
+		{"lerp", nativeLerp},

 		//compound utils
 		{"concat", nativeConcat}, //array, dictionary, string
@@ -2038,7 +2175,7 @@ int Toy_hookStandard(Toy_Interpreter* interpreter, Toy_Literal identifier, Toy_L
 	//store the library in an aliased dictionary
 	if (!TOY_IS_NULL(alias)) {
 		//make sure the name isn't taken
-		if (Toy_isDelcaredScopeVariable(interpreter->scope, alias)) {
+		if (Toy_isDeclaredScopeVariable(interpreter->scope, alias)) {
 			interpreter->errorOutput("Can't override an existing variable\n");
 			Toy_freeLiteral(alias);
 			return -1;
@@ -3,4 +3,3 @@
 #include "toy_interpreter.h"

 int Toy_hookStandard(Toy_Interpreter* interpreter, Toy_Literal identifier, Toy_Literal alias);
-
@@ -1,23 +1,23 @@
-#include "lib_about.h"
+#include "lib_toy_version_info.h"

 #include "toy_memory.h"

-int Toy_hookAbout(Toy_Interpreter* interpreter, Toy_Literal identifier, Toy_Literal alias) {
-	//the about keys
+int Toy_hookToyVersionInfo(Toy_Interpreter* interpreter, Toy_Literal identifier, Toy_Literal alias) {
+	//the info keys
 	Toy_Literal majorKeyLiteral = TOY_TO_STRING_LITERAL(Toy_createRefString("major"));
 	Toy_Literal minorKeyLiteral = TOY_TO_STRING_LITERAL(Toy_createRefString("minor"));
 	Toy_Literal patchKeyLiteral = TOY_TO_STRING_LITERAL(Toy_createRefString("patch"));
 	Toy_Literal buildKeyLiteral = TOY_TO_STRING_LITERAL(Toy_createRefString("build"));
 	Toy_Literal authorKeyLiteral = TOY_TO_STRING_LITERAL(Toy_createRefString("author"));

-	//the about identifiers
+	//the info identifiers
 	Toy_Literal majorIdentifierLiteral = TOY_TO_IDENTIFIER_LITERAL(Toy_createRefString("major"));
 	Toy_Literal minorIdentifierLiteral = TOY_TO_IDENTIFIER_LITERAL(Toy_createRefString("minor"));
 	Toy_Literal patchIdentifierLiteral = TOY_TO_IDENTIFIER_LITERAL(Toy_createRefString("patch"));
 	Toy_Literal buildIdentifierLiteral = TOY_TO_IDENTIFIER_LITERAL(Toy_createRefString("build"));
 	Toy_Literal authorIdentifierLiteral = TOY_TO_IDENTIFIER_LITERAL(Toy_createRefString("author"));

-	//the about values
+	//the info values
 	Toy_Literal majorLiteral = TOY_TO_INTEGER_LITERAL(TOY_VERSION_MAJOR);
 	Toy_Literal minorLiteral = TOY_TO_INTEGER_LITERAL(TOY_VERSION_MINOR);
 	Toy_Literal patchLiteral = TOY_TO_INTEGER_LITERAL(TOY_VERSION_PATCH);
@@ -27,7 +27,7 @@ int Toy_hookAbout(Toy_Interpreter* interpreter, Toy_Literal identifier, Toy_Lite
 	//store as an aliased dictionary
 	if (!TOY_IS_NULL(alias)) {
 		//make sure the name isn't taken
-		if (Toy_isDelcaredScopeVariable(interpreter->scope, alias)) {
+		if (Toy_isDeclaredScopeVariable(interpreter->scope, alias)) {
 			interpreter->errorOutput("Can't override an existing variable\n");
 			Toy_freeLiteral(alias);

@@ -83,11 +83,11 @@ int Toy_hookAbout(Toy_Interpreter* interpreter, Toy_Literal identifier, Toy_Lite
 	//store globally
 	else {
 		//make sure the names aren't taken
-		if (Toy_isDelcaredScopeVariable(interpreter->scope, majorKeyLiteral) ||
-			Toy_isDelcaredScopeVariable(interpreter->scope, minorKeyLiteral) ||
-			Toy_isDelcaredScopeVariable(interpreter->scope, patchKeyLiteral) ||
-			Toy_isDelcaredScopeVariable(interpreter->scope, buildKeyLiteral) ||
-			Toy_isDelcaredScopeVariable(interpreter->scope, authorKeyLiteral)) {
+		if (Toy_isDeclaredScopeVariable(interpreter->scope, majorKeyLiteral) ||
+			Toy_isDeclaredScopeVariable(interpreter->scope, minorKeyLiteral) ||
+			Toy_isDeclaredScopeVariable(interpreter->scope, patchKeyLiteral) ||
+			Toy_isDeclaredScopeVariable(interpreter->scope, buildKeyLiteral) ||
+			Toy_isDeclaredScopeVariable(interpreter->scope, authorKeyLiteral)) {
 			interpreter->errorOutput("Can't override an existing variable\n");
 			Toy_freeLiteral(alias);

@@ -0,0 +1,5 @@
+#pragma once
+
+#include "toy_interpreter.h"
+
+int Toy_hookToyVersionInfo(Toy_Interpreter* interpreter, Toy_Literal identifier, Toy_Literal alias);
@@ -2,7 +2,7 @@ CC=gcc

 IDIR+=. ../source
 CFLAGS+=$(addprefix -I,$(IDIR)) -g -Wall -W -Wno-unused-parameter -Wno-unused-function -Wno-unused-variable
-LIBS+=-ltoy
+LIBS+=-ltoy -lm

 ODIR = obj
 SRC = $(wildcard *.c)
@@ -1,15 +1,14 @@
 #include "repl_tools.h"
-#include "lib_about.h"
+#include "drive_system.h"
+#include "lib_toy_version_info.h"
 #include "lib_standard.h"
 #include "lib_random.h"
 #include "lib_runner.h"
+#include "lib_math.h"

 #include "toy_console_colors.h"

-#include "toy_lexer.h"
-#include "toy_parser.h"
-#include "toy_compiler.h"
-#include "toy_interpreter.h"
+#include "toy.h"

 #include <stdio.h>
 #include <stdlib.h>
@@ -28,10 +27,11 @@ void repl(const char* initialInput) {
 	Toy_initInterpreter(&interpreter);

 	//inject the libs
-	Toy_injectNativeHook(&interpreter, "about", Toy_hookAbout);
+	Toy_injectNativeHook(&interpreter, "toy_version_info", Toy_hookToyVersionInfo);
 	Toy_injectNativeHook(&interpreter, "standard", Toy_hookStandard);
 	Toy_injectNativeHook(&interpreter, "random", Toy_hookRandom);
 	Toy_injectNativeHook(&interpreter, "runner", Toy_hookRunner);
+	Toy_injectNativeHook(&interpreter, "math", Toy_hookMath);

 	for(;;) {
 		if (!initialInput) {
@@ -106,16 +106,9 @@ void repl(const char* initialInput) {
 int main(int argc, const char* argv[]) {
 	Toy_initCommandLine(argc, argv);

-	//lib setup (hacky - only really for this program)
-	Toy_initDriveDictionary();
-
-	Toy_Literal driveLiteral = TOY_TO_STRING_LITERAL(Toy_createRefString("scripts"));
-	Toy_Literal pathLiteral = TOY_TO_STRING_LITERAL(Toy_createRefString("scripts"));
-
-	Toy_setLiteralDictionary(Toy_getDriveDictionary(), driveLiteral, pathLiteral);
-
-	Toy_freeLiteral(driveLiteral);
-	Toy_freeLiteral(pathLiteral);
+	//setup the drive system (for filesystem access)
+	Toy_initDriveSystem();
+	Toy_setDrivePath("scripts", "scripts");

 	//command line specific actions
 	if (Toy_commandLine.error) {
@@ -151,7 +144,7 @@ int main(int argc, const char* argv[]) {
 		Toy_runSourceFile(Toy_commandLine.sourcefile);

 		//lib cleanup
-		Toy_freeDriveDictionary();
+		Toy_freeDriveSystem();

 		return 0;
 	}
@@ -161,7 +154,7 @@ int main(int argc, const char* argv[]) {
 		Toy_runSource(Toy_commandLine.source);

 		//lib cleanup
-		Toy_freeDriveDictionary();
+		Toy_freeDriveSystem();

 		return 0;
 	}
@@ -203,11 +196,17 @@ int main(int argc, const char* argv[]) {
 			return -1;
 		}

-		//run the binary file
-		Toy_runBinaryFile(Toy_commandLine.binaryfile);
+		if (Toy_commandLine.parseBytecodeHeader) {
+			//only parse the bytecode header
+			Toy_parseBinaryFileHeader(Toy_commandLine.binaryfile);
+		}
+		else {
+			//run the binary file
+			Toy_runBinaryFile(Toy_commandLine.binaryfile);
+		}

 		//lib cleanup
-		Toy_freeDriveDictionary();
+		Toy_freeDriveSystem();

 		return 0;
 	}
@@ -228,7 +227,7 @@ int main(int argc, const char* argv[]) {
 	repl(initialSource);

 	//lib cleanup
-	Toy_freeDriveDictionary();
+	Toy_freeDriveSystem();

 	return 0;
 }
@@ -1,8 +1,9 @@
 #include "repl_tools.h"
-#include "lib_about.h"
+#include "lib_toy_version_info.h"
 #include "lib_standard.h"
 #include "lib_random.h"
 #include "lib_runner.h"
+#include "lib_math.h"

 #include "toy_console_colors.h"

@@ -78,10 +79,10 @@ const unsigned char* Toy_compileString(const char* source, size_t* size) {
 	Toy_initParser(&parser, &lexer);
 	Toy_initCompiler(&compiler);

-	//run the parser until the end of the source
+	//step 1 - run the parser until the end of the source
 	Toy_ASTNode* node = Toy_scanParser(&parser);
 	while(node != NULL) {
-		//pack up and leave
+		//on error, pack up and leave
 		if (node->type == TOY_AST_NODE_ERROR) {
 			Toy_freeASTNode(node);
 			Toy_freeCompiler(&compiler);
@@ -94,7 +95,7 @@ const unsigned char* Toy_compileString(const char* source, size_t* size) {
 		node = Toy_scanParser(&parser);
 	}

-	//get the bytecode dump
+	//step 2 - get the bytecode dump
 	const unsigned char* tb = Toy_collateCompiler(&compiler, size);

 	//cleanup
@@ -111,10 +112,11 @@ void Toy_runBinary(const unsigned char* tb, size_t size) {
 	Toy_initInterpreter(&interpreter);

 	//inject the libs
-	Toy_injectNativeHook(&interpreter, "about", Toy_hookAbout);
+	Toy_injectNativeHook(&interpreter, "toy_version_info", Toy_hookToyVersionInfo);
 	Toy_injectNativeHook(&interpreter, "standard", Toy_hookStandard);
 	Toy_injectNativeHook(&interpreter, "random", Toy_hookRandom);
 	Toy_injectNativeHook(&interpreter, "runner", Toy_hookRunner);
+	Toy_injectNativeHook(&interpreter, "math", Toy_hookMath);

 	Toy_runInterpreter(&interpreter, tb, (int)size);
 	Toy_freeInterpreter(&interpreter);
@@ -149,3 +151,59 @@ void Toy_runSourceFile(const char* fname) {
 	Toy_runSource(source);
 	free((void*)source);
 }
+
+//utils for debugging the header
+static unsigned char readByte(const unsigned char* tb, int* count) {
+	unsigned char ret = *(unsigned char*)(tb + *count);
+	*count += 1;
+	return ret;
+}
+
+static const char* readString(const unsigned char* tb, int* count) {
+	const unsigned char* ret = tb + *count;
+	*count += (int)strlen((char*)ret) + 1; //+1 for null character
+	return (const char*)ret;
+}
+
+void Toy_parseBinaryFileHeader(const char* fname) {
+	size_t size = 0; //not used
+	const unsigned char* tb = Toy_readFile(fname, &size);
+	if (!tb || size < 4) {
+		return;
+	}
+
+	int count = 0;
+
+	//header section
+	const unsigned char major = readByte(tb, &count);
+	const unsigned char minor = readByte(tb, &count);
+	const unsigned char patch = readByte(tb, &count);
+
+	const char* build = readString(tb, &count);
+
+	printf("Toy Programming Language Interpreter Version %d.%d.%d (interpreter built on %s)\n\n", TOY_VERSION_MAJOR, TOY_VERSION_MINOR, TOY_VERSION_PATCH, TOY_VERSION_BUILD);
+
+	printf("Toy Programming Language Bytecode Version ");
+
+	//print the output
+	if (major == TOY_VERSION_MAJOR && minor == TOY_VERSION_MINOR && patch == TOY_VERSION_PATCH) {
+		printf("%d.%d.%d", major, minor, patch);
+	}
+	else {
+		printf(TOY_CC_FONT_YELLOW TOY_CC_BACK_BLACK "%d.%d.%d" TOY_CC_RESET, major, minor, patch);
+	}
+
+	printf(" (interpreter built on ");
+
+	if (strncmp(build, TOY_VERSION_BUILD, strlen(TOY_VERSION_BUILD)) == 0) {
+		printf("%s", build);
+	}
+	else {
+		printf(TOY_CC_FONT_YELLOW TOY_CC_BACK_BLACK "%s" TOY_CC_RESET, build);
+	}
+
+	printf(")\n");
+
+	//cleanup
+	free((void*)tb);
+}
@@ -1,14 +1,84 @@
 #pragma once

+/*!
+# repl_tools.h
+
+This header provides a number of tools for compiling and running Toy, and is used primarily by the repl. However, it can also be modified and used by any host program with a little effort.
+
+This is not a core part of Toy or a library, and as such `repl_tools.h` and `repl_tools.c` can both be found in the `repl/` folder.
+!*/
+
 #include "toy_common.h"

+/*!
+## Defined Functions
+!*/
+
+/*!
+### const char* Toy_readFile(const char* path, size_t* fileSize)
+
+This function reads in a file, and returns it as a constant buffer. It also sets the variable pointed to by `fileSize` to the size of the given buffer.
+
+On error, this function returns `NULL`.
+!*/
 const unsigned char* Toy_readFile(const char* path, size_t* fileSize);
+
+/*!
+### int Toy_writeFile(const char* path, const unsigned char* bytes, size_t size)
+
+This function writes the buffer pointed to by `bytes` to a file specified by `path`. The buffer's size should be specified by `size`.
+
+On error, this function returns a non-zero value.
+!*/
 int Toy_writeFile(const char* path, const unsigned char* bytes, size_t size);

+/*!
+### const unsigned char* Toy_compileString(const char* source, size_t* size)
+
+This function takes a cstring of Toy source code, and returns a compiled buffer based on that source code. The variable pointed to by `size` is set to the size of the bytecode.
+
+On error, this function returns `NULL`.
+!*/
 const unsigned char* Toy_compileString(const char* source, size_t* size);

+/*!
+### void Toy_runBinary(const unsigned char* tb, size_t size)
+
+This function takes a bytecode array of `size` size, and executes it. The libraries available to the code are currently:
+
+* lib_toy_version_info
+* lib_standard
+* lib_random
+* lib_runner
+!*/
 void Toy_runBinary(const unsigned char* tb, size_t size);
+
+/*!
+### void Toy_runBinaryFile(const char* fname)
+
+This function loads in the binary file specified by `fname`, and passes it to `Toy_runBinary()`.
+!*/
 void Toy_runBinaryFile(const char* fname);
+
+/*!
+### void Toy_runSource(const char* source)
+
+This function compiles the source with `Toy_compileString()`, and passes it to `Toy_runBinary()`.
+!*/
 void Toy_runSource(const char* source);
+
+/*!
+### void Toy_runSourceFile(const char* fname)
+
+This function loads in the file specified by `fname`, compiles it, and passes it to `Toy_runBinary()`.
+!*/
 void Toy_runSourceFile(const char* fname);

+/*!
+### void Toy_parseBinaryFileHeader(const char* fname)
+
+This function parses the header information stored within the bytecode file `fname`.
+
+This is only used for debugging and validation purposes.
+!*/
+void Toy_parseBinaryFileHeader(const char* fname);
@@ -4,7 +4,7 @@ fn fib(n : int) {
 	return fib(n-1) + fib(n-2);
 }

-for (var i = 0; i < 20; i++) {
+for (var i = 0; i <= 35; i++) {
 	var res = fib(i);
 	print string i + ": " + string res;
 }
@@ -0,0 +1,13 @@
+fn f() {
+    //
+}
+
+fn g() {
+    fn i() {
+        //
+    }
+}
+
+fn h() {
+    //
+}
@@ -11,14 +11,14 @@ OBJ = $(addprefix $(ODIR)/,$(SRC:.c=.o))
 OUTNAME=toy

 ifeq ($(findstring CYGWIN, $(shell uname)),CYGWIN)
-	LIBLINE =-Wl,--out-implib=../$(TOY_OUTDIR)/lib$(OUTNAME).dll.a -Wl,--export-all-symbols -Wl,--enable-auto-import -Wl,--whole-archive $(OBJ) -Wl,--no-whole-archive
+	LIBLINE=-Wl,-rpath,. -Wl,--out-implib=../$(TOY_OUTDIR)/lib$(OUTNAME).dll.a -Wl,--export-all-symbols -Wl,--enable-auto-import -Wl,--whole-archive $(OBJ) -Wl,--no-whole-archive
 	OUT=../$(TOY_OUTDIR)/$(OUTNAME).dll
 else ifeq ($(shell uname),Linux)
-	LIBLINE=-Wl,--out-implib=../$(TOY_OUTDIR)/lib$(OUTNAME).a -Wl,--whole-archive $(OBJ) -Wl,--no-whole-archive
+	LIBLINE=-Wl,-rpath,. -Wl,--out-implib=../$(TOY_OUTDIR)/lib$(OUTNAME).a -Wl,--whole-archive $(OBJ) -Wl,--no-whole-archive
 	OUT=../$(TOY_OUTDIR)/lib$(OUTNAME).so
 	CFLAGS += -fPIC
 else ifeq ($(OS),Windows_NT)
-	LIBLINE =-Wl,--out-implib=../$(TOY_OUTDIR)/lib$(OUTNAME).dll.a -Wl,--export-all-symbols -Wl,--enable-auto-import -Wl,--whole-archive $(OBJ) -Wl,--no-whole-archive
+	LIBLINE=-Wl,-rpath,. -Wl,--out-implib=../$(TOY_OUTDIR)/lib$(OUTNAME).dll.a -Wl,--export-all-symbols -Wl,--enable-auto-import -Wl,--whole-archive $(OBJ) -Wl,--no-whole-archive
 	OUT=../$(TOY_OUTDIR)/$(OUTNAME).dll
 else ifeq ($(shell uname),Darwin)
 	LIBLINE = $(OBJ)
@@ -0,0 +1,87 @@
+#pragma once
+
+/*!
+# toy.h - A Toy Programming Language
+
+If you're looking how to use Toy directly, try https://toylang.com/
+Otherwise, this header may help learn how Toy works internally.
+!*/
+
+/*!
+## Utilities
+
+These headers define a bunch of useful macros, based on what platform you build for.
+
+The most important macro is `TOY_API`, which specifies functions intended for the end user.
+
+* [toy_common.h](toy_common_h.md)
+* [toy_console_colors.h](toy_console_colors_h.md)
+* [toy_memory.h](toy_memory_h.md)
+!*/
+
+#include "toy_common.h"
+#include "toy_console_colors.h"
+#include "toy_memory.h"
+
+/*!
+## Core Pipeline
+
+From source to execution, each step is as follows:
+
+```
+source   -> lexer       -> token
+token    -> parser      -> AST
+AST      -> compiler    -> bytecode
+bytecode -> interpreter -> result
+```
+
+I should note that the parser -> compiler phase is actually made up of two steps - the write step and the collate step. See `Toy_compileString()` in `repl/repl_tools.c` for an example of how to compile properly.
+
+* [toy_lexer.h](toy_lexer_h.md)
+* [toy_parser.h](toy_parser_h.md)
+* [toy_compiler.h](toy_compiler_h.md)
+* [toy_interpreter.h](toy_interpreter_h.md)
+!*/
+
+#include "toy_lexer.h"
+#include "toy_parser.h"
+#include "toy_compiler.h"
+#include "toy_interpreter.h"
+
+/*!
+## Building Block Structures
+
+Literals represent any value within the language, including some internal ones that you never see.
+
+Literal arrays are contiguous arrays within memory, and are the most heavily used structure in Toy.
+
+Literal dictionaries are unordered key-value hashmaps, that use a running strategy for collisions.
+
+* [toy_literal.h](toy_literal_h.md)
+* [toy_literal_array.h](toy_literal_array_h.md)
+* [toy_literal_dictionary.h](toy_literal_dictionary_h.md)
+!*/
+
+#include "toy_literal.h"
+#include "toy_literal_array.h"
+#include "toy_literal_dictionary.h"
+
+/*!
+## Other Components
+
+You probably won't use these directly, but they're a good learning opportunity.
+
+`Toy_Scope` holds the variables of a specific scope within Toy - be it a script, a function, a block, etc. Scopes are also where the type system lives at runtime. They use identifier literals as keys, exclusively.
+
+`Toy_RefString` is a utility class that wraps traditional C strings, making them less memory intensive and faster to copy and move. In reality, since strings are considered immutable, multiple variables can point to the same string to save memory, and you can just create a new one of these vars pointing to the original rather than copying entirely for a speed boost. This module has it's own memory allocator system that is plugged into the main memory allocator.
+
+`Toy_RefFunction` acts similarly to `Toy_RefString`, but instead operates on function bytecode.
+
+* [toy_scope.h](toy_scope_h.md)
+* [toy_refstring.h](toy_refstring_h.md)
+* [toy_reffunction.h](toy_reffunction_h.md)
+!*/
+
+#include "toy_scope.h"
+#include "toy_refstring.h"
+#include "toy_reffunction.h"
@@ -124,6 +124,16 @@ static void freeASTNodeCustom(Toy_ASTNode* node, bool freeSelf) {
 			//NO-OP
 		break;

+		case TOY_AST_NODE_AND:
+			Toy_freeASTNode(node->pathAnd.left);
+			Toy_freeASTNode(node->pathAnd.right);
+		break;
+
+		case TOY_AST_NODE_OR:
+			Toy_freeASTNode(node->pathOr.left);
+			Toy_freeASTNode(node->pathOr.right);
+		break;
+
 		case TOY_AST_NODE_PREFIX_INCREMENT:
 			Toy_freeLiteral(node->prefixIncrement.identifier);
 		break;
@@ -348,6 +358,26 @@ void Toy_emitASTNodeContinue(Toy_ASTNode** nodeHandle) {
 	*nodeHandle = tmp;
 }

+void Toy_emitASTNodeAnd(Toy_ASTNode** nodeHandle, Toy_ASTNode* rhs) {
+	Toy_ASTNode* tmp = TOY_ALLOCATE(Toy_ASTNode, 1);
+
+	tmp->type = TOY_AST_NODE_AND;
+	tmp->pathAnd.left = *nodeHandle;
+	tmp->pathAnd.right = rhs;
+
+	*nodeHandle = tmp;
+}
+
+void Toy_emitASTNodeOr(Toy_ASTNode** nodeHandle, Toy_ASTNode* rhs) {
+	Toy_ASTNode* tmp = TOY_ALLOCATE(Toy_ASTNode, 1);
+
+	tmp->type = TOY_AST_NODE_OR;
+	tmp->pathOr.left = *nodeHandle;
+	tmp->pathOr.right = rhs;
+
+	*nodeHandle = tmp;
+}
+
 void Toy_emitASTNodePrefixIncrement(Toy_ASTNode** nodeHandle, Toy_Literal identifier) {
 	Toy_ASTNode* tmp = TOY_ALLOCATE(Toy_ASTNode, 1);

@@ -29,6 +29,8 @@ typedef enum Toy_ASTNodeType {
 	TOY_AST_NODE_FOR, //for control flow
 	TOY_AST_NODE_BREAK, //for control flow
 	TOY_AST_NODE_CONTINUE, //for control flow
+	TOY_AST_NODE_AND, //for control flow
+	TOY_AST_NODE_OR, //for control flow
 	TOY_AST_NODE_PREFIX_INCREMENT, //increment a variable
 	TOY_AST_NODE_POSTFIX_INCREMENT, //increment a variable
 	TOY_AST_NODE_PREFIX_DECREMENT, //decrement a variable
@@ -204,6 +206,24 @@ typedef struct Toy_NodeContinue {
 	Toy_ASTNodeType type;
 } Toy_NodeContinue;

+//and operator
+void Toy_emitASTNodeAnd(Toy_ASTNode** nodeHandle, Toy_ASTNode* rhs); //handled node becomes lhs
+
+typedef struct Toy_NodeAnd {
+	Toy_ASTNodeType type;
+	Toy_ASTNode* left;
+	Toy_ASTNode* right;
+} Toy_NodeAnd;
+
+//or operator
+void Toy_emitASTNodeOr(Toy_ASTNode** nodeHandle, Toy_ASTNode* rhs); //handled node becomes lhs
+
+typedef struct Toy_NodeOr {
+	Toy_ASTNodeType type;
+	Toy_ASTNode* left;
+	Toy_ASTNode* right;
+} Toy_NodeOr;
+
 //pre-post increment/decrement
 void Toy_emitASTNodePrefixIncrement(Toy_ASTNode** nodeHandle, Toy_Literal identifier);
 void Toy_emitASTNodePrefixDecrement(Toy_ASTNode** nodeHandle, Toy_Literal identifier);
@@ -263,6 +283,8 @@ union Toy_private_node {
 	Toy_NodeFor pathFor;
 	Toy_NodeBreak pathBreak;
 	Toy_NodeContinue pathContinue;
+	Toy_NodeAnd pathAnd;
+	Toy_NodeOr pathOr;
 	Toy_NodePrefixIncrement prefixIncrement;
 	Toy_NodePrefixDecrement prefixDecrement;
 	Toy_NodePostfixIncrement postfixIncrement;
@@ -270,4 +292,5 @@ union Toy_private_node {
 	Toy_NodeImport import;
 };

+//see toy_parser.h for more documentation on this function
 TOY_API void Toy_freeASTNode(Toy_ASTNode* node);
@@ -4,7 +4,7 @@
 #include <string.h>
 #include <assert.h>

-//test variable sizes based on platform
+//test variable sizes based on platform - see issue #35
 #define STATIC_ASSERT(test_for_true) static_assert((test_for_true), "(" #test_for_true ") failed")

 STATIC_ASSERT(sizeof(char) == 1);
@@ -15,6 +15,12 @@ STATIC_ASSERT(sizeof(unsigned char) == 1);
 STATIC_ASSERT(sizeof(unsigned short) == 2);
 STATIC_ASSERT(sizeof(unsigned int) == 4);

+static const char* build = __DATE__ " " __TIME__;
+
+const char* Toy_private_version_build() {
+	return build;
+}
+
 //declare the singleton with default values
 Toy_CommandLine Toy_commandLine = {
 	.error = false,
@@ -27,6 +33,7 @@ Toy_CommandLine Toy_commandLine = {
 	.source = NULL,
 	.initialfile = NULL,
 	.enablePrintNewline = true,
+	.parseBytecodeHeader = false,
 	.verbose = false
 };

@@ -87,6 +94,16 @@ void Toy_initCommandLine(int argc, const char* argv[]) {
 			continue;
 		}

+		if (!strcmp(argv[i], "-p")) {
+			Toy_commandLine.parseBytecodeHeader = true;
+
+			if (Toy_commandLine.binaryfile) {
+				Toy_commandLine.error = false;
+			}
+
+			continue;
+		}
+
 		if (!strcmp(argv[i], "-n")) {
 			Toy_commandLine.enablePrintNewline = false;
 			Toy_commandLine.error = false;
@@ -122,6 +139,7 @@ void Toy_helpCommandLine(int argc, const char* argv[]) {
 	printf("  -c, --compile filename\tParse and compile the specified source file into an output file.\n");
 	printf("  -o, --output outfile\t\tName of the output file built with --compile (default: out.tb).\n");
 	printf("  -t, --initial filename\tStart the repl as normal, after first running the given file.\n");
+	printf("  -p\t\t\t\tParse the given bytecode's header, then exit (requires file.tb).\n");
 	printf("  -n\t\t\t\tDisable the newline character at the end of the print statement.\n");
 }

@@ -1,15 +1,23 @@
 #pragma once

+/*!
+# toy_common.h
+
+This file is generally included in most header files within Toy, as it is where the TOY_API macro is defined. It also has some utilities intended for use only by the repl.
+
+## Defined Macros
+!*/
+
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdint.h>

-#define TOY_VERSION_MAJOR 1
-#define TOY_VERSION_MINOR 1
-#define TOY_VERSION_PATCH 1
-#define TOY_VERSION_BUILD __DATE__ " " __TIME__
+/*!
+### TOY_API
+
+This definition of this macro is platform-dependant, and used to enable cross-platform compilation of shared and static libraries.
+!*/

-//platform/compiler-specific instructions
 #if defined(__linux__) || defined(__MINGW32__) || defined(__GNUC__)

 #define TOY_API extern
@@ -28,7 +36,54 @@

 #endif

-//for processing the command line arguments
+/*!
+### TOY_VERSION_MAJOR
+
+The current major version of Toy. This value is embedded into the bytecode, and the interpreter will refuse to run bytecode with a major version that does not match it’s own version.
+
+This value MUST fit into an unsigned char.
+!*/
+
+#define TOY_VERSION_MAJOR 1
+
+/*!
+### TOY_VERSION_MINOR
+
+The current minor version of Toy. This value is embedded into the bytecode, and the interpreter will refuse to run bytecode with a minor version that is greater than its own minor version.
+
+This value MUST fit into an unsigned char.
+!*/
+
+#define TOY_VERSION_MINOR 3
+
+/*!
+### TOY_VERSION_PATCH
+
+The current patch version of Toy. This value is embedded into the bytecode.
+
+This value MUST fit into an unsigned char.
+!*/
+
+#define TOY_VERSION_PATCH 2
+
+/*!
+### TOY_VERSION_BUILD
+
+The current build version of Toy. This value is embedded into the bytecode.
+
+This evaluates to a c-string, which contains build information such as compilation date and time of the interpreter. When in verbose mode, the compiler will display a warning if the build version of the bytecode does not match the build version of the interpreter.
+
+This macro may also be used to store additonal information about forks of the Toy codebase.
+!*/
+
+#define TOY_VERSION_BUILD Toy_private_version_build()
+TOY_API const char* Toy_private_version_build();
+
+/*
+The following code is intended only for use within the repl.
+*/
+
+//for processing the command line arguments in the repl
 typedef struct {
 	bool error;
 	bool help;
@@ -40,6 +95,7 @@ typedef struct {
 	char* source;
 	char* initialfile;
 	bool enablePrintNewline;
+	bool parseBytecodeHeader;
 	bool verbose;
 } Toy_CommandLine;

@@ -48,7 +48,7 @@ static int writeLiteralTypeToCache(Toy_LiteralArray* literalCache, Toy_Literal l
 	}

 	//optimisation: check if exactly this literal array exists
-	int index = Toy_findLiteralIndex(literalCache, literal);
+	int index = Toy_private_findLiteralIndex(literalCache, literal);
 	if (index < 0) {
 		index = Toy_pushLiteralArray(literalCache, literal);
 	}
@@ -74,7 +74,7 @@ static int writeNodeCompoundToCache(Toy_Compiler* compiler, Toy_ASTNode* node) {
 			switch(node->compound.nodes[i].pair.left->type) {
 				case TOY_AST_NODE_LITERAL: {
 					//keys are literals
-					int key = Toy_findLiteralIndex(&compiler->literalCache, node->compound.nodes[i].pair.left->atomic.literal);
+					int key = Toy_private_findLiteralIndex(&compiler->literalCache, node->compound.nodes[i].pair.left->atomic.literal);
 					if (key < 0) {
 						key = Toy_pushLiteralArray(&compiler->literalCache, node->compound.nodes[i].pair.left->atomic.literal);
 					}
@@ -103,7 +103,7 @@ static int writeNodeCompoundToCache(Toy_Compiler* compiler, Toy_ASTNode* node) {
 			switch(node->compound.nodes[i].pair.right->type) {
 				case TOY_AST_NODE_LITERAL: {
 					//values are literals
-					int val = Toy_findLiteralIndex(&compiler->literalCache, node->compound.nodes[i].pair.right->atomic.literal);
+					int val = Toy_private_findLiteralIndex(&compiler->literalCache, node->compound.nodes[i].pair.right->atomic.literal);
 					if (val < 0) {
 						val = Toy_pushLiteralArray(&compiler->literalCache, node->compound.nodes[i].pair.right->atomic.literal);
 					}
@@ -142,7 +142,7 @@ static int writeNodeCompoundToCache(Toy_Compiler* compiler, Toy_ASTNode* node) {
 			switch(node->compound.nodes[i].type) {
 				case TOY_AST_NODE_LITERAL: {
 					//values
-					int val = Toy_findLiteralIndex(&compiler->literalCache, node->compound.nodes[i].atomic.literal);
+					int val = Toy_private_findLiteralIndex(&compiler->literalCache, node->compound.nodes[i].atomic.literal);
 					if (val < 0) {
 						val = Toy_pushLiteralArray(&compiler->literalCache, node->compound.nodes[i].atomic.literal);
 					}
@@ -230,7 +230,7 @@ static int writeNodeCollectionToCache(Toy_Compiler* compiler, Toy_ASTNode* node)

 static int writeLiteralToCompiler(Toy_Compiler* compiler, Toy_Literal literal) {
 	//get the index
-	int index = Toy_findLiteralIndex(&compiler->literalCache, literal);
+	int index = Toy_private_findLiteralIndex(&compiler->literalCache, literal);

 	if (index < 0) {
 		if (TOY_IS_TYPE(literal)) {
@@ -259,6 +259,87 @@ static int writeLiteralToCompiler(Toy_Compiler* compiler, Toy_Literal literal) {
 	return index;
 }

+//BUGFIX: check to see if this node lies within this tree
+bool checkNodeInTree(Toy_ASTNode* tree, Toy_ASTNode* node) {
+	if (tree == node) {
+		return true;
+	}
+
+	if (tree == NULL) {
+		return false;
+	}
+
+	switch(tree->type) {
+		case TOY_AST_NODE_UNARY:
+			return checkNodeInTree(tree->unary.child, node);
+
+		case TOY_AST_NODE_BINARY:
+			return checkNodeInTree(tree->binary.left, node) || checkNodeInTree(tree->binary.right, node);
+
+		case TOY_AST_NODE_TERNARY:
+			return checkNodeInTree(tree->ternary.condition, node) || checkNodeInTree(tree->ternary.thenPath, node) || checkNodeInTree(tree->ternary.elsePath, node);
+
+		case TOY_AST_NODE_GROUPING:
+			return checkNodeInTree(tree->grouping.child, node);
+
+		case TOY_AST_NODE_BLOCK:
+			return checkNodeInTree(tree->block.nodes, node);
+
+		case TOY_AST_NODE_COMPOUND:
+			return checkNodeInTree(tree->compound.nodes, node);
+
+		case TOY_AST_NODE_PAIR:
+			return checkNodeInTree(tree->pair.left, node) || checkNodeInTree(tree->pair.right, node);
+
+		case TOY_AST_NODE_INDEX:
+			return checkNodeInTree(tree->index.first, node) || checkNodeInTree(tree->index.second, node) || checkNodeInTree(tree->index.third, node);
+
+		case TOY_AST_NODE_VAR_DECL:
+			return checkNodeInTree(tree->varDecl.expression, node);
+
+		case TOY_AST_NODE_FN_COLLECTION:
+			return checkNodeInTree(tree->fnCollection.nodes, node);
+
+		case TOY_AST_NODE_FN_DECL:
+			return checkNodeInTree(tree->fnDecl.arguments, node) || checkNodeInTree(tree->fnDecl.returns, node) || checkNodeInTree(tree->fnDecl.block, node);
+
+		case TOY_AST_NODE_FN_CALL:
+			return checkNodeInTree(tree->fnCall.arguments, node);
+
+		case TOY_AST_NODE_FN_RETURN:
+			return checkNodeInTree(tree->returns.returns, node);
+
+		case TOY_AST_NODE_IF:
+			return checkNodeInTree(tree->pathIf.condition, node) || checkNodeInTree(tree->pathIf.thenPath, node) || checkNodeInTree(tree->pathIf.elsePath, node);
+
+		case TOY_AST_NODE_WHILE:
+			return checkNodeInTree(tree->pathWhile.condition, node) || checkNodeInTree(tree->pathWhile.thenPath, node);
+
+		case TOY_AST_NODE_FOR:
+			return checkNodeInTree(tree->pathFor.preClause, node) || checkNodeInTree(tree->pathFor.condition, node) || checkNodeInTree(tree->pathFor.postClause, node) || checkNodeInTree(tree->pathFor.thenPath, node);
+
+		case TOY_AST_NODE_AND:
+			return checkNodeInTree(tree->pathAnd.left, node) || checkNodeInTree(tree->pathAnd.right, node);
+
+		case TOY_AST_NODE_OR:
+			return checkNodeInTree(tree->pathOr.left, node) || checkNodeInTree(tree->pathOr.right, node);
+
+		case TOY_AST_NODE_ERROR:
+		case TOY_AST_NODE_LITERAL:
+		case TOY_AST_NODE_BREAK:
+		case TOY_AST_NODE_CONTINUE:
+		case TOY_AST_NODE_PREFIX_INCREMENT:
+		case TOY_AST_NODE_PREFIX_DECREMENT:
+		case TOY_AST_NODE_POSTFIX_INCREMENT:
+		case TOY_AST_NODE_POSTFIX_DECREMENT:
+		case TOY_AST_NODE_IMPORT:
+		case TOY_AST_NODE_PASS:
+			return false;
+	}
+
+	return false;
+}
+
 //NOTE: jumpOfsets are included, because function arg and return indexes are embedded in the code body i.e. need to include their sizes in the jump
 //NOTE: rootNode should NOT include groupings and blocks
 static Toy_Opcode Toy_writeCompilerWithJumps(Toy_Compiler* compiler, Toy_ASTNode* node, void* breakAddressesPtr, void* continueAddressesPtr, int jumpOffsets, Toy_ASTNode* rootNode) {
@@ -322,7 +403,8 @@ static Toy_Opcode Toy_writeCompilerWithJumps(Toy_Compiler* compiler, Toy_ASTNode
 			//return this if...
 			Toy_Opcode ret = Toy_writeCompilerWithJumps(compiler, node->binary.right, breakAddressesPtr, continueAddressesPtr, jumpOffsets, rootNode);

-			if (node->binary.opcode == TOY_OP_INDEX && rootNode->type == TOY_AST_NODE_BINARY && (rootNode->binary.opcode >= TOY_OP_VAR_ASSIGN && rootNode->binary.opcode <= TOY_OP_VAR_MODULO_ASSIGN) && rootNode->binary.right != node) { //range-based check for assignment type; make sure the index is on the left of the assignment symbol
+			//range-based check for assignment type; make sure the index is on the left of the assignment symbol
+			if (node->binary.opcode == TOY_OP_INDEX && rootNode->type == TOY_AST_NODE_BINARY && (rootNode->binary.opcode >= TOY_OP_VAR_ASSIGN && rootNode->binary.opcode <= TOY_OP_VAR_MODULO_ASSIGN) && !checkNodeInTree(rootNode->binary.right, node)) {
 				return TOY_OP_INDEX_ASSIGN_INTERMEDIATE;
 			}

@@ -331,9 +413,35 @@ static Toy_Opcode Toy_writeCompilerWithJumps(Toy_Compiler* compiler, Toy_ASTNode
 				return node->binary.opcode;
 			}

-			if (ret != TOY_OP_EOF && (node->binary.opcode == TOY_OP_VAR_ASSIGN || node->binary.opcode == TOY_OP_AND || node->binary.opcode == TOY_OP_OR || (node->binary.opcode >= TOY_OP_COMPARE_EQUAL && node->binary.opcode <= TOY_OP_INVERT))) {
-				compiler->bytecode[compiler->count++] = (unsigned char)ret; //1 byte
-				ret = TOY_OP_EOF; //untangle in this case
+			//untangle in these cases - (WTF, are you serious?)
+			if (ret != TOY_OP_EOF) {
+				switch(node->binary.opcode) {
+					case TOY_OP_NEGATE:
+					case TOY_OP_ADDITION:
+					case TOY_OP_SUBTRACTION:
+					case TOY_OP_MULTIPLICATION:
+					case TOY_OP_DIVISION:
+					case TOY_OP_MODULO:
+					case TOY_OP_VAR_ASSIGN:
+					case TOY_OP_VAR_ADDITION_ASSIGN:
+					case TOY_OP_VAR_SUBTRACTION_ASSIGN:
+					case TOY_OP_VAR_MULTIPLICATION_ASSIGN:
+					case TOY_OP_VAR_DIVISION_ASSIGN:
+					case TOY_OP_VAR_MODULO_ASSIGN:
+					case TOY_OP_COMPARE_EQUAL:
+					case TOY_OP_COMPARE_NOT_EQUAL:
+					case TOY_OP_COMPARE_LESS:
+					case TOY_OP_COMPARE_LESS_EQUAL:
+					case TOY_OP_COMPARE_GREATER:
+					case TOY_OP_COMPARE_GREATER_EQUAL:
+					case TOY_OP_INVERT:
+						//place the rhs result before the outer instruction
+						compiler->bytecode[compiler->count++] = (unsigned char)ret; //1 byte
+						ret = TOY_OP_EOF;
+
+					default:
+						break;
+				}
 			}

 			compiler->bytecode[compiler->count++] = (unsigned char)node->binary.opcode; //1 byte
@@ -446,7 +554,7 @@ static Toy_Opcode Toy_writeCompilerWithJumps(Toy_Compiler* compiler, Toy_ASTNode
 			}

 			//write each piece of the declaration to the bytecode
-			int identifierIndex = Toy_findLiteralIndex(&compiler->literalCache, node->varDecl.identifier);
+			int identifierIndex = Toy_private_findLiteralIndex(&compiler->literalCache, node->varDecl.identifier);
 			if (identifierIndex < 0) {
 				identifierIndex = Toy_pushLiteralArray(&compiler->literalCache, node->varDecl.identifier);
 			}
@@ -479,9 +587,13 @@ static Toy_Opcode Toy_writeCompilerWithJumps(Toy_Compiler* compiler, Toy_ASTNode
 			Toy_initCompiler(fnCompiler);
 			Toy_writeCompiler(fnCompiler, node->fnDecl.arguments); //can be empty, but not NULL
 			Toy_writeCompiler(fnCompiler, node->fnDecl.returns); //can be empty, but not NULL
-			Toy_Opcode override = Toy_writeCompilerWithJumps(fnCompiler, node->fnDecl.block, NULL, NULL, -4, rootNode); //can be empty, but not NULL
-			if (override != TOY_OP_EOF) {//compensate for indexing & dot notation being screwy
-				compiler->bytecode[compiler->count++] = (unsigned char)override; //1 byte
+
+			//BUGFIX: copied from TOY_AST_NODE_BLOCK, omitting the SCOPE_BEGIN and SCOPE_END opcodes (might squeeze a few bytes out of the interpreter's scopes by declaring one less)
+			for (int i = 0; i < node->fnDecl.block->block.count; i++) {
+				Toy_Opcode override = Toy_writeCompilerWithJumps(fnCompiler, &(node->fnDecl.block->block.nodes[i]), NULL, NULL, -4, &(node->fnDecl.block->block.nodes[i]));
+				if (override != TOY_OP_EOF) {//compensate for indexing & dot notation being screwy
+					fnCompiler->bytecode[fnCompiler->count++] = (unsigned char)override; //1 byte
+				}
 			}

 			//adopt the panic state if anything happened
@@ -490,11 +602,10 @@ static Toy_Opcode Toy_writeCompilerWithJumps(Toy_Compiler* compiler, Toy_ASTNode
 			}

 			//create the function in the literal cache (by storing the compiler object)
-			Toy_Literal fnLiteral = TOY_TO_FUNCTION_LITERAL(fnCompiler, 0);
-			fnLiteral.type = TOY_LITERAL_FUNCTION_INTERMEDIATE; //NOTE: changing type
+			Toy_Literal fnLiteral = ((Toy_Literal){ .as = { .generic = fnCompiler }, .type = TOY_LITERAL_FUNCTION_INTERMEDIATE});

 			//push the name
-			int identifierIndex = Toy_findLiteralIndex(&compiler->literalCache, node->fnDecl.identifier);
+			int identifierIndex = Toy_private_findLiteralIndex(&compiler->literalCache, node->fnDecl.identifier);
 			if (identifierIndex < 0) {
 				identifierIndex = Toy_pushLiteralArray(&compiler->literalCache, node->fnDecl.identifier);
 			}
@@ -542,7 +653,7 @@ static Toy_Opcode Toy_writeCompilerWithJumps(Toy_Compiler* compiler, Toy_ASTNode
 			for (int i = 0; i < node->fnCall.arguments->fnCollection.count; i++) { //reverse order, to count from the beginning in the interpreter
 				//sub-calls
 				if (node->fnCall.arguments->fnCollection.nodes[i].type != TOY_AST_NODE_LITERAL) {
-					Toy_Opcode override = Toy_writeCompilerWithJumps(compiler, &node->fnCall.arguments->fnCollection.nodes[i], breakAddressesPtr, continueAddressesPtr, jumpOffsets, rootNode);
+					Toy_Opcode override = Toy_writeCompilerWithJumps(compiler, &node->fnCall.arguments->fnCollection.nodes[i], breakAddressesPtr, continueAddressesPtr, jumpOffsets, node); //BUGFIX: use node as rootNode, to allow indexing within argument lists
 					if (override != TOY_OP_EOF) {//compensate for indexing & dot notation being screwy
 						compiler->bytecode[compiler->count++] = (unsigned char)override; //1 byte
 					}
@@ -550,7 +661,7 @@ static Toy_Opcode Toy_writeCompilerWithJumps(Toy_Compiler* compiler, Toy_ASTNode
 				}

 				//write each argument to the bytecode
-				int argumentsIndex = Toy_findLiteralIndex(&compiler->literalCache, node->fnCall.arguments->fnCollection.nodes[i].atomic.literal);
+				int argumentsIndex = Toy_private_findLiteralIndex(&compiler->literalCache, node->fnCall.arguments->fnCollection.nodes[i].atomic.literal);
 				if (argumentsIndex < 0) {
 					argumentsIndex = Toy_pushLiteralArray(&compiler->literalCache, node->fnCall.arguments->fnCollection.nodes[i].atomic.literal);
 				}
@@ -572,7 +683,7 @@ static Toy_Opcode Toy_writeCompilerWithJumps(Toy_Compiler* compiler, Toy_ASTNode

 			//push the argument COUNT to the top of the stack
 			Toy_Literal argumentsCountLiteral =  TOY_TO_INTEGER_LITERAL(node->fnCall.argumentCount); //argumentCount is set elsewhere to support dot operator
-			int argumentsCountIndex = Toy_findLiteralIndex(&compiler->literalCache, argumentsCountLiteral);
+			int argumentsCountIndex = Toy_private_findLiteralIndex(&compiler->literalCache, argumentsCountLiteral);
 			if (argumentsCountIndex < 0) {
 				argumentsCountIndex = Toy_pushLiteralArray(&compiler->literalCache, argumentsCountLiteral);
 			}
@@ -730,12 +841,20 @@ static Toy_Opcode Toy_writeCompilerWithJumps(Toy_Compiler* compiler, Toy_ASTNode
 			compiler->count += sizeof(unsigned short); //2 bytes

 			//write the body
-			compiler->bytecode[compiler->count++] = TOY_OP_SCOPE_BEGIN; //1 byte
+			bool closeScope = false;
+			if (node->pathFor.thenPath->type != TOY_AST_NODE_BLOCK) {
+				compiler->bytecode[compiler->count++] = TOY_OP_SCOPE_BEGIN; //1 byte
+				closeScope = true;
+			}
+
 			override = Toy_writeCompilerWithJumps(compiler, node->pathFor.thenPath, &breakAddresses, &continueAddresses, jumpOffsets, rootNode);
 			if (override != TOY_OP_EOF) {//compensate for indexing & dot notation being screwy
 				compiler->bytecode[compiler->count++] = (unsigned char)override; //1 byte
 			}
-			compiler->bytecode[compiler->count++] = TOY_OP_SCOPE_END; //1 byte
+
+			if (closeScope) {
+				compiler->bytecode[compiler->count++] = TOY_OP_SCOPE_END; //1 byte
+			}

 			//for-breaks actually jump to the bottom
 			int jumpToIncrement = compiler->count;
@@ -746,6 +865,9 @@ static Toy_Opcode Toy_writeCompilerWithJumps(Toy_Compiler* compiler, Toy_ASTNode
 				compiler->bytecode[compiler->count++] = (unsigned char)override; //1 byte
 			}

+			//BUGFIX: clear the stack after each loop
+			compiler->bytecode[compiler->count++] = TOY_OP_POP_STACK; //1 byte
+
 			compiler->bytecode[compiler->count++] = TOY_OP_JUMP; //1 byte
 			unsigned short tmpVal = jumpToStart + jumpOffsets;
 			memcpy(compiler->bytecode + compiler->count, &tmpVal, sizeof(tmpVal));
@@ -769,9 +891,6 @@ static Toy_Opcode Toy_writeCompilerWithJumps(Toy_Compiler* compiler, Toy_ASTNode
 				memcpy(compiler->bytecode + point, &tmpVal, sizeof(tmpVal));
 			}

-			//clear the stack after use
-			compiler->bytecode[compiler->count++] = TOY_OP_POP_STACK; //1 byte
-
 			//cleanup
 			Toy_freeLiteralArray(&breakAddresses);
 			Toy_freeLiteralArray(&continueAddresses);
@@ -814,6 +933,54 @@ static Toy_Opcode Toy_writeCompilerWithJumps(Toy_Compiler* compiler, Toy_ASTNode
 		}
 		break;

+		case TOY_AST_NODE_AND: {
+			//process the lhs
+			Toy_Opcode override = Toy_writeCompilerWithJumps(compiler, node->pathAnd.left, breakAddressesPtr, continueAddressesPtr, jumpOffsets, rootNode);
+			if (override != TOY_OP_EOF) {//compensate for indexing & dot notation being screwy
+				compiler->bytecode[compiler->count++] = (unsigned char)override; //1 byte
+			}
+
+			//insert the AND opcode to signal a possible jump
+			compiler->bytecode[compiler->count++] = TOY_OP_AND; //1 byte
+			int jumpToEnd = compiler->count;
+			compiler->count += sizeof(unsigned short); //2 bytes
+
+			//process the rhs
+			override = Toy_writeCompilerWithJumps(compiler, node->pathAnd.right, breakAddressesPtr, continueAddressesPtr, jumpOffsets, rootNode);
+			if (override != TOY_OP_EOF) {//compensate for indexing & dot notation being screwy
+				compiler->bytecode[compiler->count++] = (unsigned char)override; //1 byte
+			}
+
+			//set the spot to jump to, to proceed
+			unsigned short tmpVal = compiler->count + jumpOffsets;
+			memcpy(compiler->bytecode + jumpToEnd, &tmpVal, sizeof(tmpVal));
+		}
+		break;
+
+		case TOY_AST_NODE_OR: {
+			//process the lhs
+			Toy_Opcode override = Toy_writeCompilerWithJumps(compiler, node->pathOr.left, breakAddressesPtr, continueAddressesPtr, jumpOffsets, rootNode);
+			if (override != TOY_OP_EOF) {//compensate for indexing & dot notation being screwy
+				compiler->bytecode[compiler->count++] = (unsigned char)override; //1 byte
+			}
+
+			//insert the AND opcode to signal a possible jump
+			compiler->bytecode[compiler->count++] = TOY_OP_OR; //1 byte
+			int jumpToEnd = compiler->count;
+			compiler->count += sizeof(unsigned short); //2 bytes
+
+			//process the rhs
+			override = Toy_writeCompilerWithJumps(compiler, node->pathOr.right, breakAddressesPtr, continueAddressesPtr, jumpOffsets, rootNode);
+			if (override != TOY_OP_EOF) {//compensate for indexing & dot notation being screwy
+				compiler->bytecode[compiler->count++] = (unsigned char)override; //1 byte
+			}
+
+			//set the spot to jump to, to proceed
+			unsigned short tmpVal = compiler->count + jumpOffsets;
+			memcpy(compiler->bytecode + jumpToEnd, &tmpVal, sizeof(tmpVal));
+		}
+		break;
+
 		case TOY_AST_NODE_FN_RETURN: {
 			//read each returned literal onto the stack, and return the number of values to return
 			for (int i = 0; i < node->returns.returns->fnCollection.count; i++) {
@@ -1182,7 +1349,7 @@ static unsigned char* collateCompilerHeaderOpt(Toy_Compiler* compiler, size_t* s
 			case TOY_LITERAL_FUNCTION_INTERMEDIATE: {
 				//extract the compiler
 				Toy_Literal fn = compiler->literalCache.literals[i];
-				void* fnCompiler = TOY_AS_FUNCTION(fn).inner.bytecode; //store the compiler here for now
+				void* fnCompiler = fn.as.generic; //store the compiler here for now

 				//collate the function into bytecode (without header)
 				size_t size = 0;
@@ -1,11 +1,20 @@
 #pragma once

+/*!
+# toy_compiler.h
+
+This header defines the compiler structure, which is used to transform abstract syntax trees into usable intermediate bytecode. There are two steps to generating bytecode - the writing step, and the collation step.
+
+During the writing step, the core of the program is generated, along with a series of literals representing the values within the program; these values are compressed and flattened into semi-unrecognizable forms. If the same literal is used multiple times in a program, such as a variable name, the name itself is replaced by a reference to the flattened literals within the cache.
+
+During the collation step, everything from the core program’s execution instructions, the flattened literals, the functions (which have their own sections and protocols within the bytecode) and version information (such as the macros defined in toy_common.h) are all combined into a single buffer of bytes, known as bytecode. This bytecode can then be safely saved to a file or immediately executed.
+!*/
+
 #include "toy_common.h"
 #include "toy_opcodes.h"
 #include "toy_ast_node.h"
 #include "toy_literal_array.h"

-//the compiler takes the nodes, and turns them into sequential chunks of bytecode, saving literals to an external array
 typedef struct Toy_Compiler {
 	Toy_LiteralArray literalCache;
 	unsigned char* bytecode;
@@ -14,9 +23,38 @@ typedef struct Toy_Compiler {
 	bool panic;
 } Toy_Compiler;

-TOY_API void Toy_initCompiler(Toy_Compiler* compiler);
-TOY_API void Toy_writeCompiler(Toy_Compiler* compiler, Toy_ASTNode* node);
-TOY_API void Toy_freeCompiler(Toy_Compiler* compiler);
+/*!
+## Define Functions

-//embed the header, data section, code section, function section, etc.
+Executing the following functions out-of-order causes undefiend behaviour.
+!*/
+
+/*!
+### void Toy_initCompiler(Toy_Compiler* compiler)
+
+This function initializes the given compiler.
+!*/
+TOY_API void Toy_initCompiler(Toy_Compiler* compiler);
+
+/*!
+### void Toy_writeCompiler(Toy_Compiler* compiler, Toy_ASTNode* node)
+
+This function writes the given `node` argument to the compiler. During the writing step, this function may be called repeatedly, with a stream of results from `Toy_scanParser()`, until `Toy_scanParser()` returns `NULL`.
+!*/
+TOY_API void Toy_writeCompiler(Toy_Compiler* compiler, Toy_ASTNode* node);
+
+/*!
+### unsigned char* Toy_collateCompiler(Toy_Compiler* compiler, size_t* size)
+
+This function returns a buffer of bytes, known as "bytecode", created from the given compiler; it also stores the size of the bytecode in the variable pointed to by `size`.
+
+Calling `Toy_collateCompiler()` multiple times on the same compiler will produce undefined behaviour.
+!*/
 TOY_API unsigned char* Toy_collateCompiler(Toy_Compiler* compiler, size_t* size);
+
+/*!
+### void Toy_freeCompiler(Toy_Compiler* compiler)
+
+This function frees a compiler. Calling this on a compiler which has not been collated will free that compiler as expected - anything written to it will be lost.
+!*/
+TOY_API void Toy_freeCompiler(Toy_Compiler* compiler);
@@ -1,6 +1,16 @@
 #pragma once

-//NOTE: you need both font AND background for these to work
+/* toy_console_colors.h - console utility
+
+This file provides a number of macros that can set the color of text in a console
+window. These are used for convenience only. They are supposed to be dropped into
+a printf()'s first argument, like so:
+
+    printf(TOY_CC_NOTICE "Hello world" TOY_CC_RESET);
+
+NOTE: you need both font AND background for these to work
+
+*/

 //platform/compiler-specific instructions
 #if defined(__linux__) || defined(__MINGW32__) || defined(__GNUC__)
@@ -1,5 +1,41 @@
 #pragma once

+/*!
+# toy_interpreter.h
+
+This header defines the interpreter structure, which is the beating heart of Toy.
+
+`Toy_Interpreter` is a stack-based, bytecode-driven interpreter with a number of customisation options, including "hooks"; native C functions wrapped in `Toy_Literal` instances, injected into the interpreter in order to give the Toy scripts access to libraries via the `import` keyword. The hooks, when invoked this way, can then inject further native functions into the interpreter's current scope. Exactly which hooks are made available varies by host program, but `standard` is the most commonly included one.
+
+Another useful customisation feature is the ability to redicrect output from the `print` and `assert` keywords, as well as any internal errors that occur. This can allow you to add in a logging system, or even hook the `print` statement up to some kind of HUD.
+
+## Defined Interfaces
+
+Note: These interfaces are *actually* defined in [toy_literal.h](toy_literal_h.md) but are documented here, because this is where it matters most.
+
+### typedef void (*Toy_PrintFn)(const char*)
+
+This is the interface used by "print functions" - that is, functions used to print messages from the `print` and `assert` keywords, as well as internal interpreter errors.
+
+### typedef int (*Toy_NativeFn)(struct Toy_Interpreter* interpreter, struct Toy_LiteralArray* arguments)
+
+This is the interface used by "native functions" - that is, functions written in C which can be called directly by Toy scripts.
+
+The arguments to the function are passed in as a `Toy_LiteralArray`.
+
+### typedef int (*Toy_HookFn)(struct Toy_Interpreter* interpreter, struct Toy_Literal identifier, struct Toy_Literal alias)
+
+This is the interface used by "hook functions" - that is, functions written in C which are invoked by using the `import` keyword, and are intended to inject other native functions into the current scope. While hook functions are capable of doing other things, this is greatly discouraged.
+
+The identifier of the library (its name) is passed in as a `Toy_Literal`, as is any given alias; if no alias is given, then `alias` will be a null literal. Here, the identifier is `standard`, while the alias is `std`.
+
+```
+import standard as std;
+```
+
+Conventionally, when an alias is given, all of the functions should instead be inserted into a `Toy_LiteralDictionary` which is then inserted into the scope with the alias as its identifier.
+!*/
+
 #include "toy_common.h"
 #include "toy_literal.h"
 #include "toy_literal_array.h"
@@ -31,21 +67,134 @@ typedef struct Toy_Interpreter {
 	bool panic;
 } Toy_Interpreter;

-//native API
+/*!
+## Defined Functions
+!*/
+
+/*!
+### void Toy_initInterpreter(Toy_Interpreter* interpreter)
+
+This function initializes the interpreter. It allocates memory for internal systems such as the stack, and zeroes-out systems that have yet to be invoked. Internally, it also invokes `Toy_resetInterpreter` to initialize the environment.
+!*/
+TOY_API void Toy_initInterpreter(Toy_Interpreter* interpreter); //start of program
+
+/*!
+### void Toy_runInterpreter(Toy_Interpreter* interpreter, const unsigned char* bytecode, size_t length)
+
+This function takes a `Toy_Interpreter` and `bytecode` (as well as the `length` of the bytecode), checks its version information, parses and un-flattens the literal cache, and executes the compiled program stored in the bytecode. This function also consumes the bytecode, so the `bytecode` argument is no longer valid after calls.
+
+If the given bytecode's embedded version is not compatible with the current interpreter, then this function will refuse to execute.
+
+Re-using a `Toy_Interpreter` instance without first resetting it is possible (that's how the repl works), however doing so may have unintended consequences if the scripts are not intended to be used in such a way. Any variables declared will persist.
+!*/
+TOY_API void Toy_runInterpreter(Toy_Interpreter* interpreter, const unsigned char* bytecode, size_t length);
+
+/*!
+### void Toy_resetInterpreter(Toy_Interpreter* interpreter)
+
+This function frees any scopes that the scripts have built up, and generates a new one. It also injects several globally available functions:
+
+* set
+* get
+* push
+* pop
+* length
+* clear
+!*/
+TOY_API void Toy_resetInterpreter(Toy_Interpreter* interpreter);
+
+/*!
+### void Toy_freeInterpreter(Toy_Interpreter* interpreter)
+
+This function frees a `Toy_Interpreter`, clearing all of the memory used within. That interpreter is no longer valid for use, and must be re-initialized.
+!*/
+TOY_API void Toy_freeInterpreter(Toy_Interpreter* interpreter);
+
+/*!
+### bool Toy_injectNativeFn(Toy_Interpreter* interpreter, const char* name, Toy_NativeFn func)
+
+This function will inject the given native function `func` into the `Toy_Interpreter`'s current scope, with the identifer as `name`. Both the name and function will be converted into literals internally before being stored. It will return true on success, otherwise it will return false.
+
+The primary use of this function is within hooks.
+!*/
 TOY_API bool Toy_injectNativeFn(Toy_Interpreter* interpreter, const char* name, Toy_NativeFn func);
+
+/*!
+### bool Toy_injectNativeHook(Toy_Interpreter* interpreter, const char* name, Toy_HookFn hook)
+
+This function will inject the given native function `hook` into the `Toy_Interpreter`'s hook cache, with the identifier as `name`. Both the name and the function will be converted into literals internally before being stored. It will return true on success, otherwise it will return false.
+
+Hooks are invoked with the `import` keyword within Toy's scripts.
+!*/
 TOY_API bool Toy_injectNativeHook(Toy_Interpreter* interpreter, const char* name, Toy_HookFn hook);

+/*!
+### bool Toy_callLiteralFn(Toy_Interpreter* interpreter, Toy_Literal func, Toy_LiteralArray* arguments, Toy_LiteralArray* returns)
+
+This function calls a `Toy_Literal` which contains a function, with the arguments to that function passed in as `arguments` and the results stored in `returns`. It returns true on success, otherwise it returns false.
+
+The literal `func` can be either a native function or a Toy function, but it won't execute a hook.
+!*/
 TOY_API bool Toy_callLiteralFn(Toy_Interpreter* interpreter, Toy_Literal func, Toy_LiteralArray* arguments, Toy_LiteralArray* returns);
+
+/*!
+### bool Toy_callFn(Toy_Interpreter* interpreter, const char* name, Toy_LiteralArray* arguments, Toy_LiteralArray* returns)
+
+This utility function will find a `Toy_literal` within the `Toy_Interpreter`'s scope with an identifier that matches `name`, and will invoke it using `Toy_callLiteralFn` (passing in `arguments` and `returns` as expected).
+!*/
 TOY_API bool Toy_callFn(Toy_Interpreter* interpreter, const char* name, Toy_LiteralArray* arguments, Toy_LiteralArray* returns);

-//utilities for the host program
-TOY_API bool Toy_parseIdentifierToValue(Toy_Interpreter* interpreter, Toy_Literal* literalPtr);
-TOY_API void Toy_setInterpreterPrint(Toy_Interpreter* interpreter, Toy_PrintFn printOutput);
-TOY_API void Toy_setInterpreterAssert(Toy_Interpreter* interpreter, Toy_PrintFn assertOutput);
-TOY_API void Toy_setInterpreterError(Toy_Interpreter* interpreter, Toy_PrintFn errorOutput);
+/*!
+### bool Toy_parseIdentifierToValue(Toy_Interpreter* interpreter, Toy_Literal* literalPtr)

-//main access
-TOY_API void Toy_initInterpreter(Toy_Interpreter* interpreter); //start of program
-TOY_API void Toy_runInterpreter(Toy_Interpreter* interpreter, const unsigned char* bytecode, size_t length); //run the code
-TOY_API void Toy_resetInterpreter(Toy_Interpreter* interpreter); //use this to reset the interpreter's environment between runs
-TOY_API void Toy_freeInterpreter(Toy_Interpreter* interpreter); //end of program
+Sometimes, native functions will receive `Toy_Literal` identifiers instead of the values - the correct values can be retreived from the given interpreter's scope using the following pattern:
+
+```c
+Toy_Literal foobarIdn = foobar;
+if (TOY_IS_IDENTIFIER(foobar) && Toy_parseIdentifierToValue(interpreter, &foobar)) {
+	freeLiteral(foobarIdn); //remember to free the identifier
+}
+```
+!*/
+TOY_API bool Toy_parseIdentifierToValue(Toy_Interpreter* interpreter, Toy_Literal* literalPtr);
+
+/*!
+### void Toy_setInterpreterPrint(Toy_Interpreter* interpreter, Toy_PrintFn printOutput)
+
+This function sets the function called by the `print` keyword. By default, the following wrapper is used:
+
+```c
+static void printWrapper(const char* output) {
+	printf("%s\n", output);
+}
+```
+
+Note: The above is a very minor lie - in reality there are some preprocessor directives to allow the repl's `-n` flag to work.
+!*/
+TOY_API void Toy_setInterpreterPrint(Toy_Interpreter* interpreter, Toy_PrintFn printOutput);
+
+/*!
+### void Toy_setInterpreterAssert(Toy_Interpreter* interpreter, Toy_PrintFn assertOutput)
+
+This function sets the function called by the `assert` keyword on failure. By default, the following wrapper is used:
+
+```c
+static void assertWrapper(const char* output) {
+	fprintf(stderr, "Assertion failure: %s\n", output);
+}
+```
+!*/
+TOY_API void Toy_setInterpreterAssert(Toy_Interpreter* interpreter, Toy_PrintFn assertOutput);
+
+/*!
+### void Toy_setInterpreterError(Toy_Interpreter* interpreter, Toy_PrintFn errorOutput)
+
+This function sets the function called when an error occurs within the interpreter. By default, the following wrapper is used:
+
+```c
+static void errorWrapper(const char* output) {
+	fprintf(stderr, "%s", output); //no newline
+}
+```
+!*/
+TOY_API void Toy_setInterpreterError(Toy_Interpreter* interpreter, Toy_PrintFn errorOutput);
@@ -237,7 +237,7 @@ static Toy_Token makeKeywordOrIdentifier(Toy_Lexer* lexer) {

 	//scan for a keyword
 	for (int i = 0; Toy_keywordTypes[i].keyword; i++) {
-		if (strlen(Toy_keywordTypes[i].keyword) == (long unsigned int)(lexer->current - lexer->start) && !strncmp(Toy_keywordTypes[i].keyword, &lexer->source[lexer->start], lexer->current - lexer->start)) {
+		if (strlen(Toy_keywordTypes[i].keyword) == (size_t)(lexer->current - lexer->start) && !strncmp(Toy_keywordTypes[i].keyword, &lexer->source[lexer->start], lexer->current - lexer->start)) {
 			Toy_Token token;

 			token.type = Toy_keywordTypes[i].type;
@@ -317,10 +317,10 @@ Toy_Token Toy_private_scanLexer(Toy_Lexer* lexer) {
 			if (advance(lexer) != '&') {
 				return makeErrorToken(lexer, "Unexpected '&'");
 			} else {
-				return makeToken(lexer, TOY_TOKEN_AND);
+				return makeToken(lexer, TOY_TOKEN_AND_AND);
 			}

-		case '|':  return makeToken(lexer, match(lexer, '|') ? TOY_TOKEN_OR : TOY_TOKEN_PIPE);
+		case '|':  return makeToken(lexer, match(lexer, '|') ? TOY_TOKEN_OR_OR : TOY_TOKEN_PIPE);

 		case '?': return makeToken(lexer, TOY_TOKEN_QUESTION);
 		case ':': return makeToken(lexer, TOY_TOKEN_COLON);
@@ -1,5 +1,11 @@
 #pragma once

+/*!
+# toy_lexer.h
+
+This header defines the lexer and token structures, which can be bound to a piece of source code, and used to tokenize it within a parser.
+!*/
+
 #include "toy_common.h"
 #include "toy_token_types.h"

@@ -20,10 +26,40 @@ typedef struct {
 	int line;
 } Toy_Token;

+/*!
+## Defined Functions
+!*/
+
+/*!
+### void Toy_initLexer(Toy_Lexer* lexer, const char* source)
+
+This function initializes a lexer, binding it to the `source` parameter; the lexer is now ready to be passed to the parser.
+!*/
 TOY_API void Toy_initLexer(Toy_Lexer* lexer, const char* source);
+
+/*!
+### Toy_Token Toy_private_scanLexer(Toy_Lexer* lexer)
+
+This function "scans" the lexer, returning a token to the parser.
+
+Private functions are not intended for general use.
+!*/
 TOY_API Toy_Token Toy_private_scanLexer(Toy_Lexer* lexer);

-//for debugging
+/*!
+### void Toy_private_printToken(Toy_Token* token)
+
+This function prints a given token to stdout.
+
+Private functions are not intended for general use.
+!*/
 TOY_API void Toy_private_printToken(Toy_Token* token);

+/*!
+### void Toy_private_setComments(Toy_Lexer* lexer, bool enabled)
+
+This function sets whether comments are allowed within source code. By default, comments are allowed, and are only disabled in the repl.
+
+Private functions are not intended for general use.
+!*/
 TOY_API void Toy_private_setComments(Toy_Lexer* lexer, bool enabled);
@@ -59,7 +59,7 @@ void Toy_freeLiteral(Toy_Literal literal) {
 	if (TOY_IS_FUNCTION(literal)) {
 		Toy_popScope(TOY_AS_FUNCTION(literal).scope);
 		TOY_AS_FUNCTION(literal).scope = NULL;
-		TOY_FREE_ARRAY(unsigned char, TOY_AS_FUNCTION(literal).inner.bytecode, TOY_AS_FUNCTION_BYTECODE_LENGTH(literal));
+		Toy_deleteRefFunction((Toy_RefFunction*)(TOY_AS_FUNCTION(literal).inner.ptr));
 	}

 	if (TOY_IS_TYPE(literal) && TOY_AS_TYPE(literal).capacity > 0) {
@@ -84,12 +84,8 @@ bool Toy_private_isTruthy(Toy_Literal x) {
 	return true;
 }

-Toy_Literal Toy_private_toStringLiteral(Toy_RefString* ptr) {
-	return ((Toy_Literal){{ .string = { .ptr = ptr }},TOY_LITERAL_STRING, 0});
-}
-
 Toy_Literal Toy_private_toIdentifierLiteral(Toy_RefString* ptr) {
-	return ((Toy_Literal){{ .identifier = { .ptr = ptr, .hash = hashString(Toy_toCString(ptr), Toy_lengthRefString(ptr)) }},TOY_LITERAL_IDENTIFIER, 0});
+	return ((Toy_Literal){{ .identifier = { .ptr = ptr, .hash = hashString(Toy_toCString(ptr), Toy_lengthRefString(ptr)) }},TOY_LITERAL_IDENTIFIER});
 }

 Toy_Literal* Toy_private_typePushSubtype(Toy_Literal* lit, Toy_Literal subtype) {
@@ -123,6 +119,10 @@ Toy_Literal Toy_copyLiteral(Toy_Literal original) {
 			Toy_LiteralArray* array = TOY_ALLOCATE(Toy_LiteralArray, 1);
 			Toy_initLiteralArray(array);

+			//preallocate enough space
+			array->capacity = TOY_AS_ARRAY(original)->capacity;
+			array->literals = TOY_GROW_ARRAY(Toy_Literal, array->literals, 0, array->capacity);
+
 			//copy each element
 			for (int i = 0; i < TOY_AS_ARRAY(original)->count; i++) {
 				Toy_pushLiteralArray(array, TOY_AS_ARRAY(original)->literals[i]);
@@ -135,6 +135,15 @@ Toy_Literal Toy_copyLiteral(Toy_Literal original) {
 			Toy_LiteralDictionary* dictionary = TOY_ALLOCATE(Toy_LiteralDictionary, 1);
 			Toy_initLiteralDictionary(dictionary);

+			//preallocate enough space
+			dictionary->capacity = TOY_AS_DICTIONARY(original)->capacity;
+			dictionary->entries = TOY_ALLOCATE(Toy_private_dictionary_entry, dictionary->capacity);
+
+			for (int i = 0; i < dictionary->capacity; i++) {
+				dictionary->entries[i].key = TOY_TO_NULL_LITERAL;
+				dictionary->entries[i].value = TOY_TO_NULL_LITERAL;
+			}
+
 			//copy each entry
 			for (int i = 0; i < TOY_AS_DICTIONARY(original)->capacity; i++) {
 				if ( !TOY_IS_NULL(TOY_AS_DICTIONARY(original)->entries[i].key) ) {
@@ -146,10 +155,8 @@ Toy_Literal Toy_copyLiteral(Toy_Literal original) {
 		}

 		case TOY_LITERAL_FUNCTION: {
-			unsigned char* buffer = TOY_ALLOCATE(unsigned char, TOY_AS_FUNCTION_BYTECODE_LENGTH(original));
-			memcpy(buffer, TOY_AS_FUNCTION(original).inner.bytecode, TOY_AS_FUNCTION_BYTECODE_LENGTH(original));
+			Toy_Literal literal = TOY_TO_FUNCTION_LITERAL(Toy_copyRefFunction( TOY_AS_FUNCTION(original).inner.ptr ));

-			Toy_Literal literal = TOY_TO_FUNCTION_LITERAL(buffer, TOY_AS_FUNCTION_BYTECODE_LENGTH(original));
 			TOY_AS_FUNCTION(literal).scope = Toy_copyScope(TOY_AS_FUNCTION(original).scope);

 			return literal;
@@ -174,7 +181,7 @@ Toy_Literal Toy_copyLiteral(Toy_Literal original) {
 			return original; //literally a shallow copy
 		}

-		case TOY_LITERAL_ARRAY_INTERMEDIATE: {
+		case TOY_LITERAL_ARRAY_INTERMEDIATE: { //TODO: efficient preallocation?
 			Toy_LiteralArray* array = TOY_ALLOCATE(Toy_LiteralArray, 1);
 			Toy_initLiteralArray(array);

@@ -190,7 +197,7 @@ Toy_Literal Toy_copyLiteral(Toy_Literal original) {
 			return ret;
 		}

-		case TOY_LITERAL_DICTIONARY_INTERMEDIATE: {
+		case TOY_LITERAL_DICTIONARY_INTERMEDIATE: { //TODO: efficient preallocation?
 			Toy_LiteralArray* array = TOY_ALLOCATE(Toy_LiteralArray, 1);
 			Toy_initLiteralArray(array);

@@ -206,7 +213,7 @@ Toy_Literal Toy_copyLiteral(Toy_Literal original) {
 			return ret;
 		}

-		case TOY_LITERAL_TYPE_INTERMEDIATE: {
+		case TOY_LITERAL_TYPE_INTERMEDIATE: { //TODO: efficient preallocation?
 			Toy_LiteralArray* array = TOY_ALLOCATE(Toy_LiteralArray, 1);
 			Toy_initLiteralArray(array);

@@ -378,8 +385,10 @@ int Toy_hashLiteral(Toy_Literal lit) {
 		case TOY_LITERAL_INTEGER:
 			return hashUInt((unsigned int)TOY_AS_INTEGER(lit));

-		case TOY_LITERAL_FLOAT:
-			return hashUInt(*(unsigned int*)(&TOY_AS_FLOAT(lit)));
+		case TOY_LITERAL_FLOAT: {
+			unsigned int* ptr = (unsigned int*)(&TOY_AS_FLOAT(lit));
+			return hashUInt(*ptr);
+		}

 		case TOY_LITERAL_STRING:
 			return hashString(Toy_toCString(TOY_AS_STRING(lit)), Toy_lengthRefString(TOY_AS_STRING(lit)));
@@ -446,8 +455,8 @@ static void printToBuffer(const char* str) {
 		globalPrintBuffer = TOY_GROW_ARRAY(char, globalPrintBuffer, oldCapacity, globalPrintCapacity);
 	}

-	snprintf(globalPrintBuffer + globalPrintCount, strlen(str) + 1, "%s", str);
-	globalPrintCount += strlen(str);
+	size_t total = snprintf(globalPrintBuffer + globalPrintCount, strlen(str) + 1, "%s", str ? str : "\0");
+	globalPrintCount += total;
 }

 //exposed functions
@@ -1,8 +1,19 @@
 #pragma once

+/*!
+# toy_literal.h
+
+This header defines the literal structure, which is used extensively throughout Toy to represent values of some kind.
+
+The main way of interacting with literals is to use a macro of some kind, as the exact implementation of `Toy_Literal` has and will change based on the needs of Toy.
+
+User data can be passed around within Toy as an opaque type - use the tag value for determining what kind of opaque it is, or leave it as 0.
+!*/
+
 #include "toy_common.h"

 #include "toy_refstring.h"
+#include "toy_reffunction.h"

 //forward delcare stuff
 struct Toy_Literal;
@@ -14,6 +25,31 @@ typedef int (*Toy_NativeFn)(struct Toy_Interpreter* interpreter, struct Toy_Lite
 typedef int (*Toy_HookFn)(struct Toy_Interpreter* interpreter, struct Toy_Literal identifier, struct Toy_Literal alias);
 typedef void (*Toy_PrintFn)(const char*);

+/*!
+## Defined Enums
+
+### Toy_LiteralType
+
+* `TOY_LITERAL_NULL`
+* `TOY_LITERAL_BOOLEAN`
+* `TOY_LITERAL_INTEGER`
+* `TOY_LITERAL_FLOAT`
+* `TOY_LITERAL_STRING`
+* `TOY_LITERAL_ARRAY`
+* `TOY_LITERAL_DICTIONARY`
+* `TOY_LITERAL_FUNCTION`
+* `TOY_LITERAL_FUNCTION_NATIVE`
+* `TOY_LITERAL_FUNCTION_HOOK`
+* `TOY_LITERAL_IDENTIFIER`
+* `TOY_LITERAL_TYPE`
+* `TOY_LITERAL_OPAQUE`
+* `TOY_LITERAL_ANY`
+
+These are the main values of `Toy_LiteralType`, each of which represents a potential state of the `Toy_Literal` structure. Do not interact with a literal without determining its type with the `IS_*` macros first.
+
+Other type values are possible, but are only used internally.
+!*/
+
 typedef enum {
 	TOY_LITERAL_NULL,
 	TOY_LITERAL_BOOLEAN,
@@ -55,7 +91,7 @@ typedef struct Toy_Literal {

 		struct {
 			union {
-				void* bytecode;  //8
+				Toy_RefFunction* ptr;  //8
 				Toy_NativeFn native; //8
 				Toy_HookFn hook; //8
 			} inner;  //8
@@ -63,12 +99,11 @@ typedef struct Toy_Literal {
 		} function; //16

 		struct { //for variable names
-            Toy_RefString* ptr;  //8
+			Toy_RefString* ptr;  //8
 			int hash; //4
-        } identifier; //16
+		} identifier; //16

 		struct {
-			
 			struct Toy_Literal* subtypes; //8
 			Toy_LiteralType typeOf;  //4
 			unsigned char capacity; //1
@@ -80,12 +115,37 @@ typedef struct Toy_Literal {
 			void* ptr; //8
 			int tag; //4
 		} opaque; //16
+
+		void* generic; //8
 	} as; //16

 	Toy_LiteralType type; //4
-	int bytecodeLength; //4 - shenanigans with byte alignment reduces the size of Toy_Literal
+	//4 - unused
+	//shenanigans with byte alignment reduces the size of Toy_Literal
 } Toy_Literal;

+/*!
+## Defined Macros
+!*/
+
+/*!
+The following macros are used to determine if a given literal, passed in as `value`, is of a specific type. It should be noted that `TOY_IS_FUNCTION` will return false for native and hook functions.
+
+* `TOY_IS_NULL(value)`
+* `TOY_IS_BOOLEAN(value)`
+* `TOY_IS_INTEGER(value)`
+* `TOY_IS_FLOAT(value)`
+* `TOY_IS_STRING(value)`
+* `TOY_IS_ARRAY(value)`
+* `TOY_IS_DICTIONARY(value)`
+* `TOY_IS_FUNCTION(value)`
+* `TOY_IS_FUNCTION_NATIVE(value)`
+* `TOY_IS_FUNCTION_HOOK(value)`
+* `TOY_IS_IDENTIFIER(value)`
+* `TOY_IS_TYPE(value)`
+* `TOY_IS_OPAQUE(value)`
+!*/
+
 #define TOY_IS_NULL(value)						((value).type == TOY_LITERAL_NULL)
 #define TOY_IS_BOOLEAN(value)					((value).type == TOY_LITERAL_BOOLEAN)
 #define TOY_IS_INTEGER(value)					((value).type == TOY_LITERAL_INTEGER)
@@ -100,6 +160,23 @@ typedef struct Toy_Literal {
 #define TOY_IS_TYPE(value)						((value).type == TOY_LITERAL_TYPE)
 #define TOY_IS_OPAQUE(value)					((value).type == TOY_LITERAL_OPAQUE)

+/*!
+The following macros are used to cast a literal to a specific C type to be used.
+
+* `TOY_AS_BOOLEAN(value)`
+* `TOY_AS_INTEGER(value)`
+* `TOY_AS_FLOAT(value)`
+* `TOY_AS_STRING(value)`
+* `TOY_AS_ARRAY(value)`
+* `TOY_AS_DICTIONARY(value)`
+* `TOY_AS_FUNCTION(value)`
+* `TOY_AS_FUNCTION_NATIVE(value)`
+* `TOY_AS_FUNCTION_HOOK(value)`
+* `TOY_AS_IDENTIFIER(value)`
+* `TOY_AS_TYPE(value)`
+* `TOY_AS_OPAQUE(value)`
+!*/
+
 #define TOY_AS_BOOLEAN(value)					((value).as.boolean)
 #define TOY_AS_INTEGER(value)					((value).as.integer)
 #define TOY_AS_FLOAT(value)						((value).as.number)
@@ -113,46 +190,191 @@ typedef struct Toy_Literal {
 #define TOY_AS_TYPE(value)						((value).as.type)
 #define TOY_AS_OPAQUE(value)					((value).as.opaque.ptr)

-#define TOY_TO_NULL_LITERAL						((Toy_Literal){{ .integer = 0 }, TOY_LITERAL_NULL, 0})
-#define TOY_TO_BOOLEAN_LITERAL(value)			((Toy_Literal){{ .boolean = value }, TOY_LITERAL_BOOLEAN, 0})
-#define TOY_TO_INTEGER_LITERAL(value)			((Toy_Literal){{ .integer = value }, TOY_LITERAL_INTEGER, 0})
-#define TOY_TO_FLOAT_LITERAL(value)				((Toy_Literal){{ .number = value }, TOY_LITERAL_FLOAT, 0})
-#define TOY_TO_STRING_LITERAL(value)			Toy_private_toStringLiteral(value)
-#define TOY_TO_ARRAY_LITERAL(value)				((Toy_Literal){{ .array = value }, TOY_LITERAL_ARRAY, 0})
-#define TOY_TO_DICTIONARY_LITERAL(value)		((Toy_Literal){{ .dictionary = value }, TOY_LITERAL_DICTIONARY, 0})
-#define TOY_TO_FUNCTION_LITERAL(value, l)		((Toy_Literal){{ .function = { .inner = { .bytecode = value }, .scope = NULL }}, TOY_LITERAL_FUNCTION, l})
-#define TOY_TO_FUNCTION_NATIVE_LITERAL(value)	((Toy_Literal){{ .function = { .inner = { .native = value }, .scope = NULL }}, TOY_LITERAL_FUNCTION_NATIVE, 0})
-#define TOY_TO_FUNCTION_HOOK_LITERAL(value)		((Toy_Literal){{ .function = { .inner = { .hook = value }, .scope = NULL }}, TOY_LITERAL_FUNCTION_HOOK, 0})
+/*!
+The following macros are used to create a new literal, with the given `value` as it's internal value.
+
+* `TOY_TO_NULL_LITERAL` - does not need parantheses
+* `TOY_TO_BOOLEAN_LITERAL(value)`
+* `TOY_TO_INTEGER_LITERAL(value)`
+* `TOY_TO_FLOAT_LITERAL(value)`
+* `TOY_TO_STRING_LITERAL(value)`
+* `TOY_TO_ARRAY_LITERAL(value)`
+* `TOY_TO_DICTIONARY_LITERAL(value)`
+* `TOY_TO_FUNCTION_LITERAL(value, l)` - `l` represents the length of the bytecode passed as `value`
+* `TOY_TO_FUNCTION_NATIVE_LITERAL(value)`
+* `TOY_TO_FUNCTION_HOOK_LITERAL(value)`
+* `TOY_TO_IDENTIFIER_LITERAL(value)`
+* `TOY_TO_TYPE_LITERAL(value, c)` - `c` is the true of the type should be const
+* `TOY_TO_OPAQUE_LITERAL(value, t)` - `t` is the integer tag
+!*/
+
+#define TOY_TO_NULL_LITERAL						((Toy_Literal){{ .integer = 0 }, TOY_LITERAL_NULL})
+#define TOY_TO_BOOLEAN_LITERAL(value)			((Toy_Literal){{ .boolean = value }, TOY_LITERAL_BOOLEAN})
+#define TOY_TO_INTEGER_LITERAL(value)			((Toy_Literal){{ .integer = value }, TOY_LITERAL_INTEGER})
+#define TOY_TO_FLOAT_LITERAL(value)				((Toy_Literal){{ .number = value }, TOY_LITERAL_FLOAT})
+#define TOY_TO_STRING_LITERAL(value)			((Toy_Literal){{ .string = { .ptr = value }},TOY_LITERAL_STRING})
+#define TOY_TO_ARRAY_LITERAL(value)				((Toy_Literal){{ .array = value }, TOY_LITERAL_ARRAY})
+#define TOY_TO_DICTIONARY_LITERAL(value)		((Toy_Literal){{ .dictionary = value }, TOY_LITERAL_DICTIONARY})
+#define TOY_TO_FUNCTION_LITERAL(value)			((Toy_Literal){{ .function = { .inner = { .ptr = value }, .scope = NULL }}, TOY_LITERAL_FUNCTION})
+#define TOY_TO_FUNCTION_NATIVE_LITERAL(value)	((Toy_Literal){{ .function = { .inner = { .native = value }, .scope = NULL }}, TOY_LITERAL_FUNCTION_NATIVE})
+#define TOY_TO_FUNCTION_HOOK_LITERAL(value)		((Toy_Literal){{ .function = { .inner = { .hook = value }, .scope = NULL }}, TOY_LITERAL_FUNCTION_HOOK})
 #define TOY_TO_IDENTIFIER_LITERAL(value)		Toy_private_toIdentifierLiteral(value)
-#define TOY_TO_TYPE_LITERAL(value, c)			((Toy_Literal){{ .type = { .typeOf = value, .constant = c, .subtypes = NULL, .capacity = 0, .count = 0 }}, TOY_LITERAL_TYPE, 0})
-#define TOY_TO_OPAQUE_LITERAL(value, t)			((Toy_Literal){{ .opaque = { .ptr = value, .tag = t }}, TOY_LITERAL_OPAQUE, 0})
+#define TOY_TO_TYPE_LITERAL(value, c)			((Toy_Literal){{ .type = { .typeOf = value, .constant = c, .subtypes = NULL, .capacity = 0, .count = 0 }}, TOY_LITERAL_TYPE})
+#define TOY_TO_OPAQUE_LITERAL(value, t)			((Toy_Literal){{ .opaque = { .ptr = value, .tag = t }}, TOY_LITERAL_OPAQUE})

-//BUGFIX: For blank indexing
+//BUGFIX: For blank indexing - not for general use
 #define TOY_IS_INDEX_BLANK(value)				((value).type == TOY_LITERAL_INDEX_BLANK)
-#define TOY_TO_INDEX_BLANK_LITERAL				((Toy_Literal){{ .integer = 0 }, TOY_LITERAL_INDEX_BLANK, 0})
+#define TOY_TO_INDEX_BLANK_LITERAL				((Toy_Literal){{ .integer = 0 }, TOY_LITERAL_INDEX_BLANK})

-TOY_API void Toy_freeLiteral(Toy_Literal literal);
+/*!
+## More Defined Macros

-#define TOY_IS_TRUTHY(x) Toy_private_isTruthy(x)
+The following macros are utilities used throughout Toy's internals, and are available for the user as well.
+!*/

-#define TOY_AS_FUNCTION_BYTECODE_LENGTH(lit)	((lit).bytecodeLength)
+/*!
+### TOY_IS_TRUTHY(x)

+Returns true of the literal `x` is truthy, otherwise it returns false.
+
+Currently, every value is considered truthy except `false`, which is falsy and `null`, which is neither true or false.
+!*/
+
+#define TOY_IS_TRUTHY(x) 						Toy_private_isTruthy(x)
+
+/*!
+### TOY_AS_FUNCTION_BYTECODE_LENGTH(lit)
+
+Returns the length of a Toy function's bytecode.
+
+This macro is only valid on `TOY_LITERAL_FUNCTION`.
+!*/
+#define TOY_AS_FUNCTION_BYTECODE_LENGTH(lit)	(Toy_lengthRefFunction((lit).inner.ptr))
+
+/*!
+### TOY_MAX_STRING_LENGTH
+
+The maximum length of a string in Toy, which is 4096 bytes by default. This can be changed at compile time, but the results of doing so are not officially supported.
+!*/
 #define TOY_MAX_STRING_LENGTH					4096
+
+/*!
+### TOY_HASH_I(lit)
+
+Identifiers are the names of values within Toy; to speed up execution, their "hash value" is computed at compile time and stored within them. Use this to access it, if needed.
+
+This macro is only valid on `TOY_LITERAL_IDENTIFIER`.
+!*/
 #define TOY_HASH_I(lit)							((lit).as.identifier.hash)
+
+/*!
+### TOY_TYPE_PUSH_SUBTYPE(lit, subtype)
+
+When building a complex type, such as the type of an array or dictionary, you may need to specify inner types. Use this to push a `subtype`. calling `Toy_freeLiteral()` on the outermost type should clean up all inner types, as expected.
+
+This macro returns the index of the newly pushed value within it's parent.
+
+This macro is only valid on `TOY_LITERAL_TYPE`, for both `type` and `subtype`.
+!*/
 #define TOY_TYPE_PUSH_SUBTYPE(lit, subtype)		Toy_private_typePushSubtype(lit, subtype)
+
+/*!
+### TOY_GET_OPAQUE_TAG(o)
+
+Returns the value of the opaque `o`'s tag.
+
+This macro is only valid on `TOY_LITERAL_OPAQUE`.
+!*/
 #define TOY_GET_OPAQUE_TAG(o)					o.as.opaque.tag

-//BUGFIX: macros are not functions
-TOY_API bool Toy_private_isTruthy(Toy_Literal x);
-TOY_API Toy_Literal Toy_private_toStringLiteral(Toy_RefString* ptr);
-TOY_API Toy_Literal Toy_private_toIdentifierLiteral(Toy_RefString* ptr);
-TOY_API Toy_Literal* Toy_private_typePushSubtype(Toy_Literal* lit, Toy_Literal subtype);
+/*!
+## Defined Functions
+!*/

-//utils
+/*!
+### void Toy_freeLiteral(Toy_Literal literal)
+
+This function frees the given literal's memory. Any internal pointers are now invalid.
+
+This function should be called on EVERY literal when it is no longer needed, regardless of type.
+!*/
+TOY_API void Toy_freeLiteral(Toy_Literal literal);
+
+/*!
+### Toy_Literal Toy_copyLiteral(Toy_Literal original)
+
+This function returns a copy of the given literal. Literals should never be copied without this function, as it handles a lot of internal memory allocations.
+!*/
 TOY_API Toy_Literal Toy_copyLiteral(Toy_Literal original);
+
+/*!
+### bool Toy_literalsAreEqual(Toy_Literal lhs, Toy_Literal rhs)
+
+This checks to see if two given literals are equal.
+
+When an integer and a float are compared, the integer is cooerced into a float for the duration of the call.
+
+Arrays or dictionaries are equal only if their keys and values all equal. Likewise, types only equal if all subtypes are equal, in order.
+
+Functions and opaques are never equal to anything, while values with the type `TOY_LITERAL_ANY` are always equal.
+!*/
 TOY_API bool Toy_literalsAreEqual(Toy_Literal lhs, Toy_Literal rhs);
+
+/*!
+### int Toy_hashLiteral(Toy_Literal lit)
+
+This finds the hash of a literal, for various purposes. Different hashing algorithms are used for different types, and some types can't be hashed at all.
+
+types that can't be hashed are
+
+* all kinds of functions
+* type
+* opaque
+* any
+
+In the case of identifiers, their hashes are precomputed on creation and are stored within the literal.
+!*/
 TOY_API int Toy_hashLiteral(Toy_Literal lit);

-//not thread-safe
+/*!
+### void Toy_printLiteral(Toy_Literal literal)
+
+This wraps a call to `Toy_printLiteralCustom`, with a printf-stdout wrapper as `printFn`.
+!*/
 TOY_API void Toy_printLiteral(Toy_Literal literal);
+
+/*!
+### void Toy_printLiteralCustom(Toy_Literal literal, PrintFn printFn)
+
+This function passes the string representation of `literal` to `printFn`. 
+
+This function is not thread safe - due to the loopy and recursive nature of printing compound values, this function uses some globally persistent variables.
+!*/
 TOY_API void Toy_printLiteralCustom(Toy_Literal literal, Toy_PrintFn);
+
+/*!
+### bool Toy_private_isTruthy(Toy_Literal x)
+
+Utilized by the `TOY_IS_TRUTHY` macro.
+
+Private functions are not intended for general use.
+!*/
+TOY_API bool Toy_private_isTruthy(Toy_Literal x);
+
+/*!
+### bool Toy_private_toIdentifierLiteral(Toy_RefString* ptr)
+
+Utilized by the `TOY_TO_IDENTIFIER_LITERAL` macro.
+
+Private functions are not intended for general use.
+!*/
+TOY_API Toy_Literal Toy_private_toIdentifierLiteral(Toy_RefString* ptr);
+
+/*!
+### bool Toy_private_typePushSubtype(Toy_Literal* lit, Toy_Literal subtype)
+
+Utilized by the `TOY_TYPE_PUSH_SUBTYPE` macro.
+
+Private functions are not intended for general use.
+!*/
+TOY_API Toy_Literal* Toy_private_typePushSubtype(Toy_Literal* lit, Toy_Literal subtype);
@@ -52,7 +52,7 @@ Toy_Literal Toy_popLiteralArray(Toy_LiteralArray* array) {
 }

 //find a literal in the array that matches the "literal" argument
-int Toy_findLiteralIndex(Toy_LiteralArray* array, Toy_Literal literal) {
+int Toy_private_findLiteralIndex(Toy_LiteralArray* array, Toy_Literal literal) {
 	for (int i = 0; i < array->count; i++) {
 		//not the same type
 		if (array->literals[i].type != literal.type) {
@@ -1,5 +1,13 @@
 #pragma once

+/*!
+# literal_array.h
+
+This header defines the array structure, which manages a series of `Toy_Literal` instances in sequential memory. The array does not take ownership of given literals, instead it makes an internal copy.
+
+The array type is one of two fundemental data structures used throughout Toy - the other is the dictionary.
+!*/
+
 #include "toy_common.h"

 #include "toy_literal.h"
@@ -10,13 +18,65 @@ typedef struct Toy_LiteralArray {
 	int count;
 } Toy_LiteralArray;

+/*!
+## Defined Functions
+!*/
+
+/*
+### void Toy_initLiteralArray(Toy_LiteralArray* array)
+
+This function initializes a `Toy_LiteralArray` pointed to by `array`.
+*/
 TOY_API void Toy_initLiteralArray(Toy_LiteralArray* array);
+
+/*!
+### void Toy_freeLiteralArray(Toy_LiteralArray* array)
+
+This function frees a `Toy_LiteralArray` pointed to by `array`. Every literal within is passed to `Toy_freeLiteral()` before its memory is released.
+!*/
 TOY_API void Toy_freeLiteralArray(Toy_LiteralArray* array);
+
+/*!
+### int Toy_pushLiteralArray(Toy_LiteralArray* array, Toy_Literal literal)
+
+This function adds a new `literal` to the end of the `array`, growing the array's internal buffer if needed.
+
+This function returns the index of the inserted value.
+!*/
 TOY_API int Toy_pushLiteralArray(Toy_LiteralArray* array, Toy_Literal literal);
+
+/*!
+### Toy_Literal Toy_popLiteralArray(Toy_LiteralArray* array)
+
+This function removes the literal at the end of the `array`, and returns it.
+!*/
 TOY_API Toy_Literal Toy_popLiteralArray(Toy_LiteralArray* array);
+
+/*!
+### bool Toy_setLiteralArray(Toy_LiteralArray* array, Toy_Literal index, Toy_Literal value)
+
+This function frees the literal at the position represented by the integer literal `index`, and stores `value` in its place.
+
+This function returns true on success, otherwise it returns false.
+!*/
 TOY_API bool Toy_setLiteralArray(Toy_LiteralArray* array, Toy_Literal index, Toy_Literal value);
+
+/*!
+### Toy_Literal Toy_getLiteralArray(Toy_LiteralArray* array, Toy_Literal index)
+
+This function returns the literal at the position represented by the integer literal `index`, or returns a null literal if none is found.
+
+If `index` is not an integer literal or is out of bounds, this function returns a null literal.
+!*/
 TOY_API Toy_Literal Toy_getLiteralArray(Toy_LiteralArray* array, Toy_Literal index);

-int Toy_findLiteralIndex(Toy_LiteralArray* array, Toy_Literal literal);
+/*!
+### int Toy_private_findLiteralIndex(Toy_LiteralArray* array, Toy_Literal literal)

-//TODO: add a function to get the capacity & count
+This function scans through the array, and returns the index of the first element that matches the given `literal`, otherwise it returns -1.
+
+Private functions are not intended for general use.
+!*/
+int Toy_private_findLiteralIndex(Toy_LiteralArray* array, Toy_Literal literal);
+
+//TODO: add a function to get the capacity & count
@@ -131,7 +131,6 @@ static void freeEntryArray(Toy_private_dictionary_entry* array, int capacity) {

 //exposed functions
 void Toy_initLiteralDictionary(Toy_LiteralDictionary* dictionary) {
-	//HACK: because modulo by 0 is undefined, set the capacity to a non-zero value (and allocate the arrays)
 	dictionary->entries = NULL;
 	dictionary->capacity = 0;
 	dictionary->contains = 0;
@@ -1,9 +1,31 @@
 #pragma once

+/*!
+# toy_literal_dictionary.h
+
+This header defines the dictionary structure (as well as the private entry structure), which manages a series of `Toy_Literal` instances stored in a key-value hash map. The dictionary does not take ownership of given literals, instead it makes an internal copy.
+
+The dictionary type is one of two fundemental data structures used throughout Toy - the other is the array.
+!*/
+
 #include "toy_common.h"

 #include "toy_literal.h"

+/*!
+## Defined Macros
+!*/
+
+/*!
+### TOY_DICTIONARY_MAX_LOAD
+
+If the contents of a dictionary exceeds this percentage of it's capacity, then a new buffer is created, the old contents are copied over one-by-one, and the original buffer is freed.
+
+Since this process can be memory and time intensive, a configurable macro is used to allow for fine-grained control across the lang.
+
+The current default value is `0.75`, representing 75% capacity.
+!*/
+
 //TODO: benchmark this
 #define TOY_DICTIONARY_MAX_LOAD 0.75

@@ -19,11 +41,56 @@ typedef struct Toy_LiteralDictionary {
 	int contains; //count + tombstones, for internal use
 } Toy_LiteralDictionary;

+/*!
+## Defined Functions
+!*/
+
+/*!
+### void Toy_initLiteralDictionary(Toy_LiteralDictionary* dictionary)
+
+This function initializes the `Toy_LiteralDictionary` pointed to by `dictionary`.
+!*/
 TOY_API void Toy_initLiteralDictionary(Toy_LiteralDictionary* dictionary);
+
+/*!
+### void Toy_freeLiteralDictionary(Toy_LiteralDictionary* dictionary)
+
+This function frees a `Toy_LiteralDictionary` pointed to by `dictionary`. Every literal within is passed to `Toy_freeLiteral()` before its memory is released.
+!*/
 TOY_API void Toy_freeLiteralDictionary(Toy_LiteralDictionary* dictionary);

+/*!
+### void Toy_setLiteralDictionary(Toy_LiteralDictionary* dictionary, Toy_Literal key, Toy_Literal value)
+
+This function inserts the given key-value pair of literals into `dictionary`, creating it if it doesn't exist, or freeing and overwriting it if `key` is already present. This function may also expand the memory buffer if needed.
+
+When expanding the memory buffer, a full copy of the existing dictionary's contents is created - this can be memory intensive.
+
+Literal functions and opaques cannot be used as keys.
+!*/
 TOY_API void Toy_setLiteralDictionary(Toy_LiteralDictionary* dictionary, Toy_Literal key, Toy_Literal value);
+
+/*!
+### Toy_Literal Toy_getLiteralDictionary(Toy_LiteralDictionary* dictionary, Toy_Literal key)
+
+This function returns the value of the literal within `dictionary` identified by `key`, or a null literal if it doesn't exist.
+
+Literal functions and opaques cannot be used as keys.
+!*/
 TOY_API Toy_Literal Toy_getLiteralDictionary(Toy_LiteralDictionary* dictionary, Toy_Literal key);
+
+/*!
+### void Toy_removeLiteralDictionary(Toy_LiteralDictionary* dictionary, Toy_Literal key)
+
+This function removes the key-value pair of literals from `dictionary` identified by `key`, if it exists.
+
+Literal functions and opaques cannot be used as keys.
+!*/
 TOY_API void Toy_removeLiteralDictionary(Toy_LiteralDictionary* dictionary, Toy_Literal key);

+/*!
+### bool Toy_existsLiteralDictionary(Toy_LiteralDictionary* dictionary, Toy_Literal key)
+
+This function returns true if the key-value pair identified by `key` exists within `dictionary`, otherwise it returns false.
+!*/
 TOY_API bool Toy_existsLiteralDictionary(Toy_LiteralDictionary* dictionary, Toy_Literal key);
@@ -1,5 +1,6 @@
 #include "toy_memory.h"
 #include "toy_refstring.h"
+#include "toy_reffunction.h"

 #include "toy_console_colors.h"

@@ -21,7 +22,7 @@ void* Toy_private_defaultMemoryAllocator(void* pointer, size_t oldSize, size_t n
 	void* mem = realloc(pointer, newSize);

 	if (mem == NULL) {
-		fprintf(stderr, TOY_CC_ERROR "[internal] Memory allocation error (requested %zu, replacing %zu)\n" TOY_CC_RESET, newSize, oldSize);
+		fprintf(stderr, TOY_CC_ERROR "[internal] Memory allocation error (requested %d, replacing %d)\n" TOY_CC_RESET, (int)newSize, (int)oldSize);
 		return NULL;
 	}

@@ -49,4 +50,5 @@ void Toy_setMemoryAllocator(Toy_MemoryAllocatorFn fn) {

 	allocator = fn;
 	Toy_setRefStringAllocatorFn(fn);
+	Toy_setRefFunctionAllocatorFn(fn);
 }
@@ -1,21 +1,112 @@
 #pragma once

+/*!
+# toy_memory.h
+
+This header defines all of the memory management utilities. Any and all heap-based memory management goes through these utilities.
+
+A default memory allocator function is used internally, but it can be overwritten for diagnostic and platform related purposes.
+!*/
+
 #include "toy_common.h"

+/*!
+## Defined Macros
+!*/
+
+/*!
+### TOY_GROW_CAPACITY(capacity)
+
+This macro calculates, in place, what size of memory should be allocated based on the previous size.
+!*/
 #define TOY_GROW_CAPACITY(capacity) 						((capacity) < 8 ? 8 : (capacity) * 2)
+
+/*!
+### TOY_GROW_CAPACITY_FAST(capacity)
+
+This macro calculates, in place, what size of memory should be allocated based on the previous size. It grows faster than `TOY_GROW_CAPACITY`.
+!*/
 #define TOY_GROW_CAPACITY_FAST(capacity)					((capacity) < 32 ? 32 : (capacity) * 2)

+/*
+### TOY_ALLOCATE(type, count)
+
+This macro wraps `Toy_reallocate()`, which itself calls the allocator function. `type` is the type that will be allocated, and `count` is the number which will be needed (usually calculated with `TOY_GROW_CAPACITY`).
+
+This returns a pointer of `type`.
+*/
 #define TOY_ALLOCATE(type, count)							((type*)Toy_reallocate(NULL, 0, sizeof(type) * (count)))

+/*!
+### TOY_FREE(type, pointer)
+
+This macro wraps `Toy_reallocate()`, which itself calls the allocator function. `type` is the type that will be freed, and `pointer` is to what is being freed. This should only be used when a single element has been allocated, as opposed to an array.
+!*/
 #define TOY_FREE(type, pointer)								Toy_reallocate(pointer, sizeof(type), 0)
+
+/*!
+### TOY_FREE_ARRAY(type, pointer, oldCount)
+
+This macro wraps `Toy_reallocate()`, which itself calls the allocator function. `type` is the type that will be freed, `pointer` is a reference to what is being freed, and `oldCount` is the size of the array being freed. This should only be used when an array has been allocated, as opposed to a single element.
+!*/
 #define TOY_FREE_ARRAY(type, pointer, oldCount)				Toy_reallocate((type*)pointer, sizeof(type) * (oldCount), 0)

+/*!
+### TOY_GROW_ARRAY(type, pointer, oldCount, count)
+
+This macro wraps `Toy_reallocate()`, which itself calls the allocator function. `type` is the type that is being operated on, `pointer` is what is being resized, `oldCount` is the previous size of the array and `count` is the new size of the array (usually calculated with `TOY_GROW_CAPACITY`).
+
+This returns a pointer of `type`.
+!*/
 #define TOY_GROW_ARRAY(type, pointer, oldCount, count)		(type*)Toy_reallocate((type*)pointer, sizeof(type) * (oldCount), sizeof(type) * (count))
+
+/*!
+### TOY_SHRINK_ARRAY(type, pointer, oldCount, count)
+
+This macro wraps `Toy_reallocate()`, which itself calls the allocator function. `type` is the type that is being operated on, `pointer` is what is being resized, `oldCount` is the previous size of the array and `count` is the new size of the array.
+
+This returns a pointer of `type`.
+!*/
 #define TOY_SHRINK_ARRAY(type, pointer, oldCount, count)	(type*)Toy_reallocate((type*)pointer, sizeof(type) * (oldCount), sizeof(type) * (count))

-//implementation details
+/*!
+## Defined Interfaces
+!*/
+
+/*!
+### typedef void* (*Toy_MemoryAllocatorFn)(void* pointer, size_t oldSize, size_t newSize)
+
+This function interface is used for defining any memory allocator functions.
+
+Any and all memory allocator functions should:
+
+* Take a `pointer` to a previously allocated block of memory, or `NULL`
+* Take the `oldSize`, which is the previous size of the `pointer` allocated, in bytes (`oldSize` can be 0)
+* Take the `newSize`, which is the new size of the buffer to be allocaated, in bytes (`newSize` can be 0)
+* Return the newly allocated buffer, or `NULL` if `newSize` is zero
+* Return `NULL` on error
+!*/
+
+typedef void* (*Toy_MemoryAllocatorFn)(void* pointer, size_t oldSize, size_t newSize);
+
+/*!
+## Defined Functions
+!*/
+
+/*!
+### TOY_API void* Toy_reallocate(void* pointer, size_t oldSize, size_t newSize)
+
+This function shouldn't be called directly. Instead, use one of the given macros.
+
+This function wraps a call to the internal assigned memory allocator.
+!*/
 TOY_API void* Toy_reallocate(void* pointer, size_t oldSize, size_t newSize);

-//assign the memory allocator
-typedef void* (*Toy_MemoryAllocatorFn)(void* pointer, size_t oldSize, size_t newSize);
+/*!
+### void Toy_setMemoryAllocator(Toy_MemoryAllocatorFn)
+
+This function sets the memory allocator, replacing the default memory allocator.
+
+This function also overwrites any given refstring and reffunction memory allocators, see [toy_refstring.h](toy_refstring_h.md).
+!*/
 TOY_API void Toy_setMemoryAllocator(Toy_MemoryAllocatorFn);
@@ -29,8 +29,8 @@ typedef enum Toy_Opcode {
 	TOY_OP_SCOPE_BEGIN,
 	TOY_OP_SCOPE_END,

-	TOY_OP_TYPE_DECL,		//declare a type to be used (as a literal)
-	TOY_OP_TYPE_DECL_LONG,	//declare a type to be used (as a long literal)
+	TOY_OP_TYPE_DECL_removed,
+	TOY_OP_TYPE_DECL_LONG_removed,

 	TOY_OP_VAR_DECL,		//declare a variable to be used (as a literal)
 	TOY_OP_VAR_DECL_LONG,	//declare a variable to be used (as a long literal)
@@ -86,5 +86,9 @@ typedef enum Toy_Opcode {
 	TOY_OP_FN_END, //different from SECTION_END
 	TOY_OP_SECTION_END = 255,
 	//TODO: add more
+
+	//prefix & postfix signals (used internally)
+	TOY_OP_PREFIX,
+	TOY_OP_POSTFIX,
 } Toy_Opcode;

@@ -119,6 +119,7 @@ ParseRule parseRules[];
 static void declaration(Toy_Parser* parser, Toy_ASTNode** nodeHandle);
 static void parsePrecedence(Toy_Parser* parser, Toy_ASTNode** nodeHandle, PrecedenceRule rule);
 static Toy_Literal readTypeToLiteral(Toy_Parser* parser);
+static void varDecl(Toy_Parser* parser, Toy_ASTNode** nodeHandle);

 //TODO: resolve the messy order of these
 //the expression rules
@@ -167,6 +168,10 @@ static Toy_Opcode compound(Toy_Parser* parser, Toy_ASTNode** nodeHandle) {
 			consume(parser, TOY_TOKEN_COMMA, "Expected ',' in array or dictionary");
 		}

+		if (match(parser, TOY_TOKEN_BRACKET_RIGHT)) { //allow for trailing commas
+			break;
+		}
+
 		iterations++;

 		Toy_ASTNode* left = NULL;
@@ -334,6 +339,28 @@ static Toy_Opcode grouping(Toy_Parser* parser, Toy_ASTNode** nodeHandle) {
 	}
 }

+static Toy_Opcode circuit(Toy_Parser* parser, Toy_ASTNode** nodeHandle) {
+	advance(parser);
+
+	//handle short-circuitable operators - && ||
+	switch (parser->previous.type) {
+		case TOY_TOKEN_AND_AND: {
+			parsePrecedence(parser, nodeHandle, PREC_AND + 1);
+			return TOY_OP_AND;
+		}
+
+		case TOY_TOKEN_OR_OR: {
+			parsePrecedence(parser, nodeHandle, PREC_OR + 1);
+			return TOY_OP_OR;
+		}
+
+		default: {
+			error(parser, parser->previous, "Unexpected token passed to grouping precedence rule");
+			return TOY_OP_EOF;
+		}
+	}
+}
+
 static Toy_Opcode binary(Toy_Parser* parser, Toy_ASTNode** nodeHandle) {
 	advance(parser);

@@ -367,76 +394,66 @@ static Toy_Opcode binary(Toy_Parser* parser, Toy_ASTNode** nodeHandle) {

 		//assignment
 		case TOY_TOKEN_ASSIGN: {
-			parsePrecedence(parser, nodeHandle, PREC_ASSIGNMENT);
+			parsePrecedence(parser, nodeHandle, PREC_ASSIGNMENT + 1);
 			return TOY_OP_VAR_ASSIGN;
 		}

 		case TOY_TOKEN_PLUS_ASSIGN: {
-			parsePrecedence(parser, nodeHandle, PREC_ASSIGNMENT);
+			parsePrecedence(parser, nodeHandle, PREC_ASSIGNMENT + 1);
 			return TOY_OP_VAR_ADDITION_ASSIGN;
 		}

 		case TOY_TOKEN_MINUS_ASSIGN: {
-			parsePrecedence(parser, nodeHandle, PREC_ASSIGNMENT);
+			parsePrecedence(parser, nodeHandle, PREC_ASSIGNMENT + 1);
 			return TOY_OP_VAR_SUBTRACTION_ASSIGN;
 		}

 		case TOY_TOKEN_MULTIPLY_ASSIGN: {
-			parsePrecedence(parser, nodeHandle, PREC_ASSIGNMENT);
+			parsePrecedence(parser, nodeHandle, PREC_ASSIGNMENT + 1);
 			return TOY_OP_VAR_MULTIPLICATION_ASSIGN;
 		}

 		case TOY_TOKEN_DIVIDE_ASSIGN: {
-			parsePrecedence(parser, nodeHandle, PREC_ASSIGNMENT);
+			parsePrecedence(parser, nodeHandle, PREC_ASSIGNMENT + 1);
 			return TOY_OP_VAR_DIVISION_ASSIGN;
 		}

 		case TOY_TOKEN_MODULO_ASSIGN: {
-			parsePrecedence(parser, nodeHandle, PREC_ASSIGNMENT);
+			parsePrecedence(parser, nodeHandle, PREC_ASSIGNMENT + 1);
 			return TOY_OP_VAR_MODULO_ASSIGN;
 		}

 		//comparison
 		case TOY_TOKEN_EQUAL: {
-			parsePrecedence(parser, nodeHandle, PREC_COMPARISON);
+			parsePrecedence(parser, nodeHandle, PREC_COMPARISON + 1);
 			return TOY_OP_COMPARE_EQUAL;
 		}

 		case TOY_TOKEN_NOT_EQUAL: {
-			parsePrecedence(parser, nodeHandle, PREC_COMPARISON);
+			parsePrecedence(parser, nodeHandle, PREC_COMPARISON + 1);
 			return TOY_OP_COMPARE_NOT_EQUAL;
 		}

 		case TOY_TOKEN_LESS: {
-			parsePrecedence(parser, nodeHandle, PREC_COMPARISON);
+			parsePrecedence(parser, nodeHandle, PREC_COMPARISON + 1);
 			return TOY_OP_COMPARE_LESS;
 		}

 		case TOY_TOKEN_LESS_EQUAL: {
-			parsePrecedence(parser, nodeHandle, PREC_COMPARISON);
+			parsePrecedence(parser, nodeHandle, PREC_COMPARISON + 1);
 			return TOY_OP_COMPARE_LESS_EQUAL;
 		}

 		case TOY_TOKEN_GREATER: {
-			parsePrecedence(parser, nodeHandle, PREC_COMPARISON);
+			parsePrecedence(parser, nodeHandle, PREC_COMPARISON + 1);
 			return TOY_OP_COMPARE_GREATER;
 		}

 		case TOY_TOKEN_GREATER_EQUAL: {
-			parsePrecedence(parser, nodeHandle, PREC_COMPARISON);
+			parsePrecedence(parser, nodeHandle, PREC_COMPARISON + 1);
 			return TOY_OP_COMPARE_GREATER_EQUAL;
 		}

-		case TOY_TOKEN_AND: {
-			parsePrecedence(parser, nodeHandle, PREC_AND);
-			return TOY_OP_AND;
-		}
-
-		case TOY_TOKEN_OR: {
-			parsePrecedence(parser, nodeHandle, PREC_OR);
-			return TOY_OP_OR;
-		}
-
 		default:
 			error(parser, parser->previous, "Unexpected token passed to binary precedence rule");
 			return TOY_OP_EOF;
@@ -627,6 +644,14 @@ static Toy_Opcode castingPrefix(Toy_Parser* parser, Toy_ASTNode** nodeHandle) {
 		}
 		break;

+		//BUGFIX: handle this here, and not in castingPrefix, so "any" can be recognized as a type properly
+		case TOY_TOKEN_ANY: {
+			Toy_Literal literal = TOY_TO_TYPE_LITERAL(TOY_LITERAL_ANY, false);
+			Toy_emitASTNodeLiteral(nodeHandle, literal);
+			Toy_freeLiteral(literal);
+		}
+		break;
+
 		default:
 			error(parser, parser->previous, "Unexpected token passed to casting precedence rule");
 			return TOY_OP_EOF;
@@ -658,7 +683,7 @@ static Toy_Opcode castingInfix(Toy_Parser* parser, Toy_ASTNode** nodeHandle) {
 		break;

 		case TOY_TOKEN_LITERAL_STRING:
-			atomic(parser, nodeHandle);
+			string(parser, nodeHandle);
 		break;

 		default:
@@ -684,7 +709,7 @@ static Toy_Opcode incrementPrefix(Toy_Parser* parser, Toy_ASTNode** nodeHandle)

 	Toy_freeASTNode(tmpNode);

-	return TOY_OP_EOF;
+	return TOY_OP_PREFIX;
 }

 static Toy_Opcode incrementInfix(Toy_Parser* parser, Toy_ASTNode** nodeHandle) {
@@ -701,7 +726,7 @@ static Toy_Opcode incrementInfix(Toy_Parser* parser, Toy_ASTNode** nodeHandle) {

 	Toy_freeASTNode(tmpNode);

-	return TOY_OP_EOF;
+	return TOY_OP_POSTFIX;
 }

 static Toy_Opcode decrementPrefix(Toy_Parser* parser, Toy_ASTNode** nodeHandle) {
@@ -718,7 +743,7 @@ static Toy_Opcode decrementPrefix(Toy_Parser* parser, Toy_ASTNode** nodeHandle)

 	Toy_freeASTNode(tmpNode);

-	return TOY_OP_EOF;
+	return TOY_OP_PREFIX;
 }

 static Toy_Opcode decrementInfix(Toy_Parser* parser, Toy_ASTNode** nodeHandle) {
@@ -735,10 +760,18 @@ static Toy_Opcode decrementInfix(Toy_Parser* parser, Toy_ASTNode** nodeHandle) {

 	Toy_freeASTNode(tmpNode);

-	return TOY_OP_EOF;
+	return TOY_OP_POSTFIX;
 }

 static Toy_Opcode fnCall(Toy_Parser* parser, Toy_ASTNode** nodeHandle) {
+	//wait - is the previous token a type? this should be casting instead
+	if (parser->previous.type >= TOY_TOKEN_NULL && parser->previous.type <= TOY_TOKEN_ANY) {
+		//casting value
+		parsePrecedence(parser, nodeHandle, PREC_CALL);
+
+		return TOY_OP_TYPE_CAST; //opcode value
+	}
+
 	advance(parser); //skip the left paren

 	//binary() is an infix rule - so only get the RHS of the operator
@@ -918,7 +951,7 @@ ParseRule parseRules[] = { //must match the token types
 	{NULL, NULL, PREC_NONE},// TOKEN_DICTIONARY,
 	{NULL, NULL, PREC_NONE},// TOKEN_FUNCTION,
 	{NULL, NULL, PREC_NONE},// TOKEN_OPAQUE,
-	{NULL, NULL, PREC_NONE},// TOKEN_ANY,
+	{castingPrefix, NULL, PREC_CALL},// TOKEN_ANY,

 	//keywords and reserved words
 	{NULL, NULL, PREC_NONE},// TOKEN_AS,
@@ -981,8 +1014,8 @@ ParseRule parseRules[] = { //must match the token types
 	{NULL, binary, PREC_COMPARISON},// TOKEN_GREATER,
 	{NULL, binary, PREC_COMPARISON},// TOKEN_LESS_EQUAL,
 	{NULL, binary, PREC_COMPARISON},// TOKEN_GREATER_EQUAL,
-	{NULL, binary, PREC_AND},// TOKEN_AND,
-	{NULL, binary, PREC_OR},// TOKEN_OR,
+	{NULL, circuit, PREC_AND},// TOKEN_AND,
+	{NULL, circuit, PREC_OR},// TOKEN_OR,

 	//other operators
 	{NULL, question, PREC_TERNARY}, //TOKEN_QUESTION,
@@ -1257,6 +1290,23 @@ static void parsePrecedence(Toy_Parser* parser, Toy_ASTNode** nodeHandle, Preced
 			continue;
 		}

+		//BUGFIX: keep going, don't skip out on a postfix
+		if (opcode == TOY_OP_PREFIX || opcode == TOY_OP_POSTFIX) {
+			Toy_freeASTNode(*nodeHandle);
+			*nodeHandle = rhsNode;
+			continue;
+		}
+
+		if (opcode == TOY_OP_AND) {
+			Toy_emitASTNodeAnd(nodeHandle, rhsNode);
+			continue;
+		}
+
+		if (opcode == TOY_OP_OR) {
+			Toy_emitASTNodeOr(nodeHandle, rhsNode);
+			continue;
+		}
+
 		Toy_emitASTNodeBinary(nodeHandle, rhsNode, opcode);

 		//optimise away the constants
@@ -1376,7 +1426,13 @@ static void forStmt(Toy_Parser* parser, Toy_ASTNode** nodeHandle) {

 	//check the pre-clause
 	if (parser->current.type != TOY_TOKEN_SEMICOLON) {
-		declaration(parser, &preClause); //allow defining variables in the pre-clause
+		//allow defining variables in the pre-clause
+		if (match(parser, TOY_TOKEN_VAR)) {
+			varDecl(parser, &preClause);
+		}
+		else {
+			parsePrecedence(parser, &preClause, PREC_ASSIGNMENT);
+		}
 	}
 	else {
 		consume(parser, TOY_TOKEN_SEMICOLON, "Expected ';' after empty declaration of for clause");
@@ -1,10 +1,62 @@
 #pragma once

+/*!
+# toy_parser.h
+
+This header defines the parser structure which, after being initialized with a lexer produces a series of abstract syntax trees to be passed to the compiler. The following is a utility function provided by [repl_tools.h](repl_tools_h.md), demonstrating how to use the parser.
+
+```c
+//generate bytecode from a given string
+const unsigned char* Toy_compileString(const char* source, size_t* size) {
+	//declare the relevant instances
+	Toy_Lexer lexer;
+	Toy_Parser parser;
+	Toy_Compiler compiler;
+
+	//initialize each of them
+	Toy_initLexer(&lexer, source);
+	Toy_initParser(&parser, &lexer);
+	Toy_initCompiler(&compiler);
+
+	//when the parser returns NULL, it is finished
+	Toy_ASTNode* node = Toy_scanParser(&parser);
+	while(node != NULL) {
+		//if the parser returns an error node, clean up and exit gracefully
+		if (node->type == TOY_AST_NODE_ERROR) {
+			Toy_freeASTNode(node);
+			Toy_freeCompiler(&compiler);
+			Toy_freeParser(&parser);
+			//no need to clean the lexer
+			return NULL;
+		}
+
+		//write the node to the compiler
+		Toy_writeCompiler(&compiler, node);
+		Toy_freeASTNode(node);
+
+		//grab the next node
+		node = Toy_scanParser(&parser);
+	}
+
+	//get the bytecode to be returned
+	const unsigned char* tb = Toy_collateCompiler(&compiler, size);
+
+	//cleanup
+	Toy_freeCompiler(&compiler);
+	Toy_freeParser(&parser);
+	//no need to clean the lexer
+
+	//finally
+	return tb;
+}
+```
+!*/
+
 #include "toy_common.h"
 #include "toy_lexer.h"
 #include "toy_ast_node.h"

-//DOCS: parsers are bound to a lexer, and turn the outputted tokens into AST nodes
+//Parsers are bound to a lexer, and turn the outputted tokens into AST nodes
 typedef struct {
 	Toy_Lexer* lexer;
 	bool error; //I've had an error
@@ -15,6 +67,37 @@ typedef struct {
 	Toy_Token previous;
 } Toy_Parser;

+/*!
+## Defined Functions
+!*/
+
+/*!
+### void Toy_initParser(Toy_Parser* parser, Toy_Lexer* lexer)
+
+This function initializes a `Toy_Parser`, binding the given `Toy_Lexer` to it.
+!*/
 TOY_API void Toy_initParser(Toy_Parser* parser, Toy_Lexer* lexer);
+
+/*!
+### void Toy_freeParser(Toy_Parser* parser)
+
+This function frees a `Toy_Parser` once its task is completed.
+!*/
 TOY_API void Toy_freeParser(Toy_Parser* parser);
+
+/*!
+### Toy_ASTNode* Toy_scanParser(Toy_Parser* parser)
+
+This function returns an abstract syntax tree representing part of the program, or an error node. The abstract syntax tree must be passed to `Toy_writeCompiler()` and/or `Toy_freeASTNode()`.
+
+This function should be called repeatedly until it returns `NULL`, indicating the end of the program.
+!*/
 TOY_API Toy_ASTNode* Toy_scanParser(Toy_Parser* parser);
+
+/*!
+### void Toy_freeASTNode(Toy_ASTNode* node)
+
+This function cleans up any valid instance of `Toy_ASTNode` pointer passed to it. It is most commonly used to clean up the values returned by `Toy_scanParser`, after they have been passsed to `Toy_writeCompiler`, or when the node is an error node.
+
+Note: this function is *actually* defined in toy_ast_node.h, but documented here, because this is where it matters most.
+!*/
@@ -0,0 +1,55 @@
+#include "toy_reffunction.h"
+
+#include <string.h>
+
+//memory allocation
+extern void* Toy_private_defaultMemoryAllocator(void* pointer, size_t oldSize, size_t newSize);
+static Toy_RefFunctionAllocatorFn allocate = Toy_private_defaultMemoryAllocator;
+
+void Toy_setRefFunctionAllocatorFn(Toy_RefFunctionAllocatorFn allocator) {
+	allocate = allocator;
+}
+
+//API
+Toy_RefFunction* Toy_createRefFunction(const void* data, size_t length) {
+	//allocate the memory area (including metadata space)
+	Toy_RefFunction* refFunction = allocate(NULL, 0, sizeof(size_t) + sizeof(int) + sizeof(char) * length);
+
+	if (refFunction == NULL) {
+		return NULL;
+	}
+
+	//set the data
+	refFunction->refCount = 1;
+	refFunction->length = length;
+	memcpy(refFunction->data, data, refFunction->length);
+
+	return refFunction;
+}
+
+void Toy_deleteRefFunction(Toy_RefFunction* refFunction) {
+	//decrement, then check
+	refFunction->refCount--;
+	if (refFunction->refCount <= 0) {
+		allocate(refFunction, sizeof(size_t) + sizeof(int) + sizeof(char) * (refFunction->length + 1), 0);
+	}
+}
+
+int Toy_countRefFunction(Toy_RefFunction* refFunction) {
+	return refFunction->refCount;
+}
+
+size_t Toy_lengthRefFunction(Toy_RefFunction* refFunction) {
+	return refFunction->length;
+}
+
+Toy_RefFunction* Toy_copyRefFunction(Toy_RefFunction* refFunction) {
+	//Cheaty McCheater Face
+	refFunction->refCount++;
+	return refFunction;
+}
+
+Toy_RefFunction* Toy_deepCopyRefFunction(Toy_RefFunction* refFunction) {
+	//create a new function, with a new refCount
+	return Toy_createRefFunction(refFunction->data, refFunction->length);
+}
@@ -0,0 +1,88 @@
+#pragma once
+
+/*!
+# toy_reffunction.h
+
+This header defines the Toy_RefFunction structure, as well as all of the related utilities.
+
+See [Toy_RefString](toy_refstring_h.md) for more information about the reference pattern.
+
+This module reserves the right to instead preform a deep copy when it sees fit (this is for future debugging purposes).
+!*/
+
+#include "toy_common.h"
+
+//the RefFunction structure
+typedef struct Toy_RefFunction {
+	size_t length;
+	int refCount;
+	unsigned char data[];
+} Toy_RefFunction;
+
+/*!
+## Defined Interfaces
+!*/
+
+/*!
+### typedef void* (*Toy_RefFunctionAllocatorFn)(void* pointer, size_t oldSize, size_t newSize)
+
+This interface conforms to Toy's memory API, and generally shouldn't be used without a good reason.
+!*/
+typedef void* (*Toy_RefFunctionAllocatorFn)(void* pointer, size_t oldSize, size_t newSize);
+
+/*!
+## Defined Functions
+!*/
+
+/*!
+### void Toy_setRefFunctionAllocatorFn(Toy_RefFunctionAllocatorFn)
+
+This function conforms to and is invoked by Toy's memory API, and generally shouldn't be used without a good reason.
+!*/
+TOY_API void Toy_setRefFunctionAllocatorFn(Toy_RefFunctionAllocatorFn);
+
+/*!
+### Toy_RefFunction* Toy_createRefFunction(const void* data, size_t length)
+
+This function returns a new `Toy_RefFunction`, containing a copy of `data`, or `NULL` on error.
+
+This function also sets the returned `refFunction`'s reference counter to 1.
+!*/
+TOY_API Toy_RefFunction* Toy_createRefFunction(const void* data, size_t length);
+
+/*!
+### void Toy_deleteRefFunction(Toy_RefFunction* refFunction)
+
+This function reduces the `refFunction`'s reference counter by 1 and, if it reaches 0, frees the memory.
+!*/
+TOY_API void Toy_deleteRefFunction(Toy_RefFunction* refFunction);
+
+/*!
+### int Toy_countRefFunction(Toy_RefFunction* refFunction)
+
+This function returns the total number of references to `refFunction`, for debugging.
+!*/
+TOY_API int Toy_countRefFunction(Toy_RefFunction* refFunction);
+
+/*!
+### size_t Toy_lengthRefFunction(Toy_RefFunction* refFunction)
+
+This function returns the length of the underlying bytecode of `refFunction`.
+!*/
+TOY_API size_t Toy_lengthRefFunction(Toy_RefFunction* refFunction);
+
+/*!
+### Toy_RefFunction* Toy_copyRefFunction(Toy_RefFunction* refFunction)
+
+This function increases the reference counter of `refFunction` by 1, before returning the given pointer.
+
+This function reserves the right to create a deep copy where needed.
+!*/
+TOY_API Toy_RefFunction* Toy_copyRefFunction(Toy_RefFunction* refFunction);
+
+/*!
+### Toy_RefFunction* Toy_deepCopyRefFunction(Toy_RefFunction* refFunction)
+
+This function behaves identically to `Toy_copyRefFunction`, except that it explicitly forces a deep copy of the internal memory. Using this function should be done carefully, as it incurs a performance penalty that negates the benefit of this module.
+!*/
+TOY_API Toy_RefFunction* Toy_deepCopyRefFunction(Toy_RefFunction* refFunction);
@@ -1,13 +1,24 @@
 #pragma once

+/*!
+# toy_refstring.h
+
+This header defines the structure `Toy_RefString`, as well as all of the related utilities.
+
+[refstring](https://github.com/Ratstail91/refstring) is a stand-alone utility written to reduce the amount of memory manipulation used within Toy. It was independantly written and tested, before being incorporated into Toy proper. As such it has it's own memory management API, which by default is tied into Toy's [core memory API](toy_memory_h.md).
+
+Instances of `Toy_RefString` are reference counted - that is, rather than copying an existing string in memory, a pointer to the refstring is returned, and the internal reference counter is increased by 1. When the pointer is no longer needed, `Toy_DeleteRefString` can be called; this will decrement the internal reference counter by 1, and only free it when it reaches 0. This has multiple benefits, when used correctly:
+
+* Reduced memory usage
+* Faster program execution
+
+This module reserves the right to instead preform a deep copy when it sees fit (this is for future debugging purposes).
+!*/
+
 #include "toy_common.h"

 #include <string.h>

-//memory allocation hook
-typedef void* (*Toy_RefStringAllocatorFn)(void* pointer, size_t oldSize, size_t newSize);
-TOY_API void Toy_setRefStringAllocatorFn(Toy_RefStringAllocatorFn);
-
 //the RefString structure
 typedef struct Toy_RefString {
 	size_t length;
@@ -15,17 +26,100 @@ typedef struct Toy_RefString {
 	char data[];
 } Toy_RefString;

-//API
+/*!
+## Defined Interfaces
+!*/
+
+/*!
+### typedef void* (*Toy_RefStringAllocatorFn)(void* pointer, size_t oldSize, size_t newSize)
+
+This interface conforms to Toy's memory API, and generally shouldn't be used without a good reason.
+!*/
+typedef void* (*Toy_RefStringAllocatorFn)(void* pointer, size_t oldSize, size_t newSize);
+
+/*!
+## Defined Functions
+!*/
+
+/*!
+### void Toy_setRefStringAllocatorFn(Toy_RefStringAllocatorFn)
+
+This function conforms to and is invoked by Toy's memory API, and generally shouldn't be used without a good reason.
+!*/
+TOY_API void Toy_setRefStringAllocatorFn(Toy_RefStringAllocatorFn);
+
+/*!
+### Toy_RefString* Toy_createRefString(const char* cstring)
+
+This function wraps `Toy_CreateRefStringLength`, by determining the length of the given `cstring` and passing it to the other function.
+!*/
 TOY_API Toy_RefString* Toy_createRefString(const char* cstring);
+
+/*!
+### Toy_RefString* Toy_createRefStringLength(const char* cstring, size_t length)
+
+This function returns a new `Toy_RefString`, containing a copy of `cstring`, or `NULL` on error.
+
+This function also sets the returned refstring's reference counter to 1.
+!*/
 TOY_API Toy_RefString* Toy_createRefStringLength(const char* cstring, size_t length);
+
+/*!
+### void Toy_deleteRefString(Toy_RefString* refString)
+
+This function reduces the `refString`'s reference counter by 1 and, if it reaches 0, frees the memory.
+!*/
 TOY_API void Toy_deleteRefString(Toy_RefString* refString);
+
+/*!
+### int Toy_countRefString(Toy_RefString* refString)
+
+This function returns the total number of references to `refString`, for debugging.
+!*/
 TOY_API int Toy_countRefString(Toy_RefString* refString);
+
+/*!
+### size_t Toy_lengthRefString(Toy_RefString* refString)
+
+This function returns the length of the underlying cstring of `refString`.
+!*/
 TOY_API size_t Toy_lengthRefString(Toy_RefString* refString);
+
+/*!
+### Toy_RefString* Toy_copyRefString(Toy_RefString* refString)
+
+This function increases the reference counter of `refString` by 1, before returning the given pointer.
+
+This function reserves the right to create a deep copy where needed.
+!*/
 TOY_API Toy_RefString* Toy_copyRefString(Toy_RefString* refString);
+
+/*!
+### Toy_RefString* Toy_deepCopyRefString(Toy_RefString* refString)
+
+This function behaves identically to `Toy_copyRefString`, except that it explicitly forces a deep copy of the internal memory. Using this function should be done carefully, as it incurs a performance penalty that negates the benefit of this module.
+!*/
 TOY_API Toy_RefString* Toy_deepCopyRefString(Toy_RefString* refString);
+
+/*!
+### const char* Toy_toCString(Toy_RefString* refString)
+
+This function exposes the interal cstring of `refString`. Only use this function when dealing with external APIs.
+!*/
 TOY_API const char* Toy_toCString(Toy_RefString* refString);
+
+/*!
+### bool Toy_equalsRefString(Toy_RefString* lhs, Toy_RefString* rhs)
+
+This function returns true when the two refstrings are either the same refstring, or contain the same value. Otherwise it returns false.
+!*/
 TOY_API bool Toy_equalsRefString(Toy_RefString* lhs, Toy_RefString* rhs);
+
+/*!
+### bool Toy_equalsRefStringCString(Toy_RefString* lhs, char* cstring)
+
+This function returns true when the `refString` contains the same value as the `cstring`. Otherwise it returns false.
+!*/
 TOY_API bool Toy_equalsRefStringCString(Toy_RefString* lhs, char* cstring);

 //TODO: merge refstring memory
-
@@ -256,7 +256,7 @@ bool Toy_declareScopeVariable(Toy_Scope* scope, Toy_Literal key, Toy_Literal typ
 	return true;
 }

-bool Toy_isDelcaredScopeVariable(Toy_Scope* scope, Toy_Literal key) {
+bool Toy_isDeclaredScopeVariable(Toy_Scope* scope, Toy_Literal key) {
 	while (scope != NULL) {
 		if (Toy_existsLiteralDictionary(&scope->variables, key)) {
 			return true;
@@ -1,5 +1,15 @@
 #pragma once

+/*!
+# toy_scope.h
+
+This header defines the scope structure, which stores all of the variables used within a given block of code.
+
+Scopes are arranged into a linked list of ancestors, each of which is reference counted. When a scope is popped off the end of the chain, every ancestor scope has it's reference counter reduced by 1 and, if any reach 0, they are freed.
+
+This is also where Toy's type system lives.
+!*/
+
 #include "toy_literal.h"
 #include "toy_literal_array.h"
 #include "toy_literal_dictionary.h"
@@ -11,16 +21,70 @@ typedef struct Toy_Scope {
 	int references; //how many scopes point here
 } Toy_Scope;

+/*!
+## Defined Functions
+!*/
+
+/*!
+### Toy_Scope* Toy_pushScope(Toy_Scope* scope)
+
+This function creates a new `Toy_scope` with `scope` as it's ancestor, and returns it.
+!*/
 TOY_API Toy_Scope* Toy_pushScope(Toy_Scope* scope);
+
+/*!
+### Toy_Scope* Toy_popScope(Toy_Scope* scope)
+
+This function frees the given `scope`, and returns it's ancestor.
+!*/
 TOY_API Toy_Scope* Toy_popScope(Toy_Scope* scope);
+
+/*!
+### Toy_Scope* Toy_copyScope(Toy_Scope* original)
+
+This function copies an existing scope, and returns the copy.
+
+This copies the internal dictionaries, so it can be memory intensive.
+!*/
 TOY_API Toy_Scope* Toy_copyScope(Toy_Scope* original);

-//returns false if error
-TOY_API bool Toy_declareScopeVariable(Toy_Scope* scope, Toy_Literal key, Toy_Literal type);
-TOY_API bool Toy_isDelcaredScopeVariable(Toy_Scope* scope, Toy_Literal key);
+/*!
+### bool Toy_declareScopeVariable(Toy_Scope* scope, Toy_Literal key, Toy_Literal type)

-//return false if undefined
+This function declares a new variable `key` within `scope`, giving it the type of `type`.
+
+This function returns true on success, otherwise it returns failure (such as if the given key already exists).
+!*/
+TOY_API bool Toy_declareScopeVariable(Toy_Scope* scope, Toy_Literal key, Toy_Literal type);
+
+/*!
+### bool Toy_isDeclaredScopeVariable(Toy_Scope* scope, Toy_Literal key)
+
+This function checks to see if a given variable with the name `key` has been previously declared.
+!*/
+TOY_API bool Toy_isDeclaredScopeVariable(Toy_Scope* scope, Toy_Literal key);
+
+/*!
+### bool Toy_setScopeVariable(Toy_Scope* scope, Toy_Literal key, Toy_Literal value, bool constCheck)
+
+This function sets an existing variable named `key` to the value of `value`. This function fails if `constCheck` is true and the given key's type has the constaant flag set. It also fails if the given key doesn't exist.
+
+This function returns true on success, otherwise it returns false.
+!*/
 TOY_API bool Toy_setScopeVariable(Toy_Scope* scope, Toy_Literal key, Toy_Literal value, bool constCheck);
+
+/*!
+### bool Toy_getScopeVariable(Toy_Scope* scope, Toy_Literal key, Toy_Literal* value)
+
+This function sets the literal pointed to by `value` to equal the variable named `key`.
+
+This function returns true on success, otherwise it returns false.
+!*/
 TOY_API bool Toy_getScopeVariable(Toy_Scope* scope, Toy_Literal key, Toy_Literal* value);

+/*!
+### Toy_Literal Toy_getScopeType(Toy_Scope* scope, Toy_Literal key)
+
+This function returns a new `Toy_Literal` representing the type of the variable named `key`.
+!*/
 TOY_API Toy_Literal Toy_getScopeType(Toy_Scope* scope, Toy_Literal key);
@@ -74,8 +74,8 @@ typedef enum Toy_TokenType {
 	TOY_TOKEN_GREATER,
 	TOY_TOKEN_LESS_EQUAL,
 	TOY_TOKEN_GREATER_EQUAL,
-	TOY_TOKEN_AND,
-	TOY_TOKEN_OR,
+	TOY_TOKEN_AND_AND,
+	TOY_TOKEN_OR_OR,

 	//other operators
 	TOY_TOKEN_QUESTION,
@@ -2,9 +2,9 @@ CC=gcc

 IDIR +=. ../source ../repl
 CFLAGS +=$(addprefix -I,$(IDIR)) -g -Wall -W -Wno-unused-parameter -Wno-unused-function -Wno-unused-variable
-LIBS +=
+LIBS +=-lm
 ODIR = obj
-TARGETS = $(wildcard ../source/*.c) $(wildcard ../repl/lib_*.c) ../repl/repl_tools.c
+TARGETS = $(wildcard ../source/*.c) $(wildcard ../repl/lib_*.c) ../repl/repl_tools.c ../repl/drive_system.c
 TESTS = $(wildcard test_*.c)
 OBJ = $(addprefix $(ODIR)/,$(TARGETS:../source/%.c=%.o)) $(addprefix $(ODIR)/,$(TESTS:.c=.o))

@@ -15,7 +15,7 @@ all: $(OBJ) $(TESTS:%.c=../$(TOY_OUTDIR)/%.exe)
 ../$(TOY_OUTDIR)/%.exe: $(ODIR)/%.o
 	@$(CC) -o $@ $< $(TARGETS:../source/%.c=$(ODIR)/%.o) $(CFLAGS) $(LIBS)
 ifeq ($(shell uname)$(DISABLE_VALGRIND),Linux)
-	valgrind --leak-check=full --track-origins=yes $@
+	valgrind --leak-check=full --track-origins=yes --show-leak-kinds=all $@
 else
 	$@
 endif
@@ -0,0 +1,7 @@
+var s = "42";
+var t = "69";
+
+assert int (s + t) - 1 == 4268, "casting parentheses failed";
+
+
+print "All good";
@@ -10,4 +10,20 @@
 }


+//test function coercion
+{
+	fn f(arg: float) {
+		assert typeof arg == float, "argument coercion failed";
+	}
+
+	f(42);
+
+	fn g(): float {
+		return 42;
+	}
+
+	assert typeof g() == float, "return coercion failed";
+}
+
+
 print "All good";
@@ -23,5 +23,8 @@ assert !false, "!false";
 var c = false;
 assert !c, "!c";

+//test multiple comparisons
+assert 1 == 2 == false, "Left-accociative equality failed";
+

 print "All good";
@@ -0,0 +1,23 @@
+var days = [
+    "sunday",
+    "monday",
+    "tuesday",
+    "wednesday",
+    "thursday",
+    "friday",
+    "saturday"
+];
+
+var rng = 10; //for chosen at random
+
+
+var index = rng % days.length();
+
+assert index == 3, "dot modulo bugfix failed";
+
+rng %= days.length();
+
+assert rng == 3, "dot modulo assign bugfix failed";
+
+
+print "All good";
@@ -0,0 +1,30 @@
+{
+	fn a() {
+		fn b() {
+			return 42;
+		}
+
+		return b;
+	}
+
+	assert a()() == 42, "function within function failed";
+}
+
+{
+	fn a() {
+		fn b() {
+			fn c() {
+				return 42;
+			}
+
+			return c;
+		}
+
+		return b;
+	}
+
+	assert a()()() == 42, "function within function within function failed";
+}
+
+
+print "All good";
@@ -0,0 +1,11 @@
+//test for casting + grouping, see #67
+{
+	assert string(10 % 4) == "2", "basic group casting failed";
+	assert string 4 == "4", "normal casting failed";
+	
+	assert typeof string(10 % 4) == string, "group casting type failed";
+}
+
+
+
+print "All good";
@@ -0,0 +1,15 @@
+var a = 0;
+
+if (a++ >= 1) {
+	assert false, "increment postfix bugfix failed (first check)";
+}
+
+
+if (a++ >= 1) {
+	
+}
+
+assert a == 2, "increment postfix bugfix failed (second check)";
+
+
+print "All good";
@@ -92,4 +92,14 @@
 }


+//test deep-combine example
+{
+	fn combine(a, b, c, d) {
+		return [[a, b], [c, d]];
+	}
+
+	assert combine(1, 2, 3, 4) == [[1, 2], [3, 4]], "deep-combine example failed";
+}
+
+
 print "All good";
@@ -0,0 +1,10 @@
+
+var result; //result must exist to ensure assingment, rather than declaration is invoked by the comparison below
+
+var lhs = [0];
+var rhs = [0];
+
+result = lhs[0] < rhs[0]; //make sure this doesn't invoke TOY_OP_INDEX_ASSIGN_INTERMEDIATE
+
+
+print "All good";
@@ -0,0 +1,20 @@
+fn max(lhs, rhs) {
+    if (lhs > rhs) {
+        return lhs;
+    }
+    else {
+        return rhs;
+    }
+}
+
+var array = [42];
+
+var result = null;
+
+//problematic line
+result = max(0, array[0]);
+
+assert result == 42, "Indexing in argument list failed";
+
+
+print "All good";
@@ -0,0 +1,185 @@
+import math;
+
+
+// test pow
+{
+	assert pow(5, 3) == 125, "pow(5, 3) failed";
+	assert pow(-5, 3) == -125, "pow(-5, 3) failed";
+	assert pow(-5.5, 3) == -166.375, "pow(-5.5, 3) failed";
+	assert pow(0, 1) == 0.0, "pow(0, 1) failed";
+	assert pow(-0.0, 1) == -0.0, "pow(0, 1) failed";
+}
+
+// test sqrt
+{
+	assert sqrt(25) == 5, "sqrt(25) failed";
+	assert sqrt(256.0) == 16, "sqrt(256.0) failed";
+	assert checkIsNaN(sqrt(-256.0)), "sqrt(-256.0) failed";
+	assert sqrt(1) == 1, "sqrt(1) failed";
+	assert sqrt(0) == 0, "sqrt(0) failed";
+}
+
+// test cbrt
+{
+	assert cbrt(64) == 4, "cbrt(64) failed";
+	assert cbrt(4096.0) == 16, "cbrt(4096.0) failed";
+	assert cbrt(-64) == -4, "cbrt(-64) failed";
+	assert cbrt(1) == 1, "cbrt(1) failed";
+	assert cbrt(0) == 0, "cbrt(0) failed";
+}
+
+// test hypot
+{
+	assert hypot(3, 4) == 5, "hypot(3, 4) failed";
+}
+
+// test toRad
+{
+	assert toRadians(0) == 0, "toRadians(0) failed";
+	assert toRadians(180) == PI, "toRadians(180) failed";
+	assert toRadians(360) == 2 * PI, "toRadians(360) failed";
+}
+
+
+// test toDeg
+{
+	assert toDegrees(0) == 0, "toDegrees(0) failed";
+	assert toDegrees(PI) == 180, "toDegrees(PI) failed";
+	assert toDegrees(2 * PI) == 360, "toDegrees(2*PI) failed";
+}
+
+// test sin
+{
+	assert epsilionCompare(sin(PI), 0), "sin(PI) failed";
+	assert epsilionCompare(sin(PI / 2), 1), "sin(PI/2) failed";
+	assert epsilionCompare(sin(0), 0), "sin(0) failed";
+}
+
+
+// test cos
+{
+	assert epsilionCompare(cos(PI), -1), "cos(PI) failed";
+	assert epsilionCompare(cos(PI / 2), 0), "cos(PI/2) failed";
+	assert epsilionCompare(cos(0), 1), "cos(0) failed";
+}
+
+// test tan
+{
+	assert epsilionCompare(tan(PI), 0), "tan(PI) failed";
+	assert epsilionCompare(tan(PI / 4), 1), "tan(PI/4) failed";
+	assert epsilionCompare(tan(0), 0), "tan(0) failed";
+}
+
+
+// test asin
+{
+	assert epsilionCompare(asin(1), 1.570796), "asin(1) failed";
+	assert epsilionCompare(asin(-0.5), -0.523599), "asin(-0.5) failed";
+	assert epsilionCompare(asin(0), 0), "asin(0) failed";
+}
+
+
+// test acos
+{
+	assert epsilionCompare(acos(1), 0), "acos(1) failed";
+	assert epsilionCompare(acos(0.5), 1.047198), "acos(0.5) failed";
+	assert epsilionCompare(acos(0), 1.570796), "acos(0) failed";
+}
+
+
+// test atan
+{
+	assert epsilionCompare(atan(1), 0.785398), "acos(1) failed";
+	assert epsilionCompare(atan(INFINITY), 1.570796), "atan(INFINITY) failed";
+	assert epsilionCompare(atan(0), 0), "atan(0) failed";
+}
+
+
+// test atan2
+{
+	assert epsilionCompare(atans(0, 0), 0), "atan2(0, 0) failed";
+	assert epsilionCompare(atans(7, 0), 1.570796), "atans(7, 0) failed";
+}
+
+
+// test sinh
+{
+	assert epsilionCompare(sinh(1), 1.175201), "sinh(1) failed";
+	assert epsilionCompare(sinh(-1), -1.175201), "sinh(-1) failed";
+	assert epsilionCompare(sinh(0), 0), "sinh(0) failed";
+}
+
+
+// test cosh
+{
+	assert epsilionCompare(cosh(1), 1.543081), "cosh(1) failed";
+	assert epsilionCompare(cosh(-1), 1.543081), "cosh(-1) failed";
+	assert epsilionCompare(cosh(0), 1), "cosh(0) failed";
+}
+
+
+// test tanh
+{
+	assert epsilionCompare(tanh(1), 0.761594), "tanh(1) failed";
+	assert epsilionCompare(tanh(-1), -0.761594), "tanh(-1) failed";
+	assert epsilionCompare(tanh(0), 0), "tanh(0) failed";
+}
+
+
+// test asinh
+{
+	assert epsilionCompare(asinh(1), 0.881374), "asinh(1) failed";
+	assert epsilionCompare(asinh(-1), -0.881374), "asinh(-1) failed";
+	assert epsilionCompare(asinh(0), 0), "asinh(0) failed";
+}
+
+
+// test acosh
+{
+	assert epsilionCompare(acosh(1), 0), "acosh(1) failed";
+	assert checkIsNaN(acosh(-1)) == true, "acosh(-1) failed";
+	assert checkIsNaN(acosh(0)) == true, "acosh(0) failed";
+}
+
+
+// test atanh
+{
+	assert checkIsInfinite(atanh(1)) == true, "atanh(1) failed";
+	assert checkIsInfinite(atanh(-1)) == true, "atanh(-1) failed";
+	assert epsilionCompare(atanh(0), 0), "atanh(0) failed";
+}
+
+
+// test checkIsNaN
+{
+	assert checkIsNaN(NAN) == true, "checkIsNaN(NAN) failed";
+	assert checkIsNaN(INFINITY) == false, "checkIsNaN(INFINITY) failed";
+	assert checkIsNaN(0.0) == false, "checkIsNaN(0.0) failed";
+	assert checkIsNaN(INFINITY - INFINITY) == true, "checkIsNaN(INFINITY - INFINITY) failed";
+}
+
+
+// test checkIsFinite
+{
+	assert checkIsFinite(NAN) == false, "checkIsFinite(NAN) failed";
+	assert checkIsFinite(INFINITY) == false, "checkIsFinite(INFINITY) failed";
+	assert checkIsFinite(0.0) == true, "checkIsFinite(0.0) failed";
+	assert checkIsFinite(1) == true, "checkIsFinite(1) failed";
+}
+
+
+// test checkIsInfinite
+{
+	assert checkIsInfinite(NAN) == false, "checkIsInfinite(NAN) failed";
+	assert checkIsInfinite(INFINITY) == true, "checkIsInfinite(INFINITY) failed";
+	assert checkIsInfinite(0.0) == false, "checkIsInfinite(0.0) failed";
+	assert checkIsInfinite(1) == false, "checkIsInfinite(1) failed";
+}
+
+// test epsilionCompare
+{
+	assert epsilionCompare(1, 1) == true, "epsilionCompare(1, 1) failed";
+	assert epsilionCompare(1, 1.000001) == true, "epsilionCompare(1, 1.000001) failed";
+	assert epsilionCompare(1, 1.001) == false, "epsilionCompare(1, 1.001) failed";
+	assert epsilionCompare(0, 0) == true, "epsilionCompare(0, 0) failed";
+}
@@ -101,6 +101,63 @@ import standard;
 }


+//test sign
+{
+	assert sign(4) == 1, "sign(int) failed";
+	assert sign(-4) == -1, "sign(-int) failed";
+	assert sign(4.1) == 1, "sign(float) failed";
+	assert sign(-4.1) == -1, "sign(-float) failed";
+	assert sign(0) == 1, "sign(0) failed";
+
+	var x = 4.1;
+
+	assert x.sign() == 1, "var.sign() failed";
+
+	assert typeof sign(1.0) == int, "typeof sign() == int failed";
+}
+
+
+//test normalize
+{
+	assert normalize(4) == 1, "normalize(int) failed";
+	assert normalize(-4) == -1, "normalize(-int) failed";
+	assert normalize(4.1) == 1, "normalize(float) failed";
+	assert normalize(-4.1) == -1, "normalize(-float) failed";
+	assert normalize(0) == 0, "normalize(0) failed";
+
+	var x = 4.1;
+
+	assert x.normalize() == 1, "var.normalize() failed";
+
+	assert typeof normalize(1.0) == int, "typeof normalize() == int failed";
+}
+
+
+//test clamp
+{
+	assert clamp(1, 0, 5) == 1, "clamp(1, 0, 5) failed";
+	assert clamp(0, 1, 5) == 1, "clamp(0, 1, 5) failed";
+	assert clamp(10, 1, 5) == 5, "clamp(10, 1, 5) failed";
+
+	assert clamp(1.0, 0.0, 5.0) == 1, "clamp(1.0, 0.0, 5.0) failed";
+	assert clamp(0.0, 1.0, 5.0) == 1, "clamp(0.0, 1.0, 5.0) failed";
+	assert clamp(10.0, 1.0, 5.0) == 5, "clamp(10.0, 1.0, 5.0) failed";
+
+	assert typeof clamp(10, 1, 5) == int, "typeof clamp(10, 1, 5) == int failed";
+	assert typeof clamp(10.0, 1, 5) == int, "typeof clamp(10.0, 1, 5) == int failed";
+	assert typeof clamp(10, 1, 5.0) == float, "typeof clamp(10, 1, 5.0) == float failed";
+}
+
+
+//test lerp
+{
+	assert lerp(0, 10, 0.5) == 5, "lerp 50% failed";
+	assert lerp(0, 10, 1.5) == 15, "lerp 150% failed";
+
+	assert typeof lerp(0, 10, 0) == float, "typeof lerp result failed";
+}
+
+
 //test concat
 {
 	//test array concat
@@ -1,5 +1,5 @@
-import about as about;
-import about;
+import toy_version_info as toy_version_info;
+import toy_version_info;

 assert author == "Kayne Ruse, KR Game Studios", "Author failed";

@@ -0,0 +1,14 @@
+//These operators should short-circuit
+assert (true && false) == false, "(true && false) == false failed";
+assert (false && true) == false, "(false && true) == false failed";
+
+assert (true || false) == true, "(true || false) == true failed";
+assert (false || true) == true, "(false || true) == true failed";
+
+
+//make sure the right value is being returned when chained
+assert "a" && "b" && "c" == "c", "chained && failed";
+assert "a" || "b" || "c" == "a", "chained || failed";
+
+
+print "All good";
@@ -0,0 +1,8 @@
+var array = [
+    1, 2, 3,
+    4, 5, 6,
+    7, 8, 9, //explicitly leave a trailing comma
+];
+
+
+print "All good";
@@ -22,4 +22,9 @@ var dict: complex = [
 	"third array": [7, 8, 9]
 ];

+
+//check the any type is recognized as a type within an array
+var a: [type] = [int, bool, any];
+
+
 print "All good";
@@ -0,0 +1,79 @@
+#include "drive_system.h"
+
+#include "toy_console_colors.h"
+
+#include <stdio.h>
+#include <string.h>
+
+int main() {
+	{
+		//test init and quit
+		Toy_initDriveSystem();
+		Toy_freeDriveSystem();
+	}
+
+	{
+		//setup
+		Toy_initDriveSystem();
+
+		//test storing a value as a drive
+		Toy_setDrivePath("drive", "folder");
+
+		//cleanup
+		Toy_freeDriveSystem();
+	}
+
+	{
+		//setup
+		Toy_initDriveSystem();
+
+		//create a dummy interpreter (only needed for the error output function)
+		Toy_Interpreter interpreter;
+		Toy_initInterpreter(&interpreter);
+
+		//prerequisite
+		Toy_setDrivePath("drive", "path/to/drive");
+
+		//create the argument literal
+		Toy_Literal argumentLiteral = TOY_TO_STRING_LITERAL(Toy_createRefString("drive:/path/to/file"));
+
+		//test retrieving a relative path, as a literal, from the drive system
+		Toy_Literal resultLiteral = Toy_getDrivePathLiteral(&interpreter, &argumentLiteral);
+
+		//assert the correct value was returned
+		const char* cstring = Toy_toCString(TOY_AS_STRING(resultLiteral));
+		if (strcmp(cstring, "path/to/drive/path/to/file") != 0) {
+			fprintf(stderr, TOY_CC_ERROR "ERROR: Incorrect value retrieved from drive system: %s" TOY_CC_RESET, cstring);
+			return -1;
+		}
+
+		//cleanup
+		Toy_freeLiteral(argumentLiteral);
+		Toy_freeLiteral(resultLiteral);
+		Toy_freeInterpreter(&interpreter);
+		Toy_freeDriveSystem();
+	}
+
+	{
+		//setup
+		Toy_initDriveSystem();
+
+		//test storing enough drives to trigger internal dictionary expansion
+		Toy_setDrivePath("A", "folder");
+		Toy_setDrivePath("B", "folder");
+		Toy_setDrivePath("C", "folder");
+		Toy_setDrivePath("D", "folder");
+		Toy_setDrivePath("E", "folder");
+		Toy_setDrivePath("F", "folder");
+		Toy_setDrivePath("G", "folder");
+		Toy_setDrivePath("H", "folder");
+		Toy_setDrivePath("I", "folder");
+		Toy_setDrivePath("J", "folder");
+
+		//cleanup
+		Toy_freeDriveSystem();
+	}
+
+	printf(TOY_CC_NOTICE "All good\n" TOY_CC_RESET);
+	return 0;
+}
@@ -18,6 +18,7 @@ static void noPrintFn(const char* output) {
 	//NO OP
 }

+int failedAssertions = 0;
 int ignoredAssertions = 0;
 static void noAssertFn(const char* output) {
 	if (strncmp(output, "!ignore", 7) == 0) {
@@ -27,6 +28,7 @@ static void noAssertFn(const char* output) {
 		fprintf(stderr, TOY_CC_ERROR "Assertion failure: ");
 		fprintf(stderr, "%s", output);
 		fprintf(stderr, "\n" TOY_CC_RESET); //default new line
+		failedAssertions++;
 	}
 }

@@ -108,19 +110,26 @@ int main() {
 		//run each file in tests/scripts/
 		const char* filenames[] = {
 			"arithmetic.toy",
+			"casting-parentheses-bugfix.toy",
 			"casting.toy",
 			"coercions.toy",
 			"comparisons.toy",
 			"dot-and-matrix.toy",
 			"dot-assignments-bugfix.toy",
 			"dot-chaining.toy",
+			"dot-modulo-bugfix.toy",
 			"dottify-bugfix.toy",
+			"function-within-function-bugfix.toy",
 			"functions.toy",
+			"group-casting-bugfix.toy",
+			"increment-postfix-bugfix.toy",
 			"index-arrays.toy",
 			"index-assignment-both-bugfix.toy",
+			"index-assignment-intermediate-bugfix.toy",
 			"index-assignment-left-bugfix.toy",
 			"index-dictionaries.toy",
 			"index-strings.toy",
+			"indexing-in-argument-list-bugfix.toy",
 			"jumps.toy",
 			"jumps-in-functions.toy",
 			"logicals.toy",
@@ -132,7 +141,9 @@ int main() {
 			"panic-within-functions.toy",
 			"polyfill-insert.toy",
 			"polyfill-remove.toy",
+			"short-circuit.toy",
 			"ternary-expressions.toy",
+			"trailing-comma-bugfix.toy",
 			"types.toy",
 			NULL
 		};
@@ -153,7 +164,10 @@ int main() {
 		return -1;
 	}

-	printf(TOY_CC_NOTICE "All good\n" TOY_CC_RESET);
-	return 0;
+	if (failedAssertions == 0) {
+		printf(TOY_CC_NOTICE "All good\n" TOY_CC_RESET);
+	}
+
+	return failedAssertions;
 }

@@ -12,11 +12,13 @@
 #include <string.h>

 #include "../repl/repl_tools.h"
+#include "../repl/drive_system.h"

-#include "../repl/lib_about.h"
+#include "../repl/lib_toy_version_info.h"
+#include "../repl/lib_standard.h"
 #include "../repl/lib_random.h"
 #include "../repl/lib_runner.h"
-#include "../repl/lib_standard.h"
+#include "../repl/lib_math.h"

 //supress the print output
 static void noPrintFn(const char* output) {
@@ -63,24 +65,19 @@ typedef struct Payload {

 int main() {
 	//setup the runner filesystem (hacky)
-	Toy_initDriveDictionary();
+	Toy_initDriveSystem();

-	Toy_Literal driveLiteral = TOY_TO_STRING_LITERAL(Toy_createRefString("scripts"));
-	Toy_Literal pathLiteral = TOY_TO_STRING_LITERAL(Toy_createRefString("scripts"));
-
-	Toy_setLiteralDictionary(Toy_getDriveDictionary(), driveLiteral, pathLiteral);
-
-	Toy_freeLiteral(driveLiteral);
-	Toy_freeLiteral(pathLiteral);
+	Toy_setDrivePath("scripts", "scripts");

 	{
 		//run each file in test/scripts
 		Payload payloads[] = {
 			{"interactions.toy", "standard", Toy_hookStandard}, //interactions needs standard
-			{"about.toy", "about", Toy_hookAbout},
+			{"toy_version_info.toy", "toy_version_info", Toy_hookToyVersionInfo},
 			{"standard.toy", "standard", Toy_hookStandard},
 			{"runner.toy", "runner", Toy_hookRunner},
 			{"random.toy", "random", Toy_hookRandom},
+			{"math.toy", "math", Toy_hookMath},
 			{NULL, NULL, NULL}
 		};

@@ -113,7 +110,7 @@ int main() {
 	}

 	//lib cleanup
-	Toy_freeDriveDictionary();
+	Toy_freeDriveSystem();

 	if (!failedAsserts) {
 		printf(TOY_CC_NOTICE "All good\n" TOY_CC_RESET);
@@ -0,0 +1,427 @@
+/*
+ * Project: https://github.com/likle/cargs
+ * License: MIT
+ */
+
+#include <assert.h>
+#include <cargs.h>
+#include <memory.h>
+#include <stdio.h>
+#include <string.h>
+
+#define CAG_OPTION_PRINT_DISTANCE 4
+#define CAG_OPTION_PRINT_MIN_INDENTION 20
+
+static void cag_option_print_value(const cag_option *option,
+		size_t *accessor_length, FILE *destination) {
+	if (option->value_name != NULL) {
+		*accessor_length += fprintf(destination, "=%s", option->value_name);
+	}
+}
+
+static void cag_option_print_letters(const cag_option *option, bool *first,
+		size_t *accessor_length, FILE *destination) {
+	const char *access_letter;
+	access_letter = option->access_letters;
+	if (access_letter != NULL) {
+		while (*access_letter) {
+			if (*first) {
+				*accessor_length += fprintf(destination, "-%c", *access_letter);
+				*first = false;
+			} else {
+				*accessor_length += fprintf(destination, ", -%c",
+						*access_letter);
+			}
+			++access_letter;
+		}
+	}
+}
+
+static void cag_option_print_name(const cag_option *option, bool *first,
+		size_t *accessor_length, FILE *destination) {
+	if (option->access_name != NULL) {
+		if (*first) {
+			*accessor_length += fprintf(destination, "--%s",
+					option->access_name);
+		} else {
+			*accessor_length += fprintf(destination, ", --%s",
+					option->access_name);
+		}
+	}
+}
+
+static size_t cag_option_get_print_indention(const cag_option *options,
+		size_t option_count) {
+	size_t option_index, indention, result;
+	const cag_option *option;
+
+	result = CAG_OPTION_PRINT_MIN_INDENTION;
+
+	for (option_index = 0; option_index < option_count; ++option_index) {
+		indention = CAG_OPTION_PRINT_DISTANCE;
+		option = &options[option_index];
+		if (option->access_letters != NULL && *option->access_letters) {
+			indention += strlen(option->access_letters) * 4 - 2;
+			if (option->access_name != NULL) {
+				indention += strlen(option->access_name) + 4;
+			}
+		} else if (option->access_name != NULL) {
+			indention += strlen(option->access_name) + 2;
+		}
+
+		if (option->value_name != NULL) {
+			indention += strlen(option->value_name) + 1;
+		}
+
+		if (indention > result) {
+			result = indention;
+		}
+	}
+
+	return result;
+}
+
+void cag_option_print(const cag_option *options, size_t option_count,
+		FILE *destination) {
+	size_t option_index, indention, i, accessor_length;
+	const cag_option *option;
+	bool first;
+
+	indention = cag_option_get_print_indention(options, option_count);
+
+	for (option_index = 0; option_index < option_count; ++option_index) {
+		option = &options[option_index];
+		accessor_length = 0;
+		first = true;
+
+		fputs("  ", destination);
+
+		cag_option_print_letters(option, &first, &accessor_length, destination);
+		cag_option_print_name(option, &first, &accessor_length, destination);
+		cag_option_print_value(option, &accessor_length, destination);
+
+		for (i = accessor_length; i < indention; ++i) {
+			fputs(" ", destination);
+		}
+
+		fputs(" ", destination);
+		fputs(option->description, destination);
+
+		fprintf(destination, "\n");
+	}
+}
+
+void cag_option_prepare(cag_option_context *context, const cag_option *options,
+		size_t option_count, int argc, char **argv) {
+	// This just initialized the values to the beginning of all the arguments.
+	context->options = options;
+	context->option_count = option_count;
+	context->argc = argc;
+	context->argv = argv;
+	context->index = 1;
+	context->inner_index = 0;
+	context->forced_end = false;
+}
+
+static const cag_option* cag_option_find_by_name(cag_option_context *context,
+		char *name, size_t name_size) {
+	const cag_option *option;
+	size_t i;
+
+	// We loop over all the available options and stop as soon as we have found
+	// one. We don't use any hash map table, since there won't be that many
+	// arguments anyway.
+	for (i = 0; i < context->option_count; ++i) {
+		option = &context->options[i];
+
+		// The option might not have an item name, we can just skip those.
+		if (option->access_name == NULL) {
+			continue;
+		}
+
+		// Try to compare the name of the access name. We can use the name_size or
+		// this comparison, since we are guaranteed to have null-terminated access
+		// names.
+		if (strncmp(option->access_name, name, name_size) == 0) {
+			return option;
+		}
+	}
+
+	return NULL;
+}
+
+static const cag_option* cag_option_find_by_letter(cag_option_context *context,
+		char letter) {
+	const cag_option *option;
+	size_t i;
+
+	// We loop over all the available options and stop as soon as we have found
+	// one. We don't use any look up table, since there won't be that many
+	// arguments anyway.
+	for (i = 0; i < context->option_count; ++i) {
+		option = &context->options[i];
+
+		// If this option doesn't have any access letters we will skip them.
+		if (option->access_letters == NULL) {
+			continue;
+		}
+
+		// Verify whether this option has the access letter in it's access letter
+		// string. If it does, then this is our option.
+		if (strchr(option->access_letters, letter) != NULL) {
+			return option;
+		}
+	}
+
+	return NULL;
+}
+
+static void cag_option_parse_value(cag_option_context *context,
+		const cag_option *option, char **c) {
+	// And now let's check whether this option is supposed to have a value, which
+	// is the case if there is a value name set. The value can be either submitted
+	// with a '=' sign or a space, which means we would have to jump over to the
+	// next argv index. This is somewhat ugly, but we do it to behave the same as
+	// the other option parsers.
+	if (option->value_name != NULL) {
+		if (**c == '=') {
+			context->value = ++(*c);
+		} else {
+			// If the next index is larger or equal to the argument count, then the
+			// parameter for this option is missing. The user will know about this,
+			// since the value pointer of the context will be NULL because we don't
+			// set it here in that case.
+			if (context->argc > context->index + 1) {
+				// We consider this argv to be the value, no matter what the contents
+				// are.
+				++context->index;
+				*c = context->argv[context->index];
+				context->value = *c;
+			}
+		}
+
+		// Move c to the end of the value, to not confuse the caller about our
+		// position.
+		while (**c) {
+			++(*c);
+		}
+	}
+}
+
+static void cag_option_parse_access_name(cag_option_context *context, char **c) {
+	const cag_option *option;
+	char *n;
+
+	// Now we need to extract the access name, which is any symbol up to a '=' or
+	// a '\0'.
+	n = *c;
+	while (**c && **c != '=') {
+		++*c;
+	}
+
+	// Now this will obviously always be true, but we are paranoid. Sometimes. It
+	// doesn't hurt to check.
+	assert(*c >= n);
+
+	// Figure out which option this name belongs to. This might return NULL if the
+	// name is not registered, which means the user supplied an unknown option. In
+	// that case we return true to indicate that we finished with this option. We
+	// have to skip the value parsing since we don't know whether the user thinks
+	// this option has one or not. Since we don't set any identifier specifically,
+	// it will remain '?' within the context.
+	option = cag_option_find_by_name(context, n, (size_t) (*c - n));
+	if (option == NULL) {
+		// Since this option is invalid, we will move on to the next index. There is
+		// nothing we can do about this.
+		++context->index;
+		return;
+	}
+
+	// We found an option and now we can specify the identifier within the
+	// context.
+	context->identifier = option->identifier;
+
+	// And now we try to parse the value. This function will also check whether
+	// this option is actually supposed to have a value.
+	cag_option_parse_value(context, option, c);
+
+	// And finally we move on to the next index.
+	++context->index;
+}
+
+static void cag_option_parse_access_letter(cag_option_context *context,
+		char **c) {
+	const cag_option *option;
+	char *n = *c;
+	char *v;
+
+	// Figure out which option this letter belongs to. This might return NULL if
+	// the letter is not registered, which means the user supplied an unknown
+	// option. In that case we return true to indicate that we finished with this
+	// option. We have to skip the value parsing since we don't know whether the
+	// user thinks this option has one or not. Since we don't set any identifier
+	// specifically, it will remain '?' within the context.
+	option = cag_option_find_by_letter(context, n[context->inner_index]);
+	if (option == NULL) {
+		++context->index;
+		context->inner_index = 0;
+		return;
+	}
+
+	// We found an option and now we can specify the identifier within the
+	// context.
+	context->identifier = option->identifier;
+
+	// And now we try to parse the value. This function will also check whether
+	// this option is actually supposed to have a value.
+	v = &n[++context->inner_index];
+	cag_option_parse_value(context, option, &v);
+
+	// Check whether we reached the end of this option argument.
+	if (*v == '\0') {
+		++context->index;
+		context->inner_index = 0;
+	}
+}
+
+static void cag_option_shift(cag_option_context *context, int start, int option,
+		int end) {
+	char *tmp;
+	int a_index, shift_index, shift_count, left_index, right_index;
+
+	shift_count = option - start;
+
+	// There is no shift is required if the start and the option have the same
+	// index.
+	if (shift_count == 0) {
+		return;
+	}
+
+	// Lets loop through the option strings first, which we will move towards the
+	// beginning.
+	for (a_index = option; a_index < end; ++a_index) {
+		// First remember the current option value, because we will have to save
+		// that later at the beginning.
+		tmp = context->argv[a_index];
+
+		// Let's loop over all option values and shift them one towards the end.
+		// This will override the option value we just stored temporarily.
+		for (shift_index = 0; shift_index < shift_count; ++shift_index) {
+			left_index = a_index - shift_index;
+			right_index = a_index - shift_index - 1;
+			context->argv[left_index] = context->argv[right_index];
+		}
+
+		// Now restore the saved option value at the beginning.
+		context->argv[a_index - shift_count] = tmp;
+	}
+
+	// The new index will be before all non-option values, in such a way that they
+	// all will be moved again in the next fetch call.
+	context->index = end - shift_count;
+}
+
+static bool cag_option_is_argument_string(const char *c) {
+	return *c == '-' && *(c + 1) != '\0';
+}
+
+static int cag_option_find_next(cag_option_context *context) {
+	int next_index, next_option_index;
+	char *c;
+
+	// Prepare to search the next option at the next index.
+	next_index = context->index;
+	next_option_index = next_index;
+
+	// Grab a pointer to the string and verify that it is not the end. If it is
+	// the end, we have to return false to indicate that we finished.
+	c = context->argv[next_option_index];
+	if (context->forced_end || c == NULL) {
+		return -1;
+	}
+
+	// Check whether it is a '-'. We need to find the next option - and an option
+	// always starts with a '-'. If there is a string "-\0", we don't consider it
+	// as an option neither.
+	while (!cag_option_is_argument_string(c)) {
+		c = context->argv[++next_option_index];
+		if (c == NULL) {
+			// We reached the end and did not find any argument anymore. Let's tell
+			// our caller that we reached the end.
+			return -1;
+		}
+	}
+
+	// Indicate that we found an option which can be processed. The index of the
+	// next option will be returned.
+	return next_option_index;
+}
+
+bool cag_option_fetch(cag_option_context *context) {
+	char *c;
+	int old_index, new_index;
+
+	// Reset our identifier to a question mark, which indicates an "unknown"
+	// option. The value is set to NULL, to make sure we are not carrying the
+	// parameter from the previous option to this one.
+	context->identifier = '?';
+	context->value = NULL;
+
+	// Check whether there are any options left to parse and remember the old
+	// index as well as the new index. In the end we will move the option junk to
+	// the beginning, so that non option arguments can be read.
+	old_index = context->index;
+	new_index = cag_option_find_next(context);
+	if (new_index >= 0) {
+		context->index = new_index;
+	} else {
+		return false;
+	}
+
+	// Grab a pointer to the beginning of the option. At this point, the next
+	// character must be a '-', since if it was not the prepare function would
+	// have returned false. We will skip that symbol and proceed.
+	c = context->argv[context->index];
+	assert(*c == '-');
+	++c;
+
+	// Check whether this is a long option, starting with a double "--".
+	if (*c == '-') {
+		++c;
+
+		// This might be a double "--" which indicates the end of options. If this
+		// is the case, we will not move to the next index. That ensures that
+		// another call to the fetch function will not skip the "--".
+		if (*c == '\0') {
+			context->forced_end = true;
+		} else {
+			// We parse now the access name. All information about it will be written
+			// to the context.
+			cag_option_parse_access_name(context, &c);
+		}
+	} else {
+		// This is no long option, so we can just parse an access letter.
+		cag_option_parse_access_letter(context, &c);
+	}
+
+	// Move the items so that the options come first followed by non-option
+	// arguments.
+	cag_option_shift(context, old_index, new_index, context->index);
+
+	return context->forced_end == false;
+}
+
+char cag_option_get(const cag_option_context *context) {
+	// We just return the identifier here.
+	return context->identifier;
+}
+
+const char* cag_option_get_value(const cag_option_context *context) {
+	// We just return the internal value pointer of the context.
+	return context->value;
+}
+
+int cag_option_get_index(const cag_option_context *context) {
+	// Either we point to a value item,
+	return context->index;
+}
@@ -0,0 +1,169 @@
+/*
+ * Project: https://github.com/likle/cargs
+ * License: MIT
+ */
+
+#ifndef CARGS_H_
+#define CARGS_H_
+
+/**
+ * This is a simple alternative cross-platform implementation of getopt, which
+ * is used to parse argument strings submitted to the executable (argc and argv
+ * which are received in the main function).
+ */
+
+#ifndef CAG_LIBRARY_H
+#define CAG_LIBRARY_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdio.h>
+
+#if defined(_WIN32) || defined(__CYGWIN__)
+#define CAG_EXPORT __declspec(dllexport)
+#define CAG_IMPORT __declspec(dllimport)
+#elif __GNUC__ >= 4
+#define CAG_EXPORT __attribute__((visibility("default")))
+#define CAG_IMPORT __attribute__((visibility("default")))
+#else
+#define CAG_EXPORT
+#define CAG_IMPORT
+#endif
+
+#if defined(CAG_SHARED)
+#if defined(CAG_EXPORTS)
+#define CAG_PUBLIC CAG_EXPORT
+#else
+#define CAG_PUBLIC CAG_IMPORT
+#endif
+#else
+#define CAG_PUBLIC
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * An option is used to describe a flag/argument option submitted when the
+ * program is run.
+ */
+typedef struct cag_option {
+	const char identifier;
+	const char *access_letters;
+	const char *access_name;
+	const char *value_name;
+	const char *description;
+} cag_option;
+
+/**
+ * A context is used to iterate over all options provided. It stores the parsing
+ * state.
+ */
+typedef struct cag_option_context {
+	const struct cag_option *options;
+	size_t option_count;
+	int argc;
+	char **argv;
+	int index;
+	int inner_index;
+	bool forced_end;
+	char identifier;
+	char *value;
+} cag_option_context;
+
+/**
+ * This is just a small macro which calculates the size of an array.
+ */
+#define CAG_ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))
+
+/**
+ * @brief Prints all options to the terminal.
+ *
+ * This function prints all options to the terminal. This can be used to
+ * generate the output for a "--help" option.
+ *
+ * @param options The options which will be printed.
+ * @param option_count The option count which will be printed.
+ * @param destination The destination where the output will be printed.
+ */
+CAG_PUBLIC void cag_option_print(const cag_option *options, size_t option_count,
+		FILE *destination);
+
+/**
+ * @brief Prepare argument options context for parsing.
+ *
+ * This function prepares the context for iteration and initializes the context
+ * with the supplied options and arguments. After the context has been prepared,
+ * it can be used to fetch arguments from it.
+ *
+ * @param context The context which will be initialized.
+ * @param options The registered options which are available for the program.
+ * @param option_count The amount of options which are available for the
+ * program.
+ * @param argc The amount of arguments the user supplied in the main function.
+ * @param argv A pointer to the arguments of the main function.
+ */
+CAG_PUBLIC void cag_option_prepare(cag_option_context *context,
+		const cag_option *options, size_t option_count, int argc, char **argv);
+
+/**
+ * @brief Fetches an option from the argument list.
+ *
+ * This function fetches a single option from the argument list. The context
+ * will be moved to that item. Information can be extracted from the context
+ * after the item has been fetched.
+ * The arguments will be re-ordered, which means that non-option arguments will
+ * be moved to the end of the argument list. After all options have been
+ * fetched, all non-option arguments will be positioned after the index of
+ * the context.
+ *
+ * @param context The context from which we will fetch the option.
+ * @return Returns true if there was another option or false if the end is
+ * reached.
+ */
+CAG_PUBLIC bool cag_option_fetch(cag_option_context *context);
+
+/**
+ * @brief Gets the identifier of the option.
+ *
+ * This function gets the identifier of the option, which should be unique to
+ * this option and can be used to determine what kind of option this is.
+ *
+ * @param context The context from which the option was fetched.
+ * @return Returns the identifier of the option.
+ */
+CAG_PUBLIC char cag_option_get(const cag_option_context *context);
+
+/**
+ * @brief Gets the value from the option.
+ *
+ * This function gets the value from the option, if any. If the option does not
+ * contain a value, this function will return NULL.
+ *
+ * @param context The context from which the option was fetched.
+ * @return Returns a pointer to the value or NULL if there is no value.
+ */
+CAG_PUBLIC const char* cag_option_get_value(const cag_option_context *context);
+
+/**
+ * @brief Gets the current index of the context.
+ *
+ * This function gets the index within the argv arguments of the context. The
+ * context always points to the next item which it will inspect. This is
+ * particularly useful to inspect the original argument array, or to get
+ * non-option arguments after option fetching has finished.
+ *
+ * @param context The context from which the option was fetched.
+ * @return Returns the current index of the context.
+ */
+CAG_PUBLIC int cag_option_get_index(const cag_option_context *context);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
+#endif
+
+#endif /* CARGS_H_ */
+
@@ -0,0 +1,949 @@
+/*
+ * disassembler.c
+ *
+ *  Created on: 10 ago. 2023
+ *      Original Author: Emiliano Augusto Gonzalez (egonzalez . hiperion @ gmail . com)
+ * 
+ * Further modified by Kayne Ruse, and added to the Toy Programming Language tool repository.
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdint.h>
+#include <stdbool.h>
+
+#include "disassembler_utils.h"
+#include "disassembler.h"
+
+#define SPC(n)  printf("%.*s", n, "| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | |");
+#define EP(x)   [x] = #x
+
+const char *OP_STR[] = {
+        EP(DIS_OP_EOF),                       //
+        EP(DIS_OP_PASS),                      //
+        EP(DIS_OP_ASSERT),                    //
+        EP(DIS_OP_PRINT),                     //
+        EP(DIS_OP_LITERAL),                   //
+        EP(DIS_OP_LITERAL_LONG),              //
+        EP(DIS_OP_LITERAL_RAW),               //
+        EP(DIS_OP_NEGATE),                    //
+        EP(DIS_OP_ADDITION),                  //
+        EP(DIS_OP_SUBTRACTION),               //
+        EP(DIS_OP_MULTIPLICATION),            //
+        EP(DIS_OP_DIVISION),                  //
+        EP(DIS_OP_MODULO),                    //
+        EP(DIS_OP_GROUPING_BEGIN),            //
+        EP(DIS_OP_GROUPING_END),              //
+        EP(DIS_OP_SCOPE_BEGIN),               //
+        EP(DIS_OP_SCOPE_END),                 //
+        EP(DIS_OP_TYPE_DECL_removed),         //
+        EP(DIS_OP_TYPE_DECL_LONG_removed),    //
+        EP(DIS_OP_VAR_DECL),                  //
+        EP(DIS_OP_VAR_DECL_LONG),             //
+        EP(DIS_OP_FN_DECL),                   //
+        EP(DIS_OP_FN_DECL_LONG),              //
+        EP(DIS_OP_VAR_ASSIGN),                //
+        EP(DIS_OP_VAR_ADDITION_ASSIGN),       //
+        EP(DIS_OP_VAR_SUBTRACTION_ASSIGN),    //
+        EP(DIS_OP_VAR_MULTIPLICATION_ASSIGN), //
+        EP(DIS_OP_VAR_DIVISION_ASSIGN),       //
+        EP(DIS_OP_VAR_MODULO_ASSIGN),         //
+        EP(DIS_OP_TYPE_CAST),                 //
+        EP(DIS_OP_TYPE_OF),                   //
+        EP(DIS_OP_IMPORT),                    //
+        EP(DIS_OP_EXPORT_removed),            //
+        EP(DIS_OP_INDEX),                     //
+        EP(DIS_OP_INDEX_ASSIGN),              //
+        EP(DIS_OP_INDEX_ASSIGN_INTERMEDIATE), //
+        EP(DIS_OP_DOT),                       //
+        EP(DIS_OP_COMPARE_EQUAL),             //
+        EP(DIS_OP_COMPARE_NOT_EQUAL),         //
+        EP(DIS_OP_COMPARE_LESS),              //
+        EP(DIS_OP_COMPARE_LESS_EQUAL),        //
+        EP(DIS_OP_COMPARE_GREATER),           //
+        EP(DIS_OP_COMPARE_GREATER_EQUAL),     //
+        EP(DIS_OP_INVERT),                    //
+        EP(DIS_OP_AND),                       //
+        EP(DIS_OP_OR),                        //
+        EP(DIS_OP_JUMP),                      //
+        EP(DIS_OP_IF_FALSE_JUMP),             //
+        EP(DIS_OP_FN_CALL),                   //
+        EP(DIS_OP_FN_RETURN),                 //
+        EP(DIS_OP_POP_STACK),                 //
+        EP(DIS_OP_TERNARY),                   //
+        EP(DIS_OP_FN_END),                    //
+};
+
+const char *LIT_STR[] = {
+        EP(DIS_LITERAL_NULL),                    //
+        EP(DIS_LITERAL_BOOLEAN),                 //
+        EP(DIS_LITERAL_INTEGER),                 //
+        EP(DIS_LITERAL_FLOAT),                   //
+        EP(DIS_LITERAL_STRING),                  //
+        EP(DIS_LITERAL_ARRAY),                   //
+        EP(DIS_LITERAL_DICTIONARY),              //
+        EP(DIS_LITERAL_FUNCTION),                //
+        EP(DIS_LITERAL_IDENTIFIER),              //
+        EP(DIS_LITERAL_TYPE),                    //
+        EP(DIS_LITERAL_OPAQUE),                  //
+        EP(DIS_LITERAL_ANY),                     //
+        EP(DIS_LITERAL_TYPE_INTERMEDIATE),       //
+        EP(DIS_LITERAL_ARRAY_INTERMEDIATE),      //
+        EP(DIS_LITERAL_DICTIONARY_INTERMEDIATE), //
+        EP(DIS_LITERAL_FUNCTION_INTERMEDIATE),   //
+        EP(DIS_LITERAL_FUNCTION_ARG_REST),       //
+        EP(DIS_LITERAL_FUNCTION_NATIVE),         //
+        EP(DIS_LITERAL_FUNCTION_HOOK),           //
+        EP(DIS_LITERAL_INDEX_BLANK),             //
+};
+
+enum DIS_ARG_TYPE {
+    DIS_ARG_NONE,    //
+    DIS_ARG_BYTE,    //
+    DIS_ARG_WORD,    //
+    DIS_ARG_INTEGER, //
+    DIS_ARG_FLOAT,   //
+    DIS_ARG_STRING   //
+};
+
+const uint8_t OP_ARGS[DIS_OP_END_OPCODES][3] = {
+      // |  first arg  | second arg | jump |
+        { DIS_ARG_NONE, DIS_ARG_NONE, false }, // DIS_OP_EOF
+        { DIS_ARG_NONE, DIS_ARG_NONE, false }, // DIS_OP_PASS
+        { DIS_ARG_NONE, DIS_ARG_NONE, false }, // DIS_OP_ASSERT
+        { DIS_ARG_NONE, DIS_ARG_NONE, false }, // DIS_OP_PRINT
+        { DIS_ARG_BYTE, DIS_ARG_NONE, false }, // DIS_OP_LITERAL
+        { DIS_ARG_WORD, DIS_ARG_NONE, false }, // DIS_OP_LITERAL_LONG
+        { DIS_ARG_NONE, DIS_ARG_NONE, false }, // DIS_OP_LITERAL_RAW
+        { DIS_ARG_NONE, DIS_ARG_NONE, false }, // DIS_OP_NEGATE
+        { DIS_ARG_NONE, DIS_ARG_NONE, false }, // DIS_OP_ADDITION
+        { DIS_ARG_NONE, DIS_ARG_NONE, false }, // DIS_OP_SUBTRACTION
+        { DIS_ARG_NONE, DIS_ARG_NONE, false }, // DIS_OP_MULTIPLICATION
+        { DIS_ARG_NONE, DIS_ARG_NONE, false }, // DIS_OP_DIVISION
+        { DIS_ARG_NONE, DIS_ARG_NONE, false }, // DIS_OP_MODULO
+        { DIS_ARG_NONE, DIS_ARG_NONE, false }, // DIS_OP_GROUPING_BEGIN
+        { DIS_ARG_NONE, DIS_ARG_NONE, false }, // DIS_OP_GROUPING_END
+        { DIS_ARG_NONE, DIS_ARG_NONE, false }, // DIS_OP_SCOPE_BEGIN
+        { DIS_ARG_NONE, DIS_ARG_NONE, false }, // DIS_OP_SCOPE_END
+        { DIS_ARG_NONE, DIS_ARG_NONE, false }, // DIS_OP_TYPE_DECL_removed
+        { DIS_ARG_NONE, DIS_ARG_NONE, false }, // DIS_OP_TYPE_DECL_LONG_removed
+        { DIS_ARG_BYTE, DIS_ARG_BYTE, false }, // DIS_OP_VAR_DECL
+        { DIS_ARG_WORD, DIS_ARG_WORD, false }, // DIS_OP_VAR_DECL_LONG
+        { DIS_ARG_BYTE, DIS_ARG_BYTE, false }, // DIS_OP_FN_DECL
+        { DIS_ARG_WORD, DIS_ARG_WORD, false }, // DIS_OP_FN_DECL_LONG
+        { DIS_ARG_NONE, DIS_ARG_NONE, false }, // DIS_OP_VAR_ASSIGN
+        { DIS_ARG_NONE, DIS_ARG_NONE, false }, // DIS_OP_VAR_ADDITION_ASSIGN
+        { DIS_ARG_NONE, DIS_ARG_NONE, false }, // DIS_OP_VAR_SUBTRACTION_ASSIGN
+        { DIS_ARG_NONE, DIS_ARG_NONE, false }, // DIS_OP_VAR_MULTIPLICATION_ASSIGN
+        { DIS_ARG_NONE, DIS_ARG_NONE, false }, // DIS_OP_VAR_DIVISION_ASSIGN
+        { DIS_ARG_NONE, DIS_ARG_NONE, false }, // DIS_OP_VAR_MODULO_ASSIGN
+        { DIS_ARG_NONE, DIS_ARG_NONE, false }, // DIS_OP_TYPE_CAST
+        { DIS_ARG_NONE, DIS_ARG_NONE, false }, // DIS_OP_TYPE_OF
+        { DIS_ARG_NONE, DIS_ARG_NONE, false }, // DIS_OP_IMPORT
+        { DIS_ARG_NONE, DIS_ARG_NONE, false }, // DIS_OP_EXPORT_removed
+        { DIS_ARG_NONE, DIS_ARG_NONE, false }, // DIS_OP_INDEX
+        { DIS_ARG_BYTE, DIS_ARG_NONE, false }, // DIS_OP_INDEX_ASSIGN
+        { DIS_ARG_NONE, DIS_ARG_NONE, false }, // DIS_OP_INDEX_ASSIGN_INTERMEDIATE
+        { DIS_ARG_NONE, DIS_ARG_NONE, false }, // DIS_OP_DOT
+        { DIS_ARG_NONE, DIS_ARG_NONE, false }, // DIS_OP_COMPARE_EQUAL
+        { DIS_ARG_NONE, DIS_ARG_NONE, false }, // DIS_OP_COMPARE_NOT_EQUAL
+        { DIS_ARG_NONE, DIS_ARG_NONE, false }, // DIS_OP_COMPARE_LESS
+        { DIS_ARG_NONE, DIS_ARG_NONE, false }, // DIS_OP_COMPARE_LESS_EQUAL
+        { DIS_ARG_NONE, DIS_ARG_NONE, false }, // DIS_OP_COMPARE_GREATER
+        { DIS_ARG_NONE, DIS_ARG_NONE, false }, // DIS_OP_COMPARE_GREATER_EQUAL
+        { DIS_ARG_NONE, DIS_ARG_NONE, false }, // DIS_OP_INVERT
+        { DIS_ARG_WORD, DIS_ARG_NONE, true  }, // DIS_OP_AND
+        { DIS_ARG_WORD, DIS_ARG_NONE, true  }, // DIS_OP_OR
+        { DIS_ARG_WORD, DIS_ARG_NONE, true  }, // DIS_OP_JUMP
+        { DIS_ARG_WORD, DIS_ARG_NONE, true  }, // DIS_OP_IF_FALSE_JUMP
+        { DIS_ARG_NONE, DIS_ARG_NONE, false }, // DIS_OP_FN_CALL
+        { DIS_ARG_WORD, DIS_ARG_NONE, false }, // DIS_OP_FN_RETURN
+        { DIS_ARG_NONE, DIS_ARG_NONE, false }, // DIS_OP_POP_STACK
+        { DIS_ARG_NONE, DIS_ARG_NONE, false }, // DIS_OP_TERNARY
+};
+
+typedef struct dis_program_s {
+    uint8_t *program;
+    uint32_t len;
+    uint32_t pc;
+} dis_program_t;
+
+typedef struct fun_code_s {
+    uint32_t start;
+    uint32_t len;
+    char *fun;
+} fun_code_t;
+
+typedef struct lit_s {
+    char *fun;
+    char *str;
+} *lit_t;
+
+uint32_t jump_label;
+uint32_t function_queue_len = 0;
+uint32_t lit_fn_queue_len = 0;
+queue_node_t *function_queue_front = NULL;
+queue_node_t *function_queue_rear = NULL;
+queue_node_t *lit_fn_queue_front = NULL;
+queue_node_t *lit_fn_queue_rear = NULL;
+
+static void dis_print_opcode(uint8_t op);
+
+static uint8_t readByte(const uint8_t *tb, uint32_t *count) {
+    uint8_t ret = *(uint8_t*) (tb + *count);
+    *count += 1;
+    return ret;
+}
+
+static uint16_t readWord(const uint8_t *tb, uint32_t *count) {
+    uint16_t ret = 0;
+    memcpy(&ret, tb + *count, 2);
+    *count += 2;
+    return ret;
+}
+
+static int32_t readInt(const uint8_t *tb, uint32_t *count) {
+    int ret = 0;
+    memcpy(&ret, tb + *count, 4);
+    *count += 4;
+    return ret;
+}
+
+static float readFloat(const uint8_t *tb, uint32_t *count) {
+    float ret = 0;
+    memcpy(&ret, tb + *count, 4);
+    *count += 4;
+    return ret;
+}
+
+static char* readString(const uint8_t *tb, uint32_t *count) {
+    const unsigned char *ret = tb + *count;
+    *count += strlen((char*) ret) + 1; //+1 for null character
+    return (char*) ret;
+}
+
+static void consumeByte(uint8_t byte, uint8_t *tb, uint32_t *count) {
+    if (byte != tb[*count]) {
+        printf("[internal] Failed to consume the correct byte (expected %u, found %u)\n", byte, tb[*count]);
+        exit(1);
+    }
+
+    *count += 1;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static void dis_disassembler_init(dis_program_t **prg) {
+    (*prg) = malloc(sizeof(struct dis_program_s));
+    (*prg)->program = NULL;
+    (*prg)->len = 0;
+    (*prg)->pc = 0;
+}
+
+static void dis_disassembler_deinit(dis_program_t **prg) {
+    if((*prg)->program != NULL)
+        free((*prg)->program);
+    free((*prg));
+}
+
+static uint8_t dis_load_file(const char *filename, dis_program_t **prg, bool alt_fmt) {
+    FILE *f;
+    size_t fsize, bytes;
+    uint32_t count = 0;
+    uint8_t buf = 0;
+
+    f = fopen(filename, "r");
+    if (f == NULL) {
+        printf("Not able to open the file.\n");
+        return 1;
+    }
+
+    fseek(f, 0, SEEK_END);
+    fsize = ftell(f);
+    fseek(f, 0, SEEK_SET);
+    (*prg)->program = malloc(fsize * sizeof(uint8_t));
+
+    while ((bytes = fread(&buf, sizeof(uint8_t), 1, f)) == 1)
+        (*prg)->program[count++] = buf;
+
+    (*prg)->len = fsize;
+
+    if (!alt_fmt)
+        printf("\nFile: %s\nSize: %zu\n", filename, fsize);
+    else
+        printf("\n.comment File: %s, Size: %zu\n", filename, fsize);
+
+    fclose(f);
+    return 0;
+}
+
+static void dis_read_header(dis_program_t **prg, bool alt_fmt) {
+    const unsigned char major = readByte((*prg)->program, &((*prg)->pc));
+    const unsigned char minor = readByte((*prg)->program, &((*prg)->pc));
+    const unsigned char patch = readByte((*prg)->program, &((*prg)->pc));
+    const char *build = readString((*prg)->program, &((*prg)->pc));
+
+    if (!alt_fmt)
+        printf("[Header Version: %d.%d.%d (%s)]\n", major, minor, patch, build);
+    else
+        printf(".comment Header Version: %d.%d.%d (%s)\n", major, minor, patch, build);
+}
+
+static void dis_print_opcode(uint8_t op) {
+    if (op == 255) {
+        printf("SECTION_END");
+        return;
+    }
+
+    if (op < DIS_OP_END_OPCODES)
+        printf("%s", (OP_STR[op] + 7));
+    else
+        printf("(OP UNKNOWN [%c])", op);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+#define S_OP(n, p) \
+		switch (OP_ARGS[opcode][n]) { \
+		    case DIS_ARG_NONE: \
+		    break; \
+		    case DIS_ARG_BYTE: \
+		        uint = readByte((*prg)->program, &pc); \
+		        if (p) printf(" b(%d)", uint); \
+		    break; \
+		    case DIS_ARG_WORD: \
+		        uint = readWord((*prg)->program, &pc);\
+		        if (p) printf(" w(%d)", uint); \
+		    break; \
+		    case DIS_ARG_INTEGER: \
+		        intg = readInt((*prg)->program, &pc); \
+		        if (p) printf(" i(%d)", intg); \
+		    break; \
+		    case DIS_ARG_FLOAT: \
+		        flt = readFloat((*prg)->program, &pc); \
+		        if (p) printf(" f(%f)", flt); \
+		    break; \
+		    case DIS_ARG_STRING: \
+		        str = readString((*prg)->program, &pc); \
+		        if (p) printf(" s(%s)", str); \
+		    break; \
+		    default: \
+		        printf("ERROR, unknown argument type\n"); \
+		        exit(1); \
+		}
+
+static void dis_disassemble_section(dis_program_t **prg, uint32_t pc, uint32_t len, uint8_t spaces, bool is_function, options_t config) {
+    uint8_t opcode = 0;
+    uint16_t uint = 0;
+    int32_t intg = 0;
+    float flt = 0;
+    char *str = NULL;
+
+    // first 4 bytes of the program section within a function are actually specifying the parameter and return lists
+    if (is_function) {
+        printf("\n");
+        uint16_t args = readWord((*prg)->program, &pc);
+        uint16_t rets = readWord((*prg)->program, &pc);
+        if (!config.alt_format_flag) {
+            SPC(spaces);
+            printf("| ");
+        } else
+            printf("    .comment args:%d, rets:%d", args, rets);
+    }
+
+    uint32_t pc_start = pc;
+
+    uint32_t labels_qty = 0;
+    uint16_t *label_line = NULL;
+    uint32_t *label_id = NULL;
+    if (config.alt_format_flag) {
+        // first pass: search jump labels
+        label_line = malloc(sizeof(uint16_t));
+        label_id = malloc(sizeof(uint32_t));
+
+        while (pc < len) {
+            label_line = realloc(label_line, (labels_qty + 1) * sizeof(uint16_t));
+            label_id = realloc(label_id, (labels_qty + 1) * sizeof(uint32_t));
+
+            opcode = (*prg)->program[pc];
+            if (config.alt_format_flag && (opcode == 255 || opcode == 0)) {
+                ++pc;
+                continue;
+            }
+
+            if (opcode > DIS_OP_END_OPCODES)
+                continue;
+
+            ++pc;
+
+            S_OP(0, 0);
+
+            if (OP_ARGS[opcode][2]) {
+                label_line[labels_qty] = uint;
+                label_id[labels_qty] = jump_label++;
+                ++labels_qty;
+            }
+
+            S_OP(1, 0);
+        }
+
+        pc = pc_start;
+    }
+
+    while (pc < len) {
+        opcode = (*prg)->program[pc];
+
+        if (config.alt_format_flag) {
+            for (uint32_t lbl = 0; lbl < labels_qty; lbl++) {
+                if (pc - pc_start == label_line[lbl]) {
+                    printf("\nJL_%04d_:", label_id[lbl]);
+                    break;
+                }
+            }
+        }
+
+        if (config.alt_format_flag && (opcode == 255 || opcode == 0)) {
+            ++pc;
+            continue;
+        }
+
+        printf("\n");
+        if (!config.alt_format_flag) {
+            SPC(spaces);
+            printf("| ");
+            printf("[%05d](%03d) ", (pc++) - pc_start, opcode);
+        } else {
+            printf("    ");
+            pc++;
+        }
+
+        dis_print_opcode(opcode);
+
+        if (opcode >= DIS_OP_END_OPCODES)
+            continue;
+
+        if (config.alt_format_flag) {
+            if (OP_ARGS[opcode][2]) {
+                uint = readWord((*prg)->program, &pc);
+                for (uint32_t lbl = 0; lbl < labels_qty; lbl++) {
+                    if (uint == label_line[lbl]) {
+                        printf(" JL_%04d_", label_id[lbl]);
+                        break;
+                    }
+                }
+            } else
+                S_OP(0, 1);
+        } else
+            S_OP(0, 1);
+
+        S_OP(1, 1);
+    }
+
+    if (config.alt_format_flag) {
+        free(label_line);
+        free(label_id);
+    }
+
+    if (config.alt_format_flag && (*prg)->program[pc - 5] != DIS_OP_FN_RETURN)
+        printf("\n    FN_RETURN w(0)");
+}
+
+#define LIT_ADD(a, b, c)  b[c] = a;  ++c;
+static void dis_read_interpreter_sections(dis_program_t **prg, uint32_t *pc, uint8_t spaces, char *tree, options_t config) {
+    uint32_t literal_count = 0;
+    uint8_t literal_type[65536];
+    char *lit_str = NULL;
+
+    const unsigned short literalCount = readWord((*prg)->program, pc);
+
+    if(!config.group_flag)
+        printf("\n");
+
+    if (!config.alt_format_flag) {
+        SPC(spaces);
+        printf("| ");
+        printf("  ");
+        printf("--- ( Reading %d literals from cache ) ---\n", literalCount);
+    }
+
+    if (config.alt_format_flag)
+        lit_str = calloc(1, sizeof(char));
+
+    for (int i = 0; i < literalCount; i++) {
+        const unsigned char literalType = readByte((*prg)->program, pc);
+
+        switch (literalType) {
+            case DIS_LITERAL_NULL:
+                LIT_ADD(DIS_LITERAL_NULL, literal_type, literal_count);
+                if (!config.alt_format_flag) {
+                    SPC(spaces);
+                    printf("| | ");
+                    printf("[%05d] ( null )\n", i);
+                } else {
+                    str_append(&lit_str, "    .lit NULL\n");
+                }
+
+                break;
+
+            case DIS_LITERAL_BOOLEAN: {
+                const bool b = readByte((*prg)->program, pc);
+                LIT_ADD(DIS_LITERAL_BOOLEAN, literal_type, literal_count);
+                if (!config.alt_format_flag) {
+                    SPC(spaces);
+                    printf("| | ");
+                    printf("[%05d] ( boolean %s )\n", i, b ? "true" : "false");
+                } else {
+                    char bs[10];
+                    sprintf(bs, "%s\n", b ? "true" : "false");
+                    str_append(&lit_str, "    .lit BOOLEAN ");
+                    str_append(&lit_str, bs);
+                }
+            }
+                break;
+
+            case DIS_LITERAL_INTEGER: {
+                const int d = readInt((*prg)->program, pc);
+                LIT_ADD(DIS_LITERAL_INTEGER, literal_type, literal_count);
+                if (!config.alt_format_flag) {
+                    SPC(spaces);
+                    printf("| | ");
+                    printf("[%05d] ( integer %d )\n", i, d);
+                } else {
+                    char ds[20];
+                    sprintf(ds, "%d\n", d);
+                    str_append(&lit_str, "    .lit INTEGER ");
+                    str_append(&lit_str, ds);
+                }
+            }
+                break;
+
+            case DIS_LITERAL_FLOAT: {
+                const float f = readFloat((*prg)->program, pc);
+                LIT_ADD(DIS_LITERAL_FLOAT, literal_type, literal_count);
+                if (!config.alt_format_flag) {
+                    SPC(spaces);
+                    printf("| | ");
+                    printf("[%05d] ( float %f )\n", i, f);
+                } else {
+                    char fs[20];
+                    sprintf(fs, "%f\n", f);
+                    str_append(&lit_str, "    .lit FLOAT ");
+                    str_append(&lit_str, fs);
+                }
+            }
+                break;
+
+            case DIS_LITERAL_STRING: {
+                const char *s = readString((*prg)->program, pc);
+                LIT_ADD(DIS_LITERAL_STRING, literal_type, literal_count);
+                if (!config.alt_format_flag) {
+                    SPC(spaces);
+                    printf("| | ");
+                    printf("[%05d] ( string \"%s\" )\n", i, s);
+                } else {
+                    str_append(&lit_str, "    .lit STRING \"");
+                    str_append(&lit_str, s);
+                    str_append(&lit_str, "\"\n");
+                }
+            }
+                break;
+
+            case DIS_LITERAL_ARRAY_INTERMEDIATE:
+            case DIS_LITERAL_ARRAY: {
+                unsigned short length = readWord((*prg)->program, pc);
+                if (!config.alt_format_flag) {
+                    SPC(spaces);
+                    printf("| | ");
+                    printf("[%05d] ( array ", i);
+                } else {
+                    str_append(&lit_str, "    .lit ARRAY ");
+                }
+
+                for (int i = 0; i < length; i++) {
+                    int index = readWord((*prg)->program, pc);
+                    if (!config.alt_format_flag) {
+                        printf("%d ", index);
+                    } else {
+                        char ds[20];
+                        sprintf(ds, "%d ", index);
+                        str_append(&lit_str, ds);
+
+                    }
+                    LIT_ADD(DIS_LITERAL_NULL, literal_type, literal_count);
+                    if (!(i % 15) && i != 0) {
+                        if (!config.alt_format_flag) {
+                            printf("\\\n");
+                            SPC(spaces);
+                            printf("| | ");
+                            printf("           ");
+                        } else {
+                            str_append(&lit_str, "\\\n               ");
+                        }
+                    }
+                }
+                if (!config.alt_format_flag) {
+                    printf(")");
+                    printf("\n");
+                } else {
+                    str_append(&lit_str, "\n");
+                }
+
+                LIT_ADD(DIS_LITERAL_ARRAY, literal_type, literal_count);
+            }
+                break;
+
+            case DIS_LITERAL_DICTIONARY_INTERMEDIATE:
+            case DIS_LITERAL_DICTIONARY: {
+                unsigned short length = readWord((*prg)->program, pc);
+                if (!config.alt_format_flag) {
+                    SPC(spaces);
+                    printf("| | ");
+                    printf("[%05d] ( dictionary ", i);
+                } else {
+                    str_append(&lit_str, "    .lit DICTIONARY ");
+                }
+                for (int i = 0; i < length / 2; i++) {
+                    int key = readWord((*prg)->program, pc);
+                    int val = readWord((*prg)->program, pc);
+
+                    if (!config.alt_format_flag)
+                        printf("(key: %d, val:%d) ", key, val);
+                    else {
+                        char s[100];
+                        sprintf(s, "%d,%d ", key, val);
+                        str_append(&lit_str, s);
+                    }
+
+                    if (!(i % 5) && i != 0) {
+                        if (!config.alt_format_flag) {
+                            printf("\\\n");
+                            SPC(spaces);
+                            printf("| | ");
+                            printf("                ");
+                        } else {
+                            str_append(&lit_str, "\\\n                    ");
+                        }
+                    }
+                }
+                if (!config.alt_format_flag) {
+                    printf(")");
+                    printf("\n");
+                } else {
+                    str_append(&lit_str, "\n");
+                }
+                LIT_ADD(DIS_LITERAL_DICTIONARY, literal_type, literal_count);
+            }
+                break;
+
+            case DIS_LITERAL_FUNCTION: {
+                unsigned short index = readWord((*prg)->program, pc);
+                LIT_ADD(DIS_LITERAL_FUNCTION_INTERMEDIATE, literal_type, literal_count);
+                if (!config.alt_format_flag) {
+                    SPC(spaces);
+                    printf("| | ");
+                    printf("[%05d] ( function index: %d )\n", i, index);
+                } else {
+                    char s[100];
+                    sprintf(s, "    .lit FUNCTION %d\n", index);
+                    str_append(&lit_str, s);
+                }
+            }
+                break;
+
+            case DIS_LITERAL_IDENTIFIER: {
+                const char *str = readString((*prg)->program, pc);
+                LIT_ADD(DIS_LITERAL_IDENTIFIER, literal_type, literal_count);
+                if (!config.alt_format_flag) {
+                    SPC(spaces);
+                    printf("| | ");
+                    printf("[%05d] ( identifier %s )\n", i, str);
+                } else {
+                    str_append(&lit_str, "    .lit IDENTIFIER ");
+                    str_append(&lit_str, str);
+                    str_append(&lit_str, "\n");
+                }
+            }
+                break;
+
+            case DIS_LITERAL_TYPE:
+            case DIS_LITERAL_TYPE_INTERMEDIATE: {
+                uint8_t literalType = readByte((*prg)->program, pc);
+                uint8_t constant = readByte((*prg)->program, pc);
+                if (!config.alt_format_flag) {
+                    SPC(spaces);
+                    printf("| | ");
+                    printf("[%05d] ( type %s: %d)\n", i, (LIT_STR[literalType] + 12), constant);
+                } else {
+                    char s[100];
+                    sprintf(s, "    .lit TYPE %s %d", (LIT_STR[literalType] + 12), constant);
+                    str_append(&lit_str, s);
+                }
+
+                if (literalType == DIS_LITERAL_ARRAY) {
+                    uint16_t vt = readWord((*prg)->program, pc);
+                    if (!config.alt_format_flag) {
+                        SPC(spaces);
+                        printf("| | ");
+                        printf("\n          ( subtype: %d)\n", vt);
+                    } else {
+                        char s[100];
+                        sprintf(s, " SUBTYPE %d\n", vt);
+                        str_append(&lit_str, s);
+                    }
+                } else
+                    if (literalType == DIS_LITERAL_DICTIONARY) {
+                        uint8_t kt = readWord((*prg)->program, pc);
+                        uint8_t vt = readWord((*prg)->program, pc);
+                        if (!config.alt_format_flag) {
+                            SPC(spaces);
+                            printf("| | ");
+                            printf("\n          ( subtype: [%d, %d] )\n\n\n", kt, vt);
+                        } else {
+                            char s[100];
+                            sprintf(s, " SUBTYPE %d,%d\n", kt, vt);
+                            str_append(&lit_str, s);
+                        }
+                    } else {
+                        if (!config.alt_format_flag)
+                            printf("\n");
+                        else
+                            str_append(&lit_str, "\n");
+                    }
+
+                LIT_ADD(literalType, literal_type, literal_count);
+            }
+                break;
+
+            case DIS_LITERAL_INDEX_BLANK:
+                LIT_ADD(DIS_LITERAL_INDEX_BLANK, literal_type, literal_count);
+                if (!config.alt_format_flag) {
+                    SPC(spaces);
+                    printf("| | ");
+                    printf("[%05d] ( blank )\n", i);
+                } else {
+                    str_append(&lit_str, "    .lit BLANK\n");
+                }
+                break;
+        }
+    }
+
+    if (!config.group_flag) {
+        printf(lit_str);
+    } else {
+        lit_t fn_str = (lit_t)(lit_fn_queue_rear->data);
+        fn_str->str = calloc(1, strlen(lit_str) + 1);
+        strcpy(fn_str->str, lit_str);
+    }
+    free(lit_str);
+
+    consumeByte(DIS_OP_SECTION_END, (*prg)->program, pc);
+
+    if (!config.alt_format_flag) {
+        SPC(spaces);
+        printf("| ");
+        printf("--- ( end literal section ) ---\n");
+    }
+
+    int functionCount = readWord((*prg)->program, pc);
+    int functionSize = readWord((*prg)->program, pc);
+
+    if (functionCount) {
+        if (!config.alt_format_flag) {
+            SPC(spaces);
+            printf("|\n");
+            SPC(spaces);
+            printf("| ");
+            printf("--- ( fn count: %d, total size: %d ) ---\n", functionCount, functionSize);
+        }
+
+        uint32_t fcnt = 0;
+        char tree_local[2048];
+
+        for (uint32_t i = 0; i < literal_count; i++) {
+            if (literal_type[i] == DIS_LITERAL_FUNCTION_INTERMEDIATE) {
+                size_t size = (size_t) readWord((*prg)->program, pc);
+
+                uint32_t fpc_start = *pc;
+                uint32_t fpc_end = *pc + size - 1;
+
+                tree_local[0] = '\0';
+                if (!config.alt_format_flag) {
+                    sprintf(tree_local, "%s.%d", tree, fcnt);
+                    if (tree_local[0] == '_')
+                        memcpy(tree_local, tree_local + 1, strlen(tree_local));
+                } else {
+                    sprintf(tree_local, "%s_%d", tree, fcnt);
+                    if (tree_local[0] == '_')
+                        memcpy(tree_local, tree_local + 1, strlen(tree_local));
+                }
+
+                if (!config.alt_format_flag) {
+                    SPC(spaces);
+                    printf("| |\n");
+                    SPC(spaces);
+                    printf("| | ");
+                    printf("( fun %s [ start: %d, end: %d ] )", tree_local, fpc_start, fpc_end);
+                } else {
+                    if (!config.group_flag)
+                        printf("\nLIT_FUN_%s:", tree_local);
+                    else {
+                        lit_t new_lit = malloc(sizeof(struct lit_s));
+                        new_lit->fun = calloc(1, strlen(tree_local) + 1);
+                        strcpy(new_lit->fun, tree_local);
+                        dis_enqueue((void*) new_lit, &lit_fn_queue_front, &lit_fn_queue_rear, &lit_fn_queue_len);
+                    }
+                }
+
+                if ((*prg)->program[*pc + size - 1] != DIS_OP_FN_END) {
+                    printf("\nERROR: Failed to find function end\n");
+                    exit(1);
+                }
+
+                dis_read_interpreter_sections(prg, &fpc_start, spaces + 4, tree_local, config);
+
+                if (!config.alt_format_flag) {
+                    SPC(spaces);
+                    printf("| | |\n");
+                    SPC(spaces + 4);
+                    printf("| ");
+                    printf("--- ( reading code for %s ) ---", tree_local);
+                    dis_disassemble_section(prg, fpc_start, fpc_end, spaces + 4, true, config);
+                    printf("\n");
+                    SPC(spaces + 4);
+                    printf("| ");
+                    printf("--- ( end code section ) ---\n");
+                } else {
+                    fun_code_t *fun = malloc(sizeof(struct fun_code_s));
+                    fun->fun = malloc(strlen(tree_local) + 1);
+                    strcpy(fun->fun, tree_local);
+                    fun->start = fpc_start;
+                    fun->len = fpc_end;
+                    dis_enqueue((void*) fun, &function_queue_front, &function_queue_rear, &function_queue_len);
+                }
+
+                fcnt++;
+                *pc += size;
+            }
+        }
+
+        if (!config.alt_format_flag) {
+            SPC(spaces);
+            printf("|\n");
+            SPC(spaces);
+            printf("| ");
+            printf("--- ( end fn section ) ---\n");
+        }
+    }
+
+    consumeByte(DIS_OP_SECTION_END, (*prg)->program, pc);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void disassemble(const char *filename, options_t config) {
+    dis_program_t *prg;
+
+    jump_label = 0;
+
+    dis_disassembler_init(&prg);
+    if (dis_load_file(filename, &prg, config.alt_format_flag)) {
+        dis_disassembler_deinit(&prg);
+        exit(1);
+    }
+
+    dis_read_header(&prg, config.alt_format_flag);
+
+    printf("\n.start MAIN\n");
+
+    consumeByte(DIS_OP_SECTION_END, prg->program, &(prg->pc));
+
+    if (!config.group_flag) {
+        if (config.alt_format_flag)
+            printf("\nLIT_MAIN:");
+
+        dis_read_interpreter_sections(&prg, &(prg->pc), 0, "", config);
+
+        if (!config.alt_format_flag) {
+            printf("|\n| ");
+            printf("--- ( reading main code ) ---");
+        } else
+            printf("\nMAIN:");
+
+        dis_disassemble_section(&prg, prg->pc, prg->len, 0, false, config);
+
+        if (!config.alt_format_flag) {
+            printf("\n| ");
+            printf("--- ( end main code section ) ---");
+        } else
+            printf("\n");
+
+        if (config.alt_format_flag) {
+            while (function_queue_front != NULL) {
+                fun_code_t *fun = (fun_code_t*) function_queue_front->data;
+                printf("\nFUN_%s:", fun->fun);
+                free(fun->fun);
+
+                dis_disassemble_section(&prg, fun->start, fun->len, 0, true, config);
+
+                dis_dequeue(&function_queue_front, &function_queue_rear, &function_queue_len);
+                printf("\n");
+            }
+        }
+    } else {
+        config.alt_format_flag = true;
+
+        lit_t new_lit = malloc(sizeof(struct lit_s));
+        new_lit->fun = calloc(1, 6 * sizeof(char));
+        strcpy(new_lit->fun, "MAIN");
+        dis_enqueue((void*) new_lit, &lit_fn_queue_front, &lit_fn_queue_rear, &lit_fn_queue_len);
+
+        dis_read_interpreter_sections(&prg, &(prg->pc), 0, "", config);
+        printf("\n");
+
+        while (lit_fn_queue_front != NULL) {
+            lit_t litf = (lit_t) lit_fn_queue_front->data;
+
+            if (!strcmp(litf->fun, "MAIN")) {
+                printf("MAIN:\n");
+                printf("%s", str_replace_substr_all(litf->str, ".lit FUNCTION ", ".lit FUNCTION (code=FUN_) "));
+
+                dis_disassemble_section(&prg, prg->pc, prg->len, 0, false, config);
+                free(litf->fun);
+                free(litf->str);
+                dis_dequeue(&lit_fn_queue_front, &lit_fn_queue_rear, &lit_fn_queue_len);
+                printf("\n\n");
+                continue;
+            }
+
+            printf("FUN_%s:\n", litf->fun);
+            char sbtr[strlen(litf->fun) +  19];
+            sprintf(sbtr, ".lit FUNCTION (code=FUN_%s_) ", litf->fun);
+            printf("%s", str_replace_substr_all(litf->str, ".lit FUNCTION ", sbtr));
+
+            queue_node_t *fqf = function_queue_front;
+            while (fqf != NULL) {
+                fun_code_t *fun = (fun_code_t*) fqf->data;
+                if (!strcmp(fun->fun, litf->fun)) {
+                    dis_disassemble_section(&prg, fun->start, fun->len, 0, true, config);
+                    break;
+                }
+                fqf = fqf->next;
+            }
+
+            free(litf->fun);
+            free(litf->str);
+            dis_dequeue(&lit_fn_queue_front, &lit_fn_queue_rear, &lit_fn_queue_len);
+
+            printf("\n\n");
+        }
+
+        while (function_queue_front != NULL) {
+            free(((fun_code_t*)(function_queue_front->data))->fun);
+            dis_dequeue(&function_queue_front, &function_queue_rear, &function_queue_len);
+        }
+    }
+
+    printf("\n");
+    dis_disassembler_deinit(&prg);
+}
@@ -0,0 +1,133 @@
+/*
+ * disassembler.c
+ *
+ *  Created on: 10 ago. 2023
+ *      Original Author: Emiliano Augusto Gonzalez (egonzalez . hiperion @ gmail . com)
+ *
+ * Further modified by Kayne Ruse, and added to the Toy Programming Language tool repository.
+ */
+
+#ifndef DISASSEMBLER_H_
+#define DISASSEMBLER_H_
+
+typedef struct options_s {
+    bool alt_format_flag;
+    bool group_flag;
+} options_t;
+
+typedef enum DIS_OPCODES {
+    DIS_OP_EOF,                        //
+
+    // do nothing
+    DIS_OP_PASS,                       //
+
+    // basic statements
+    DIS_OP_ASSERT,                     //
+    DIS_OP_PRINT,                      //
+
+    // data
+    DIS_OP_LITERAL,                    //
+    DIS_OP_LITERAL_LONG,               //
+    DIS_OP_LITERAL_RAW,                //
+
+    // arithmetic operators
+    DIS_OP_NEGATE,                     //
+    DIS_OP_ADDITION,                   //
+    DIS_OP_SUBTRACTION,                //
+    DIS_OP_MULTIPLICATION,             //
+    DIS_OP_DIVISION,                   //
+    DIS_OP_MODULO,                     //
+    DIS_OP_GROUPING_BEGIN,             //
+    DIS_OP_GROUPING_END,               //
+
+    // variable stuff
+    DIS_OP_SCOPE_BEGIN,                //
+    DIS_OP_SCOPE_END,                  //
+
+    DIS_OP_TYPE_DECL_removed,          // deprecated
+    DIS_OP_TYPE_DECL_LONG_removed,     // deprecated
+
+    DIS_OP_VAR_DECL,                   //
+    DIS_OP_VAR_DECL_LONG,              //
+
+    DIS_OP_FN_DECL,                    //
+    DIS_OP_FN_DECL_LONG,               //
+
+    DIS_OP_VAR_ASSIGN,                 //
+    DIS_OP_VAR_ADDITION_ASSIGN,        //
+    DIS_OP_VAR_SUBTRACTION_ASSIGN,     //
+    DIS_OP_VAR_MULTIPLICATION_ASSIGN,  //
+    DIS_OP_VAR_DIVISION_ASSIGN,        //
+    DIS_OP_VAR_MODULO_ASSIGN,          //
+
+    DIS_OP_TYPE_CAST,                  //
+    DIS_OP_TYPE_OF,                    //
+
+    DIS_OP_IMPORT,                     //
+    DIS_OP_EXPORT_removed,             // deprecated
+
+    // for indexing
+    DIS_OP_INDEX,                      //
+    DIS_OP_INDEX_ASSIGN,               //
+    DIS_OP_INDEX_ASSIGN_INTERMEDIATE,  //
+    DIS_OP_DOT,                        //
+
+    // comparison of values
+    DIS_OP_COMPARE_EQUAL,              //
+    DIS_OP_COMPARE_NOT_EQUAL,          //
+    DIS_OP_COMPARE_LESS,               //
+    DIS_OP_COMPARE_LESS_EQUAL,         //
+    DIS_OP_COMPARE_GREATER,            //
+    DIS_OP_COMPARE_GREATER_EQUAL,      //
+    DIS_OP_INVERT,                     //
+
+    // logical operators
+    DIS_OP_AND,                        //
+    DIS_OP_OR,                         //
+
+    // jumps, and conditional jumps (absolute)
+    DIS_OP_JUMP,                       //
+    DIS_OP_IF_FALSE_JUMP,              //
+    DIS_OP_FN_CALL,                    //
+    DIS_OP_FN_RETURN,                  //
+
+    // pop the stack at the end of a complex statement
+    DIS_OP_POP_STACK,                  //
+
+    //ternary shorthand
+    DIS_OP_TERNARY,                    //
+
+    //meta
+    DIS_OP_FN_END,                     // different from SECTION_END
+    DIS_OP_END_OPCODES,                // mark for end opcodes list. Not valid opcode
+    DIS_OP_SECTION_END = 255,
+} dis_opcode_t;
+
+typedef enum DIS_LITERAL_TYPE {
+    DIS_LITERAL_NULL,       //
+    DIS_LITERAL_BOOLEAN,    //
+    DIS_LITERAL_INTEGER,    //
+    DIS_LITERAL_FLOAT,      //
+    DIS_LITERAL_STRING,     //
+    DIS_LITERAL_ARRAY,      //
+    DIS_LITERAL_DICTIONARY, //
+    DIS_LITERAL_FUNCTION,   //
+    DIS_LITERAL_IDENTIFIER, //
+    DIS_LITERAL_TYPE,       //
+    DIS_LITERAL_OPAQUE,     //
+    DIS_LITERAL_ANY,        //
+
+    // these are meta-level types - not for general use
+    DIS_LITERAL_TYPE_INTERMEDIATE,       // used to process types in the compiler only
+    DIS_LITERAL_ARRAY_INTERMEDIATE,      // used to process arrays in the compiler only
+    DIS_LITERAL_DICTIONARY_INTERMEDIATE, // used to process dictionaries in the compiler only
+    DIS_LITERAL_FUNCTION_INTERMEDIATE,   // used to process functions in the compiler only
+    DIS_LITERAL_FUNCTION_ARG_REST,       // used to process function rest parameters only
+    DIS_LITERAL_FUNCTION_NATIVE,         // for handling native functions only
+    DIS_LITERAL_FUNCTION_HOOK,           // for handling hook functions within literals only
+    DIS_LITERAL_INDEX_BLANK,             // for blank indexing i.e. arr[:]
+} dis_literal_type_t;
+
+extern void disassemble(const char *filename, options_t config);
+
+#endif /* DISASSEMBLER_H_ */
@@ -0,0 +1,92 @@
+/*
+ * utils.c
+ *
+ *  Created on: 10 ago. 2023
+ *      Original Author: Emiliano Augusto Gonzalez (egonzalez . hiperion @ gmail . com)
+ *
+ * Further modified by Kayne Ruse, and added to the Toy Programming Language tool repository.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "disassembler_utils.h"
+
+void dis_enqueue(void *x, queue_node_t **queue_front, queue_node_t **queue_rear, uint32_t *len) {
+    queue_node_t *temp;
+
+    temp = (queue_node_t*) malloc(sizeof(struct queue_node_s));
+    temp->data = x;
+    temp->next = NULL;
+
+    if ((*queue_front) == NULL && (*queue_rear) == NULL) {
+        (*queue_front) = (*queue_rear) = temp;
+        ++(*len);
+        return;
+    }
+    (*queue_rear)->next = temp;
+    (*queue_rear) = temp;
+
+    ++(*len);
+}
+
+void dis_dequeue(queue_node_t **queue_front, queue_node_t **queue_rear, uint32_t *len) {
+    struct queue_node_s *temp = (*queue_front);
+
+    if ((*queue_front) == NULL) {
+        printf("Error : QUEUE is empty!!");
+        return;
+    }
+    if ((*queue_front) == (*queue_rear))
+        (*queue_front) = (*queue_rear) = NULL;
+
+    else
+        (*queue_front) = (*queue_front)->next;
+
+    --(*len);
+    free(temp->data);
+    free(temp);
+}
+
+///
+
+void str_append(char **str, const char *app) {
+    if ((*str) == NULL)
+        return;
+
+    *str = realloc(*str, (strlen(*str) + strlen(app) + 1) * sizeof(char));
+    memcpy((*str) + strlen(*str), app, strlen(app) + 1);
+}
+
+char* str_replace_substr_all(char *mainstr, char *substr, char *newstr) {
+    int lenmain, lensub, i, j, lennew, startindex = -1, c;
+    lenmain = strlen(mainstr);
+    lensub = strlen(substr);
+    lennew = strlen(newstr);
+    char *result = (char*) malloc(sizeof(char) * (lenmain + 200));
+    for (c = 0, i = 0; i < lenmain; i++) {
+        if (lenmain - i >= lensub && *(mainstr + i) == *(substr)) {
+            startindex = i;
+            for (j = 1; j < lensub; j++)
+                if (*(mainstr + i + j) != *(substr + j)) {
+                    startindex = -1;
+                    break;
+                }
+            if (startindex != -1) {
+                for (j = 0; j < lennew; j++, c++) {
+                    *(result + c) = *(newstr + j);
+                }
+                i = i + lensub - 1;
+            } else {
+                *(result + c) = *(mainstr + i);
+                c++;
+            }
+        } else {
+            *(result + c) = *(mainstr + i);
+            c++;
+        }
+    }
+    *(result + c) = '\0';
+    return result;
+}
@@ -0,0 +1,26 @@
+/*
+ * utils.h
+ *
+ *  Created on: 10 ago. 2023
+ *      Original Author: Emiliano Augusto Gonzalez (egonzalez . hiperion @ gmail . com)
+ *
+ * Further modified by Kayne Ruse, and added to the Toy Programming Language tool repository.
+ */
+
+#ifndef UTILS_H_
+#define UTILS_H_
+
+#include <stdint.h>
+
+typedef struct queue_node_s {
+	void *data;
+	struct queue_node_s *next;
+} queue_node_t;
+
+void dis_enqueue(void *x, queue_node_t **queue_front, queue_node_t **queue_rear, uint32_t *len);
+void dis_dequeue(queue_node_t **queue_front, queue_node_t **queue_rear, uint32_t *len);
+
+void str_append(char **str, const char *app);
+char* str_replace_substr_all(char *mainstr, char *substr, char *newstr);
+
+#endif /* UTILS_H_ */
@@ -0,0 +1,53 @@
+#include <stdlib.h>
+
+#include "cargs.h"
+#include "disassembler.h"
+
+static struct cag_option options[] = {
+        {
+                .identifier = 'a',
+                .access_letters = "a",
+                .access_name = NULL,
+                .value_name = NULL,
+                .description = "Alternate format"
+        }, {
+                .identifier = 'g',
+                .access_letters = "g",
+                .access_name = NULL,
+                .value_name = NULL,
+                .description = "Group literals with functions"
+        }, {
+                .identifier = 'h',
+                .access_letters = "h",
+                .access_name = "help",
+                .description = "Shows the command help"
+        }
+};
+
+int main(int argc, char *argv[]) {
+	char identifier;
+	cag_option_context context;
+	options_t config = { false, false };
+
+	cag_option_prepare(&context, options, CAG_ARRAY_SIZE(options), argc, argv);
+	while (cag_option_fetch(&context)) {
+		identifier = cag_option_get(&context);
+		switch (identifier) {
+		case 'a':
+			config.alt_format_flag = true;
+			break;
+		case 'g':
+		    config.group_flag = true;
+		    config.alt_format_flag = true;
+		    break;
+		case 'h':
+			printf("Usage: disassembler [OPTION] file\n");
+			cag_option_print(options, CAG_ARRAY_SIZE(options), stdout);
+			return EXIT_SUCCESS;
+		}
+	}
+
+	disassemble(argv[context.index], config);
+
+	return EXIT_SUCCESS;
+}
@@ -0,0 +1,27 @@
+CC=gcc
+
+IDIR+=.
+CFLAGS+=$(addprefix -I,$(IDIR)) -g -Wall -W -Wno-unused-parameter -Wno-unused-function -Wno-unused-variable
+LIBS+=
+
+ODIR = obj
+SRC = $(wildcard *.c)
+OBJ = $(addprefix $(ODIR)/,$(SRC:.c=.o))
+OUTDIR=../../out
+OUT=$(OUTDIR)/disassembler
+
+all: $(OBJ)
+	$(CC) $(CFLAGS) -o $(OUT) $(OBJ) $(LIBS)
+
+$(OBJ): | $(ODIR)
+
+$(ODIR):
+	mkdir $(ODIR)
+
+$(ODIR)/%.o: %.c
+	$(CC) -c -o $@ $< $(CFLAGS)
+
+.PHONY: clean
+
+clean:
+	$(RM) -r $(ODIR)
@@ -0,0 +1,73 @@
+//changing of the guard - made for @hyperiondev's microcontrollers
+#include <iostream>
+#include <fstream>
+#include <string>
+#include <algorithm>
+
+std::string convert(std::string str) {
+	str = str.substr(str.find_last_of("\\/")+1);
+	std::transform(str.begin(), str.end(), str.begin(), ::toupper);
+	std::replace(str.begin(), str.end(), '.', '_');
+	return str;
+}
+
+std::string convertToGuardStart(std::string str) {
+	str = convert(str);
+	return "#ifndef " + str + "\n#define " + str + "\n";
+}
+
+std::string convertToGuardEnd(std::string str) {
+	str = convert(str);
+	return "\n#endif //" + str + "\n";
+}
+
+int main(int argc, char** argv) {
+	if (argc <= 1) {
+		return -1;
+	}
+
+	for (int fileCounter = 1; fileCounter < argc; fileCounter++) {
+		std::ifstream is; //input stream
+		std::string buffer; //store output file
+
+		//open
+		is.open(argv[fileCounter]);
+		if (!is.is_open()) {
+			return -1;
+		}
+
+		while (!is.eof()) {
+			std::string top; //I dislike C++
+			getline(is, top);
+
+			//check for pragma guard
+			if (top == "#pragma once") {
+				top = convertToGuardStart(argv[fileCounter]);
+				getline(is, buffer, '\0');
+				buffer += convertToGuardEnd(argv[fileCounter]);
+			}
+			else {
+				top += "\n";
+				getline(is, buffer, '\0');
+			}
+
+			buffer = top + buffer;
+		}
+
+		//finally
+		is.close();
+
+		std::ofstream os;
+
+		os.open(argv[fileCounter]);
+		if (!os.is_open()) {
+			return -1;
+		}
+
+		os << buffer;
+
+		os.close();
+	}
+
+	return 0;
+}
@@ -0,0 +1,105 @@
+//MECHA: Markdown Embedded Comment Heuristic Analyzer
+
+/*!
+# Handy-Dandy *MECHA* Docs!
+
+The following is the source code for MECHA - a tool for reading in source code, and splicing out the markdown embedded within. It can also spit out chunks of code, though that's a bit uglier.
+
+In theory, this should work correctly on all languages that conform to C-style comments, including Toy.
+
+To build it, simply run `g++ -o mecha mecha.cpp`.
+
+To run the result, you must pass in a series of filenames via the command line.
+
+## License
+
+This tool is considered part of Toy's toolchain, so Toy's zlib license should cover it.
+
+## Header Files
+
+If you're reading this as a comment in the source code, this is what I mean by ugly. Thankfully, this section is outputted correctly in markdown.
+
+!*/
+
+//*!```
+#include <iostream>
+#include <fstream>
+#include <string>
+#include <algorithm>
+//!*
+
+/*!```
+
+# Recursive Docs
+
+If you run mecha on it's own source code, it should Just Work, producing a file called mecha_cpp.md
+!*/
+
+int main(int argc, char** argv) {
+	if (argc <= 1) {
+		return -1;
+	}
+
+	for (int fileCounter = 1; fileCounter < argc; fileCounter++) {
+		std::ifstream is; //input stream
+		std::string buffer; //store output file
+
+		//open
+		is.open(argv[fileCounter]);
+		if (!is.is_open()) {
+			return -1;
+		}
+
+		while (!is.eof()) {
+			//skip until correct characters found
+			if (is.get() != '*') {
+				continue;
+			}
+
+			if (is.get() != '!') {
+				continue;
+			}
+
+			//found the start of the block - begin reading markdown content
+			while (!is.eof()) {
+				char c = is.get();
+
+				if (c == '!' && is.peek() == '*') {
+					break;
+				}
+
+				buffer += c;
+			}
+
+			//bugfix
+			if (buffer.length() >= 2 && buffer.substr(buffer.length()-2)  == "//") {
+				buffer.pop_back();
+				buffer.pop_back();
+			}
+		}
+
+		//finally
+		is.close();
+
+		if (buffer.length() == 0) {
+			continue;
+		}
+
+		std::ofstream os;
+		std::string ofname = argv[fileCounter];
+
+		std::replace(ofname.begin(), ofname.end(), '.', '_');
+		ofname += ".md";
+
+		os.open(ofname);
+		if (!os.is_open()) {
+			return -1;
+		}
+
+		os << buffer;
+
+		os.close();
+	}
+
+	return 0;
+}
Author	SHA1	Message	Date
Kayne Ruse	b602e2ff87	Tweaked build trigger	2024-09-22 15:04:27 +10:00
Kayne Ruse	0b99eb7b0c	Bumped patch version	2024-09-22 14:45:04 +10:00
Kayne Ruse	2505cedc79	Update README.md	2024-09-22 14:43:20 +10:00
Kayne Ruse	d7035a59c8	Updated CI	2024-08-11 21:25:11 +10:00
Kayne Ruse	ea584d8950	Fixed the failing build on mingw Squashed commit of the following: commit c48929d25a84331ca8bd1b27be2c6aa4f3b4db12 Author: Kayne Ruse <kayneruse@gmail.com> Date: Fri Aug 9 23:12:49 2024 +1000 Update c-cpp.yml I'm only going a little bit nuts. commit 3f65882bdc75f1712c9a3c9d2ddf0e53a27ce4b9 Author: Kayne Ruse <kayneruse@gmail.com> Date: Fri Aug 9 22:49:18 2024 +1000 Update c-cpp.yml It would be great if this was documented better. commit d3abeda7c2776bb2e82ca635cd659967afa6ad75 Author: Kayne Ruse <kayneruse@gmail.com> Date: Fri Aug 9 21:40:39 2024 +1000 Bumped license date commit 17bbce9d7ca212064bc95e467933c5602a89fb4c Author: Kayne Ruse <kayneruse@gmail.com> Date: Fri Aug 9 21:33:57 2024 +1000 Fixed the failing build on mingw There seems to be persistent issues with different compilers displaying the values of size_t, so I simply cast it to an integer. commit 843a76d0ac44328776f8ecf83a66caa7ea7fdef6 Author: Kayne Ruse <kayneruse@gmail.com> Date: Fri Aug 9 21:17:17 2024 +1000 Updated CI commit 08cd89c58d8d028438b9f83a60f5dd9265cc3465 Author: Kayne Ruse <kayneruse@gmail.com> Date: Fri Aug 9 21:09:03 2024 +1000 Why did that fail last time?	2024-08-09 23:25:56 +10:00
Kayne Ruse	2ce9a0cf42	Fixed an AST bug	2024-07-20 16:27:07 +10:00
Kayne Ruse	b77f0fb50d	Merge pull request #117 from hiperiondev/main Add prefix in function for label code	2023-09-01 23:36:58 +10:00
hiperiondev	edb5a52562	Add prefix in function for label code	2023-08-29 22:41:52 -03:00
Kayne Ruse	9dc9316853	Merge pull request #116 from hiperiondev/main Correct format	2023-08-29 13:07:22 +10:00
hiperiondev	a864a1a226	Correct format	2023-08-28 23:57:46 -03:00
Kayne Ruse	c645026620	Merge pull request #115 from hiperiondev/main Add disassemblre group option	2023-08-29 12:50:56 +10:00
hiperiondev	a9ccd65da1	Add disassemblre group option	2023-08-28 23:46:02 -03:00
Kayne Ruse	0da5201829	Merge pull request #114 from hiperiondev/main Correct disassembler	2023-08-24 21:43:15 +10:00
hiperiondev	6be29ed8c5	Add implicit fn return	2023-08-23 20:48:06 -03:00
hiperiondev	6341d3337f	Correct disassembler	2023-08-23 12:37:28 -03:00
Kayne Ruse	d4f952eafc	Merge pull request #110 from hiperiondev/main Add disassembler alternative format	2023-08-23 22:09:33 +10:00
hiperiondev	d5bc07d3b3	Add header reference	2023-08-23 08:36:27 -03:00
hiperiondev	5a851f6fbe	Rename	2023-08-22 20:35:22 -03:00
hiperiondev	d8c6a3ec27	Correct memory leak	2023-08-22 20:21:43 -03:00
hiperiondev	b5883e248b	Correct format	2023-08-22 19:45:14 -03:00
hiperiondev	52048f2466	Correct literal format	2023-08-22 19:31:06 -03:00
hiperiondev	6b8e95d250	Add disassembler alternative format	2023-08-22 18:23:27 -03:00
Ratstail91	5721edc2d1	Tweaked disassembler pretty printing, because I'm bored	2023-08-22 07:27:36 +10:00
Ratstail91	db52c13613	Removed extra scope around for loop body blocks, resolved #107	2023-08-22 01:11:49 +10:00
Ratstail91	7290efe069	Tweaked valgrind test @add00 you'll want to merge these and test them	2023-08-22 00:43:48 +10:00
Ratstail91	0cf92bdeae	Added contributors to the README, removed a binary that was accidentally committed	2023-08-19 06:53:34 +10:00
Kayne Ruse	4c9a2e5378	Merge pull request #106 from hiperiondev/main Disassembler: Some optimizations	2023-08-15 03:57:29 +10:00
hiperiondev	1e11e9eea7	Start independent code from PC zero. Add hierarchical notation for function index. Add guard for end literals. Some presentation formats.	2023-08-14 14:46:07 -03:00
Kayne Ruse	cce8ae1ea3	Added disassembler, thanks @hiperiondev, bumped minor version	2023-08-14 23:06:05 +10:00
Kayne Ruse	ce54912232	Removed an extra pair of SCOPE_BEGIN and SCOPE_END from function bytecode This should reduce the memory footprint a bit	2023-08-14 22:17:33 +10:00
Kayne Ruse	23b55fc360	Fixed execFnDecl accidentally modifying the literalCache for a moment, resolved #105	2023-08-14 10:47:10 +10:00
Kayne Ruse	62fe86f99b	Fixed indexing in argument lists, resolved #102	2023-08-09 02:25:07 +10:00
Ratstail91	401de578a5	Short circuitable operators are extremely loose	2023-08-06 04:53:46 +10:00
Kayne Ruse	fb4258f9df	Fixed broken test	2023-08-06 04:38:55 +10:00
Ratstail91	f885fdaf4c	Short circuits are now functioning correctly, resolved #73	2023-08-06 04:28:02 +10:00
Kayne Ruse	cfec1b6911	Added int to float coercions to function args and returns, when specified	2023-08-06 02:17:32 +10:00
Kayne Ruse	a63bdaef1c	Merge remote-tracking branch 'refs/remotes/origin/main'	2023-08-04 18:43:32 +10:00
Kayne Ruse	3783c94064	Allow trailing commas when writing a compound	2023-08-04 18:43:07 +10:00
Ratstail91	d292b33184	Tweaked types to stop MSVC complaining	2023-08-04 18:24:54 +10:00
Kayne Ruse	64944c24f6	Snipped some duplicate code, resolved #97	2023-08-04 14:52:01 +10:00
Kayne Ruse	604604e8bc	Two opcodes weren't being used, resolved #98	2023-08-04 14:51:08 +10:00
Kayne Ruse	67e49b7477	Fixed the way an identifier was handled, resolved #99	2023-08-04 14:45:07 +10:00
Kayne Ruse	967963c9d7	Fixed a spelling mistake	2023-08-03 15:22:06 +10:00
Kayne Ruse	9b469e6eb0	Merge pull request #94 from Add00/main Adding a math library to toy	2023-08-03 01:40:19 +10:00
Add00	f8094fa17e	Added hyperbolic and additional comparisons	2023-08-02 11:25:27 -04:00
Add00	8714c56c3e	Implemented feedback	2023-08-02 08:39:50 -04:00
Add00	9faaa311e0	Fixed Memory Leak	2023-08-01 17:50:20 -04:00
Add00	f5ba1181c0	Added arc versions of trigonometric functions	2023-08-01 13:41:55 -04:00
Add00	b06b2d9485	test cases and additional functions	2023-08-01 09:04:37 -04:00
Add00	e3e9ca7ece	Added math library	2023-07-31 23:31:12 -04:00
Add00	81fe278c96	Added partial cos and sine implementations	2023-07-31 19:02:55 -04:00
Add00	027d093e21	Added math constants for pi and e	2023-07-31 13:56:06 -04:00
Add00	2eaf7fc71a	Merge branch 'main' of https://github.com/Add00/Toy	2023-07-31 13:16:01 -04:00
Add00	c43310f316	Code clean up	2023-07-31 13:13:10 -04:00
Add00	6e07c5f2f4	Merge branch 'Ratstail91:main' into main	2023-07-31 13:11:06 -04:00
Ratstail91	7690dce3f6	Fixed casting and grouping	2023-07-31 17:26:07 +10:00
Ratstail91	1ed1993489	Whoops, lets try that again.	2023-07-31 16:55:27 +10:00
Ratstail91	9b5327b83d	Merge bug	2023-07-31 16:22:04 +10:00
Ratstail91	10dbe8f8f1	Fixed casting + grouping, resolved #67	2023-07-31 16:20:45 +10:00
Ratstail91	9e4ad7a9a5	Fixed casting + grouping, resolved #67	2023-07-31 16:17:33 +10:00
Add00	5317a12383	Added radian and degree conversion functions.	2023-07-30 23:17:43 -04:00
Ratstail91	35bfa1b9f1	Tweak, these were annoying me	2023-07-31 12:06:04 +10:00
Kayne Ruse	7f692b4cb4	Renamed the about library to toy_version_info library, resovled #81	2023-07-31 11:15:10 +10:00
Kayne Ruse	0cef0abdb5	Adjusted the layout of nativeClamp() and nativeLerp(), thanks Add00!	2023-07-31 04:51:40 +10:00
Kayne Ruse	6ba42b5a9b	Merge pull request #93 from Add00/main Adding clamp and lerp functions to standard library	2023-07-31 04:12:15 +10:00
Add00	3cb62274c9	Fixed merge issue	2023-07-30 13:21:42 -04:00
Add00	60b561d809	Merge branch 'Ratstail91:main' into main	2023-07-30 13:16:57 -04:00
Add00	70b2dcd829	Added clamp and lerp functions to standard library	2023-07-30 13:15:39 -04:00
Ratstail91	0955b3ff38	Tweak to the MSVC build	2023-07-31 02:04:27 +10:00
Kayne Ruse	4137935468	Added sign() and normalize() to standard lib	2023-07-30 17:46:00 +10:00
Kayne Ruse	ebeabcb9d4	Reordered some functions for clarity, caught a bug or two	2023-07-28 02:42:57 +10:00
Kayne Ruse	4d33a9473a	Added tools/changing-of-the-guard.cpp, resolved #89 A present for @hyperiondev - just run this in the 'includes/' directory. It's easier than changing things by hand.	2023-07-28 01:09:58 +10:00
Kayne Ruse	61e3cdba82	Fixed a potential linker issue	2023-07-26 08:13:05 +10:00
Ratstail91	3b7d2be87e	Discovered and fixed a misplaced macro	2023-07-26 01:44:15 +10:00
Kayne Ruse	fa175203c9	Tweaked docs	2023-07-26 01:08:54 +10:00
Kayne Ruse	b4a3e9b42b	Renamed drive system files, see #88	2023-07-26 00:53:41 +10:00
Kayne Ruse	6347778ead	Moved drive system to repl, resolved #88	2023-07-26 00:46:47 +10:00
Kayne Ruse	ba98624e82	Fixed C-API function name, resolved #87 , thanks @hiperiondev	2023-07-26 00:22:45 +10:00
Ratstail91	24ce965e76	Smoothed out building on Windows	2023-07-23 23:57:48 +10:00
Kayne Ruse	29c130135c	Tweak	2023-07-23 18:34:52 +10:00
Kayne Ruse	01eca37560	Comment tweak	2023-07-22 19:14:33 +10:00
Kayne Ruse	8e5ec7d847	Tweaked docs in repl_tools.h and toy.h	2023-07-22 19:11:45 +10:00
Kayne Ruse	9ed6383630	Wrote tests for the drive system, resolved #75	2023-07-21 05:20:59 +10:00
Kayne Ruse	1ec0f63f76	Removed unneeded safties from the libs I missed removing these before, and I haven't needed these in a long time.	2023-07-21 04:25:36 +10:00
Kayne Ruse	d2341ae227	Bumped version number	2023-07-21 03:08:06 +10:00
Kayne Ruse	3782f2aaaa	Comment tweak	2023-07-21 02:59:07 +10:00
Kayne Ruse	b636ab9e31	Added a new issue template	2023-07-21 02:41:45 +10:00
Kayne Ruse	cdfe17ad53	Added mecha-style comment docs to a bunch of headers	2023-07-20 19:44:40 +10:00
Kayne Ruse	3d7d1179c9	Added mecha tool	2023-07-19 18:09:18 +10:00
Kayne Ruse	c3c46b4fc6	Refactored parseIdentiferToValue(), removed unneeded safties	2023-07-15 00:34:15 +10:00
Kayne Ruse	0e41b00ef4	Fixed a post-fix increment issue, highlighted in the game engine	2023-06-20 13:54:21 +10:00
Kayne Ruse	f6ec6a8c73	The any type is now recognized as a type properly	2023-06-19 23:16:46 +10:00
Kayne Ruse	2157b2f540	Fixed an obscure compiler bug involving assignments and indexing, read more TOY_OP_INDEX_ASSIGN_INTERMEDIATE was being used when it shouldn't have. Now the check runs down the whole binary->right branch to ensure the given node doesn't exist in that tree.	2023-06-15 12:29:25 +10:00
Kayne Ruse	1481216e69	Fixed chained functions, resolved #52	2023-06-14 17:41:30 +10:00
Kayne Ruse	f25f389b4e	Removed a macro that potentially broke the build Gonna have to live with repl code in the lib for now.	2023-06-14 16:53:48 +10:00
Kayne Ruse	deff784df8	Removed a speed test script	2023-06-14 16:40:01 +10:00
Kayne Ruse	54e82846c3	Massive dict copying optimisation, read more I simply pre-allocated the new dict to the right size. This skips internal copying logic which was repeated on every expansion. This Should increase scope copying as well. I applied the same logic to arrays, but the increase in speed was tiny.	2023-06-13 14:49:46 +10:00
Kayne Ruse	67fce427eb	Added an initial sorted test to the sort() function	2023-06-13 08:17:42 +10:00
Kayne Ruse	8a2cb61435	Made quicksort on mostly-sorted arrays more efficient	2023-06-13 07:28:54 +10:00
Ratstail91	50d03e28fc	Fixed MSVC compilation	2023-06-12 00:05:24 +10:00
Kayne Ruse	763581c73b	Added header-only parsing to the repl, read more Also: * Ensured TOY_VERSION_BUILD is consistent throughout the whole build * Updated README.md	2023-06-07 23:55:30 +10:00
Kayne Ruse	cdb2613e5d	Disallowed fn decl in for loop pre clause	2023-06-07 19:20:50 +10:00
Kayne Ruse	733df87c08	Added dist target, lowered recursion depth limit	2023-06-07 14:58:51 +10:00
Kayne Ruse	bfd506f497	Forgot memory allocator for reffunctions	2023-06-07 02:02:35 +10:00
Kayne Ruse	18b59c9e84	Bumped version number	2023-06-07 00:11:34 +10:00
Ratstail91	d3eb31d964	Added TOY_DISABLE_REPL option for compiling	2023-06-07 00:04:05 +10:00
Kayne Ruse	07f4a98b95	Replacing Toy_Literal function bytecode with Toy_RefFunction, addressing #77 This seems to have worked way too easily.	2023-06-06 23:35:59 +10:00
Kayne Ruse	0949fd6ff9	Dang	2023-06-06 21:46:42 +10:00
Kayne Ruse	03e5096f10	Moved test_sum into it's own directory under scripts/	2023-06-06 21:14:05 +10:00
Kayne Ruse	bb81b8c474	Changed recursion limit to 10,000 (was 200)	2023-06-06 21:02:01 +10:00
Kayne Ruse	cf6db57787	Whitespace tweak	2023-03-25 01:43:51 +11:00
Kayne Ruse	17f0e4476b	Caught a bug that the test cases failed to find	2023-03-17 21:58:13 +11:00
Kayne Ruse	1095e1a885	Added type casting a grouping bugfix, resolved #76	2023-03-17 20:57:47 +11:00
Kayne Ruse	2edfbbe3ef	Found a compiler bug, thanks Aedan!	2023-03-17 14:01:16 +11:00
Ratstail91	4b83f1f0d6	Fixed a dumb typo	2023-03-15 06:39:19 +11:00
Kayne Ruse	e2fa1cf2e8	Moved lib_runner's drive system into the core of the lang	2023-03-15 06:12:35 +11:00
Kayne Ruse	a04d2c4816	Tweaked TOY_EXPORT omitting extra repl stuff	2023-03-15 04:56:26 +11:00
Kayne Ruse	f2f8aed23a	Added short-circuiting support to && and \|\|	2023-03-11 17:59:09 +11:00
Kayne Ruse	68ed52b347	Tweaked precedence of binary expressions	2023-03-11 17:47:43 +11:00
Kayne Ruse	88dac53ae0	Added toy.h, thanks for the suggestion GabrielGavrilov! Resolved #72	2023-03-10 08:41:58 +11:00