Tweaked build trigger

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?

.github/FUNDING.yml

@@ -0,0 +1,5 @@
+# These are supported funding model platforms
+
+patreon: krgamestudios
+ko_fi: krgamestudios
+custom: ["https://www.paypal.com/donate/?hosted_button_id=73Q82T2ZHV8AA"]

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,29 @@
+---
+name: Bug Report
+about: Create a report to help us improve
+labels: bug
+---
+
+## Describe the bug
+
+A clear and concise description of what the bug is.
+
+## To Reproduce
+
+Steps to reproduce the behaviour:
+
+1. run `git pull` on the repository
+2. run `make rebuild` on the code
+3. ...
+
+You can include some screenshots here if you'd like!
+
+## Versioning
+
+- OS: [for example MacOS, Windows, iOS, Android]
+- Version: [What version of Toy was this running?]
+
+### Additional context
+
+Add any other context about the problem here.
+

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,17 @@
+---
+name: Feature Request
+about: Suggest an idea
+labels: enhancement
+---
+
+### Describe the feature you’d like
+
+A clear and concise description of what you’d like to be able to do with Toy.
+
+### Describe alternatives you've considered
+
+A clear and concise description of any alternative solutions or workarounds you've considered.
+
+### Additional context
+
+Add any other context about the feature request here.

.github/ISSUE_TEMPLATE/question.md

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

.github/workflows/continuous-integration-v1.yml

@@ -0,0 +1,43 @@
+name: Continuous Integration v1.x
+
+#trigger when these occur
+on:
+  push:
+    branches:
+      - v1
+  pull_request:
+    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@v4
+    - name: install valgrind
+      run: sudo apt install valgrind
+    - name: make test (valgrind)
+      run: make test
+  
+  test-sanitized:
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v4
+    - name: make test (sanitized)
+      run: make test-sanitized
+  
+  test-mingw32:
+    runs-on: windows-latest
+    
+    steps:
+      - uses: actions/checkout@v4
+      - name: make test (mingw32)
+        run: make test

.github/workflows/pages-deploy.yml

@@ -1,46 +0,0 @@
-name: Deploy from the mirror
-
-on:
-  # Runs on pushes targeting the docs branch
-  push:
-    branches: ["mirror"]
-  
-  # Allows you to run this workflow manually from the Actions tab
-  workflow_dispatch:
-
-# Sets permissions of the GITHUB_TOKEN to allow deployment to GitHub Pages
-permissions:
-  contents: read
-  pages: write
-  id-token: write
-
-concurrency:
-  group: "pages"
-  cancel-in-progress: false
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-      - name: Setup Pages
-        uses: actions/configure-pages@v5
-      - name: Build with Jekyll
-        uses: actions/jekyll-build-pages@v1
-        with:
-          source: ./
-          destination: ./_site
-      - name: Upload artifact
-        uses: actions/upload-pages-artifact@v3
-
-  deploy:
-    environment:
-      name: github-pages
-      url: ${{ steps.deployment.outputs.page_url }}
-    runs-on: ubuntu-latest
-    needs: build
-    steps:
-      - name: Deploy to GitHub Pages
-        id: deployment
-        uses: actions/deploy-pages@v4

.github/workflows/pages-mirror.yml

@@ -1,28 +0,0 @@
-name: Send to the pages mirror
-
-on:
-  push:
-    branches: ["v1-docs"]
-  workflow_dispatch:
-
-jobs:
-  mirror:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - name: Unshallow the actions repo
-        run: git fetch --unshallow origin ${{ github.ref_name }}
-      - name: Making secret key file
-        run: touch ~/mirror_secret
-      - name: Protecting secret key file
-        run: chmod 600 ~/mirror_secret
-      - name: Writing key to secret key file
-        run: echo '${{ secrets.MIRROR_SECRET }}' >> ~/mirror_secret
-      - name: Tweaking git to use the secret key file
-        run: git config --add --local core.sshCommand 'ssh -i ~/mirror_secret'
-      - name: Adding git remote
-        run: git remote add mirror ${{ secrets.MIRROR_ADDRESS }}
-      - name: Renaming git branch
-        run: git branch -m mirror
-      - name: Pushing to git remote
-        run: git push -f mirror

.gitignore

@@ -0,0 +1,59 @@
+# Prerequisites
+*.d
+
+# Object files
+*.o
+*.ko
+*.obj
+*.elf
+
+# 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/

CNAME

@@ -1 +0,0 @@
-toylang.com

LICENSE.md

@@ -0,0 +1,13 @@
+# License
+
+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.
+
+Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+
+3. This notice may not be removed or altered from any source distribution.

README.md

@@ -0,0 +1,86 @@
+<p align="center">
+  <image src="toylogo.png" />
+</p>
+
+# 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.
+
+# 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 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
+
+## Building
+
+For Windows(mingw32 & cygwin), Linux and MacOS, simply run `make` in the root directory.
+
+For Windows(MSVC), Visual Studio project files are included.
+
+Note: MacOS and Windows(MSVC) are not officially supported, but we'll do our best!
+
+## Tools
+
+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
+
+```
+import standard; //for a bunch of utility functions
+
+print "Hello world"; //"print" is a keyword
+
+var msg = "foobar"; //declare a variable like this
+
+assert true, "This message won't be seen"; //assert is another keyword
+
+//-------------------------
+
+fn makeCounter() { //declare a function like this
+	var total: int = 0; //declare a variable with a type like this
+
+	fn counter(): int { //declare a return type like this
+		return ++total;
+	}
+
+	return counter; //closures are explicitly supported
+}
+
+var tally = makeCounter();
+
+print tally(); //1
+print tally(); //2
+print tally(); //3
+```
+
+# License
+
+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.

Repl.vcxproj

@@ -0,0 +1,159 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <VCProjectVersion>17.0</VCProjectVersion>
+    <ProjectGuid>{97F823E5-3AB8-47EF-B142-C15DD7CADF76}</ProjectGuid>
+    <Keyword>Win32Proj</Keyword>
+    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v143</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v143</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v143</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v143</PlatformToolset>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="Shared">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <LinkIncremental>true</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <LinkIncremental>true</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <IgnoreImportLibrary>false</IgnoreImportLibrary>
+    <OutDir>$(SolutionDir)out\</OutDir>
+    <IntDir>$(Platform)\$(Configuration)\$(ProjectName)\</IntDir>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <OutDir>$(SolutionDir)out\</OutDir>
+    <IntDir>$(Platform)\$(Configuration)\$(ProjectName)\</IntDir>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
+      <WarningLevel>Level3</WarningLevel>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <Optimization>Disabled</Optimization>
+    </ClCompile>
+    <Link>
+      <TargetMachine>MachineX86</TargetMachine>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <SubSystem>Console</SubSystem>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+      <WarningLevel>Level3</WarningLevel>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+    </ClCompile>
+    <Link>
+      <TargetMachine>MachineX86</TargetMachine>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <SubSystem>Console</SubSystem>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <Link>
+      <AdditionalDependencies>Toy.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalLibraryDirectories>$(SolutionDir)out</AdditionalLibraryDirectories>
+    </Link>
+    <ClCompile>
+      <AdditionalIncludeDirectories>$(SolutionDir)/source;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <LanguageStandard_C>stdc17</LanguageStandard_C>
+      <PreprocessorDefinitions>%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <LanguageStandard_C>stdc17</LanguageStandard_C>
+      <PreprocessorDefinitions>%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>$(SolutionDir)/source;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <AdditionalLibraryDirectories>$(SolutionDir)out</AdditionalLibraryDirectories>
+      <AdditionalDependencies>Toy.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <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>
+</Project>

Toy.vcxproj

@@ -0,0 +1,184 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <VCProjectVersion>17.0</VCProjectVersion>
+    <ProjectGuid>{26360002-CC2A-469A-9B28-BA0C1AF41657}</ProjectGuid>
+    <Keyword>Win32Proj</Keyword>
+    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v143</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v143</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v143</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v143</PlatformToolset>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="Shared">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <LinkIncremental>true</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <LinkIncremental>true</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <OutDir>$(SolutionDir)out\</OutDir>
+    <IntDir>$(Platform)\$(Configuration)\$(ProjectName)\</IntDir>
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <OutDir>$(SolutionDir)out\</OutDir>
+    <IntDir>$(Platform)\$(Configuration)\$(ProjectName)\</IntDir>
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_WINDOWS;_USRDLL;TOY_EXPORTS;TOY_EXPORT;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
+      <WarningLevel>Level3</WarningLevel>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <Optimization>Disabled</Optimization>
+    </ClCompile>
+    <Link>
+      <TargetMachine>MachineX86</TargetMachine>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <SubSystem>Windows</SubSystem>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;_USRDLL;TOY_EXPORTS;TOY_EXPORT;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+      <WarningLevel>Level3</WarningLevel>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+    </ClCompile>
+    <Link>
+      <TargetMachine>MachineX86</TargetMachine>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <SubSystem>Windows</SubSystem>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile>
+      <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" />
+    <ClCompile Include="source\toy_builtin.c" />
+    <ClCompile Include="source\toy_common.c" />
+    <ClCompile Include="source\toy_compiler.c" />
+    <ClCompile Include="source\toy_interpreter.c" />
+    <ClCompile Include="source\toy_keyword_types.c" />
+    <ClCompile Include="source\toy_lexer.c" />
+    <ClCompile Include="source\toy_literal.c" />
+    <ClCompile Include="source\toy_literal_array.c" />
+    <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" />
+    <ClInclude Include="source\toy_compiler.h" />
+    <ClInclude Include="source\toy_console_colors.h" />
+    <ClInclude Include="source\toy_interpreter.h" />
+    <ClInclude Include="source\toy_keyword_types.h" />
+    <ClInclude Include="source\toy_lexer.h" />
+    <ClInclude Include="source\toy_literal.h" />
+    <ClInclude Include="source\toy_literal_array.h" />
+    <ClInclude Include="source\toy_literal_dictionary.h" />
+    <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" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>

Toylang.sln

@@ -0,0 +1,44 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 17
+VisualStudioVersion = 17.4.33213.308
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Toy", "Toy.vcxproj", "{26360002-CC2A-469A-9B28-BA0C1AF41657}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Repl", "Repl.vcxproj", "{97F823E5-3AB8-47EF-B142-C15DD7CADF76}"
+	ProjectSection(ProjectDependencies) = postProject
+		{26360002-CC2A-469A-9B28-BA0C1AF41657} = {26360002-CC2A-469A-9B28-BA0C1AF41657}
+	EndProjectSection
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|x64 = Debug|x64
+		Debug|x86 = Debug|x86
+		Release|x64 = Release|x64
+		Release|x86 = Release|x86
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{26360002-CC2A-469A-9B28-BA0C1AF41657}.Debug|x64.ActiveCfg = Debug|x64
+		{26360002-CC2A-469A-9B28-BA0C1AF41657}.Debug|x64.Build.0 = Debug|x64
+		{26360002-CC2A-469A-9B28-BA0C1AF41657}.Debug|x86.ActiveCfg = Debug|Win32
+		{26360002-CC2A-469A-9B28-BA0C1AF41657}.Debug|x86.Build.0 = Debug|Win32
+		{26360002-CC2A-469A-9B28-BA0C1AF41657}.Release|x64.ActiveCfg = Release|x64
+		{26360002-CC2A-469A-9B28-BA0C1AF41657}.Release|x64.Build.0 = Release|x64
+		{26360002-CC2A-469A-9B28-BA0C1AF41657}.Release|x86.ActiveCfg = Release|Win32
+		{26360002-CC2A-469A-9B28-BA0C1AF41657}.Release|x86.Build.0 = Release|Win32
+		{97F823E5-3AB8-47EF-B142-C15DD7CADF76}.Debug|x64.ActiveCfg = Debug|x64
+		{97F823E5-3AB8-47EF-B142-C15DD7CADF76}.Debug|x64.Build.0 = Debug|x64
+		{97F823E5-3AB8-47EF-B142-C15DD7CADF76}.Debug|x86.ActiveCfg = Debug|Win32
+		{97F823E5-3AB8-47EF-B142-C15DD7CADF76}.Debug|x86.Build.0 = Debug|Win32
+		{97F823E5-3AB8-47EF-B142-C15DD7CADF76}.Release|x64.ActiveCfg = Release|x64
+		{97F823E5-3AB8-47EF-B142-C15DD7CADF76}.Release|x64.Build.0 = Release|x64
+		{97F823E5-3AB8-47EF-B142-C15DD7CADF76}.Release|x86.ActiveCfg = Release|Win32
+		{97F823E5-3AB8-47EF-B142-C15DD7CADF76}.Release|x86.Build.0 = Release|Win32
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {7089F1AD-8EC0-4F27-AFD1-5FD43D91AABC}
+	EndGlobalSection
+EndGlobal

_config.yml

@@ -1,4 +0,0 @@
-remote_theme: pages-themes/slate@v0.2.0
-plugins:
-- jekyll-remote-theme # add this line to the plugins list if you already have one
-

_includes/head-custom.html

@@ -1,32 +0,0 @@
-<title>Toy | A Toy Programming Langauge</title>
-<meta name="description" content="A Toy Programming Language" />
-<meta name="author" content="Kayne Ruse, Ratstail91" />
-<meta name="keywords" content="programming,coding" />
-
-<meta property="og:url" content="https://toylang.com" />
-<meta property="og:type" content="website" />
-<meta property="og:image" content="https://toylang.com/repo-preview.png" />
-<meta property="og:title" content="Toy | A Toy Programming Language" />
-<meta property="og:description" content="A Toy Programming Language" />
-
-<meta property="twitter:card" content="summary_large_image" />
-<meta property="twitter:url" content="https://toylang.com" />
-<meta property="twitter:type" content="website" />
-<meta property="twitter:image" content="https://toylang.com/repo-preview.png" />
-<meta property="twitter:title" content="Toy | A Toy Programming Language" />
-<meta property="twitter:description" content="A Toy Programming Language" />
-
-<!-- Google tag (gtag.js) -->
-<script async src="https://www.googletagmanager.com/gtag/js?id=G-57STKDE8LE"></script>
-<script>
-	  window.dataLayer = window.dataLayer || [];
-	    function gtag(){dataLayer.push(arguments);}
-	    gtag('js', new Date());
-
-	    gtag('config', 'G-57STKDE8LE');
-</script>
-
-<!-- tweak for markdown layouts -->
-<style>
-	* {tab-size: 4;}
-</style>

_layouts/default.html

@@ -1,51 +0,0 @@
-<!DOCTYPE html>
-<html lang="{{ site.lang | default: "en-US" }}">
-
-  <head>
-    <meta charset='utf-8'>
-    <meta http-equiv="X-UA-Compatible" content="IE=edge">
-    <meta name="viewport" content="width=device-width,maximum-scale=2">
-    <link rel="stylesheet" type="text/css" media="screen" href="{{ '/assets/css/style.css?v=' | append: site.github.build_revision | relative_url }}">
-
-    {% include head-custom.html %}
-  </head>
-
-  <body>
-
-    <!-- HEADER -->
-    <div id="header_wrap" class="outer">
-        <header class="inner">
-          {% if site.github.is_project_page %}
-            <a id="forkme_banner" href="{{ site.github.repository_url }}">View on GitHub</a>
-          {% endif %}
-
-          <a rel="canonical" href="https://toylang.com/"><h1 id="project_title">{{ site.title | default: site.github.repository_name }}</h1></a>
-          <h2 id="project_tagline">{{ site.description | default: site.github.project_tagline }}</h2>
-
-          {% if site.show_downloads %}
-            <section id="downloads">
-              <a class="zip_download_link" href="{{ site.github.zip_url }}">Download this project as a .zip file</a>
-              <a class="tar_download_link" href="{{ site.github.tar_url }}">Download this project as a tar.gz file</a>
-            </section>
-          {% endif %}
-        </header>
-    </div>
-
-    <!-- MAIN CONTENT -->
-    <div id="main_content_wrap" class="outer">
-      <section id="main_content" class="inner" style="max-width: 840px;">
-        {{ content }}
-      </section>
-    </div>
-
-    <!-- FOOTER  -->
-    <div id="footer_wrap" class="outer">
-      <footer class="inner">
-        {% if site.github.is_project_page %}
-        <p class="copyright">{{ site.title | default: site.github.repository_name }} maintained by <a href="{{ site.github.owner_url }}">{{ site.github.owner_name }}</a></p>
-        {% endif %}
-        <p>Published with <a href="https://pages.github.com">GitHub Pages</a></p>
-      </footer>
-    </div>
-  </body>
-</html>

browserconfig.xml

@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<browserconfig>
-    <msapplication>
-        <tile>
-            <square150x150logo src="/mstile-150x150.png"/>
-            <TileColor>#da532c</TileColor>
-        </tile>
-    </msapplication>
-</browserconfig>

c-api/toy_common_h.md

@@ -1,37 +0,0 @@
-
-
-# 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
-
-### TOY_API
-
-This definition of this macro is platform-dependant, and used to enable cross-platform compilation of shared and static libraries.
-
-### 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 its own version.
-
-This value MUST fit into an unsigned char.
-
-### 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.
-
-### TOY_VERSION_PATCH
-
-The current patch version of Toy. This value is embedded into the bytecode.
-
-This value MUST fit into an unsigned char.
-
-### 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 additional information about forks of the Toy codebase.

c-api/toy_literal_h.md

@@ -1,184 +0,0 @@
-
-
-# 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.
-
-## 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.
-
-## 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)`
-
-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)`
-
-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 parentheses
-* `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
-
-## More Defined Macros
-
-The following macros are utilities used throughout Toy's internals, and are available for the user as well.
-
-### TOY_IS_TRUTHY(x)
-
-Returns true if 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 nor false.
-
-### TOY_AS_FUNCTION_BYTECODE_LENGTH(lit)
-
-Returns the length of a Toy function's bytecode.
-
-This macro is only valid on `TOY_LITERAL_FUNCTION`.
-
-### 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.
-
-### 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`.
-
-### 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 its parent.
-
-This macro is only valid on `TOY_LITERAL_TYPE`, for both `type` and `subtype`.
-
-### TOY_GET_OPAQUE_TAG(o)
-
-Returns the value of the opaque `o`'s tag.
-
-This macro is only valid on `TOY_LITERAL_OPAQUE`.
-
-## Defined Functions
-
-### 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_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.
-
-### 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 coerced 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.
-
-### 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.
-
-### void Toy_printLiteral(Toy_Literal literal)
-
-This wraps a call to `Toy_printLiteralCustom`, with a printf-stdout wrapper as `printFn`.
-
-### 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.
-
-### bool Toy_private_isTruthy(Toy_Literal x)
-
-Utilized by the `TOY_IS_TRUTHY` macro.
-
-Private functions are not intended for general use.
-
-### bool Toy_private_toIdentifierLiteral(Toy_RefString* ptr)
-
-Utilized by the `TOY_TO_IDENTIFIER_LITERAL` macro.
-
-Private functions are not intended for general use.
-
-### 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.

deep-dive/building-toy.md

@@ -1,32 +0,0 @@
-
-# Building Toy
-
-This tutorial assumes you're using git, GCC, and make.
-
-To embed toy into your program, simply clone the [git repository](https://github.com/Ratstail91/Toy).
-
-Toy's makefile uses the exported variable `TOY_OUTDIR` to define where the output of the build command will place the result. If you're building Toy as a submodule (which is recommended), then you MUST set this value to a directory name, relative to the root directory.
-
-```make
-export TOY_OUTDIR = out
-```
-
-Next, you'll want to run make the from within Toy's `source`, assuming the output directory has been created. There are two options for building Toy - `library` (default) or `static`; the former will create a shared library (and a .dll file on Windows), while the latter will create a static library.
-
-```make
-toy: $(OUTDIR)
-	$(MAKE) -C Toy/source
-
-$(OUTDIR):
-	mkdir $(OUTDIR)
-```
-
-Finally, link against the outputted library, with the source directory as the location of the header files.
-
-```make
-all: $(OBJ) toy
-	$(CC) $(CFLAGS) -o $(OUT) $(OBJ) -L$(TOY_OUTDIR) -ltoy
-```
-
-These snippets of makefile are only an example - the repository has a more fully featured set of makefiles which can also produce a usable REPL program.
-

deep-dive/compiling-toy.md

@@ -1,97 +0,0 @@
-
-# Compiling Toy
-
-This tutorial is a subsection of [Embedding Toy](deep-dive/embedding-toy) that has been spun off into its own page for the sake of brevity/sanity. It's recommended that you read the main article first.
-
-The exact phases outlined here are entirely implementation-dependent - that is, they aren't required, and are simply how the canonical implementation of Toy works.
-
-## How the Compilation works
-
-There are four main phases to running a Toy source file. These are:
-
-```
-lexing -> parsing -> compiling -> interpreting
-```
-
-Each phase has a dedicated set of functions and structures, as well as intermediate structures between these that carry information.
-
-```
-source   -> lexer       -> token
-token    -> parser      -> AST
-AST      -> compiler    -> bytecode
-bytecode -> interpreter -> result
-```
-
-## Lexer
-
-Exactly how the source code is loaded into a C-string is left up to the user, however once it's loaded, it can be bound to a `Toy_Lexer` structure.
-
-```c
-Toy_Lexer lexer;
-Toy_initLexer(&lexer, source);
-```
-
-The lexer, when invoked, will break down the string of characters into individual `Tokens`.
-
-The lexer does not need to be freed after use, however the source code does.
-
-## Parser
-
-The `Toy_Parser` structure takes a `Toy_Lexer` as an argument when initialized.
-
-```c
-Toy_Parser parser; 
-Toy_initParser(&parser, &lexer);
-
-Toy_ASTNode* node = Toy_scanParser(&parser);
-
-Toy_freeParser(&parser);
-```
-
-The parser pumps the lexer for tokens, one at a time, and converts them into structures called Abstract Syntax Trees (or ASTs for short). Each AST represents a single top-level statement within the Toy script. You'll know when the parser is finished with the lexer's source when `Toy_scanParser()` begins returning `NULL` pointers.
-
-The AST Nodes produced by `Toy_scanParser()` must be freed manually, and the parser itself should not be used again.
-
-## Compiler
-
-The actual compilation phase has two steps - instruction writing and collation.
-
-```c
-size_t size;
-Toy_Compiler compiler;
-
-Toy_initCompiler(&compiler);
-Toy_writeCompiler(&compiler, node); //node is an Toy_ASTNode
-
-unsigned char* tb = Toy_collateCompiler(&compiler, &size);
-
-Toy_freeCompiler(&compiler);
-```
-
-The writing step is the process in which AST nodes are compressed into bytecode instructions, while literal values are extracted and placed aside in a cache (usually in a compressed, intermediate state).
-
-The collation phase, however, is when the bytecode instructions, along with the now flattened intermediate literals and function bodies are combined. The bytecode header specified in [Developing Toy](deep-dive/developing-toy) is placed at the beginning of this blob of bytes during this step.
-
-The Toy bytecode (abbreviated to `tb`), along with the `size` variable indicating the size of the bytecode, are the result of the compilation. This bytecode can be saved into a file for later consumption by the host at runtime - you must ensure that any bytecode files have the `.tb` extension.
-
-Alternatively, the bytecode in memory can be passed directly to the interpreter.
-
-## Interpreter
-
-The interpreter acts based on the contents of the bytecode given to it.
-
-```c
-Toy_Interpreter interpreter;
-Toy_initInterpreter(&interpreter);
-Toy_runInterpreter(&interpreter, tb, size);
-Toy_freeInterpreter(&interpreter);
-```
-
-Exactly how it accomplishes this task is implementation dependant - as long as the results match expectations.
-
-## REPL
-
-An example program, called `toyrepl`, is provided alongside Toy's core. This program can handle many things, such as loading, compiling and executing Toy scripts; it's capable of compiling any valid Toy program for later use, even those that rely on non-standard libraries. It also has a number of commonly needed libraries provided.
-
-To get a list of options, run `toyrepl -h`.
-

deep-dive/developing-toy.md

@@ -1,300 +0,0 @@
-# Developing Toy
-
-Here you'll find some of the implementation details.
-
-# Bytecode
-
-The output of Toy's compiler, and the input of the interpreter, is known as "bytecode". Here, I've attempted to fully document the layout of the canonical bytecode's structure, but since this was written after most of this was implemented, there may be small discrepancies present.
-
-There are four main sections of the bytecode:
-
-* Header
-* Literal Cache
-* Function Definitions
-* Program Definition
-
-## Bytecode Header Format
-
-Note: The bytecode header format must not change.
-
-This section is used to define what version of Toy is currently running, as well as to prevent any version/fork clashes.
-
-The header consists of four values:
-
-* TOY_VERSION_MAJOR
-* TOY_VERSION_MINOR
-* TOY_VERSION_PATCH
-* TOY_VERSION_BUILD
-
-The first three are single unsigned bytes, embedded at the beginning of the bytecode in sequence. These represent the major, minor and patch versions of the language. The fourth value is a null-terminated c-string of unspecified data, which is *intended* but not required to specify the time that the language's compiler was itself compiled. The build string can hold arbitrary data, such as the current maintainer's name, current fork of the language, or other versioning info.
-
-There are some strict rules when interpreting these values (mimicking, but not conforming to [semver.org](https://semver.org/)):
-
-* Under no circumstance, should you ever run bytecode whose major version is different - there are definitely broken APIs involved.
-* Under no circumstance, should you ever run bytecode whose minor version is above the interpreter's minor version - the bytecode could potentially use unimplemented features.
-* You may, at your own risk, attempt to run bytecode whose patch version is different.
-* You may, at your own risk, attempt to run bytecode whose build version is different.
-
-All interpreter implementations retain the right to reject any bytecode whose header data does not conform to the above specification.
-
-The latest version information can be found in [toy_common.h](https://github.com/Ratstail91/Toy/blob/main/source/toy_common.h)
-
-## Literal Cache
-
-In Toy, a "Literal" is a value of some kind, be it an integer, or a dictionary, or even a variable name. Rather than embedding the same literal (potentially) many times within the bytecode, the "Literal Cache" was devised to act as an immutable, indexable repository of any literals needed. When bytecode is first loaded into the interpreter, the first thing that happens (after the header is parsed) is the reconstruction of the literal cache. The internal function `readInterpreterSections()` is responsible for this step.
-
-The first `unsigned short` to be read from this section is `literalCount`, which defines the number of literals which are to be read. Once all literals have been read out of this section, the opcode `TOY_OP_SECTION_END` is expected to be consumed. Some preprocessor macros can also enable or disable debug printing functionality within the REPL.
-
-The list of valid literal types are:
-
-
-### TOY_LITERAL_NULL
-
-This literal is simply inserted into the literal cache when encountered.
-
-### TOY_LITERAL_BOOLEAN
-
-This literal specifies that the next byte is its value, either true or false.
-
-### TOY_LITERAL_INTEGER
-
-This literal specifies that the next 4 bytes are its value, interpreted as a 32-bit integer.
-
-### TOY_LITERAL_FLOAT
-
-This literal specifies that the next 4 bytes are its value, interpreted as a 32-bit floating point integer.
-
-### TOY_LITERAL_STRING
-
-This literal specifies that the next collection of null terminated bytes are its value, interpreted as a null-terminated string.
-
-### TOY_LITERAL_ARRAY_INTERMEDIATE
-
-`TOY_LITERAL_ARRAY_INTERMEDIATE` specifies that the literal to be read is a flattened `LiteralArray`. A "flattened" compound literal does not actually store its contents, only references to its contents' positions within the literal cache.
-
-To read this array, you must first read an `unsigned short` which specifies the size, then read that many additional `unsigned shorts`, which are indices. Finally, the original `LiteralArray` can be reconstructed using those indices, in order.
-
-As the final step, the newly reconstructed `LiteralArray` is added to the literal cache.
-
-### TOY_LITERAL_DICTIONARY_INTERMEDIATE
-
-`TOY_LITERAL_DICTIONARY_INTERMEDIATE` specifies that the literal to be read is a flattened `LiteralDictionary`. A "flattened" compound literal does not actually store its contents, only references to its contents' positions within the literal cache.
-
-To read this dictionary, you must first read an `unsigned short` which specifies the size (both keys and values), then read that many additional `unsigned shorts`, which are indices of keys and values. Finally, the original `LiteralDictionary` can be reconstructed using those key and value indices.
-
-As the final step, the newly reconstructed `LiteralDictionary` is added to the literal cache.
-
-### TOY_LITERAL_FUNCTION
-
-When a `TOY_LITERAL_FUNCTION` is encountered, the next `unsigned short` to be read (the function index) should be converted into an integer literal, before having its type manually changed to `TOY_LITERAL_FUNCTION_INTERMEDIATE` for storage within the literal cache.
-
-Functions will be processed properly in a later step - so this literal is added to the cache as a placeholder until that point.
-
-### TOY_LITERAL_IDENTIFIER
-
-This literal specifies that the next collection of null terminated bytes are its value, interpreted as a null-terminated string.
-
-### TOY_LITERAL_TYPE
-
-This literal specifies that the next byte is the type of a literal, and the following byte is a boolean specifying const-ness.
-
-(This literal type may be integrated with `TOY_LITERAL_TYPE_INTERMEDIATE` at some point.)
-
-### TOY_LITERAL_TYPE_INTERMEDIATE
-
-This literal specifies that the next byte is the type of a literal, and the following byte is a boolean specifying const-ness.
-
-Then, if the type is `TOY_LITERAL_ARRAY`, the following `unsigned short` is an index within the cache, representing the type of the contents.
-
-Otherwise, if the type is `TOY_LITERAL_DICTIONARY`, the following two `unsigned short`s are indices within the cache, representing the types of the keys and values.
-
-### TOY_LITERAL_INDEX_BLANK
-
-This literal is simply inserted into the literal cache when encountered.
-
-## Function Definitions
-
-The second stage of `readInterpreterSections()` is used to read the third section of the given bytecode - the function definitions.
-
-The first `unsigned short` is the number of functions present within this section. The second `unsigned short` is the length of this entire section (this one is not necessarily needed, and may be removed at some point).
-
-For each `TOY_LITERAL_FUNCTION_INTERMEDIATE` within the cache, you must read an `unsigned short` as the size. Then, the following `size` block of bytecode is to be copied, wholesale, into the specified cached literal, before setting that literal's type to `TOY_LITERAL_FUNCTION`. While the function is not operational yet, it will be further processed when needed.
-
-Once all function literals have been read out of this section, the opcode `TOY_OP_SECTION_END` is expected to be consumed.
-
-## Program Definition
-
-TODO
-
-### Opcodes
-
-TODO: finish these
-
-|Toy_Opcode|Value|Description|
-|---|---|---|
-|TOY_OP_EOF|0|End of File signal. Used internally as an OK signal.|
-|TOY_OP_PASS|1|Does nothing - a no-op.|
-|TOY_OP_ASSERT|2|Pops `rhs`, `lhs`\* from the stack. `rhs` must be a string, identifiers are not accepted. If `lhs` is `null` or `false`, prints `rhs` to the assert output, and cancels the script.|
-|TOY_OP_PRINT|3|Pops one\* literal from the stack, and prints it to the print output.|
-|TOY_OP_LITERAL|4|Read one byte as an index; retrieve the given index's literal from the cache, and push it to the stack.|
-|TOY_OP_LITERAL_LONG|5|Same as `TOY_OP_LITERAL`, except you read two bytes at a time.|
-|TOY_OP_LITERAL_RAW|6|Pops one literal from the stack. If it's an identifier, explicitly replace it with it's value. Push the literal to the stack.|
-|TOY_OP_NEGATE|7|Pops one\* literal from the stack. If it's an integer or float\*\*, push the negative value to the stack.|
-|TOY_OP_ADDITION|8|Pops `rhs`\*, `lhs`\* from the stack. If both are strings, attempts to concatenate them, and push the result to the stack\*\*. Otherwise, will attempt\*\* to add `lhs` to `rhs` (coercing integers to floats if needed), and push the result to the stack.|
-|TOY_OP_SUBTRACTION|9|Pops `rhs`\*, `lhs`\* from the stack. Attempts\*\* to subtract `rhs` from `lhs` (coercing integers to floats if needed), and push the result to the stack.|
-|TOY_OP_MULTIPLICATION|10|Pops `rhs`\*, `lhs`\* from the stack. Attempts\*\* to multiply `lhs` by `rhs` (coercing integers to floats if needed), and push the result to the stack.|
-|TOY_OP_DIVISION|11|Pops `rhs`\*, `lhs`\* from the stack. Attempts\*\* to divide `lhs` by `rhs` (coercing integers to floats if needed), and push the result to the stack.|
-|TOY_OP_MODULO|12|Pops `rhs`\*, `lhs`\* from the stack. Attempts\*\* to modulo `lhs` by `rhs`, and push the result to the stack.|
-|TOY_OP_GROUPING_BEGIN|13|Begin operating on a group; analagous to the `(` operator.|
-|TOY_OP_GROUPING_END|14|Finish operating on a group; analagous to the `)` operator.|
-|TOY_OP_SCOPE_BEGIN|15|Push an inner-scope onto the stack; analogous to the `{` operator.|
-|TOY_OP_SCOPE_END|16|Push an inner-scope off of the stack; analogous to the `}` operator.|
-|TOY_OP_TYPE_DECL|17|Not used.|
-|TOY_OP_TYPE_DECL_LONG|18|Not used.|
-|TOY_OP_VAR_DECL|19|Read one byte, retrieving that literal from the cache as `identifier`, and then read the next byte, retrieving that literal from the cache as `type`. Attempt\*\* to declare a variable with `identifier` as its name and `type` as its type, then pop the top of the stack\* as it's value (cooerce integer values to floats if `type` specifies a float).|
-|TOY_OP_VAR_DECL_LONG|20|Same as `TOY_OP_VAR_DECL`, except you read two bytes at a time.|
-|TOY_OP_FN_DECL|21|Read one byte, retrieving that literal from the cache as `identifier`, and then read the next byte, retrieving that literal from the cache as `function`. Attempt\*\* to declare a variable with `identifier` as its name and `fn const` as it's type, then set `function` as its value. The function's scope has the current scope as its ancestor.|
-|TOY_OP_FN_DECL_LONG|22|Same as `TOY_OP_FN_DECL`, except you read two bytes at a time.|
-|TOY_OP_VAR_ASSIGN|23|Pops `rhs`*, `lhs` from the stack. `lhs` must be an identifier. Attempts\*\* to store the value of `rhs`, with `lhs` as it's identifier.|
-|TOY_OP_VAR_ADDITION_ASSIGN|24|Equivilent of `TOY_OP_ADDITION` followed by `TOY_OP_VAR_ASSIGN`.|
-|TOY_OP_VAR_SUBTRACTION_ASSIGN|25|Equivilent of `TOY_OP_SUBTRACTION` followed by `TOY_OP_VAR_ASSIGN`.|
-|TOY_OP_VAR_MULTIPLICATION_ASSIGN|26|Equivilent of `TOY_OP_MULTIPLICATION` followed by `TOY_OP_VAR_ASSIGN`.|
-|TOY_OP_VAR_DIVISION_ASSIGN|27|Equivilent of `TOY_OP_DIVISION` followed by `TOY_OP_VAR_ASSIGN`.|
-|TOY_OP_VAR_MODULO_ASSIGN|28|Equivilent of `TOY_OP_MODULO` followed by `TOY_OP_VAR_ASSIGN`.|
-|TOY_OP_TYPE_CAST|29|Pops `val`\*, `type`\* from the stack. Attempts** to change the type of `val` to `type`, and push the result to the stack. Only works on `bool`, `int`, `float` and `string` types, and only if the value is in the correct format.|
-|TOY_OP_TYPE_OF|30|Pops `rhs` from the stack. If `rhs` is an identifier, it determines the the type of the variable specified, otherwise it determines the type of `rhs` directly. The result is pushed to the stack.|
-|TOY_OP_IMPORT|31|Pops `alias` and `identifier` from the stack. Attempts\*\* to invoke a hook specified by `identifier`, with the given `alias`.|
-|TOY_OP_EXPORT_removed|32|Removed.|
-|TOY_OP_INDEX|33|Pops `third`\*, `second`\*, `first`\* and `compound`\* from the stack. Pushes the value specified by `compound[first : second : third]` onto the stack.
-|TOY_OP_INDEX_ASSIGN|34|Pops `assign`\*, `third`\*, `second`\*, `first`\* and `compound`\* from the stack. Sets the value specified by `compound[first : second : third]` to be `assign`.|
-|TOY_OP_INDEX_ASSIGN_INTERMEDIATE|35|Due to the unfortunately bonkers nature of indexing, this is needed as part of `TOY_OP_INDEX_ASSIGN`. It acts the same as `TOY_OP_INDEX`, but leaves an additional copy of some variables on the stack for `TOY_OP_INDEX_ASSIGN` to process.
-|TOY_OP_DOT|36|
-|TOY_OP_COMPARE_EQUAL|37|
-|TOY_OP_COMPARE_NOT_EQUAL|38|
-|TOY_OP_COMPARE_LESS|39|
-|TOY_OP_COMPARE_LESS_EQUAL|40|
-|TOY_OP_COMPARE_GREATER|41|
-|TOY_OP_COMPARE_GREATER_EQUAL|42|
-|TOY_OP_INVERT|43|
-|TOY_OP_AND|44|
-|TOY_OP_OR|45|
-|TOY_OP_JUMP|46|
-|TOY_OP_IF_FALSE_JUMP|47|
-|TOY_OP_FN_CALL|48|
-|TOY_OP_FN_RETURN|49|
-|TOY_OP_POP_STACK|50|
-|TOY_OP_TERNARY|51|
-|TOY_OP_FN_END|52|
-|TOY_OP_SECTION_END|255|
-|TOY_OP_PREFIX|256|Used internally.|
-|TOY_OP_POSTFIX|257|Used internally.|
-
-
-\*If this literal is an identifier, it is instead replaced with the correct given value from the current scope.  
-\*\*On failure, the script will print an error message to the error output and exit.  
-
-## Function Internal Structure
-
-TODO: loose first argument, args & returns counters in the program space
-
-# Parser Structure and Operations
-
-TODO
-
-# Compiler Structure and Operations
-
-TODO
-
-# Interpreter Structure and Operations
-
-The Toy interpreter is, at it's core, just a big loop that reads bytes from memory and acts on them. Here, I'll break down exactly how it works, from a top-down perspective.
-
-## Running the Interpreter
-
-There are four main functions for running the interpreter:
-
-* `Toy_initInterpreter`
-* `Toy_runInterpreter`
-* `Toy_resetInterpreter`
-* `Toy_freeInterpreter`
-
-First, `init` zeroes out the interpreter, sets up the printing functions, and delegates to `reset`, which in turn sets up the program's scope (and injects the default global functions). The initialization function is split into two this way so that `reset` can be used independently on a "dirty" interpreter to ready it for another script (or another run of the same script). `reset` is usually not needed and may be removed in future.
-
-`free` simply frees the interpreter after execution.
-
-Interestingly, `run` doesn't jump straight into execution. Instead, it first does its own bit of setup, before reading out the bytecode's header. If the header indicates an incompatible version, then the interpreter will refuse to run, to prevent mistakes from ruining the program.
-
-`run` will also delegate to a function called `readInterpreterSections()`, which reads and reconstructs the "literalCache" - a collection of all values within the program (variable identifiers, variable values, function bytecode, etc.)
-
-Next, `run` will pass to a function called `execInterpreter()`, which contains the program's loop.
-
-Finally, `run` will automatically free the bytecode and associated literalCache (this may change at some point).
-
-## Executing the Interpreter
-
-Opcodes within the bytecode are 1 byte in length, and specify a single action to take. Each possible action is defined within the interpreter in a function that begins with `exec`, and are called from within a big looping switch statement. If any of these `exec` functions encounters an error, they can simply return false to break the loop.
-
-The interpreter is stack-based; most, if not all, the actions are preformed on literals within a specially designated array called `stack`. For example:
-
-```c
-	case TOY_OP_PRINT:
-		if (!execPrint(interpreter)) {
-			return;
-		}
-	break;
-```
-
-When the opcode `TOY_OP_PRINT` is encountered, the top literal within the stack is popped off, and printed (more info on literals below).
-
-```c
-static bool execPrint(Toy_Interpreter* interpreter) {
-	//get the top literal
-	Toy_Literal lit = Toy_popLiteralArray(&interpreter->stack);
-
-	//if the top literal is an identifier, get it's value
-	Toy_Literal idn = lit;
-	if (TOY_IS_IDENTIFIER(lit) && Toy_parseIdentifierToValue(interpreter, &lit)) {
-		Toy_freeLiteral(idn);
-	}
-
-	//print as a string to the current print method
-	Toy_printLiteralCustom(lit, interpreter->printOutput);
-
-	//free the literal
-	Toy_freeLiteral(lit);
-
-	//continue the loop
-	return true;
-}
-```
-
-## Identity Crisis
-
-As in most programming languages, variables can be represented by names specified by the programmer; in Toy, these are called "identifiers". These identifiers can be passed around in place of their actual values, but can't be used directly. To retrieve a value, you must first "parse" it, like so:
-
-```c
-Toy_Literal idn = literal; //cache the literal, just in case it's an identifier
-if (TOY_IS_IDENTIFIER(literal) && Toy_parseIdentifierToValue(interpreter, &literal)) { //if it is an identifier, parse it...
-	Toy_freeLiteral(idn); //always remember to free the original identifier, otherwise you'll have a memory leak!
-}
-```
-
-You will often see this pattern throughout the codebase.
-
-## Other Utility Functions
-
-Other functions are available at the top of the interpreter source file:
-
-* printing utilities
-* injection utilities
-* parsing utilities
-* bytecode utilities
-* function utilities (these are at the very bottom of the source file)
-
-# Literals
-
-TODO
-
-# Arrays & Dictionaries
-
-TODO

deep-dive/embedding-toy.md

@@ -1,120 +0,0 @@
-
-# Embedding Toy
-
-This tutorial assumes that you've managed to embed Toy into your program by following the tutorial [Building Toy](deep-dive/building-toy).
-
-Here, we'll look at some ways in which you can utilize Toy's C API within your host program.
-
-Be aware that when you create a new Literal object, you must call `Toy_freeLiteral()` on it afterwards! If you don't, your program will leak memory as Toy has no internal tracker for such things.
-
-## Embedded API Macros
-
-The functions intended for usage by the API are prepended with the C macro `TOY_API`. The exact value of this macro can vary by platform, or even be empty. In addition, the macros defined in [literal.h](https://github.com/Ratstail91/Toy/blob/main/source/toy_literal.h) are available for use when manipulating literals. These include:
-
-* `TOY_IS_*` - check if a literal is a specific type
-* `TOY_AS_*` - cast the literal to a specific type
-* `TOY_TO_*_LITERAL` - create a literal of a specific type
-* `TOY_IS_TRUTHY` - check if a literal is truthy
-* `TOY_MAX_STRING_LENGTH` - the maximum length of a string in Toy (can be altered if needed)
-
-## Structures Used Throughout Toy
-
-The main unit of data within Toy's internals is `Toy_Literal`, which can contain any value that can exist within the Toy language - even identifiers. The exact implementation of `Toy_Literal` may change or evolve as time goes on, so it's recommended that you only interact with literals directly by using the macros and functions outlined [above](#embedded-api-macros). See the [types](getting-started/types) page for information on exactly what data types exist in Toy.
-
-There are two main "compound structures" used within Toy's internals - the `Toy_LiteralArray` and `Toy_LiteralDictionary`. The former is an array of `Toy_Literal` instances stored sequentially in memory for fast lookups, while the latter is a key-value hashmap designed for efficient lookups based on a `Toy_Literal` key. These are both accessible via the language as well.
-
-These compound structures hold **copies** of literals given to them, rather than taking ownership of existing literals.
-
-## Compiling Toy Scripts
-
-Please see [Compiling Toy](deep-dive/compiling-toy) for more information on the process of turning scripts into bytecode.
-
-## Interpreting Toy
-
-The `Toy_Interpreter` structure is the beating heart of Toy - You'll usually only need one interpreter, as it can be reset as needed.
-
-The four basic functions are used as follows:
-
-```c
-//assume "tb" and "size" are the results of compilation
-Toy_Interpreter interpreter;
-
-Toy_initInterpreter(&interpreter);
-Toy_runInterpreter(&interpreter, tb, size);
-Toy_resetInterpreter(&interpreter); //You usually want to reset between runs with the same interpreter
-Toy_freeInterpreter(&interpreter);
-```
-
-In addition to this, you might also wish to "inject" a series of usable libraries into the interpreter, which can be `import`-ed within the language itself. This process only needs to be done once, after initialization, but before the first run.
-
-```c
-Toy_injectNativeHook(&interpreter, "standard", Toy_hookStandard);
-```
-
-A "hook" is a callback function which is invoked when the given library is imported. `standard` is the most commonly used library available.
-
-```
-import standard;
-```
-
-Hooks can simply inject native functions into the current scope, or they can do other, more esoteric things (though this is not recommended).
-
-```c
-//a utility structure for storing the native C functions
-typedef struct Natives {
-	char* name;
-	Toy_NativeFn fn;
-} Natives;
-
-int Toy_hookStandard(Toy_Interpreter* interpreter, Toy_Literal identifier, Toy_Literal alias) {
-	//the list of available native C functions that can be called from Toy
-	Natives natives[] = {
-		{"clock", nativeClock},
-		{NULL, NULL}
-	};
-
-	//inject each native C functions into the current scope
-	for (int i = 0; natives[i].name; i++) {
-		Toy_injectNativeFn(interpreter, natives[i].name, natives[i].fn);
-	}
-
-	return 0;
-}
-```
-
-## Calling Toy from C
-
-In some situations, you may find it convenient to call a function written in Toy from the host program. For this, a pair of utility functions have been provided:
-
-```c
-TOY_API bool Toy_callLiteralFn(Toy_Interpreter* interpreter, Toy_Literal func, Toy_LiteralArray* arguments, Toy_LiteralArray* returns);
-TOY_API bool Toy_callFn	   (Toy_Interpreter* interpreter, char* name,	   Toy_LiteralArray* arguments, Toy_LiteralArray* returns);
-```
-
-The first argument must be an interpreter. The third argument is a pointer to a `Toy_LiteralArray` containing a list of arguments to pass to the function, and the fourth is a pointer to a `Toy_LiteralArray` where the return values can be stored (an array is used here for a potential future feature). The contents of the argument array are consumed and left in an indeterminate state (but is safe to free), while the returns array always has one value - if the function did not return a value, then it contains a `null` literal.
-
-The second arguments to these functions are either the function to be called as a `Toy_Literal`, or the name of the function within the interpreter's scope. The latter API simply finds the specified `Toy_Literal` if it exists and calls the former. As with most APIs, these return `false` if something went wrong.
-
-## Memory Allocation
-
-Depending on your platform of choice, you may want to alter how the memory is allocated within Toy. You can do this with the simple memory API:
-
-```c
-//signature returns the new pointer to be used
-typedef void* (*Toy_MemoryAllocatorFn)(void* pointer, size_t oldSize, size_t newSize);
-TOY_API void Toy_setMemoryAllocator(Toy_MemoryAllocatorFn);
-```
-
-Pass it a function which matches the above signature, and it'll be callable via the following macros:
-
-* `TOY_ALLOCATE(type, count)`
-* `TOY_FREE(type, pointer)`
-* `TOY_GROW_ARRAY(type, pointer, oldCount, newCount)`
-* `TOY_SHRINK_ARRAY(type, pointer, oldCount, newCount)`
-* `TOY_FREE_ARRAY(type, pointer, oldCount)`
-
-Also, the following macros are provided to calculate the ideal array capacities (the latter of which is for rapidly growing structures):
-
-* `TOY_GROW_CAPACITY(capacity)`
-* `TOY_GROW_CAPACITY_FAST(capacity)`
-

deep-dive/roadmapping-toy.md

@@ -1,30 +0,0 @@
-
-# Roadmapping Toy
-
-## Game And Game Engine
-
-The Toy programming language was designed from the beginning as though it was supposed to be embedded into an imaginary game engine. Development on said engine and an associated game have proceeded smoothly so far.
-
-## Microprocessor Support
-
-A fork of the language intended to run on microprocessors is currently under development by 3rd parties. Support and advice will be provided to them where needed.
-
-## Nice To Have Features
-
-Potential future additions include:
-
-* A threading library
-* A timer library
-* More random generation libraries (numbers, perlin noise, wave function collapse?)
-* Multiple return values from functions
-* Interpolated strings
-
-Some of these have always been planned, but were sidelined or are incomplete for one reason or another.
-
-## Nope Features
-
-Some things that simply will not be added in the foreseeable future are:
-
-* Classes & Structures
-* Do-while loops
-

deep-dive/testing-toy.md

@@ -1,5 +0,0 @@
-# Testing Toy
-
-Toy uses GitHub CI/CD for comprehensive automated testing - however, all the tests are under `test/`, and can be executed by running `make test`. Doing so on Linux will attempt to use valgrind; to disable using valgrind, pass in `DISABLE_VALGRIND=true` as an environment variable. GitHub CI also has access to the option `make test-sanitized` which attempts to use memory sanitation.
-
-The tests consist of a number of different situations and edge cases that have been discovered, and should probably be thoroughly tested one way or another. There are also several "-bugfix.toy" scripts that explicitly test a bug that has been encountered in one way or another to prevent regressions. The libs that are stored in `repl/` are also tested - their tests are under `/tests/scripts/lib`; some error cases are also checked by the mustfail tests in `/test/scripts/mustfail`.

deep-dive/theorizing-toy.md

@@ -1,23 +0,0 @@
-# Theorizing Toy
-
-Sooner or later, every coder will try to create their own programming language. In my case, it took me over a decade and a half to realize that was even an option, but once I did, I read through a fantastic book called [Crafting Interpreters](https://craftinginterpreters.com/). This sent me down the rabbit hole, so to speak.
-
-The main driving idea behind the Toy programming language has remained the same from the very beginning - I wanted a scripting language that could be embedded into a larger host program to allow for easy modification by the end user. Specifically, I wanted to enable easy modding of video games made in an imaginary game engine.
-
-At the time of writing, I've started working on said engine, building it around Toy, and adjusting Toy to fit the engine as needed. I've also begun working on a game within that engine, as I believe the best way to build an engine is to build a game with it first. The engine has been dubbed "Box", and the game is called "Skylands".
-
-But this post isn't about the engine; it's about Toy - I want to explain, in some detail, my thought processes when developing it. Let's start at the beginning.
-
-```toy
-print "Hello world";
-```
-
-I've drawn the `print` keyword from Crafting Interpreter's Lox language, for much the same reason as explained in the book - it's a simple and easy way to debug issues. You'll be able to print out any kind of value or variable from this statement - but it loses some context, like function implementations and the values of `opaque` literals.
-
-Let's touch on variables quickly. There's about a dozen variable types that can be used, depending on how you count them. They include `bool`, `int`, `float`, `string` and a couple of compound types - but strict typing in Toy is completely optional (`any` is used by default). There are also functions, which are reusable chunks of code, and a pretty standard set of operators with their traditional precedences.
-
-One way in which Toy stands out is the bytecode compilation step. Before execution, the source code must be compiled into an intermediate bytecode format (a trait also inherited from Lox) before it can be executed by the interpreter. The exact specifications of the bytecode formatting are not currently documented (yet). The intermediate bytecode stage and the independence of the interpreter from the compiler also allow unique features, such as the possibility of operating on a microcontroller.
-
-One major native feature that is missing from Toy is an input system, such as from stdin. Instead, Toy is intended to receive its instructions from the host program, including any input needed. One such example would be a game controller library - something that takes in button presses and calls certain Toy functions to move a character around the game world. Toy is almost infinitely extensible via the C API's hook injection system.
-
-I would like to keep the core language nice and simple, as much as possible - something you can explain with just the quick-start page. However, feedback and criticism are always welcome.

game-engine/box-version-info-library.md

@@ -1,35 +0,0 @@
-
-# Box Version Info Library
-
-The box_version_info library simply provides version info about the current build of Box.
-
-The box_version_info library can usually be accessed with the `import` keyword:
-
-```
-import box_version_info;
-import box_version_info as box_version_info; //can be aliased
-```
-
-## Defined Variables
-
-### major
-
-This variable is the major version number of `Box` at the time of compilation.
-
-### minor
-
-This variable is the minor version number of `Box` at the time of compilation.
-
-### patch
-
-This variable is the patch version number of `Box` at the time of compilation.
-
-### build
-
-This variable is a string representing the date and time that the engine was compiled.
-
-### author
-
-This variable contains the name of `Box`'s lead author, and his game studio.
-
-

game-engine/game-engine.md

@@ -1,117 +0,0 @@
-
-# Preface
-
-The game engine is incomplete and still evolving, as such this page should be considered outdated at all times...
-
-# Game Engine
-
-The Toy programming language was designed from the beginning as an embedded scripting language for some kind of game engine. Different iterations have existed with different implementations, some of which could charitably be said to function. The current version, and the most stable and feature-complete so far, has reached a point where it needs some kind of concrete engine to improve any further.
-
-Currently, the engine exists within its own repository, which can be found here:
-
-[https://github.com/Ratstail91/Box](https://github.com/Ratstail91/Box)
-
-## Engine Structure
-
-The engine's APIs depend heavily on Toy's drive system, so that must be initialized at the beginning of the `main()` function.
-
-The engine proper is invoked with just three lifecycle functions`:
-
-```c
-#include "box_engine.h"
-
-int main(int argc, char* argv[]) {
-	//initialize the drive system
-	Toy_initDriveSystem();
-	Toy_setDrivePath("scripts", "assets/scripts");
-
-	//invoke the engine
-	Box_initEngine("scripts:/init.toy"); //passing in the specified init file
-	Box_execEngine();
-	Box_freeEngine();
-
-	//clean up the drive system when you're done
-	Toy_freeDriveSystem();
-
-	return 0;
-}
-
-```
-
-The engine proper holds the following elements:
-
-* SDL2 video and audio elements
-* Frame rate controls
-* Toy interpreter
-* Input keyboard mapping dictionaries
-* The root node
-
-Video and audio in the game engine are handled by SDL2 and SDL2_mixer - this allows for the game to, in theory, be built on multiple platforms. For the time being, however, we're just targeting Windows due to a lack of testing machines.
-
-The engine is calibrated to run at 60 FPS - if the "simulation time" falls too far behind the real time, then frame rendering is skipped in favour of speeding up the game logic. Likewise, if the simulation time runs too fast, then the simulation step is skipped instead and an extra frame is drawn. This process can lead to multiple skips in a row, in both directions.
-
-The engine's interpreter is the core of the scripting system. Other interpreters may be generated and cleared during Toy's internal processes, but this one lasts for the duration of the program.
-
-The keyboard inputs can be remapped using API functions - these mappings are stored and accessed within a pair of Toy dictionaries that have simply been embedded directly into the engine for easy access.
-
-The nodes form a deep tree-like structure, with the "root node" at it's base.
-
-## Node Structure
-
-The fundamental building block of the engine's logic is the node structure - nodes can represent anything within the game world, from entities to abstract global systems. You can think of entities as having a 1:1 mapping to Toy scripts, as each one is given bytecode on initialization that populates its internals (external libraries like the runner library are still possible).
-
-A node holds the following elements:
-
-* A reference to it's parent
-* An array of references to its children, and bookkeeping variables for tracking them
-* A dictionary of functions defined in the Toy script
-* A single SDL texture reference, and controls for rendering it (including as an animated sprite sheet)
-* Position, motion and scale values
-
-The nodes are deeply integrated with Toy scripts, while Toy was written specifically for this purpose. The tree-like structure of the nodes all exist entirely within the computer's heap memory as a result of Toy's memory model - this comes with performance drawbacks and clean up requirements. Child nodes should never be referenced directly, as they may be `NULL` references that have been released, but not yet pruned.
-
-The rules of execution for scripts and functions is as follows:
-
-* The script is executed during node initialization
-* All functions (regardless of name) are stored within the node - effectively preserving the scope of the script as a whole
-* These functions can now be invoked from elsewhere in the program
-* Certain function names (listed below) are invoked at specific times during the game loop throughout the entire node tree
-* If the specially named functions do not exist, the node is simply skipped
-* Every function, which is intended to be called through `callNodeFn()` or at specific times in the loop, must take the `opaque` node as its first argument
-
-## Special Function Names
-
-The following functions, which are defined within the node scripts, are invoked at specific times within the game loop. Note that if you want code to execute *during* node creation, place it within the script's root scope. Variables that you want to persist between calls should also be placed in the script's root.
-
-* `onLoad(node: opaque)`
-* `onInit(node: opaque)`
-* `onFrameStart(node: opaque)`
-* `onUpdate(node: opaque, delta: int)`
-* `onFrameEnd(node: opaque)`
-* `onStep(node: opaque)`
-* `onFree(node: opaque)`
-* `onDraw(node: opaque)`
-* `onKeyDown(node: opaque, event: string)`
-* `onKeyUp(node: opaque, event: string)`
-* `onMouseMotion(node: opaque, x: int, y: int, xrel: int, yrel: int)`
-* `onMouseButtonDown(node: opaque, x: int, y: int, button: string)`
-* `onMouseButtonUp(node: opaque, x: int, y: int, button: string)`
-* `onMouseWheel(node: opaque, xrel: int, yrel: int)`
-
-(These may change or expand as more input devices are added, and the engine matures.)
-
-NOTE: `onLoad()` is invoked every time a node is loaded - but `onInit()` is only invoked once by the engine. After that, `initNode()` must be called manually on any node children that are loaded later.
-
-# Engine Libraries
-
-A series of libraries are provided to allow Toy to interface and control the engine. In addition, the libraries stored within Toy's `repl/` directory are also available (see the main page for the list).
-
-During startup, the script named `init.toy` in the assets/scripts directory is executed. This file can be used to configure input mappings, as well as initializing the window and node tree.
-
-* Engine Library
-* Node Library
-* Input Library
-* Music Library
-* Sound Library
-
-

getting-started/math.md

@@ -1,127 +0,0 @@
-# Math Library
-
-The math library is a collection of mathematical functions and constants that provide a wide range of calculations that are commonly used. All functions in this library take either integers or floats as parameters and will return the result as a float.
-
-The math library can usually be accessed with the `import` keyword:
-
-```
-import math;
-```
-
-## Defined Constants
-
-### PI: float
-
-This constant represents the ratio of a circle's circumference to its diameter. Its value is approximately `3.14159265358979323846`.
-
-### E: float
-
-This constant represents Euler's number, the base of natural logarithms. Its value is approximately `2.71828182845904523536`.
-
-### EPSILON: float
-
-This constant represents the acceptable amount of error when comparing floats with the functions provided by this library (see [Defined Comparison Functions](#defined-comparison-functions)). Its default value is `0.000001`.
-
-### NAN: float
-
-This constant represents "Not-a-Number", often returned when a calculation is impossible, e.g. `sqrt(-1)`.
-
-### INFINITY: float
-
-This constant represents an uncountable value.
-
-## Defined Power Functions
-
-### pow(x, y): float
-
-This function returns `x` to the power of `y`.
-
-### sqrt(x): float
-
-This function returns the square root of `x`.
-
-### qbrt(x): float
-
-This function returns the cube root of `x`.
-
-### hypot(x, y): float
-
-This function returns the length of the hypotenuse, assuming `x` and `y` are the legs in a right-angle triangle.
-
-## Defined Trigonometric Functions
-
-### toRadians(d): float
-
-This function converts `d` into radians.
-
-### toDegrees(r): float
-
-This function converts `r` into degrees.
-
-### sin(x): float
-
-This function returns the sine of `x`.
-
-### cos(x): float
-
-This function returns the cosine of `x`.
-
-### tan(x): float
-
-This function returns the tangent of `x`.
-
-### asin(x): float
-
-This function returns the arc sine of `x`.
-
-### acos(x): float
-
-This function returns the arc cosine of `x`.
-
-### atan(x): float
-
-This function returns the arc tangent of `x`.
-
-## Defined Hyperbolic Functions
-
-### sinh(x): float
-
-This function returns the hyperbolic sine of `x`
-
-### cosh(x): float
-
-This function returns the hyperbolic cosine of `x`
-
-### tanh(x): float
-
-This function returns the hyperbolic tangent of `x`
-
-### asinh(x): float
-
-This function returns the inverse hyperbolic sine of `x`
-
-### acosh(x): float
-
-This function returns the inverse hyperbolic cosine of `x`
-
-### atanh(x): float
-
-This function returns the inverse hyperbolic tangent of `x`
-
-## Defined Comparison Functions
-
-### checkIsNaN(x): bool
-
-This function returns true if `x` is NaN, otherwise it returns false.
-
-### checkIsFinite(x): bool
-
-This function returns true if `x` is finite, otherwise it returns false.
-
-### checkIsInfinite(x): bool
-
-This function returns true if `x` is Infinite, otherwise it returns false.
-
-### epsilionCompare(x, y): bool
-
-This function returns true if `x` and `y` are within `EPSILON` of each other, otherwise it returns false. This is very useful for comparing floating point values.

getting-started/quick-start-guide.md

@@ -1,202 +0,0 @@
-
-# Quick Start Guide
-
-This guide is intended to get you writing Toy code as fast as possible. As such, it's more of a reference for experienced coders to know what is available and what isn't.
-
-Toy programs begin at the top of the file, and continue until the end, unless an error is encountered.
-
-## Print Keyword
-
-This keyword prints values to stdout for debugging (this can be altered by the host program).
-
-```
-print "Hello World";
-```
-
-## Names and Variables
-
-Variables can store data of any kind, unless a type is specified; see [types](getting-started/types). Names can be up to 256 characters long; see [Reserved Keywords](#reserved-keywords) for a list of keywords that can't be used as a name.
-
-```
-var b = true;
-var i = 42;
-var f = 3.14;
-var s = "Hello world";
-```
-
-Numbers (both integers and floats) can be delimited with underscores (`_`), to break them up visually, e.g. `100_000`.
-
-Strings can be 4096 characters long, and the following characters can be escaped: `\n`, `\t`, `\\` and `\"`.
-
-## Compounds
-
-Larger containers of data are available - arrays and dictionaries. Arrays are collections of data stored sequentially, while dictionaries are hash-maps of key-value pairs:
-
-```
-var array = []; //define an array
-var dict = [:]; //define a dictionary
-
-dict["foo"] = "bar"; //you can use indexing to add to a dictionary
-array.push(42); //you must use a function to push to an array
-```
-
-## Control Flow
-
-You can control the program flow with either `if`, `while` or `for`. The only falsy value is `false`.
-
-```
-if (check()) {
-	//do this
-}
-else {
-	//otherwise do this
-}
-
-var i = 0;
-while (i < 10) {
-	print i++;
-}
-
-for (var i = 0; i < 10; i++) {
-	print i;
-}
-```
-
-`continue` and `break` both behave as you'd expect.
-
-## Functions
-
-Functions are defined with the `fn` keyword, and can take any number of arguments. They can return a value as well.
-
-```
-fn combine(a, b, c) {
-	return [a, b, c];
-}
-
-print combine(1, 2, 3);
-```
-
-Variable number of parameters, called rest parameters, can be passed in as an array.
-
-```
-fn combine(...rest) {
-	return rest;
-}
-
-print combine(1, 2, 3);
-```
-
-## UFCS and Global Functions
-
-Functions can be called using the universal function call syntax, which is just syntactic sugar for a normal function call:
-
-```
-fn printMe(self) {
-	print self;
-}
-
-array.printMe();
-```
-
-There are several globally available functions provided by default:
-
-```
-set(self, key, value)                         //array, dictionary
-get(self, key)                                //array, dictionary
-push(self, value)                             //array
-pop(self)                                     //array
-length(self)                                  //array, dictionary, string
-clear(self)                                   //array, dictionary
-```
-
-## Slice Notation
-
-When indexing a compound value, you can use slice notation to manipulate it's elements:
-
-```
-var greeting = "Hello world";
-
-print greeting[::-1]; //dlrow olleH
-
-greeting[0:4] = "Goodnight"; //changes greeting to equal "Goodnight world"
-```
-
-## External Libraries
-
-The host may, at its own discretion, make external libraries available to the scripts. To access these, you can use the `import` keyword:
-
-```
-import standard;
-
-print clock(); //made available by "standard"
-```
-
-## Assertion Tests
-
-For testing purposes, there is the `assert` keyword. `assert` takes two arguments, separated by a comma; if the first resolves to a truthy value, then the whole statement is a no-op. Otherwise, the second argument, which MUST be a string, is displayed as an error and the script exits.
-
-```
-var answer = 42;
-
-assert answer == 42, "This will not be seen";
-
-//both false and null trigger assert's exit condition
-assert null, "This will be seen before the script exits";
-```
-
-## Reserved Keywords
-
-The following list cannot be used as names, due to their significance (or potential later use) in the language.
-
-* any
-* as
-* astype
-* assert
-* bool
-* break
-* class (reserved)
-* const
-* continue
-* do (reserved)
-* else
-* export (reserved)
-* false
-* float
-* fn
-* for
-* foreach (reserved)
-* if
-* import
-* in (reserved)
-* int
-* null
-* of (reserved)
-* opaque
-* print
-* return
-* string
-* true
-* type
-* typeof
-* var
-* while
-
-## Full List of Operators
-
-The following mathematical operators are available. A definition is omitted here, as they are commonly used in most programming languages.
-
-```
-+  -  *  /  %  +=  -=  *=  /=  %=  ++(prefix)  --(prefix)  (postfix)++  (postfix)--
-```
-
-Likewise, the following logical operators are available (`&&` is more tightly bound than `||` due to historical reasons):
-
-```
-(  )  [  ]  {  }  !  !=  ==  <  >  <=  >=  &&  ||  ?:
-```
-
-Other operators used throughout the language are: the assignment, colon, semicolon, comma, dot and rest operators:
-
-```
-= : ; , . ...
-```

getting-started/random-library.md

@@ -1,35 +0,0 @@
-
-# Random Library
-
-The random library offers a number of functions geared towards producing pseudorandom values. This library has a concept called "generators", which are opaque objects used to generate a sequence of numbers from an initial integer seed. A seed can be generated from most values using the standard library `hash` function.
-
-The random library can usually be accessed with the `import` keyword:
-
-```
-import standard;
-import random;
-
-var generator: opaque = createRandomGenerator(clock().hash());
-```
-
-The current implementation is minimal in nature, and will be expanded or replaced in future.
-
-## Defined Functions
-
-### createRandomGenerator(seed: int): opaque
-
-This function creates a new generator opaque based on the given seed. The same seed will produce the same sequence of pseudorandom outputs from different generators using `generateRandomNumber`.
-
-Every generator must also be freed with `freeRandomGenerator`.
-
-### generateRandomNumber(self: opaque): int
-
-This function takes in a generator opaque, and returns a pseudorandom integer value.
-
-This function also mutates the generator's internal state.
-
-### freeRandomGenerator(self: opaque)
-
-This function frees an existing generator opaque.
-
-This function must be called on all generators before the program ends.

getting-started/runner-library.md

@@ -1,62 +0,0 @@
-
-# Runner Library
-
-The runner library is used to execute one script from inside another. It also has functions that allow you to retrieve variables from the other script.
-
-The runner library has a concept called a "dirty" script - dirty scripts are those which have already been run, and whose variables can be accessed. Dirty scripts must be reset before it is run again.
-
-The runner library can usually be accessed with the `import` keyword:
-
-```toy
-import runner;
-```
-
-## Defined Functions
-
-### loadScript(path: string): opaque
-
-This is used to load an external script into an opaque variable.
-
-This function does a lot of work:
-
-* It validates the file path using the drive syntax
-* It reads in the source code of the script file
-* It compiles the source script into bytecode
-* It constructs and initializes an Interpreter
-* It packages it all into an opaque variable and returns it
-
-### loadScriptBytecode(path: string): opaque
-
-This is used to load an external bytecode file into an opaque variable.
-
-This function does a lot of work:
-
-* It validates the file path using the drive syntax
-* It constructs and initializes an Interpreter
-* It packages it all into an opaque variable and returns it
-
-Note: This function resembles `loadScript()`, but skips the compilation step.
-
-### runScript(self: opaque)
-
-This function executes an external script, which must first be loaded into an opaque variable with either `loadScript()` or `loadScriptBytecode()`.
-
-### getScriptVar(self: opaque, name: string): any
-
-This function retrieves a variable from the top level of a script's environment.
-
-## callScriptFn(self: opaque, name: string, ...rest)
-
-This function retrieves a function from the top level of a script's environment, and calls it with `rest` as the argument list.
-
-### resetScript(self: opaque)
-
-This function resets the script so that it is no longer in a "dirty" state, and can be re-run using `runScript()`.
-
-### freeScript(self: opaque)
-
-This function frees a script's resources, cleaning up any memory that is no longer needed. Failing to call this will result in a memory leak.
-
-### checkScriptDirty(self: opaque): bool
-
-This function returns true if the script is "dirty", otherwise it returns false.

getting-started/standard-library.md

@@ -1,216 +0,0 @@
-
-# Standard Library
-
-The standard library offers a number of miscellaneous utility functions, which can be used for various purposes. These are the most commonly used functions, so the standard library is almost certain to be included in the host program.
-
-The standard library can usually be accessed with the `import` keyword:
-
-```
-import standard;
-```
-
-## Defined Misc. Functions
-
-### clock(): string
-
-This function returns a string representation of the current timestamp.
-
-### hash(self: any): int
-
-This function returns a hashed value of `self`.
-
-This function uses the internal literal hashing algorithms. As such, the following can't be hashed:
-
-* functions
-* types
-* opaques
-* `null`
-
-Any attempt to hash these will return -1, except `null` which returns 0.
-
-## Defined Maths Functions
-
-### abs(self): any
-
-This function returns the absolute value of any integer or float passed in.
-
-### ceil(self): int
-
-This function returns the value of any integer or float passed in, rounded up.
-
-### floor(self): int
-
-This function returns the value of any integer or float passed in, rounded down.
-
-### max(...): any
-
-This function returns the value of the highest integer or float passed in. It can take any number of arguments.
-
-### min(...): any
-
-This function returns the value of the lowest integer or float passed in. It can take any number of arguments.
-
-### round(self): int
-
-This function returns the value of any integer or float passed in, rounded to the nearest whole number.
-
-### sign(self): int
-
-This function expects an integer or float as the value for `self`.
-
-If `self` is below 0, this function returns -1. Otherwise, it returns 1.
-
-### normalize(self): int
-
-This function expects an integer or float as the value for `self`.
-
-If `self` is below 0, this function returns -1. Otherwise, if `self` is above 0, this function returns 1. Otherwise it returns 0.
-
-### clamp(value, min, max): any
-
-This function expects integers or floats as the values for `value`, `min`, and `max`.
-
-If `value` is smaller than `min`, this function will return `min`. Otherwise, if `value` larger than `max`, it will return `max`. Otherwise, it will return `value`.
-
-### lerp(start, end, amount): any
-
-This function expects integers or floats as the values for `value`, `min`, and `max`.
-
-This function will return the value of `start` adjusted towards the value of `end` by `amount`, by interpreting `amount` as a fraction.
-
-## Defined Compound Functions
-
-### concat(self, other): any
-
-This function only works when self and others are matching compounds (both arrays, dictionaries or strings). It returns a new compound of that kind, with the content of `other` appended to the content of `self`.
-
-### containsKey(self: dictionary, key): bool
-
-This function returns `true` if `self` contains the given `key`; otherwise, it returns false.
-
-### containsValue(self, value): bool
-
-This function returns `true` if `self` contains the given `value`; otherwise, it returns false.
-
-### every(self, func: fn): bool
-
-This function takes either an array or a dictionary as the `self` argument and a function as `func`. The argument `func` must take two arguments - the first is the index/key of the array/dictionary, and the second is the value. The contents of `self` are passed into `func`, one element at a time, until `func` returns `false`, at which point this function returns `false`. Otherwise, this function returns `true`.
-
-### forEach(self, func: fn)
-
-This function takes either an array or a dictionary as the `self` argument and a function as `func`. The argument `func` must take two arguments - the first is the index/key of the array/dictionary, and the second is the value. The contents of `self` are passed into `func` one element at a time.
-
-```
-import standard;
-
-fn p(i, x) {
-	print x;
-}
-
-var a = [1, 3, 5];
-
-a.forEach(p); //prints 1, 3, and 5 to stdout
-```
-
-### filter(self, func: fn): any
-
-This function takes either an array or a dictionary as the `self` argument and a function as `func`. The argument `func` must take two arguments - the first is the index/key of the array/dictionary, and the second is the value. The contents of `self` are passed into `func`, one element at a time, and the function returns a new compound for every element that `func` returned a truthy value for.
-
-### getKeys(self: dictionary): [any]
-
-This function returns an array of all non-null keys stored within the dictionary. The order is undefined.
-
-### getValues(self: dictionary): [any]
-
-This function returns an array of all values with non-null keys stored within the dictionary. The order is undefined.
-
-### indexOf(self: array, value): int
-
-This function returns the first index within `self` that is equal to `value`, or `null` if none are found.
-
-### map(self, func: fn): any
-
-This function takes either an array or a dictionary as the `self` argument, and a function as `func`. The argument `func` must take two arguments - the first is the index/key of the array/dictionary, and the second is the value. It returns an array with the results of each call - the order of the results when called on a dictionary is undefined.
-
-```
-import standard;
-
-fn increment(k, v) {
-	return v + 1;
-}
-
-var a = [1, 2, 3];
-
-print a.map(increment); //prints [2,3,4];
-```
-
-### reduce(self, default: any, func: fn): any
-
-This function takes either an array or a dictionary as the `self` argument, a default value, and a function as `func`. The argument `func` takes three arguments - the first is the accumulator, the second is the index/key, and the third is the value. It applies the given function to every element of the array/dictionary, passing the result of each call as the accumulator to the next (the default value is used for the first call). Finally, the final value of the accumulator is returned to the caller.
-
-```
-import standard;
-
-fn f(acc, k, v) {
-	return acc + v;
-}
-
-var a = [1, 2, 3, 4];
-
-print a.reduce(0, f); //prints "10"
-```
-
-### some(self, func: fn): bool
-
-This function takes either an array or a dictionary as the `self` argument, and a function as `func`. The argument `func` must take two arguments - the first is the index/key of the array/dictionary, and the second is the value. The contents of `self` are passed into `func`, one element at a time, until `func` returns `true`, at which point this function returns `true`. Otherwise, this function returns `false`.
-
-### sort(self: array, func: fn)
-
-This function takes an array as the `self` argument, and a comparison function as `func`. The argument `func` must take two arguments and return a truthy or falsy value. The contents of the array in `self` are sorted based on the results of `func`, as though the function was the less comparator function.
-
-```
-import standard;
-
-fn less(a, b) {
-	return a < b;
-}
-
-var a = [4, 1, 3, 2];
-
-print a.sort(less); //prints "[1, 2, 3, 4]"
-```
-
-### toLower(self: string): string
-
-This function returns a new string which is identical to the string `self`, except any uppercase letters are replaced with the corresponding lowercase letters.
-
-### toString(self): string
-
-This function returns a string representation of `self`. This is intended for arrays and dictionaries, but can theoretically work on any printable value.
-
-If the resulting string is longer than `TOY_MAX_STRING_LENGTH` - 1, then it is truncated.
-
-### toUpper(self: string):string
-
-This function returns a new string which is identical to the string `self`, except any lowercase letters are replaced with the corresponding uppercase letters.
-
-### trim(self: string, trimChars: string = " \t\n\r"): string
-
-This function returns a new string which is identical to the string `self`, except any characters at the beginning or end of `self` which are present in the argument `trimChars` are removed. The argument `trimChars` is optional, and has the following characters as the default value:
-
-* The space character
-* The horizontal tab character
-* The newline character
-* The carriage return character
-
-These characters used because they are the only control characters currently supported by Toy.
-
-### trimBegin(self: string, trimChars: string = " \t\n\r"): string
-
-This function is identical to `trim(self, trimChars)`, except it is only applied to the beginning of the first argument.
-
-### trimEnd(self: string, trimChars: string = " \t\n\r"): string
-
-This function is identical to `trim(self, trimChars)`, except it is only applied to the end of the first argument.
-
-

getting-started/toy-version-info-library.md

@@ -1,32 +0,0 @@
-# Toy Version Info Library
-
-The toy_version_info library simply provides version info about the current build of Toy.
-
-The toy_version_info library can usually be accessed with the `import` keyword:
-
-```
-import toy_version_info;
-import toy_version_info as toy_version_info; //can be aliased
-```
-
-## Defined Variables
-
-### major
-
-This variable is the major version number of Toy at the time of compilation.
-
-### minor
-
-This variable is the minor version number of Toy at the time of compilation.
-
-### patch
-
-This variable is the patch version number of Toy at the time of compilation.
-
-### build
-
-This variable is a string representing the date and time that the interpreter was compiled.
-
-### author
-
-This variable contains the name of Toy's lead author, and his game studio.

getting-started/types.md

@@ -1,112 +0,0 @@
-# Types
-
-The type system in Toy is opt-in, but allows a lot of robust checks at runtime when needed. Types themselves are first-class citizens. To retrieve the type of an existing variable, use the `typeof` keyword.
-
-```
-print typeof value;
-```
-
-The types available are:
-
-| Type | Signature | Description |
-| --- | --- | --- |
-| null | null | Represents a lack of any meaningful value |
-| boolean | bool | Either true or false |
-| integer | int | Any whole number. The limits are implementation dependent |
-| float | float | Any floating point number. The limits are implementation dependent |
-| string | string | A series of characters, forming text |
-| array | n/a | A series of values arranged sequentially in memory, indexable with an integer |
-| dictionary | n/a | A series of key-value pairs stored in a hash-table, indexable with the keys |
-| function | fn | A chunk of reusable code, which can potentially return a value of some kind |
-| type | type | The type of types |
-| opaque | opaque | Arbitrary data passed from the host, which Toy can't natively understand |
-| any | any | Can hold any value |
-
-## Specifying Types For Variables
-
-To specify a type for a variable, use `:` followed by the signature. In this example, the variable `total` can only ever hold integers (or  `null`):
-
-```
-var total: int = 0;
-```
-
-To specify the type of an array or dictionary, use some variation of these signatures:
-
-```
-var array: [int] = [1, 2, 3]; //an array of integers
-
-var dictionary: [string : int] = ["key":42]; //a dictionary of key-value pairs
-```
-
-Complex, hard-to-write types can be stored in variables, like so:
-
-```
-//define a variable called "entry"
-var entry: type = astype [string: [string]];
-
-//define a phonebook which follows the above signature
-var phonebook: entry = [
-	"Lucy": ["1234", "Cabbage Ln"],
-	"Bob": ["5678", "Candy Rd"]
-];
-```
-
-## Const
-
-Const-ness, or the ability to fix the value of a variable, is part of the type system. To define a constant, follow the type signature with the `const` keyword:
-
-```
-var ANSWER: int const = 42; //answer will never change
-```
-
-You can also set the members of an array or dictionary as const, or the entire compound:
-
-```
-var members: [int const] = [1, 2, 3]; //1, 2 and 3 cannot be changed, but "members" can be modified or re-assigned
-
-var everything: [int] const = [4, 5, 6]; //everything is now const
-```
-
-## Astype
-
-Due to the syntax of Toy, when storing a complex type into a variable, you may need to use the `astype` keyword to differentiate the value from an array or dictionary.
-
-```
-var t: type = astype [int]; //t is a type, representing an array of integers
-var u: type = [int]; //Error! it tried to assign an array with the sole entry "int"
-```
-
-## First-Class Citizens
-
-Types are first-class citizens. What this means is that they can be used just like any other value, as well as being stored in variables and even returning from functions.
-
-```
-fn decide(question) {
-	if (question) {
-		return int;
-	}
-	else {
-		return float;
-	}
-}
-
-var t = decide(true);
-
-var number: t = 0; //what if it had been false?
-```
-
-## Opaque Data
-
-Sometimes, you may need to pass data through Toy that Toy can't normally handle. This data is called "opaque" data and is passed around by reference rather than value. Anything can be passed in as opaque data as long as it's represented as a void pointer in C.
-
-```c
-Toy_Literal opaque = TOY_TO_OPAQUE_LITERAL(&data, 0);
-
-//...
-
-void* dataPtr = TOY_AS_OPAQUE(opaque);
-
-int tag = TOY_GET_OPAQUE_TAG(opaque); //for identifying the data in the host
-```
-
-Managing and cleaning up opaque data is a task left entirely to the host program - you can do this with the opaque literal's tag.

index.md

@@ -1,95 +0,0 @@
-<div align="center">
-  <image src="toylogo.png" />
-</div>
-
-[![Continuous Integration v1.x](https://github.com/krgamestudios/Toy/actions/workflows/continuous-integration-v1.yml/badge.svg)](https://github.com/krgamestudios/Toy/actions/workflows/continuous-integration-v1.yml)  
-
-***Notice**: These docs are valid for version 1.x only - the version 2 docs can be found at [https://toylang.com/](https://toylang.com/).*
-
-# Preamble
-
-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.
-
-The Toy reference implementation can be found on [github](https://github.com/krgamestudios/Toy/tree/v1).
-
-```
-fn makeCounter() { //declare a function like this
-	var total: int = 0; //declare a variable with a type like this
-
-	fn counter(): int { //declare a return type like this
-		return ++total;
-	}
-
-	return counter; //closures are explicitly supported
-}
-
-var tally = makeCounter();
-
-print tally(); //1
-print tally(); //2
-print tally(); //3
-```
-
-## 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 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
-
-## Getting Started
-
-* [Quick Start Guide](getting-started/quick-start-guide)
-* [Types](getting-started/types)
-* [Toy Version Info Library](getting-started/toy-version-info-library)
-* [Standard Library](getting-started/standard-library)
-* [Math Library](getting-started/math.md)
-* [Random Library](getting-started/random-library)
-* [Runner Library](getting-started/runner-library)
-
-## Deep Dive Document
-
-* [Theorizing Toy](deep-dive/theorizing-toy)
-* [Building Toy](deep-dive/building-toy)
-* [Embedding Toy](deep-dive/embedding-toy)
-* [Compiling Toy](deep-dive/compiling-toy)
-* [Developing Toy](deep-dive/developing-toy) (incomplete, but being expanded)
-* [Testing Toy](deep-dive/testing-toy)
-* [Roadmapping Toy](deep-dive/roadmapping-toy)
-
-## Public C API
-
-* [repl_tools.h](c-api/repl_tools_h.md)
-* [drive_system.h](c-api/drive_system_h.md)
-* [toy.h](c-api/toy_h.md)
-* [toy_common.h](c-api/toy_common_h.md)
-* [toy_compiler.h](c-api/toy_compiler_h.md)
-* [toy_interpreter.h](c-api/toy_interpreter_h.md)
-* [toy_lexer.h](c-api/toy_lexer_h.md)
-* [toy_literal_array.h](c-api/toy_literal_array_h.md)
-* [toy_literal_dictionary.h](c-api/toy_literal_dictionary_h.md)
-* [toy_literal.h](c-api/toy_literal_h.md)
-* [toy_memory.h](c-api/toy_memory_h.md)
-* [toy_parser.h](c-api/toy_parser_h.md)
-* [toy_reffunction.h](c-api/toy_reffunction_h.md)
-* [toy_refstring.h](c-api/toy_refstring_h.md)
-* [toy_scope.h](c-api/toy_scope_h.md)
-
-## Game Engine
-
-Note: This section is WIP.
-
-* [Game Engine](game-engine/game-engine.md)
-* [Box Version Info Library](game-engine/box-version-info-library.md)
-* Engine Library
-* Node Library
-* Input Library
-* Music Library
-* Sound Library
-

makefile

@@ -0,0 +1,109 @@
+export CFLAGS+=-std=c18 -pedantic -Werror
+
+export TOY_OUTDIR = out
+
+all: $(TOY_OUTDIR) repl
+
+#repl builds
+repl: $(TOY_OUTDIR) library
+	$(MAKE) -j8 -C repl
+
+repl-static: $(TOY_OUTDIR) static
+	$(MAKE) -j8 -C repl
+
+repl-release: clean $(TOY_OUTDIR) library-release
+	$(MAKE) -C repl release
+
+repl-static-release: clean $(TOY_OUTDIR) static-release
+	$(MAKE) -C repl release
+
+#lib builds
+library: $(TOY_OUTDIR)
+	$(MAKE) -j8 -C source library
+
+static: $(TOY_OUTDIR)
+	$(MAKE) -j8 -C source static
+
+library-release: clean $(TOY_OUTDIR)
+	$(MAKE) -j8 -C source library-release
+
+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
+
+test-sanitized: export CFLAGS+=-fsanitize=address,undefined
+test-sanitized: export LIBS+=-static-libasan
+test-sanitized: export DISABLE_VALGRIND=true
+test-sanitized: clean $(TOY_OUTDIR)
+	$(MAKE) -C test
+
+$(TOY_OUTDIR):
+	mkdir $(TOY_OUTDIR)
+
+#utils
+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:
+ifeq ($(findstring CYGWIN, $(shell uname)),CYGWIN)
+	find . -type f -name '*.o' -exec rm -f -r -v {} \;
+	find . -type f -name '*.a' -exec rm -f -r -v {} \;
+	find . -type f -name '*.exe' -exec rm -f -r -v {} \;
+	find . -type f -name '*.dll' -exec rm -f -r -v {} \;
+	find . -type f -name '*.lib' -exec rm -f -r -v {} \;
+	find . -type f -name '*.so' -exec rm -f -r -v {} \;
+	find . -empty -type d -delete
+else ifeq ($(shell uname),Linux)
+	find . -type f -name '*.o' -exec rm -f -r -v {} \;
+	find . -type f -name '*.a' -exec rm -f -r -v {} \;
+	find . -type f -name '*.exe' -exec rm -f -r -v {} \;
+	find . -type f -name '*.dll' -exec rm -f -r -v {} \;
+	find . -type f -name '*.lib' -exec rm -f -r -v {} \;
+	find . -type f -name '*.so' -exec rm -f -r -v {} \;
+	rm -rf out
+	find . -empty -type d -delete
+else ifeq ($(OS),Windows_NT)
+	$(RM) *.o *.a *.exe 
+else ifeq ($(shell uname),Darwin)
+	find . -type f -name '*.o' -exec rm -f -r -v {} \;
+	find . -type f -name '*.a' -exec rm -f -r -v {} \;
+	find . -type f -name '*.exe' -exec rm -f -r -v {} \;
+	find . -type f -name '*.dll' -exec rm -f -r -v {} \;
+	find . -type f -name '*.lib' -exec rm -f -r -v {} \;
+	find . -type f -name '*.dylib' -exec rm -f -r -v {} \;
+	find . -type f -name '*.so' -exec rm -f -r -v {} \;
+	rm -rf out
+	find . -empty -type d -delete
+else
+	@echo "Deletion failed - what platform is this?"
+endif
+
+rebuild: clean all

repl/drive_system.c

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

repl/drive_system.h

@@ -1,8 +1,9 @@
+#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 the designated folders. It does this by causing an error when a script tries to access a parent directory.
+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:
 
@@ -31,21 +32,39 @@ This utility is intended mainly for libraries to use - as such, the core of Toy
 ### 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 it is intended to be called directly from `main()`.
+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.
@@ -53,3 +72,5 @@ This function, when given a string literal of the correct format, will return a
 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);

repl/lib_math.h

@@ -0,0 +1,5 @@
+#pragma once
+
+#include "toy_interpreter.h"
+
+int Toy_hookMath(Toy_Interpreter* interpreter, Toy_Literal identifier, Toy_Literal alias);

repl/lib_random.c

@@ -0,0 +1,181 @@
+#include "lib_random.h"
+
+#include "toy_memory.h"
+
+static int hashInt(int x) {
+    x = ((x >> 16) ^ x) * 0x45d9f3b;
+    x = ((x >> 16) ^ x) * 0x45d9f3b;
+    x = ((x >> 16) ^ x) * 0x45d9f3b;
+    x = (x >> 16) ^ x;
+    return x;
+}
+
+typedef struct Toy_RandomGenerator {
+	int seed; //mutated with each call
+} Toy_RandomGenerator;
+
+//Toy native functions
+static int nativeCreateRandomGenerator(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments) {
+	//arguments
+	if (arguments->count != 1) {
+		interpreter->errorOutput("Incorrect number of arguments to createRandomGenerator\n");
+		return -1;
+	}
+
+	//get the seed argument
+	Toy_Literal seedLiteral = Toy_popLiteralArray(arguments);
+
+	Toy_Literal seedLiteralIdn = seedLiteral;
+	if (TOY_IS_IDENTIFIER(seedLiteral) && Toy_parseIdentifierToValue(interpreter, &seedLiteral)) {
+		Toy_freeLiteral(seedLiteralIdn);
+	}
+
+	if (!TOY_IS_INTEGER(seedLiteral)) {
+		interpreter->errorOutput("Incorrect literal type passed to createRandomGenerator");
+		Toy_freeLiteral(seedLiteral);
+		return -1;
+	}
+
+	//generate the generator object
+	Toy_RandomGenerator* generator = TOY_ALLOCATE(Toy_RandomGenerator, 1);
+	generator->seed = TOY_AS_INTEGER(seedLiteral);
+	Toy_Literal generatorLiteral = TOY_TO_OPAQUE_LITERAL(generator, TOY_OPAQUE_TAG_RANDOM);
+
+	//return and cleanup
+	Toy_pushLiteralArray(&interpreter->stack, generatorLiteral);
+
+	Toy_freeLiteral(seedLiteral);
+	Toy_freeLiteral(generatorLiteral);
+
+	return 1;
+}
+
+static int nativeGenerateRandomNumber(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments) {
+	//no arguments
+	if (arguments->count != 1) {
+		interpreter->errorOutput("Incorrect number of arguments to generateRandomNumber\n");
+		return -1;
+	}
+
+	//get the runner object
+	Toy_Literal generatorLiteral = Toy_popLiteralArray(arguments);
+
+	Toy_Literal generatorLiteralIdn = generatorLiteral;
+	if (TOY_IS_IDENTIFIER(generatorLiteral) && Toy_parseIdentifierToValue(interpreter, &generatorLiteral)) {
+		Toy_freeLiteral(generatorLiteralIdn);
+	}
+
+	if (TOY_GET_OPAQUE_TAG(generatorLiteral) != TOY_OPAQUE_TAG_RANDOM) {
+		interpreter->errorOutput("Unrecognized opaque literal in generateRandomNumber\n");
+		return -1;
+	}
+
+	Toy_RandomGenerator* generator = TOY_AS_OPAQUE(generatorLiteral);
+
+	//generate the new value and package up the return
+	generator->seed = hashInt(generator->seed);
+
+	Toy_Literal resultLiteral = TOY_TO_INTEGER_LITERAL(generator->seed);
+
+	Toy_pushLiteralArray(&interpreter->stack, resultLiteral);
+
+	//cleanup
+	Toy_freeLiteral(generatorLiteral);
+	Toy_freeLiteral(resultLiteral);
+
+	return 0;
+}
+
+static int nativeFreeRandomGenerator(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments) {
+	//no arguments
+	if (arguments->count != 1) {
+		interpreter->errorOutput("Incorrect number of arguments to freeRandomGenerator\n");
+		return -1;
+	}
+
+	//get the runner object
+	Toy_Literal generatorLiteral = Toy_popLiteralArray(arguments);
+
+	Toy_Literal generatorLiteralIdn = generatorLiteral;
+	if (TOY_IS_IDENTIFIER(generatorLiteral) && Toy_parseIdentifierToValue(interpreter, &generatorLiteral)) {
+		Toy_freeLiteral(generatorLiteralIdn);
+	}
+
+	if (TOY_GET_OPAQUE_TAG(generatorLiteral) != TOY_OPAQUE_TAG_RANDOM) {
+		interpreter->errorOutput("Unrecognized opaque literal in freeRandomGenerator\n");
+		return -1;
+	}
+
+	Toy_RandomGenerator* generator = TOY_AS_OPAQUE(generatorLiteral);
+
+	//clear out the runner object
+	TOY_FREE(Toy_RandomGenerator, generator);
+	Toy_freeLiteral(generatorLiteral);
+
+	return 0;
+}
+
+//call the hook
+typedef struct Natives {
+	const char* name;
+	Toy_NativeFn fn;
+} Natives;
+
+int Toy_hookRandom(Toy_Interpreter* interpreter, Toy_Literal identifier, Toy_Literal alias) {
+	//build the natives list
+	Natives natives[] = {
+		{"createRandomGenerator", nativeCreateRandomGenerator},
+		{"generateRandomNumber", nativeGenerateRandomNumber},
+		{"freeRandomGenerator", nativeFreeRandomGenerator},
+		{NULL, NULL}
+	};
+
+	//store the library in an aliased dictionary
+	if (!TOY_IS_NULL(alias)) {
+		//make sure the name isn't taken
+		if (Toy_isDeclaredScopeVariable(interpreter->scope, alias)) {
+			interpreter->errorOutput("Can't override an existing variable\n");
+			Toy_freeLiteral(alias);
+			return -1;
+		}
+
+		//create the dictionary to load up with functions
+		Toy_LiteralDictionary* dictionary = TOY_ALLOCATE(Toy_LiteralDictionary, 1);
+		Toy_initLiteralDictionary(dictionary);
+
+		//load the dict with functions
+		for (int i = 0; natives[i].name; i++) {
+			Toy_Literal name = TOY_TO_STRING_LITERAL(Toy_createRefString(natives[i].name));
+			Toy_Literal func = TOY_TO_FUNCTION_NATIVE_LITERAL(natives[i].fn);
+
+			Toy_setLiteralDictionary(dictionary, name, func);
+
+			Toy_freeLiteral(name);
+			Toy_freeLiteral(func);
+		}
+
+		//build the type
+		Toy_Literal type = TOY_TO_TYPE_LITERAL(TOY_LITERAL_DICTIONARY, true);
+		Toy_Literal strType = TOY_TO_TYPE_LITERAL(TOY_LITERAL_STRING, true);
+		Toy_Literal fnType = TOY_TO_TYPE_LITERAL(TOY_LITERAL_FUNCTION_NATIVE, true);
+		TOY_TYPE_PUSH_SUBTYPE(&type, strType);
+		TOY_TYPE_PUSH_SUBTYPE(&type, fnType);
+
+		//set scope
+		Toy_Literal dict = TOY_TO_DICTIONARY_LITERAL(dictionary);
+		Toy_declareScopeVariable(interpreter->scope, alias, type);
+		Toy_setScopeVariable(interpreter->scope, alias, dict, false);
+
+		//cleanup
+		Toy_freeLiteral(dict);
+		Toy_freeLiteral(type);
+		return 0;
+	}
+
+	//default
+	for (int i = 0; natives[i].name; i++) {
+		Toy_injectNativeFn(interpreter, natives[i].name, natives[i].fn);
+	}
+
+	return 0;
+}

repl/lib_random.h

@@ -0,0 +1,7 @@
+#pragma once
+
+#include "toy_interpreter.h"
+
+#define TOY_OPAQUE_TAG_RANDOM 200
+
+int Toy_hookRandom(Toy_Interpreter* interpreter, Toy_Literal identifier, Toy_Literal alias);

repl/lib_runner.c

@@ -0,0 +1,511 @@
+#include "lib_runner.h"
+
+#include "toy_memory.h"
+#include "toy_interpreter.h"
+
+#include "repl_tools.h"
+#include "drive_system.h"
+
+#include <stdlib.h>
+
+typedef struct Toy_Runner {
+	Toy_Interpreter interpreter;
+	const unsigned char* bytecode;
+	size_t size;
+
+	bool dirty;
+} Toy_Runner;
+
+//Toy native functions
+static int nativeLoadScript(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments) {
+	//arguments
+	if (arguments->count != 1) {
+		interpreter->errorOutput("Incorrect number of arguments to loadScript\n");
+		return -1;
+	}
+
+	//get the file path literal with a handle
+	Toy_Literal drivePathLiteral = Toy_popLiteralArray(arguments);
+
+	Toy_Literal drivePathLiteralIdn = drivePathLiteral;
+	if (TOY_IS_IDENTIFIER(drivePathLiteral) && Toy_parseIdentifierToValue(interpreter, &drivePathLiteral)) {
+		Toy_freeLiteral(drivePathLiteralIdn);
+	}
+
+	Toy_Literal filePathLiteral = Toy_getDrivePathLiteral(interpreter, &drivePathLiteral);
+
+	if (TOY_IS_NULL(filePathLiteral)) {
+		Toy_freeLiteral(filePathLiteral);
+		Toy_freeLiteral(drivePathLiteral);
+		return -1;
+	}
+
+	Toy_freeLiteral(drivePathLiteral);
+
+	//use raw types - easier
+	const char* filePath = Toy_toCString(TOY_AS_STRING(filePathLiteral));
+	size_t filePathLength = Toy_lengthRefString(TOY_AS_STRING(filePathLiteral));
+
+	//load and compile the bytecode
+	size_t fileSize = 0;
+	const char* source = (const char*)Toy_readFile(filePath, &fileSize);
+
+	if (!source) {
+		interpreter->errorOutput("Failed to load source file\n");
+		Toy_freeLiteral(filePathLiteral);
+		return -1;
+	}
+
+	const unsigned char* bytecode = Toy_compileString(source, &fileSize);
+	free((void*)source);
+
+	if (!bytecode) {
+		interpreter->errorOutput("Failed to compile source file\n");
+		Toy_freeLiteral(filePathLiteral);
+		return -1;
+	}
+
+	//build the runner object
+	Toy_Runner* runner = TOY_ALLOCATE(Toy_Runner, 1);
+	Toy_setInterpreterPrint(&runner->interpreter, interpreter->printOutput);
+	Toy_setInterpreterAssert(&runner->interpreter, interpreter->assertOutput);
+	Toy_setInterpreterError(&runner->interpreter, interpreter->errorOutput);
+	runner->interpreter.hooks = interpreter->hooks;
+	runner->interpreter.scope = NULL;
+	Toy_resetInterpreter(&runner->interpreter);
+	runner->bytecode = bytecode;
+	runner->size = fileSize;
+	runner->dirty = false;
+
+	//build the opaque object, and push it to the stack
+	Toy_Literal runnerLiteral = TOY_TO_OPAQUE_LITERAL(runner, TOY_OPAQUE_TAG_RUNNER);
+	Toy_pushLiteralArray(&interpreter->stack, runnerLiteral);
+
+	//free the drive path
+	Toy_freeLiteral(filePathLiteral);
+
+	return 1;
+}
+
+static int nativeLoadScriptBytecode(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments) {
+	//arguments
+	if (arguments->count != 1) {
+		interpreter->errorOutput("Incorrect number of arguments to loadScriptBytecode\n");
+		return -1;
+	}
+
+	//get the argument
+	Toy_Literal drivePathLiteral = Toy_popLiteralArray(arguments);
+
+	Toy_Literal drivePathLiteralIdn = drivePathLiteral;
+	if (TOY_IS_IDENTIFIER(drivePathLiteral) && Toy_parseIdentifierToValue(interpreter, &drivePathLiteral)) {
+		Toy_freeLiteral(drivePathLiteralIdn);
+	}
+
+	Toy_Literal filePathLiteral = Toy_getDrivePathLiteral(interpreter, &drivePathLiteral);
+
+	if (TOY_IS_NULL(filePathLiteral)) {
+		Toy_freeLiteral(filePathLiteral);
+		Toy_freeLiteral(drivePathLiteral);
+		return -1;
+	}
+
+	Toy_freeLiteral(drivePathLiteral);
+
+	//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;
+	unsigned char* bytecode = (unsigned char*)Toy_readFile(filePath, &fileSize);
+
+	if (!bytecode) {
+		interpreter->errorOutput("Failed to load bytecode file\n");
+		return -1;
+	}
+
+	//build the runner object
+	Toy_Runner* runner = TOY_ALLOCATE(Toy_Runner, 1);
+	Toy_setInterpreterPrint(&runner->interpreter, interpreter->printOutput);
+	Toy_setInterpreterAssert(&runner->interpreter, interpreter->assertOutput);
+	Toy_setInterpreterError(&runner->interpreter, interpreter->errorOutput);
+	runner->interpreter.hooks = interpreter->hooks;
+	runner->interpreter.scope = NULL;
+	Toy_resetInterpreter(&runner->interpreter);
+	runner->bytecode = bytecode;
+	runner->size = fileSize;
+	runner->dirty = false;
+
+	//build the opaque object, and push it to the stack
+	Toy_Literal runnerLiteral = TOY_TO_OPAQUE_LITERAL(runner, TOY_OPAQUE_TAG_RUNNER);
+	Toy_pushLiteralArray(&interpreter->stack, runnerLiteral);
+
+	//free the drive path
+	Toy_freeLiteral(filePathLiteral);
+
+	return 1;
+}
+
+static int nativeRunScript(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments) {
+	//no arguments
+	if (arguments->count != 1) {
+		interpreter->errorOutput("Incorrect number of arguments to runScript\n");
+		return -1;
+	}
+
+	//get the runner object
+	Toy_Literal runnerLiteral = Toy_popLiteralArray(arguments);
+
+	Toy_Literal runnerIdn = runnerLiteral;
+	if (TOY_IS_IDENTIFIER(runnerLiteral) && Toy_parseIdentifierToValue(interpreter, &runnerLiteral)) {
+		Toy_freeLiteral(runnerIdn);
+	}
+
+	if (TOY_GET_OPAQUE_TAG(runnerLiteral) != TOY_OPAQUE_TAG_RUNNER) {
+		interpreter->errorOutput("Unrecognized opaque literal in runScript\n");
+		return -1;
+	}
+
+	Toy_Runner* runner = TOY_AS_OPAQUE(runnerLiteral);
+
+	//run
+	if (runner->dirty) {
+		interpreter->errorOutput("Can't re-run a dirty script (try resetting it first)\n");
+		Toy_freeLiteral(runnerLiteral);
+		return -1;
+	}
+
+	unsigned char* bytecodeCopy = TOY_ALLOCATE(unsigned char, runner->size);
+	memcpy(bytecodeCopy, runner->bytecode, runner->size); //need a COPY of the bytecode, because the interpreter eats it
+
+	Toy_runInterpreter(&runner->interpreter, bytecodeCopy, runner->size);
+	runner->dirty = true;
+
+	//cleanup
+	Toy_freeLiteral(runnerLiteral);
+
+	return 0;
+}
+
+static int nativeGetScriptVar(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments) {
+	//no arguments
+	if (arguments->count != 2) {
+		interpreter->errorOutput("Incorrect number of arguments to getScriptVar\n");
+		return -1;
+	}
+
+	//get the runner object
+	Toy_Literal varName = Toy_popLiteralArray(arguments);
+	Toy_Literal runnerLiteral = Toy_popLiteralArray(arguments);
+
+	Toy_Literal varNameIdn = varName;
+	if (TOY_IS_IDENTIFIER(varName) && Toy_parseIdentifierToValue(interpreter, &varName)) {
+		Toy_freeLiteral(varNameIdn);
+	}
+
+	Toy_Literal runnerIdn = runnerLiteral;
+	if (TOY_IS_IDENTIFIER(runnerLiteral) && Toy_parseIdentifierToValue(interpreter, &runnerLiteral)) {
+		Toy_freeLiteral(runnerIdn);
+	}
+
+	if (TOY_GET_OPAQUE_TAG(runnerLiteral) != TOY_OPAQUE_TAG_RUNNER) {
+		interpreter->errorOutput("Unrecognized opaque literal in getScriptVar\n");
+		return -1;
+	}
+
+	Toy_Runner* runner = TOY_AS_OPAQUE(runnerLiteral);
+
+	//dirty check
+	if (!runner->dirty) {
+		interpreter->errorOutput("Can't access variable from a non-dirty script (try running it first)\n");
+		Toy_freeLiteral(runnerLiteral);
+		return -1;
+	}
+
+	//get the desired variable
+	Toy_Literal varIdn = TOY_TO_IDENTIFIER_LITERAL(Toy_copyRefString(TOY_AS_STRING(varName)));
+	Toy_Literal result = TOY_TO_NULL_LITERAL;
+	Toy_getScopeVariable(runner->interpreter.scope, varIdn, &result);
+
+	Toy_pushLiteralArray(&interpreter->stack, result);
+
+	//cleanup
+	Toy_freeLiteral(result);
+	Toy_freeLiteral(varIdn);
+	Toy_freeLiteral(varName);
+	Toy_freeLiteral(runnerLiteral);
+
+	return 1;
+}
+
+static int nativeCallScriptFn(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments) {
+	//no arguments
+	if (arguments->count < 2) {
+		interpreter->errorOutput("Incorrect number of arguments to callScriptFn\n");
+		return -1;
+	}
+
+	//get the rest args
+	Toy_LiteralArray tmp;
+	Toy_initLiteralArray(&tmp);
+
+	while (arguments->count > 2) {
+		Toy_Literal lit = Toy_popLiteralArray(arguments);
+		Toy_pushLiteralArray(&tmp, lit);
+		Toy_freeLiteral(lit);
+	}
+
+	Toy_LiteralArray rest;
+	Toy_initLiteralArray(&rest);
+
+	while (tmp.count > 0) { //correct the order of the rest args
+		Toy_Literal lit = Toy_popLiteralArray(&tmp);
+		Toy_pushLiteralArray(&rest, lit);
+		Toy_freeLiteral(lit);
+	}
+
+	Toy_freeLiteralArray(&tmp);
+
+	//get the runner object
+	Toy_Literal varName = Toy_popLiteralArray(arguments);
+	Toy_Literal runnerLiteral = Toy_popLiteralArray(arguments);
+
+	Toy_Literal varNameIdn = varName;
+	if (TOY_IS_IDENTIFIER(varName) && Toy_parseIdentifierToValue(interpreter, &varName)) {
+		Toy_freeLiteral(varNameIdn);
+	}
+
+	Toy_Literal runnerIdn = runnerLiteral;
+	if (TOY_IS_IDENTIFIER(runnerLiteral) && Toy_parseIdentifierToValue(interpreter, &runnerLiteral)) {
+		Toy_freeLiteral(runnerIdn);
+	}
+
+	if (TOY_GET_OPAQUE_TAG(runnerLiteral) != TOY_OPAQUE_TAG_RUNNER) {
+		interpreter->errorOutput("Unrecognized opaque literal in callScriptFn\n");
+		return -1;
+	}
+
+	Toy_Runner* runner = TOY_AS_OPAQUE(runnerLiteral);
+
+	//dirty check
+	if (!runner->dirty) {
+		interpreter->errorOutput("Can't access fn from a non-dirty script (try running it first)\n");
+		Toy_freeLiteral(runnerLiteral);
+		Toy_freeLiteralArray(&rest);
+		return -1;
+	}
+
+	//get the desired variable
+	Toy_Literal varIdn = TOY_TO_IDENTIFIER_LITERAL(Toy_copyRefString(TOY_AS_STRING(varName)));
+	Toy_Literal fn = TOY_TO_NULL_LITERAL;
+	Toy_getScopeVariable(runner->interpreter.scope, varIdn, &fn);
+
+	if (!TOY_IS_FUNCTION(fn)) {
+		interpreter->errorOutput("Can't run a non-function literal\n");
+		Toy_freeLiteral(fn);
+		Toy_freeLiteral(varIdn);
+		Toy_freeLiteral(varName);
+		Toy_freeLiteral(runnerLiteral);
+		Toy_freeLiteralArray(&rest);
+	}
+
+	//call
+	Toy_LiteralArray resultArray;
+	Toy_initLiteralArray(&resultArray);
+
+	Toy_callLiteralFn(interpreter, fn, &rest, &resultArray);
+
+	Toy_Literal result = TOY_TO_NULL_LITERAL;
+	if (resultArray.count > 0) {
+		result = Toy_popLiteralArray(&resultArray);
+	}
+
+	Toy_pushLiteralArray(&interpreter->stack, result);
+
+	//cleanup
+	Toy_freeLiteralArray(&resultArray);
+	Toy_freeLiteral(result);
+	Toy_freeLiteral(fn);
+	Toy_freeLiteral(varIdn);
+	Toy_freeLiteral(varName);
+	Toy_freeLiteral(runnerLiteral);
+	Toy_freeLiteralArray(&rest);
+
+	return 1;
+}
+
+static int nativeResetScript(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments) {
+	//no arguments
+	if (arguments->count != 1) {
+		interpreter->errorOutput("Incorrect number of arguments to resetScript\n");
+		return -1;
+	}
+
+	//get the runner object
+	Toy_Literal runnerLiteral = Toy_popLiteralArray(arguments);
+
+	Toy_Literal runnerIdn = runnerLiteral;
+	if (TOY_IS_IDENTIFIER(runnerLiteral) && Toy_parseIdentifierToValue(interpreter, &runnerLiteral)) {
+		Toy_freeLiteral(runnerIdn);
+	}
+
+	if (TOY_GET_OPAQUE_TAG(runnerLiteral) != TOY_OPAQUE_TAG_RUNNER) {
+		interpreter->errorOutput("Unrecognized opaque literal in resetScript\n");
+		return -1;
+	}
+
+	Toy_Runner* runner = TOY_AS_OPAQUE(runnerLiteral);
+
+	//reset
+	if (!runner->dirty) {
+		interpreter->errorOutput("Can't reset a non-dirty script (try running it first)\n");
+		Toy_freeLiteral(runnerLiteral);
+		return -1;
+	}
+
+	Toy_resetInterpreter(&runner->interpreter);
+	runner->dirty = false;
+	Toy_freeLiteral(runnerLiteral);
+
+	return 0;
+}
+
+static int nativeFreeScript(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments) {
+	//no arguments
+	if (arguments->count != 1) {
+		interpreter->errorOutput("Incorrect number of arguments to freeScript\n");
+		return -1;
+	}
+
+	//get the runner object
+	Toy_Literal runnerLiteral = Toy_popLiteralArray(arguments);
+
+	Toy_Literal runnerIdn = runnerLiteral;
+	if (TOY_IS_IDENTIFIER(runnerLiteral) && Toy_parseIdentifierToValue(interpreter, &runnerLiteral)) {
+		Toy_freeLiteral(runnerIdn);
+	}
+
+	if (TOY_GET_OPAQUE_TAG(runnerLiteral) != TOY_OPAQUE_TAG_RUNNER) {
+		interpreter->errorOutput("Unrecognized opaque literal in freeScript\n");
+		return -1;
+	}
+
+	Toy_Runner* runner = TOY_AS_OPAQUE(runnerLiteral);
+
+	//clear out the runner object
+	runner->interpreter.hooks = NULL;
+	Toy_freeInterpreter(&runner->interpreter);
+	TOY_FREE_ARRAY(unsigned char, runner->bytecode, runner->size);
+
+	TOY_FREE(Toy_Runner, runner);
+
+	Toy_freeLiteral(runnerLiteral);
+
+	return 0;
+}
+
+static int nativeCheckScriptDirty(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments) {
+	//no arguments
+	if (arguments->count != 1) {
+		interpreter->errorOutput("Incorrect number of arguments to checkScriptDirty\n");
+		return -1;
+	}
+
+	//get the runner object
+	Toy_Literal runnerLiteral = Toy_popLiteralArray(arguments);
+
+	Toy_Literal runnerIdn = runnerLiteral;
+	if (TOY_IS_IDENTIFIER(runnerLiteral) && Toy_parseIdentifierToValue(interpreter, &runnerLiteral)) {
+		Toy_freeLiteral(runnerIdn);
+	}
+
+	if (TOY_GET_OPAQUE_TAG(runnerLiteral) != TOY_OPAQUE_TAG_RUNNER) {
+		interpreter->errorOutput("Unrecognized opaque literal in checkScriptDirty\n");
+		return -1;
+	}
+
+	Toy_Runner* runner = TOY_AS_OPAQUE(runnerLiteral);
+
+	//run
+	Toy_Literal result = TOY_TO_BOOLEAN_LITERAL(runner->dirty);
+
+	Toy_pushLiteralArray(&interpreter->stack, result);
+
+	//cleanup
+	Toy_freeLiteral(result);
+	Toy_freeLiteral(runnerLiteral);
+
+	return 0;
+}
+
+//call the hook
+typedef struct Natives {
+	const char* name;
+	Toy_NativeFn fn;
+} Natives;
+
+int Toy_hookRunner(Toy_Interpreter* interpreter, Toy_Literal identifier, Toy_Literal alias) {
+	//build the natives list
+	Natives natives[] = {
+		{"loadScript", nativeLoadScript},
+		{"loadScriptBytecode", nativeLoadScriptBytecode},
+		{"runScript", nativeRunScript},
+		{"getScriptVar", nativeGetScriptVar},
+		{"callScriptFn", nativeCallScriptFn},
+		{"resetScript", nativeResetScript},
+		{"freeScript", nativeFreeScript},
+		{"checkScriptDirty", nativeCheckScriptDirty},
+		{NULL, NULL}
+	};
+
+	//store the library in an aliased dictionary
+	if (!TOY_IS_NULL(alias)) {
+		//make sure the name isn't taken
+		if (Toy_isDeclaredScopeVariable(interpreter->scope, alias)) {
+			interpreter->errorOutput("Can't override an existing variable\n");
+			Toy_freeLiteral(alias);
+			return -1;
+		}
+
+		//create the dictionary to load up with functions
+		Toy_LiteralDictionary* dictionary = TOY_ALLOCATE(Toy_LiteralDictionary, 1);
+		Toy_initLiteralDictionary(dictionary);
+
+		//load the dict with functions
+		for (int i = 0; natives[i].name; i++) {
+			Toy_Literal name = TOY_TO_STRING_LITERAL(Toy_createRefString(natives[i].name));
+			Toy_Literal func = TOY_TO_FUNCTION_NATIVE_LITERAL(natives[i].fn);
+
+			Toy_setLiteralDictionary(dictionary, name, func);
+
+			Toy_freeLiteral(name);
+			Toy_freeLiteral(func);
+		}
+
+		//build the type
+		Toy_Literal type = TOY_TO_TYPE_LITERAL(TOY_LITERAL_DICTIONARY, true);
+		Toy_Literal strType = TOY_TO_TYPE_LITERAL(TOY_LITERAL_STRING, true);
+		Toy_Literal fnType = TOY_TO_TYPE_LITERAL(TOY_LITERAL_FUNCTION_NATIVE, true);
+		TOY_TYPE_PUSH_SUBTYPE(&type, strType);
+		TOY_TYPE_PUSH_SUBTYPE(&type, fnType);
+
+		//set scope
+		Toy_Literal dict = TOY_TO_DICTIONARY_LITERAL(dictionary);
+		Toy_declareScopeVariable(interpreter->scope, alias, type);
+		Toy_setScopeVariable(interpreter->scope, alias, dict, false);
+
+		//cleanup
+		Toy_freeLiteral(dict);
+		Toy_freeLiteral(type);
+		return 0;
+	}
+
+	//default
+	for (int i = 0; natives[i].name; i++) {
+		Toy_injectNativeFn(interpreter, natives[i].name, natives[i].fn);
+	}
+
+	return 0;
+}
+

repl/lib_runner.h

@@ -0,0 +1,7 @@
+#pragma once
+
+#include "toy_interpreter.h"
+
+#define TOY_OPAQUE_TAG_RUNNER 100
+
+int Toy_hookRunner(Toy_Interpreter* interpreter, Toy_Literal identifier, Toy_Literal alias);

repl/lib_standard.h

@@ -0,0 +1,5 @@
+#pragma once
+
+#include "toy_interpreter.h"
+
+int Toy_hookStandard(Toy_Interpreter* interpreter, Toy_Literal identifier, Toy_Literal alias);

repl/lib_toy_version_info.c

@@ -0,0 +1,162 @@
+#include "lib_toy_version_info.h"
+
+#include "toy_memory.h"
+
+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 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 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);
+	Toy_Literal buildLiteral = TOY_TO_STRING_LITERAL(Toy_createRefString(TOY_VERSION_BUILD));
+	Toy_Literal authorLiteral = TOY_TO_STRING_LITERAL(Toy_createRefString("Kayne Ruse, KR Game Studios"));
+
+	//store as an aliased dictionary
+	if (!TOY_IS_NULL(alias)) {
+		//make sure the name isn't taken
+		if (Toy_isDeclaredScopeVariable(interpreter->scope, alias)) {
+			interpreter->errorOutput("Can't override an existing variable\n");
+			Toy_freeLiteral(alias);
+
+			Toy_freeLiteral(majorKeyLiteral);
+			Toy_freeLiteral(minorKeyLiteral);
+			Toy_freeLiteral(patchKeyLiteral);
+			Toy_freeLiteral(buildKeyLiteral);
+			Toy_freeLiteral(authorKeyLiteral);
+
+			Toy_freeLiteral(majorIdentifierLiteral);
+			Toy_freeLiteral(minorIdentifierLiteral);
+			Toy_freeLiteral(patchIdentifierLiteral);
+			Toy_freeLiteral(buildIdentifierLiteral);
+			Toy_freeLiteral(authorIdentifierLiteral);
+
+			Toy_freeLiteral(majorLiteral);
+			Toy_freeLiteral(minorLiteral);
+			Toy_freeLiteral(patchLiteral);
+			Toy_freeLiteral(buildLiteral);
+			Toy_freeLiteral(authorLiteral);
+
+			return -1;
+		}
+
+		//create the dictionary to load up with values
+		Toy_LiteralDictionary* dictionary = TOY_ALLOCATE(Toy_LiteralDictionary, 1);
+		Toy_initLiteralDictionary(dictionary);
+
+		//set each key/value pair
+		Toy_setLiteralDictionary(dictionary, majorKeyLiteral, majorLiteral);
+		Toy_setLiteralDictionary(dictionary, minorKeyLiteral, minorLiteral);
+		Toy_setLiteralDictionary(dictionary, patchKeyLiteral, patchLiteral);
+		Toy_setLiteralDictionary(dictionary, buildKeyLiteral, buildLiteral);
+		Toy_setLiteralDictionary(dictionary, authorKeyLiteral, authorLiteral);
+
+		//build the type
+		Toy_Literal type = TOY_TO_TYPE_LITERAL(TOY_LITERAL_DICTIONARY, true);
+		Toy_Literal strType = TOY_TO_TYPE_LITERAL(TOY_LITERAL_STRING, true);
+		Toy_Literal anyType = TOY_TO_TYPE_LITERAL(TOY_LITERAL_ANY, true);
+		TOY_TYPE_PUSH_SUBTYPE(&type, strType);
+		TOY_TYPE_PUSH_SUBTYPE(&type, anyType);
+
+		//set scope
+		Toy_Literal dict = TOY_TO_DICTIONARY_LITERAL(dictionary);
+		Toy_declareScopeVariable(interpreter->scope, alias, type);
+		Toy_setScopeVariable(interpreter->scope, alias, dict, false);
+
+		//cleanup
+		Toy_freeLiteral(dict);
+		Toy_freeLiteral(type);
+	}
+
+	//store globally
+	else {
+		//make sure the names aren't taken
+		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);
+
+			Toy_freeLiteral(majorKeyLiteral);
+			Toy_freeLiteral(minorKeyLiteral);
+			Toy_freeLiteral(patchKeyLiteral);
+			Toy_freeLiteral(buildKeyLiteral);
+			Toy_freeLiteral(authorKeyLiteral);
+
+			Toy_freeLiteral(majorIdentifierLiteral);
+			Toy_freeLiteral(minorIdentifierLiteral);
+			Toy_freeLiteral(patchIdentifierLiteral);
+			Toy_freeLiteral(buildIdentifierLiteral);
+			Toy_freeLiteral(authorIdentifierLiteral);
+
+			Toy_freeLiteral(majorLiteral);
+			Toy_freeLiteral(minorLiteral);
+			Toy_freeLiteral(patchLiteral);
+			Toy_freeLiteral(buildLiteral);
+			Toy_freeLiteral(authorLiteral);
+
+			return -1;
+		}
+
+		Toy_Literal intType = TOY_TO_TYPE_LITERAL(TOY_LITERAL_INTEGER, true);
+		Toy_Literal strType = TOY_TO_TYPE_LITERAL(TOY_LITERAL_STRING, true);
+
+		//major
+		Toy_declareScopeVariable(interpreter->scope, majorIdentifierLiteral, intType);
+		Toy_setScopeVariable(interpreter->scope, majorIdentifierLiteral, majorLiteral, false);
+
+		//minor
+		Toy_declareScopeVariable(interpreter->scope, minorIdentifierLiteral, intType);
+		Toy_setScopeVariable(interpreter->scope, minorIdentifierLiteral, minorLiteral, false);
+
+		//patch
+		Toy_declareScopeVariable(interpreter->scope, patchIdentifierLiteral, intType);
+		Toy_setScopeVariable(interpreter->scope, patchIdentifierLiteral, patchLiteral, false);
+
+		//build
+		Toy_declareScopeVariable(interpreter->scope, buildIdentifierLiteral, strType);
+		Toy_setScopeVariable(interpreter->scope, buildIdentifierLiteral, buildLiteral, false);
+
+		//author
+		Toy_declareScopeVariable(interpreter->scope, authorIdentifierLiteral, strType);
+		Toy_setScopeVariable(interpreter->scope, authorIdentifierLiteral, authorLiteral, false);
+
+		Toy_freeLiteral(intType);
+		Toy_freeLiteral(strType);
+	}
+
+	//cleanup
+	Toy_freeLiteral(majorKeyLiteral);
+	Toy_freeLiteral(minorKeyLiteral);
+	Toy_freeLiteral(patchKeyLiteral);
+	Toy_freeLiteral(buildKeyLiteral);
+	Toy_freeLiteral(authorKeyLiteral);
+
+	Toy_freeLiteral(majorIdentifierLiteral);
+	Toy_freeLiteral(minorIdentifierLiteral);
+	Toy_freeLiteral(patchIdentifierLiteral);
+	Toy_freeLiteral(buildIdentifierLiteral);
+	Toy_freeLiteral(authorIdentifierLiteral);
+
+	Toy_freeLiteral(majorLiteral);
+	Toy_freeLiteral(minorLiteral);
+	Toy_freeLiteral(patchLiteral);
+	Toy_freeLiteral(buildLiteral);
+	Toy_freeLiteral(authorLiteral);
+
+	return 0;
+}

repl/lib_toy_version_info.h

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

repl/makefile

@@ -0,0 +1,36 @@
+CC=gcc
+
+IDIR+=. ../source
+CFLAGS+=$(addprefix -I,$(IDIR)) -g -Wall -W -Wno-unused-parameter -Wno-unused-function -Wno-unused-variable
+LIBS+=-ltoy -lm
+
+ODIR = obj
+SRC = $(wildcard *.c)
+OBJ = $(addprefix $(ODIR)/,$(SRC:.c=.o))
+OUTNAME=toy
+OUT=../$(TOY_OUTDIR)/toyrepl
+
+all: $(OBJ)
+ifeq ($(shell uname),Darwin)
+	cp $(PWD)/$(TOY_OUTDIR)/lib$(OUTNAME).dylib /usr/local/lib/
+	$(CC) -DTOY_IMPORT $(CFLAGS) -o $(OUT) $(OBJ) $(LIBS)
+else
+	$(CC) -DTOY_IMPORT $(CFLAGS) -o $(OUT) $(OBJ) -Wl,-rpath,. -L$(realpath $(shell pwd)/../$(TOY_OUTDIR)) $(LIBS)
+endif
+
+release: all
+	strip $(OUT)
+
+$(OBJ): | $(ODIR)
+
+$(ODIR):
+	mkdir $(ODIR)
+
+$(ODIR)/%.o: %.c
+	$(CC) -c -o $@ $< $(CFLAGS)
+
+.PHONY: clean
+
+clean:
+	$(RM) $(ODIR)
+	rm /usr/local/lib/lib$(OUTNAME).dylib

repl/repl_main.c

@@ -0,0 +1,233 @@
+#include "repl_tools.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.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define INPUT_BUFFER_SIZE 2048
+
+void repl(const char* initialInput) {
+	//repl does it's own thing for now
+	bool error = false;
+
+	char input[INPUT_BUFFER_SIZE];
+	memset(input, 0, INPUT_BUFFER_SIZE);
+
+	Toy_Interpreter interpreter; //persist the interpreter for the scopes
+	Toy_initInterpreter(&interpreter);
+
+	//inject the libs
+	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) {
+			//handle EOF for exits
+			printf("> ");
+			if (!fgets(input, INPUT_BUFFER_SIZE, stdin)) {
+				break;
+			}
+		}
+
+		//escape the repl (length of 5 to accomodate the newline)
+		if (strlen(input) == 5 && (!strncmp(input, "exit", 4) || !strncmp(input, "quit", 4))) {
+			break;
+		}
+
+		//setup this iteration
+		Toy_Lexer lexer;
+		Toy_Parser parser;
+		Toy_Compiler compiler;
+
+		Toy_initLexer(&lexer, initialInput ? initialInput : input);
+		Toy_private_setComments(&lexer, initialInput != NULL); //BUGFIX: disable comments here
+		Toy_initParser(&parser, &lexer);
+		Toy_initCompiler(&compiler);
+
+		//run this iteration
+		Toy_ASTNode* node = Toy_scanParser(&parser);
+		while(node != NULL) {
+			//pack up and restart
+			if (node->type == TOY_AST_NODE_ERROR) {
+				if (Toy_commandLine.verbose) {
+					printf(TOY_CC_ERROR "Error node detected\n" TOY_CC_RESET);
+				}
+				error = true;
+				Toy_freeASTNode(node);
+				break;
+			}
+
+			Toy_writeCompiler(&compiler, node);
+			Toy_freeASTNode(node);
+			node = Toy_scanParser(&parser);
+		}
+
+		if (!error) {
+			//get the bytecode dump
+			size_t size = 0;
+			unsigned char* tb = Toy_collateCompiler(&compiler, &size);
+
+			//run the bytecode
+			Toy_runInterpreter(&interpreter, tb, size);
+		}
+
+		//clean up this iteration
+		Toy_freeCompiler(&compiler);
+		Toy_freeParser(&parser);
+		error = false;
+
+		if (initialInput) {
+			free((void*)initialInput);
+			initialInput = NULL;
+
+			if (interpreter.panic) {
+				break;
+			}
+		}
+	}
+
+	Toy_freeInterpreter(&interpreter);
+}
+
+//entry point
+int main(int argc, const char* argv[]) {
+	Toy_initCommandLine(argc, argv);
+
+	//setup the drive system (for filesystem access)
+	Toy_initDriveSystem();
+	Toy_setDrivePath("scripts", "scripts");
+
+	//command line specific actions
+	if (Toy_commandLine.error) {
+		Toy_usageCommandLine(argc, argv);
+		return 0;
+	}
+
+	if (Toy_commandLine.help) {
+		Toy_helpCommandLine(argc, argv);
+		return 0;
+	}
+
+	if (Toy_commandLine.version) {
+		Toy_copyrightCommandLine(argc, argv);
+		return 0;
+	}
+
+	//version
+	if (Toy_commandLine.verbose) {
+		printf(TOY_CC_NOTICE "Toy Programming Language Version %d.%d.%d, built '%s'\n" TOY_CC_RESET, TOY_VERSION_MAJOR, TOY_VERSION_MINOR, TOY_VERSION_PATCH, TOY_VERSION_BUILD);
+	}
+
+	//run source file
+	if (Toy_commandLine.sourcefile) {
+		//only works on toy files
+		const char* s = strrchr(Toy_commandLine.sourcefile, '.');
+		if (!s || strcmp(s, ".toy")) {
+			fprintf(stderr, TOY_CC_ERROR "Bad file extension passed to %s (expected '.toy', found '%s')" TOY_CC_RESET, argv[0], s);
+			return -1;
+		}
+
+		//run the source file
+		Toy_runSourceFile(Toy_commandLine.sourcefile);
+
+		//lib cleanup
+		Toy_freeDriveSystem();
+
+		return 0;
+	}
+
+	//run from stdin
+	if (Toy_commandLine.source) {
+		Toy_runSource(Toy_commandLine.source);
+
+		//lib cleanup
+		Toy_freeDriveSystem();
+
+		return 0;
+	}
+
+	//compile source file
+	if (Toy_commandLine.compilefile && Toy_commandLine.outfile) {
+		//only works on toy and tb files
+		const char* c = strrchr(Toy_commandLine.compilefile, '.');
+		if (!c || strcmp(c, ".toy")) {
+			fprintf(stderr, TOY_CC_ERROR "Bad file extension passed to %s (expected '.toy', found '%s')" TOY_CC_RESET, argv[0], c);
+			return -1;
+		}
+		const char* o = strrchr(Toy_commandLine.outfile, '.');
+		if (!o || strcmp(o, ".tb")) {
+			fprintf(stderr, TOY_CC_ERROR "Bad file extension passed to %s (expected '.tb', found '%s')" TOY_CC_RESET, argv[0], o);
+			return -1;
+		}
+
+		//compile and save
+		size_t size = 0;
+		const char* source = (const char*)Toy_readFile(Toy_commandLine.compilefile, &size);
+		if (!source) {
+			return 1;
+		}
+		const unsigned char* tb = Toy_compileString(source, &size);
+		if (!tb) {
+			return 1;
+		}
+		Toy_writeFile(Toy_commandLine.outfile, tb, size);
+		return 0;
+	}
+
+	//run binary
+	if (Toy_commandLine.binaryfile) {
+		//only works on tb files
+		const char* c = strrchr(Toy_commandLine.binaryfile, '.');
+		if (!c || strcmp(c, ".tb")) {
+			fprintf(stderr, TOY_CC_ERROR "Bad file extension passed to %s (expected '.tb', found '%s')" TOY_CC_RESET, argv[0], c); //this one is never seen
+			return -1;
+		}
+
+		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_freeDriveSystem();
+
+		return 0;
+	}
+
+	const char* initialSource = NULL;
+	if (Toy_commandLine.initialfile) {
+		//only works on toy files
+		const char* s = strrchr(Toy_commandLine.initialfile, '.');
+		if (!s || strcmp(s, ".toy")) {
+			fprintf(stderr, TOY_CC_ERROR "Bad file extension passed to %s (expected '.toy', found '%s')" TOY_CC_RESET, argv[0], s);
+			return -1;
+		}
+
+		size_t size;
+		initialSource = (const char*)Toy_readFile(Toy_commandLine.initialfile, &size);
+	}
+
+	repl(initialSource);
+
+	//lib cleanup
+	Toy_freeDriveSystem();
+
+	return 0;
+}

repl/repl_tools.c

@@ -0,0 +1,209 @@
+#include "repl_tools.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 <stdio.h>
+#include <stdlib.h>
+
+//IO functions
+const unsigned char* Toy_readFile(const char* path, size_t* fileSize) {
+	FILE* file = fopen(path, "rb");
+
+	if (file == NULL) {
+		fprintf(stderr, TOY_CC_ERROR "Could not open file \"%s\"\n" TOY_CC_RESET, path);
+		return NULL;
+	}
+
+	fseek(file, 0L, SEEK_END);
+	*fileSize = ftell(file);
+	rewind(file);
+
+	unsigned char* buffer = (unsigned char*)malloc(*fileSize + 1);
+
+	if (buffer == NULL) {
+		fprintf(stderr, TOY_CC_ERROR "Not enough memory to read \"%s\"\n" TOY_CC_RESET, path);
+		return NULL;
+	}
+
+	size_t bytesRead = fread(buffer, sizeof(unsigned char), *fileSize, file);
+
+	buffer[*fileSize] = '\0'; //NOTE: fread doesn't append this
+
+	if (bytesRead < *fileSize) {
+		fprintf(stderr, TOY_CC_ERROR "Could not read file \"%s\"\n" TOY_CC_RESET, path);
+		return NULL;
+	}
+
+	fclose(file);
+
+	return buffer;
+}
+
+int Toy_writeFile(const char* path, const unsigned char* bytes, size_t size) {
+	FILE* file = fopen(path, "wb");
+
+	if (file == NULL) {
+		fprintf(stderr, TOY_CC_ERROR "Could not open file \"%s\"\n" TOY_CC_RESET, path);
+		return -1;
+	}
+
+	size_t written = fwrite(bytes, size, 1, file);
+
+	if (written != 1) {
+		fprintf(stderr, TOY_CC_ERROR "Could not write file \"%s\"\n" TOY_CC_RESET, path);
+		return -1;
+	}
+
+	fclose(file);
+
+	return 0;
+}
+
+//repl functions
+const unsigned char* Toy_compileString(const char* source, size_t* size) {
+	Toy_Lexer lexer;
+	Toy_Parser parser;
+	Toy_Compiler compiler;
+
+	Toy_initLexer(&lexer, source);
+	Toy_initParser(&parser, &lexer);
+	Toy_initCompiler(&compiler);
+
+	//step 1 - run the parser until the end of the source
+	Toy_ASTNode* node = Toy_scanParser(&parser);
+	while(node != NULL) {
+		//on error, pack up and leave
+		if (node->type == TOY_AST_NODE_ERROR) {
+			Toy_freeASTNode(node);
+			Toy_freeCompiler(&compiler);
+			Toy_freeParser(&parser);
+			return NULL;
+		}
+
+		Toy_writeCompiler(&compiler, node);
+		Toy_freeASTNode(node);
+		node = Toy_scanParser(&parser);
+	}
+
+	//step 2 - get the bytecode dump
+	const unsigned char* tb = Toy_collateCompiler(&compiler, size);
+
+	//cleanup
+	Toy_freeCompiler(&compiler);
+	Toy_freeParser(&parser);
+	//no lexer to clean up
+
+	//finally
+	return tb;
+}
+
+void Toy_runBinary(const unsigned char* tb, size_t size) {
+	Toy_Interpreter interpreter;
+	Toy_initInterpreter(&interpreter);
+
+	//inject the libs
+	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);
+}
+
+void Toy_runBinaryFile(const char* fname) {
+	size_t size = 0; //not used
+	const unsigned char* tb = Toy_readFile(fname, &size);
+	if (!tb) {
+		return;
+	}
+	Toy_runBinary(tb, size);
+	//interpreter takes ownership of the binary data
+}
+
+void Toy_runSource(const char* source) {
+	size_t size = 0;
+	const unsigned char* tb = Toy_compileString(source, &size);
+	if (!tb) {
+		return;
+	}
+
+	Toy_runBinary(tb, size);
+}
+
+void Toy_runSourceFile(const char* fname) {
+	size_t size = 0; //not used
+	const char* source = (const char*)Toy_readFile(fname, &size);
+	if (!source) {
+		return;
+	}
+	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);
+}

repl/repl_tools.h

@@ -1,54 +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 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_about
+* 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);

safari-pinned-tab.svg

@@ -1,16 +0,0 @@
-<?xml version="1.0" standalone="no"?>
-<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 20010904//EN"
- "http://www.w3.org/TR/2001/REC-SVG-20010904/DTD/svg10.dtd">
-<svg version="1.0" xmlns="http://www.w3.org/2000/svg"
- width="454.000000pt" height="454.000000pt" viewBox="0 0 454.000000 454.000000"
- preserveAspectRatio="xMidYMid meet">
-<metadata>
-Created by potrace 1.14, written by Peter Selinger 2001-2017
-</metadata>
-<g transform="translate(0.000000,454.000000) scale(0.100000,-0.100000)"
-fill="#000000" stroke="none">
-<path d="M1178 4533 c-3 -5 -4 -508 -3 -1118 l0 -1111 -565 0 -565 0 -3 -1152
--2 -1152 2230 0 2230 0 -2 1152 -3 1152 -522 0 c-359 0 -523 3 -524 10 0 6 0
-509 0 1119 l-1 1107 -1133 0 c-624 0 -1135 -3 -1137 -7z"/>
-</g>
-</svg>

scripts/fib-memo.toy

@@ -0,0 +1,21 @@
+//memoize the fib function
+var memo: [int : int] = [:];
+
+fn fib(n : int) {
+	if (n < 2) {
+		return n;
+	}
+
+	var result = memo[n];
+	if (result == null) {
+		result = fib(n-1) + fib(n-2);
+		memo[n] = result;
+	}
+
+	return result;
+}
+
+for (var i = 0; i < 40; i++) {
+	var res = fib(i);
+	print string i + ": " + string res;
+}

scripts/fib.toy

@@ -0,0 +1,10 @@
+//WARNING: please think twice before using this in a test
+fn fib(n : int) {
+	if (n < 2) return n;
+	return fib(n-1) + fib(n-2);
+}
+
+for (var i = 0; i <= 35; i++) {
+	var res = fib(i);
+	print string i + ": " + string res;
+}

scripts/level.toy

@@ -0,0 +1,90 @@
+/*
+
+How to run this program:
+
+	toyrepl -n -t scripts/level.toy
+
+How to move around:
+
+	move(up);
+	move(down);
+	move(left);
+	move(right);
+
+*/
+
+//constants
+var WIDTH: int const = 12;
+var HEIGHT: int const = 12;
+
+//WIDTH * HEIGHT in size
+var tiles: [[int]] const = [
+	[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
+	[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
+	[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
+	[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
+	[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
+	[1, 0, 1, 1, 0, 0, 0, 0, 1, 1, 0, 1],
+	[1, 0, 1, 1, 0, 0, 0, 0, 1, 1, 0, 1],
+	[1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1],
+	[1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 1],
+	[1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 1],
+	[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
+	[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] //BUG: map is twisted along this diagonal
+];
+
+var tileset: [int: string] const = [
+	0: "  ",
+	1: "X "
+];
+
+//variables
+var posX: int = 4;
+var posY: int = 4;
+
+//functions
+fn draw() {
+	for (var j: int = 0; j < HEIGHT; j++) {
+		for (var i: int = 0; i < WIDTH; i++) {
+			//draw the player pos
+			if (i == posX && j == posY) {
+				print "O ";
+				continue;
+			}
+
+			print tileset[ tiles[i][j] ];
+		}
+		print "\n";
+	}
+	print "\n";
+}
+
+fn moveRelative(xrel: int, yrel: int) {
+	if (xrel > 1 || xrel < -1 || yrel > 1 || yrel < -1 || (xrel != 0 && yrel != 0)) {
+		print "too fast!\n";
+		return;
+	}
+
+	if (tiles[posX + xrel][posY + yrel] > 0) {
+		print "Can't move that way\n";
+		return;
+	}
+
+	posX += xrel;
+	posY += yrel;
+
+	draw();
+}
+
+//wrap for easy use
+var up: [int] const = [0, -1];
+var down: [int] const = [0, 1];
+var left: [int] const = [-1, 0];
+var right: [int] const = [1, 0];
+
+fn move(dir: [int] const) {
+	return moveRelative(dir[0], dir[1]);
+}
+
+//initial display
+move([0, 0]);

scripts/roguelike-seeds.toy

@@ -0,0 +1,36 @@
+/*
+
+Since this is a pseudo-random generator, and there's no internal state to the algorithm other
+than the generator opaque, there needs to be a "call counter" (current depth) to shuffle the
+initial seeds, otherwise generators created from other generators will resemble their parents,
+but one call greater.
+
+*/
+
+import standard;
+import random;
+
+var DEPTH: int const = 20;
+var levels = [];
+
+//generate the level seeds
+var generator: opaque = createRandomGenerator(clock().hash());
+
+for (var i: int = 0; i < DEPTH; i++) {
+	levels.push(generator.generateRandomNumber());
+}
+
+generator.freeRandomGenerator();
+
+//generate "levels" of a roguelike
+for (var i = 0; i < DEPTH; i++) {
+	var rng: opaque = createRandomGenerator(levels[i] + i);
+
+	print "---";
+	print levels[i];
+	print rng.generateRandomNumber();
+	print rng.generateRandomNumber();
+	print rng.generateRandomNumber();
+
+	rng.freeRandomGenerator();
+}

scripts/rule110.toy

@@ -0,0 +1,49 @@
+//number of iterations
+var SIZE: int const = 100;
+
+//lookup table
+var lookup = [
+	"*": [
+		"*": [
+			"*": " ",
+			" ": "*"
+		],
+		" ": [
+			"*": "*",
+			" ": " "
+		]
+], " ": [
+		"*": [
+			"*": "*",
+			" ": "*"
+		],
+		" ": [
+			"*": "*",
+			" ": " "
+		]
+]];
+
+//initial line to build from
+var prev: string = "";
+for (var i = 0; i < SIZE -1; i++) {
+	prev += " ";
+}
+prev += "*"; //initial
+print prev;
+
+//run
+for (var iteration = 0; iteration < SIZE -1; iteration++) {
+	//left
+	var output = (lookup[" "][prev[0]][prev[1]]);
+
+	//middle
+	for (var i = 1; i < SIZE-1; i++) {
+		output += (lookup[prev[i-1]][prev[i]][prev[i+1]]);
+	}
+
+	//right
+	output += (lookup[prev[SIZE-2]][prev[SIZE-1]][" "]);
+
+	print output;
+	prev = output;
+}

scripts/test.toy

@@ -0,0 +1,13 @@
+fn f() {
+    //
+}
+
+fn g() {
+    fn i() {
+        //
+    }
+}
+
+fn h() {
+    //
+}

site.webmanifest

@@ -1,19 +0,0 @@
-{
-    "name": "",
-    "short_name": "",
-    "icons": [
-        {
-            "src": "/android-chrome-192x192.png",
-            "sizes": "192x192",
-            "type": "image/png"
-        },
-        {
-            "src": "/android-chrome-384x384.png",
-            "sizes": "384x384",
-            "type": "image/png"
-        }
-    ],
-    "theme_color": "#ffffff",
-    "background_color": "#ffffff",
-    "display": "standalone"
-}

source/makefile

@@ -0,0 +1,54 @@
+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))
+
+OUTNAME=toy
+
+ifeq ($(findstring CYGWIN, $(shell uname)),CYGWIN)
+	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,-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,-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)
+	OUT=../$(TOY_OUTDIR)/lib$(OUTNAME).dylib
+else
+	@echo "Platform test failed - what platform is this?"
+	exit 1
+endif
+
+library: $(OBJ)
+	$(CC) -DTOY_EXPORT $(CFLAGS) -shared -o $(OUT) $(LIBLINE)
+
+static: $(OBJ)
+	ar crs ../$(TOY_OUTDIR)/lib$(OUTNAME).a $(OBJ)
+
+library-release: $(OBJ) library
+	strip $(OUT)
+
+static-release: $(OBJ) static
+	strip -d ../$(TOY_OUTDIR)/lib$(OUTNAME).a
+
+$(OBJ): | $(ODIR)
+
+$(ODIR):
+	mkdir $(ODIR)
+
+$(ODIR)/%.o: %.c
+	$(CC) -c -o $@ $< $(CFLAGS)
+
+.PHONY: clean
+
+clean:
+	$(RM) $(ODIR)

source/toy.h

@@ -1,10 +1,13 @@
+#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.
@@ -14,7 +17,13 @@ The most important macro is `TOY_API`, which specifies functions intended for th
 * [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:
@@ -32,7 +41,14 @@ I should note that the parser -> compiler phase is actually made up of two steps
 * [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.
@@ -44,17 +60,28 @@ Literal dictionaries are unordered key-value hashmaps, that use a running strate
 * [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 its own memory allocator system that is plugged into the main memory allocator.
+`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"

source/toy_ast_node.c

@@ -0,0 +1,433 @@
+#include "toy_ast_node.h"
+
+#include "toy_memory.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+
+static void freeASTNodeCustom(Toy_ASTNode* node, bool freeSelf) {
+	//don't free a NULL node
+	if (node == NULL) {
+		return;
+	}
+
+	switch(node->type) {
+		case TOY_AST_NODE_ERROR:
+			//NO-OP
+		break;
+
+		case TOY_AST_NODE_LITERAL:
+			Toy_freeLiteral(node->atomic.literal);
+		break;
+
+		case TOY_AST_NODE_UNARY:
+			Toy_freeASTNode(node->unary.child);
+		break;
+
+		case TOY_AST_NODE_BINARY:
+			Toy_freeASTNode(node->binary.left);
+			Toy_freeASTNode(node->binary.right);
+		break;
+
+		case TOY_AST_NODE_TERNARY:
+			Toy_freeASTNode(node->ternary.condition);
+			Toy_freeASTNode(node->ternary.thenPath);
+			Toy_freeASTNode(node->ternary.elsePath);
+		break;
+
+		case TOY_AST_NODE_GROUPING:
+			Toy_freeASTNode(node->grouping.child);
+		break;
+
+		case TOY_AST_NODE_BLOCK:
+			if (node->block.capacity > 0) {
+				for (int i = 0; i < node->block.count; i++) {
+					freeASTNodeCustom(node->block.nodes + i, false);
+				}
+				TOY_FREE_ARRAY(Toy_ASTNode, node->block.nodes, node->block.capacity);
+			}
+		break;
+
+		case TOY_AST_NODE_COMPOUND:
+			if (node->compound.capacity > 0) {
+				for (int i = 0; i < node->compound.count; i++) {
+					freeASTNodeCustom(node->compound.nodes + i, false);
+				}
+				TOY_FREE_ARRAY(Toy_ASTNode, node->compound.nodes, node->compound.capacity);
+			}
+		break;
+
+		case TOY_AST_NODE_PAIR:
+			Toy_freeASTNode(node->pair.left);
+			Toy_freeASTNode(node->pair.right);
+		break;
+
+		case TOY_AST_NODE_INDEX:
+			Toy_freeASTNode(node->index.first);
+			Toy_freeASTNode(node->index.second);
+			Toy_freeASTNode(node->index.third);
+		break;
+
+		case TOY_AST_NODE_VAR_DECL:
+			Toy_freeLiteral(node->varDecl.identifier);
+			Toy_freeLiteral(node->varDecl.typeLiteral);
+			Toy_freeASTNode(node->varDecl.expression);
+		break;
+
+		case TOY_AST_NODE_FN_COLLECTION:
+			if (node->fnCollection.capacity > 0) {
+				for (int i = 0; i < node->fnCollection.count; i++) {
+					freeASTNodeCustom(node->fnCollection.nodes + i, false);
+				}
+				TOY_FREE_ARRAY(Toy_ASTNode, node->fnCollection.nodes, node->fnCollection.capacity);
+			}
+		break;
+
+		case TOY_AST_NODE_FN_DECL:
+			Toy_freeLiteral(node->fnDecl.identifier);
+			Toy_freeASTNode(node->fnDecl.arguments);
+			Toy_freeASTNode(node->fnDecl.returns);
+			Toy_freeASTNode(node->fnDecl.block);
+		break;
+
+		case TOY_AST_NODE_FN_CALL:
+			Toy_freeASTNode(node->fnCall.arguments);
+		break;
+
+		case TOY_AST_NODE_FN_RETURN:
+			Toy_freeASTNode(node->returns.returns);
+		break;
+
+		case TOY_AST_NODE_IF:
+			Toy_freeASTNode(node->pathIf.condition);
+			Toy_freeASTNode(node->pathIf.thenPath);
+			Toy_freeASTNode(node->pathIf.elsePath);
+		break;
+
+		case TOY_AST_NODE_WHILE:
+			Toy_freeASTNode(node->pathWhile.condition);
+			Toy_freeASTNode(node->pathWhile.thenPath);
+		break;
+
+		case TOY_AST_NODE_FOR:
+			Toy_freeASTNode(node->pathFor.preClause);
+			Toy_freeASTNode(node->pathFor.postClause);
+			Toy_freeASTNode(node->pathFor.condition);
+			Toy_freeASTNode(node->pathFor.thenPath);
+		break;
+
+		case TOY_AST_NODE_BREAK:
+			//NO-OP
+		break;
+
+		case TOY_AST_NODE_CONTINUE:
+			//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;
+		case TOY_AST_NODE_PREFIX_DECREMENT:
+			Toy_freeLiteral(node->prefixDecrement.identifier);
+		break;
+		case TOY_AST_NODE_POSTFIX_INCREMENT:
+			Toy_freeLiteral(node->postfixIncrement.identifier);
+		break;
+		case TOY_AST_NODE_POSTFIX_DECREMENT:
+			Toy_freeLiteral(node->postfixDecrement.identifier);
+		break;
+
+		case TOY_AST_NODE_IMPORT:
+			Toy_freeLiteral(node->import.identifier);
+			Toy_freeLiteral(node->import.alias);
+		break;
+
+		case TOY_AST_NODE_PASS:
+			//EMPTY
+		break;
+	}
+
+	if (freeSelf) {
+		TOY_FREE(Toy_ASTNode, node);
+	}
+}
+
+void Toy_freeASTNode(Toy_ASTNode* node) {
+	freeASTNodeCustom(node, true);
+}
+
+//various emitters
+void Toy_emitASTNodeLiteral(Toy_ASTNode** nodeHandle, Toy_Literal literal) {
+	//allocate a new node
+	*nodeHandle = TOY_ALLOCATE(Toy_ASTNode, 1);
+
+	(*nodeHandle)->type = TOY_AST_NODE_LITERAL;
+	(*nodeHandle)->atomic.literal = Toy_copyLiteral(literal);
+}
+
+void Toy_emitASTNodeUnary(Toy_ASTNode** nodeHandle, Toy_Opcode opcode, Toy_ASTNode* child) {
+	//allocate a new node
+	*nodeHandle = TOY_ALLOCATE(Toy_ASTNode, 1);
+
+	(*nodeHandle)->type = TOY_AST_NODE_UNARY;
+	(*nodeHandle)->unary.opcode = opcode;
+	(*nodeHandle)->unary.child = child;
+}
+
+void Toy_emitASTNodeBinary(Toy_ASTNode** nodeHandle, Toy_ASTNode* rhs, Toy_Opcode opcode) {
+	Toy_ASTNode* tmp = TOY_ALLOCATE(Toy_ASTNode, 1);
+
+	tmp->type = TOY_AST_NODE_BINARY;
+	tmp->binary.opcode = opcode;
+	tmp->binary.left = *nodeHandle;
+	tmp->binary.right = rhs;
+
+	*nodeHandle = tmp;
+}
+
+void Toy_emitASTNodeTernary(Toy_ASTNode** nodeHandle, Toy_ASTNode* condition, Toy_ASTNode* thenPath, Toy_ASTNode* elsePath) {
+	Toy_ASTNode* tmp = TOY_ALLOCATE(Toy_ASTNode, 1);
+
+	tmp->type = TOY_AST_NODE_TERNARY;
+	tmp->ternary.condition = condition;
+	tmp->ternary.thenPath = thenPath;
+	tmp->ternary.elsePath = elsePath;
+
+	*nodeHandle = tmp;
+}
+
+void Toy_emitASTNodeGrouping(Toy_ASTNode** nodeHandle) {
+	Toy_ASTNode* tmp = TOY_ALLOCATE(Toy_ASTNode, 1);
+
+	tmp->type = TOY_AST_NODE_GROUPING;
+	tmp->grouping.child = *nodeHandle;
+
+	*nodeHandle = tmp;
+}
+
+void Toy_emitASTNodeBlock(Toy_ASTNode** nodeHandle) {
+	Toy_ASTNode* tmp = TOY_ALLOCATE(Toy_ASTNode, 1);
+
+	tmp->type = TOY_AST_NODE_BLOCK;
+	tmp->block.nodes = NULL; //NOTE: appended by the parser
+	tmp->block.capacity = 0;
+	tmp->block.count = 0;
+
+	*nodeHandle = tmp;
+}
+
+void Toy_emitASTNodeCompound(Toy_ASTNode** nodeHandle, Toy_LiteralType literalType) {
+	Toy_ASTNode* tmp = TOY_ALLOCATE(Toy_ASTNode, 1);
+
+	tmp->type = TOY_AST_NODE_COMPOUND;
+	tmp->compound.literalType = literalType;
+	tmp->compound.nodes = NULL;
+	tmp->compound.capacity = 0;
+	tmp->compound.count = 0;
+
+	*nodeHandle = tmp;
+}
+
+void Toy_setASTNodePair(Toy_ASTNode* node, Toy_ASTNode* left, Toy_ASTNode* right) {
+	//set - assume the node has already been allocated
+	node->type = TOY_AST_NODE_PAIR;
+	node->pair.left = left;
+	node->pair.right = right;
+}
+
+void Toy_emitASTNodeIndex(Toy_ASTNode** nodeHandle, Toy_ASTNode* first, Toy_ASTNode* second, Toy_ASTNode* third) {
+	Toy_ASTNode* tmp = TOY_ALLOCATE(Toy_ASTNode, 1);
+
+	tmp->type = TOY_AST_NODE_INDEX;
+	tmp->index.first = first;
+	tmp->index.second = second;
+	tmp->index.third = third;
+
+	*nodeHandle = tmp;
+}
+
+void Toy_emitASTNodeVarDecl(Toy_ASTNode** nodeHandle, Toy_Literal identifier, Toy_Literal typeLiteral, Toy_ASTNode* expression) {
+	Toy_ASTNode* tmp = TOY_ALLOCATE(Toy_ASTNode, 1);
+
+	tmp->type = TOY_AST_NODE_VAR_DECL;
+	tmp->varDecl.identifier = identifier;
+	tmp->varDecl.typeLiteral = typeLiteral;
+	tmp->varDecl.expression = expression;
+
+	*nodeHandle = tmp;
+}
+
+void Toy_emitASTNodeFnCollection(Toy_ASTNode** nodeHandle) { //a collection of nodes, intended for use with functions
+	Toy_ASTNode* tmp = TOY_ALLOCATE(Toy_ASTNode, 1);
+
+	tmp->type = TOY_AST_NODE_FN_COLLECTION;
+	tmp->fnCollection.nodes = NULL;
+	tmp->fnCollection.capacity = 0;
+	tmp->fnCollection.count = 0;
+
+	*nodeHandle = tmp;
+}
+
+void Toy_emitASTNodeFnDecl(Toy_ASTNode** nodeHandle, Toy_Literal identifier, Toy_ASTNode* arguments, Toy_ASTNode* returns, Toy_ASTNode* block) {
+	Toy_ASTNode* tmp = TOY_ALLOCATE(Toy_ASTNode, 1);
+
+	tmp->type = TOY_AST_NODE_FN_DECL;
+	tmp->fnDecl.identifier = identifier;
+	tmp->fnDecl.arguments = arguments;
+	tmp->fnDecl.returns = returns;
+	tmp->fnDecl.block = block;
+
+	*nodeHandle = tmp;
+}
+
+void Toy_emitASTNodeFnCall(Toy_ASTNode** nodeHandle, Toy_ASTNode* arguments) {
+	Toy_ASTNode* tmp = TOY_ALLOCATE(Toy_ASTNode, 1);
+
+	tmp->type = TOY_AST_NODE_FN_CALL;
+	tmp->fnCall.arguments = arguments;
+	tmp->fnCall.argumentCount = arguments->fnCollection.count;
+
+	*nodeHandle = tmp;
+}
+
+void Toy_emitASTNodeFnReturn(Toy_ASTNode** nodeHandle, Toy_ASTNode* returns) {
+	Toy_ASTNode* tmp = TOY_ALLOCATE(Toy_ASTNode, 1);
+
+	tmp->type = TOY_AST_NODE_FN_RETURN;
+	tmp->returns.returns = returns;
+
+	*nodeHandle = tmp;
+}
+
+void Toy_emitASTNodeIf(Toy_ASTNode** nodeHandle, Toy_ASTNode* condition, Toy_ASTNode* thenPath, Toy_ASTNode* elsePath) {
+	Toy_ASTNode* tmp = TOY_ALLOCATE(Toy_ASTNode, 1);
+
+	tmp->type = TOY_AST_NODE_IF;
+	tmp->pathIf.condition = condition;
+	tmp->pathIf.thenPath = thenPath;
+	tmp->pathIf.elsePath = elsePath;
+
+	*nodeHandle = tmp;
+}
+
+void Toy_emitASTNodeWhile(Toy_ASTNode** nodeHandle, Toy_ASTNode* condition, Toy_ASTNode* thenPath) {
+	Toy_ASTNode* tmp = TOY_ALLOCATE(Toy_ASTNode, 1);
+
+	tmp->type = TOY_AST_NODE_WHILE;
+	tmp->pathWhile.condition = condition;
+	tmp->pathWhile.thenPath = thenPath;
+
+	*nodeHandle = tmp;
+}
+
+void Toy_emitASTNodeFor(Toy_ASTNode** nodeHandle, Toy_ASTNode* preClause, Toy_ASTNode* condition, Toy_ASTNode* postClause, Toy_ASTNode* thenPath) {
+	Toy_ASTNode* tmp = TOY_ALLOCATE(Toy_ASTNode, 1);
+
+	tmp->type = TOY_AST_NODE_FOR;
+	tmp->pathFor.preClause = preClause;
+	tmp->pathFor.condition = condition;
+	tmp->pathFor.postClause = postClause;
+	tmp->pathFor.thenPath = thenPath;
+
+	*nodeHandle = tmp;
+}
+
+void Toy_emitASTNodeBreak(Toy_ASTNode** nodeHandle) {
+	Toy_ASTNode* tmp = TOY_ALLOCATE(Toy_ASTNode, 1);
+
+	tmp->type = TOY_AST_NODE_BREAK;
+
+	*nodeHandle = tmp;
+}
+
+void Toy_emitASTNodeContinue(Toy_ASTNode** nodeHandle) {
+	Toy_ASTNode* tmp = TOY_ALLOCATE(Toy_ASTNode, 1);
+
+	tmp->type = TOY_AST_NODE_CONTINUE;
+
+	*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);
+
+	tmp->type = TOY_AST_NODE_PREFIX_INCREMENT;
+	tmp->prefixIncrement.identifier = Toy_copyLiteral(identifier);
+
+	*nodeHandle = tmp;
+}
+
+void Toy_emitASTNodePrefixDecrement(Toy_ASTNode** nodeHandle, Toy_Literal identifier) {
+	Toy_ASTNode* tmp = TOY_ALLOCATE(Toy_ASTNode, 1);
+
+	tmp->type = TOY_AST_NODE_PREFIX_DECREMENT;
+	tmp->prefixDecrement.identifier = Toy_copyLiteral(identifier);
+
+	*nodeHandle = tmp;
+}
+
+void Toy_emitASTNodePostfixIncrement(Toy_ASTNode** nodeHandle, Toy_Literal identifier) {
+	Toy_ASTNode* tmp = TOY_ALLOCATE(Toy_ASTNode, 1);
+
+	tmp->type = TOY_AST_NODE_POSTFIX_INCREMENT;
+	tmp->postfixIncrement.identifier = Toy_copyLiteral(identifier);
+
+	*nodeHandle = tmp;
+}
+
+void Toy_emitASTNodePostfixDecrement(Toy_ASTNode** nodeHandle, Toy_Literal identifier) {
+	Toy_ASTNode* tmp = TOY_ALLOCATE(Toy_ASTNode, 1);
+
+	tmp->type = TOY_AST_NODE_POSTFIX_DECREMENT;
+	tmp->postfixDecrement.identifier = Toy_copyLiteral(identifier);
+
+	*nodeHandle = tmp;
+}
+
+void Toy_emitASTNodeImport(Toy_ASTNode** nodeHandle, Toy_Literal identifier, Toy_Literal alias) {
+	Toy_ASTNode* tmp = TOY_ALLOCATE(Toy_ASTNode, 1);
+
+	tmp->type = TOY_AST_NODE_IMPORT;
+	tmp->import.identifier = Toy_copyLiteral(identifier);
+	tmp->import.alias = Toy_copyLiteral(alias);
+
+	*nodeHandle = tmp;
+}
+
+void Toy_emitASTNodePass(Toy_ASTNode** nodeHandle) {
+	Toy_ASTNode* tmp = TOY_ALLOCATE(Toy_ASTNode, 1);
+
+	tmp->type = TOY_AST_NODE_PASS;
+
+	*nodeHandle = tmp;
+}

source/toy_ast_node.h

@@ -0,0 +1,296 @@
+#pragma once
+
+#include "toy_common.h"
+#include "toy_literal.h"
+#include "toy_opcodes.h"
+#include "toy_token_types.h"
+
+//nodes are the intermediaries between parsers and compilers
+typedef union Toy_private_node Toy_ASTNode;
+
+typedef enum Toy_ASTNodeType {
+	TOY_AST_NODE_ERROR,
+	TOY_AST_NODE_LITERAL, //a simple value
+	TOY_AST_NODE_UNARY, //one child + opcode
+	TOY_AST_NODE_BINARY, //two children, left and right + opcode
+	TOY_AST_NODE_TERNARY, //three children, condition, then path & else path
+	TOY_AST_NODE_GROUPING, //one child
+	TOY_AST_NODE_BLOCK, //contains a sub-node array
+	TOY_AST_NODE_COMPOUND, //contains a sub-node array
+	TOY_AST_NODE_PAIR, //contains a left and right
+	TOY_AST_NODE_INDEX, //index a variable
+	TOY_AST_NODE_VAR_DECL, //contains identifier literal, typenode, expression definition
+	TOY_AST_NODE_FN_DECL, //containd identifier literal, arguments node, returns node, block node
+	TOY_AST_NODE_FN_COLLECTION, //parts of a function
+	TOY_AST_NODE_FN_CALL, //call a function
+	TOY_AST_NODE_FN_RETURN, //for control flow
+	TOY_AST_NODE_IF, //for control flow
+	TOY_AST_NODE_WHILE, //for control flow
+	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
+	TOY_AST_NODE_POSTFIX_DECREMENT, //decrement a variable
+	TOY_AST_NODE_IMPORT, //import a library
+	TOY_AST_NODE_PASS, //for doing nothing
+} Toy_ASTNodeType;
+
+//literals
+void Toy_emitASTNodeLiteral(Toy_ASTNode** nodeHandle, Toy_Literal literal);
+
+typedef struct Toy_NodeLiteral {
+	Toy_ASTNodeType type;
+	Toy_Literal literal;
+} Toy_NodeLiteral;
+
+//unary operator
+void Toy_emitASTNodeUnary(Toy_ASTNode** nodeHandle, Toy_Opcode opcode, Toy_ASTNode* child);
+
+typedef struct Toy_NodeUnary {
+	Toy_ASTNodeType type;
+	Toy_Opcode opcode;
+	Toy_ASTNode* child;
+} Toy_NodeUnary;
+
+//binary operator
+void Toy_emitASTNodeBinary(Toy_ASTNode** nodeHandle, Toy_ASTNode* rhs, Toy_Opcode opcode); //handled node becomes lhs
+
+typedef struct Toy_NodeBinary {
+	Toy_ASTNodeType type;
+	Toy_Opcode opcode;
+	Toy_ASTNode* left;
+	Toy_ASTNode* right;
+} Toy_NodeBinary;
+
+//ternary operator
+void Toy_emitASTNodeTernary(Toy_ASTNode** nodeHandle, Toy_ASTNode* condition, Toy_ASTNode* thenPath, Toy_ASTNode* elsePath);
+
+typedef struct Toy_NodeTernary {
+	Toy_ASTNodeType type;
+	Toy_ASTNode* condition;
+	Toy_ASTNode* thenPath;
+	Toy_ASTNode* elsePath;
+} Toy_NodeTernary;
+
+//grouping of other AST nodes
+void Toy_emitASTNodeGrouping(Toy_ASTNode** nodeHandle);
+
+typedef struct Toy_NodeGrouping {
+	Toy_ASTNodeType type;
+	Toy_ASTNode* child;
+} Toy_NodeGrouping;
+
+//block of statement nodes
+void Toy_emitASTNodeBlock(Toy_ASTNode** nodeHandle);
+
+typedef struct Toy_NodeBlock {
+	Toy_ASTNodeType type;
+	Toy_ASTNode* nodes;
+	int capacity;
+	int count;
+} Toy_NodeBlock;
+
+//compound literals (array, dictionary)
+void Toy_emitASTNodeCompound(Toy_ASTNode** nodeHandle, Toy_LiteralType literalType);
+
+typedef struct Toy_NodeCompound {
+	Toy_ASTNodeType type;
+	Toy_LiteralType literalType;
+	Toy_ASTNode* nodes;
+	int capacity;
+	int count;
+} Toy_NodeCompound;
+
+void Toy_setASTNodePair(Toy_ASTNode* node, Toy_ASTNode* left, Toy_ASTNode* right); //NOTE: this is a set function, not an emit function
+
+typedef struct Toy_NodePair {
+	Toy_ASTNodeType type;
+	Toy_ASTNode* left;
+	Toy_ASTNode* right;
+} Toy_NodePair;
+
+void Toy_emitASTNodeIndex(Toy_ASTNode** nodeHandle, Toy_ASTNode* first, Toy_ASTNode* second, Toy_ASTNode* third);
+
+typedef struct Toy_NodeIndex {
+	Toy_ASTNodeType type;
+	Toy_ASTNode* first;
+	Toy_ASTNode* second;
+	Toy_ASTNode* third;
+} Toy_NodeIndex;
+
+//variable declaration
+void Toy_emitASTNodeVarDecl(Toy_ASTNode** nodeHandle, Toy_Literal identifier, Toy_Literal type, Toy_ASTNode* expression);
+
+typedef struct Toy_NodeVarDecl {
+	Toy_ASTNodeType type;
+	Toy_Literal identifier;
+	Toy_Literal typeLiteral;
+	Toy_ASTNode* expression;
+} Toy_NodeVarDecl;
+
+//NOTE: fnCollection is used by fnDecl, fnCall and fnReturn
+void Toy_emitASTNodeFnCollection(Toy_ASTNode** nodeHandle);
+
+typedef struct Toy_NodeFnCollection {
+	Toy_ASTNodeType type;
+	Toy_ASTNode* nodes;
+	int capacity;
+	int count;
+} Toy_NodeFnCollection;
+
+//function declaration
+void Toy_emitASTNodeFnDecl(Toy_ASTNode** nodeHandle, Toy_Literal identifier, Toy_ASTNode* arguments, Toy_ASTNode* returns, Toy_ASTNode* block);
+
+typedef struct Toy_NodeFnDecl {
+	Toy_ASTNodeType type;
+	Toy_Literal identifier;
+	Toy_ASTNode* arguments;
+	Toy_ASTNode* returns;
+	Toy_ASTNode* block;
+} Toy_NodeFnDecl;
+
+//function call
+void Toy_emitASTNodeFnCall(Toy_ASTNode** nodeHandle, Toy_ASTNode* arguments);
+
+typedef struct Toy_NodeFnCall {
+	Toy_ASTNodeType type;
+	Toy_ASTNode* arguments;
+	int argumentCount; //NOTE: leave this, so it can be hacked by dottify()
+} Toy_NodeFnCall;
+
+//function return
+void Toy_emitASTNodeFnReturn(Toy_ASTNode** nodeHandle, Toy_ASTNode* returns);
+
+typedef struct Toy_NodeFnReturn {
+	Toy_ASTNodeType type;
+	Toy_ASTNode* returns;
+} Toy_NodeFnReturn;
+
+//control flow path - if-else, while, for, break, continue, return
+void Toy_emitASTNodeIf(Toy_ASTNode** nodeHandle, Toy_ASTNode* condition, Toy_ASTNode* thenPath, Toy_ASTNode* elsePath);
+void Toy_emitASTNodeWhile(Toy_ASTNode** nodeHandle, Toy_ASTNode* condition, Toy_ASTNode* thenPath);
+void Toy_emitASTNodeFor(Toy_ASTNode** nodeHandle, Toy_ASTNode* preClause, Toy_ASTNode* condition, Toy_ASTNode* postClause, Toy_ASTNode* thenPath);
+void Toy_emitASTNodeBreak(Toy_ASTNode** nodeHandle);
+void Toy_emitASTNodeContinue(Toy_ASTNode** nodeHandle);
+
+typedef struct Toy_NodeIf {
+	Toy_ASTNodeType type;
+	Toy_ASTNode* condition;
+	Toy_ASTNode* thenPath;
+	Toy_ASTNode* elsePath;
+} Toy_NodeIf;
+
+typedef struct Toy_NodeWhile {
+	Toy_ASTNodeType type;
+	Toy_ASTNode* condition;
+	Toy_ASTNode* thenPath;
+} Toy_NodeWhile;
+
+typedef struct Toy_NodeFor {
+	Toy_ASTNodeType type;
+	Toy_ASTNode* preClause;
+	Toy_ASTNode* condition;
+	Toy_ASTNode* postClause;
+	Toy_ASTNode* thenPath;
+} Toy_NodeFor;
+
+typedef struct Toy_NodeBreak {
+	Toy_ASTNodeType type;
+} Toy_NodeBreak;
+
+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);
+void Toy_emitASTNodePostfixIncrement(Toy_ASTNode** nodeHandle, Toy_Literal identifier);
+void Toy_emitASTNodePostfixDecrement(Toy_ASTNode** nodeHandle, Toy_Literal identifier);
+
+typedef struct Toy_NodePrefixIncrement {
+	Toy_ASTNodeType type;
+	Toy_Literal identifier;
+} Toy_NodePrefixIncrement;
+
+typedef struct Toy_NodePrefixDecrement {
+	Toy_ASTNodeType type;
+	Toy_Literal identifier;
+} Toy_NodePrefixDecrement;
+
+typedef struct Toy_NodePostfixIncrement {
+	Toy_ASTNodeType type;
+	Toy_Literal identifier;
+} Toy_NodePostfixIncrement;
+
+typedef struct Toy_NodePostfixDecrement {
+	Toy_ASTNodeType type;
+	Toy_Literal identifier;
+} Toy_NodePostfixDecrement;
+
+//import a library
+void Toy_emitASTNodeImport(Toy_ASTNode** nodeHandle, Toy_Literal identifier, Toy_Literal alias);
+
+typedef struct Toy_NodeImport {
+	Toy_ASTNodeType type;
+	Toy_Literal identifier;
+	Toy_Literal alias;
+} Toy_NodeImport;
+
+//for doing nothing
+void Toy_emitASTNodePass(Toy_ASTNode** nodeHandle);
+
+union Toy_private_node {
+	Toy_ASTNodeType type;
+	Toy_NodeLiteral atomic;
+	Toy_NodeUnary unary;
+	Toy_NodeBinary binary;
+	Toy_NodeTernary ternary;
+	Toy_NodeGrouping grouping;
+	Toy_NodeBlock block;
+	Toy_NodeCompound compound;
+	Toy_NodePair pair;
+	Toy_NodeIndex index;
+	Toy_NodeVarDecl varDecl;
+	Toy_NodeFnCollection fnCollection;
+	Toy_NodeFnDecl fnDecl;
+	Toy_NodeFnCall fnCall;
+	Toy_NodeFnReturn returns;
+	Toy_NodeIf pathIf;
+	Toy_NodeWhile pathWhile;
+	Toy_NodeFor pathFor;
+	Toy_NodeBreak pathBreak;
+	Toy_NodeContinue pathContinue;
+	Toy_NodeAnd pathAnd;
+	Toy_NodeOr pathOr;
+	Toy_NodePrefixIncrement prefixIncrement;
+	Toy_NodePrefixDecrement prefixDecrement;
+	Toy_NodePostfixIncrement postfixIncrement;
+	Toy_NodePostfixDecrement postfixDecrement;
+	Toy_NodeImport import;
+};
+
+//see toy_parser.h for more documentation on this function
+TOY_API void Toy_freeASTNode(Toy_ASTNode* node);

source/toy_builtin.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "toy_interpreter.h"
+
+//the _index function is a historical oddity - it's used whenever a compound is indexed
+int Toy_private_index(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments);
+
+//globally available native functions
+int Toy_private_set(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments);
+int Toy_private_get(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments);
+int Toy_private_push(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments);
+int Toy_private_pop(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments);
+int Toy_private_length(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments);
+int Toy_private_clear(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments);

source/toy_common.c

@@ -0,0 +1,154 @@
+#include "toy_common.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <assert.h>
+
+//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);
+STATIC_ASSERT(sizeof(short) == 2);
+STATIC_ASSERT(sizeof(int) == 4);
+STATIC_ASSERT(sizeof(float) == 4);
+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,
+	.help = false,
+	.version = false,
+	.binaryfile = NULL,
+	.sourcefile = NULL,
+	.compilefile = NULL,
+	.outfile = "out.tb",
+	.source = NULL,
+	.initialfile = NULL,
+	.enablePrintNewline = true,
+	.parseBytecodeHeader = false,
+	.verbose = false
+};
+
+void Toy_initCommandLine(int argc, const char* argv[]) {
+	for (int i = 1; i < argc; i++) { //start at 1 to skip the program name
+		Toy_commandLine.error = true; //error state by default, set to false by successful flags
+
+		if (!strcmp(argv[i], "-h") || !strcmp(argv[i], "--help")) {
+			Toy_commandLine.help = true;
+			Toy_commandLine.error = false;
+			continue;
+		}
+
+		if (!strcmp(argv[i], "-v") || !strcmp(argv[i], "--version")) {
+			Toy_commandLine.version = true;
+			Toy_commandLine.error = false;
+			continue;
+		}
+
+		if (!strcmp(argv[i], "-d") || !strcmp(argv[i], "--debug")) {
+			Toy_commandLine.verbose = true;
+			Toy_commandLine.error = false;
+			continue;
+		}
+
+		if ((!strcmp(argv[i], "-f") || !strcmp(argv[i], "--sourcefile")) && i + 1 < argc) {
+			Toy_commandLine.sourcefile = (char*)argv[i + 1];
+			i++;
+			Toy_commandLine.error = false;
+			continue;
+		}
+
+		if ((!strcmp(argv[i], "-i") || !strcmp(argv[i], "--input")) && i + 1 < argc) {
+			Toy_commandLine.source = (char*)argv[i + 1];
+			i++;
+			Toy_commandLine.error = false;
+			continue;
+		}
+
+		if ((!strcmp(argv[i], "-c") || !strcmp(argv[i], "--compile")) && i + 1 < argc) {
+			Toy_commandLine.compilefile = (char*)argv[i + 1];
+			i++;
+			Toy_commandLine.error = false;
+			continue;
+		}
+
+		if ((!strcmp(argv[i], "-o") || !strcmp(argv[i], "--output")) && i + 1 < argc) {
+			Toy_commandLine.outfile = (char*)argv[i + 1];
+			i++;
+			Toy_commandLine.error = false;
+			continue;
+		}
+
+		if ((!strcmp(argv[i], "-t") || !strcmp(argv[i], "--initial")) && i + 1 < argc) {
+			Toy_commandLine.initialfile = (char*)argv[i + 1];
+			i++;
+			Toy_commandLine.error = false;
+			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;
+			continue;
+		}
+
+		//option without a flag + ending in .tb = binary input
+		if (i < argc) {
+			if (strncmp(&(argv[i][strlen(argv[i]) - 3]), ".tb", 3) == 0) {
+				Toy_commandLine.binaryfile = (char*)argv[i];
+				Toy_commandLine.error = false;
+				continue;
+			}
+		}
+
+		//don't keep reading in an error state
+		return;
+	}
+}
+
+void Toy_usageCommandLine(int argc, const char* argv[]) {
+	printf("Usage: %s [ file.tb | -h | -v | -d | -f file.toy | -i source | -c file.toy -o out.tb | -t file.toy ]\n\n", argv[0]);
+}
+
+void Toy_helpCommandLine(int argc, const char* argv[]) {
+	Toy_usageCommandLine(argc, argv);
+
+	printf("  -h, --help\t\t\tShow this help then exit.\n");
+	printf("  -v, --version\t\t\tShow version and copyright information then exit.\n");
+	printf("  -d, --debug\t\t\tBe verbose when operating.\n");
+	printf("  -f, --file filename\t\tParse, compile and execute the source file.\n");
+	printf("  -i, --input source\t\tParse, compile and execute this given string of source code.\n");
+	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");
+}
+
+void Toy_copyrightCommandLine(int argc, const char* argv[]) {
+	printf("Toy Programming Language Interpreter Version %d.%d.%d (built on %s)\n\n", TOY_VERSION_MAJOR, TOY_VERSION_MINOR, TOY_VERSION_PATCH, TOY_VERSION_BUILD);
+	printf("Copyright (c) 2020-2023 Kayne Ruse, KR Game Studios\n\n");
+	printf("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.\n\n");
+	printf("Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions:\n\n");
+	printf("1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.\n\n");
+	printf("2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.\n\n");
+	printf("3. This notice may not be removed or altered from any source distribution.\n\n");
+}

source/toy_common.h

@@ -0,0 +1,109 @@
+#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>
+
+/*!
+### TOY_API
+
+This definition of this macro is platform-dependant, and used to enable cross-platform compilation of shared and static libraries.
+!*/
+
+#if defined(__linux__) || defined(__MINGW32__) || defined(__GNUC__)
+
+#define TOY_API extern
+
+#elif defined(_MSC_VER)
+
+#ifndef TOY_EXPORT
+#define TOY_API __declspec(dllimport)
+#else
+#define TOY_API __declspec(dllexport)
+#endif
+
+#else
+
+#define TOY_API extern
+
+#endif
+
+/*!
+### 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;
+	bool version;
+	char* binaryfile;
+	char* sourcefile;
+	char* compilefile;
+	char* outfile; //defaults to out.tb
+	char* source;
+	char* initialfile;
+	bool enablePrintNewline;
+	bool parseBytecodeHeader;
+	bool verbose;
+} Toy_CommandLine;
+
+//these are intended for the repl only, despite using the api prefix
+TOY_API Toy_CommandLine Toy_commandLine;
+
+TOY_API void Toy_initCommandLine(int argc, const char* argv[]);
+
+TOY_API void Toy_usageCommandLine(int argc, const char* argv[]);
+TOY_API void Toy_helpCommandLine(int argc, const char* argv[]);
+TOY_API void Toy_copyrightCommandLine(int argc, const char* argv[]);

source/toy_compiler.h

@@ -1,4 +1,6 @@
+#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.
@@ -6,25 +8,53 @@ This header defines the compiler structure, which is used to transform abstract
 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"
+
+typedef struct Toy_Compiler {
+	Toy_LiteralArray literalCache;
+	unsigned char* bytecode;
+	int capacity;
+	int count;
+	bool panic;
+} Toy_Compiler;
+
+/*!
 ## Define Functions
 
-Executing the following functions out-of-order causes undefined behaviour.
+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);

source/toy_console_colors.h

@@ -0,0 +1,74 @@
+#pragma once
+
+/* 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__)
+
+//fonts color
+#define TOY_CC_FONT_BLACK      "\033[30;"
+#define TOY_CC_FONT_RED        "\033[31;"
+#define TOY_CC_FONT_GREEN      "\033[32;"
+#define TOY_CC_FONT_YELLOW     "\033[33;"
+#define TOY_CC_FONT_BLUE       "\033[34;"
+#define TOY_CC_FONT_PURPLE     "\033[35;"
+#define TOY_CC_FONT_DGREEN     "\033[6;"
+#define TOY_CC_FONT_WHITE      "\033[7;"
+#define TOY_CC_FONT_CYAN       "\x1b[36m"
+
+//background color
+#define TOY_CC_BACK_BLACK      "40m"
+#define TOY_CC_BACK_RED        "41m"
+#define TOY_CC_BACK_GREEN      "42m"
+#define TOY_CC_BACK_YELLOW     "43m"
+#define TOY_CC_BACK_BLUE       "44m"
+#define TOY_CC_BACK_PURPLE     "45m"
+#define TOY_CC_BACK_DGREEN     "46m"
+#define TOY_CC_BACK_WHITE      "47m"
+
+//useful
+#define TOY_CC_NOTICE TOY_CC_FONT_GREEN TOY_CC_BACK_BLACK
+#define TOY_CC_WARN TOY_CC_FONT_YELLOW TOY_CC_BACK_BLACK
+#define TOY_CC_ERROR TOY_CC_FONT_RED TOY_CC_BACK_BLACK
+#define TOY_CC_RESET "\033[0m"
+
+#else
+
+//fonts color
+#define TOY_CC_FONT_BLACK
+#define TOY_CC_FONT_RED
+#define TOY_CC_FONT_GREEN
+#define TOY_CC_FONT_YELLOW
+#define TOY_CC_FONT_BLUE
+#define TOY_CC_FONT_PURPLE
+#define TOY_CC_FONT_DGREEN
+#define TOY_CC_FONT_WHITE
+#define TOY_CC_FONT_CYAN
+
+//background color
+#define TOY_CC_BACK_BLACK
+#define TOY_CC_BACK_RED
+#define TOY_CC_BACK_GREEN
+#define TOY_CC_BACK_YELLOW
+#define TOY_CC_BACK_BLUE
+#define TOY_CC_BACK_PURPLE
+#define TOY_CC_BACK_DGREEN
+#define TOY_CC_BACK_WHITE
+
+//useful
+#define TOY_CC_NOTICE TOY_CC_FONT_GREEN TOY_CC_BACK_BLACK
+#define TOY_CC_WARN TOY_CC_FONT_YELLOW TOY_CC_BACK_BLACK
+#define TOY_CC_ERROR TOY_CC_FONT_RED TOY_CC_BACK_BLACK
+#define TOY_CC_RESET
+
+#endif

source/toy_interpreter.h

@@ -1,11 +1,13 @@
+#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 redirect 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.
+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
 
@@ -31,22 +33,63 @@ The identifier of the library (its name) is passed in as a `Toy_Literal`, as is
 import standard as std;
 ```
 
-Conventionally, when an alias is given, all the functions should instead be inserted into a `Toy_LiteralDictionary` which is then inserted into the scope with the alias as its identifier.
+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"
+#include "toy_literal_dictionary.h"
+#include "toy_scope.h"
+
+//the interpreter acts depending on the bytecode instructions
+typedef struct Toy_Interpreter {
+	//input
+	const unsigned char* bytecode;
+	int length;
+	int count;
+	int codeStart; //BUGFIX: for jumps, must be initialized to -1
+	Toy_LiteralArray literalCache; //read-only - built from the bytecode, refreshed each time new bytecode is provided
+
+	//operation
+	Toy_Scope* scope;
+	Toy_LiteralArray stack;
+
+	//Library APIs
+	Toy_LiteralDictionary* hooks;
+
+	//debug outputs
+	Toy_PrintFn printOutput;
+	Toy_PrintFn assertOutput;
+	Toy_PrintFn errorOutput;
+
+	int depth; //don't overflow
+	bool panic;
+} Toy_Interpreter;
+
+/*!
 ## 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.
+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:
@@ -57,36 +100,54 @@ This function frees any scopes that the scripts have built up, and generates a n
 * 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 the memory used within. That interpreter is no longer valid for use, and must be re-initialized.
+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 identifier 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.
+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);
 
+/*!
 ### bool Toy_parseIdentifierToValue(Toy_Interpreter* interpreter, Toy_Literal* literalPtr)
 
-Sometimes, native functions will receive `Toy_Literal` identifiers instead of the values - the correct values can be retrieved from the given interpreter's scope using the following pattern:
+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;
@@ -94,7 +155,10 @@ 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:
@@ -105,8 +169,11 @@ static void printWrapper(const char* 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.
+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:
@@ -116,7 +183,10 @@ 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:
@@ -126,3 +196,5 @@ static void errorWrapper(const char* output) {
 	fprintf(stderr, "%s", output); //no newline
 }
 ```
+!*/
+TOY_API void Toy_setInterpreterError(Toy_Interpreter* interpreter, Toy_PrintFn errorOutput);

source/toy_keyword_types.c

@@ -0,0 +1,77 @@
+#include "toy_keyword_types.h"
+
+#include "toy_common.h"
+
+#include <string.h>
+
+Toy_KeywordType Toy_keywordTypes[] = {
+	//type keywords
+	{TOY_TOKEN_NULL,       "null"},
+	{TOY_TOKEN_BOOLEAN,    "bool"},
+	{TOY_TOKEN_INTEGER,    "int"},
+	{TOY_TOKEN_FLOAT,      "float"},
+	{TOY_TOKEN_STRING,     "string"},
+	{TOY_TOKEN_FUNCTION,   "fn"},
+	{TOY_TOKEN_OPAQUE,     "opaque"},
+	{TOY_TOKEN_ANY,        "any"},
+
+	//other keywords
+	{TOY_TOKEN_AS,         "as"},
+	{TOY_TOKEN_ASSERT,     "assert"},
+	{TOY_TOKEN_BREAK,      "break"},
+	{TOY_TOKEN_CLASS,      "class"},
+	{TOY_TOKEN_CONST,      "const"},
+	{TOY_TOKEN_CONTINUE,   "continue"},
+	{TOY_TOKEN_DO,         "do"},
+	{TOY_TOKEN_ELSE,       "else"},
+	{TOY_TOKEN_EXPORT,     "export"},
+	{TOY_TOKEN_FOR,        "for"},
+	{TOY_TOKEN_FOREACH,    "foreach"},
+	{TOY_TOKEN_IF,         "if"},
+	{TOY_TOKEN_IMPORT,     "import"},
+	{TOY_TOKEN_IN,         "in"},
+	{TOY_TOKEN_OF,         "of"},
+	{TOY_TOKEN_PRINT,      "print"},
+	{TOY_TOKEN_RETURN,     "return"},
+	{TOY_TOKEN_TYPE,       "type"},
+	{TOY_TOKEN_ASTYPE,     "astype"},
+	{TOY_TOKEN_TYPEOF,     "typeof"},
+	{TOY_TOKEN_VAR,        "var"},
+	{TOY_TOKEN_WHILE,      "while"},
+
+	//literal values
+	{TOY_TOKEN_LITERAL_TRUE,   "true"},
+	{TOY_TOKEN_LITERAL_FALSE,  "false"},
+
+	//meta tokens
+	{TOY_TOKEN_PASS,       NULL},
+	{TOY_TOKEN_ERROR,      NULL},
+
+	{TOY_TOKEN_EOF, NULL},
+};
+
+char* Toy_findKeywordByType(Toy_TokenType type) {
+	if (type == TOY_TOKEN_EOF) {
+		return "EOF";
+	}
+
+	for(int i = 0; Toy_keywordTypes[i].keyword; i++) {
+		if (Toy_keywordTypes[i].type == type) {
+			return Toy_keywordTypes[i].keyword;
+		}
+	}
+
+	return NULL;
+}
+
+Toy_TokenType Toy_findTypeByKeyword(const char* keyword) {
+	const int length = strlen(keyword);
+
+	for (int i = 0; Toy_keywordTypes[i].keyword; i++) {
+		if (!strncmp(keyword, Toy_keywordTypes[i].keyword, length)) {
+			return Toy_keywordTypes[i].type;
+		}
+	}
+
+	return TOY_TOKEN_EOF;
+}

source/toy_keyword_types.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "toy_token_types.h"
+
+typedef struct {
+	Toy_TokenType type;
+	char* keyword;
+} Toy_KeywordType;
+
+extern Toy_KeywordType Toy_keywordTypes[];
+
+char* Toy_findKeywordByType(Toy_TokenType type);
+
+Toy_TokenType Toy_findTypeByKeyword(const char* keyword);

source/toy_lexer.c

@@ -0,0 +1,383 @@
+#include "toy_lexer.h"
+#include "toy_console_colors.h"
+#include "toy_keyword_types.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+
+//static generic utility functions
+static void cleanLexer(Toy_Lexer* lexer) {
+	lexer->source = NULL;
+	lexer->start = 0;
+	lexer->current = 0;
+	lexer->line = 1;
+	lexer->commentsEnabled = true;
+}
+
+static bool isAtEnd(Toy_Lexer* lexer) {
+	return lexer->source[lexer->current] == '\0';
+}
+
+static char peek(Toy_Lexer* lexer) {
+	return lexer->source[lexer->current];
+}
+
+static char peekNext(Toy_Lexer* lexer) {
+	if (isAtEnd(lexer)) return '\0';
+	return lexer->source[lexer->current + 1];
+}
+
+static char advance(Toy_Lexer* lexer) {
+	if (isAtEnd(lexer)) {
+		return '\0';
+	}
+
+	//new line
+	if (lexer->source[lexer->current] == '\n') {
+		lexer->line++;
+	}
+
+	lexer->current++;
+	return lexer->source[lexer->current - 1];
+}
+
+static void eatWhitespace(Toy_Lexer* lexer) {
+	const char c = peek(lexer);
+
+	switch(c) {
+		case ' ':
+		case '\r':
+		case '\n':
+		case '\t':
+			advance(lexer);
+			break;
+
+		//comments
+		case '/':
+			if (!lexer->commentsEnabled) {
+				return;
+			}
+
+			//eat the line
+			if (peekNext(lexer) == '/') {
+				while (!isAtEnd(lexer) && advance(lexer) != '\n');
+				break;
+			}
+
+			//eat the block
+			if (peekNext(lexer) == '*') {
+				advance(lexer);
+				advance(lexer);
+				while(!isAtEnd(lexer) && !(peek(lexer) == '*' && peekNext(lexer) == '/')) advance(lexer);
+				advance(lexer);
+				advance(lexer);
+				break;
+			}
+		return;
+
+		default:
+			return;
+	}
+
+	//tail recursion
+	eatWhitespace(lexer);
+}
+
+static bool isDigit(Toy_Lexer* lexer) {
+	return peek(lexer) >= '0' && peek(lexer) <= '9';
+}
+
+static bool isAlpha(Toy_Lexer* lexer) {
+	return
+		(peek(lexer) >= 'A' && peek(lexer) <= 'Z') ||
+		(peek(lexer) >= 'a' && peek(lexer) <= 'z') ||
+		peek(lexer) == '_'
+	;
+}
+
+static bool match(Toy_Lexer* lexer, char c) {
+	if (peek(lexer) == c) {
+		advance(lexer);
+		return true;
+	}
+
+	return false;
+}
+
+//token generators
+static Toy_Token makeErrorToken(Toy_Lexer* lexer, char* msg) {
+	Toy_Token token;
+
+	token.type = TOY_TOKEN_ERROR;
+	token.lexeme = msg;
+	token.length = strlen(msg);
+	token.line = lexer->line;
+
+#ifndef TOY_EXPORT
+	if (Toy_commandLine.verbose) {
+		printf("err:");
+		Toy_private_printToken(&token);
+	}
+#endif
+
+	return token;
+}
+
+static Toy_Token makeToken(Toy_Lexer* lexer, Toy_TokenType type) {
+	Toy_Token token;
+
+	token.type = type;
+	token.length = lexer->current - lexer->start;
+	token.lexeme = &lexer->source[lexer->current - token.length];
+	token.line = lexer->line;
+
+#ifndef TOY_EXPORT
+	//BUG #10: this shows TOKEN_EOF twice due to the overarching structure of the program - can't be fixed
+	if (Toy_commandLine.verbose) {
+		printf("tok:");
+		Toy_private_printToken(&token);
+	}
+#endif
+
+	return token;
+}
+
+static Toy_Token makeIntegerOrFloat(Toy_Lexer* lexer) {
+	Toy_TokenType type = TOY_TOKEN_LITERAL_INTEGER; //what am I making?
+
+	while(isDigit(lexer) || peek(lexer) == '_') advance(lexer);
+
+	if (peek(lexer) == '.' && (peekNext(lexer) >= '0' && peekNext(lexer) <= '9')) { //BUGFIX: peekNext == digit
+		type = TOY_TOKEN_LITERAL_FLOAT;
+		advance(lexer);
+		while(isDigit(lexer) || peek(lexer) == '_') advance(lexer);
+	}
+
+	Toy_Token token;
+
+	token.type = type;
+	token.lexeme = &lexer->source[lexer->start];
+	token.length = lexer->current - lexer->start;
+	token.line = lexer->line;
+
+#ifndef TOY_EXPORT
+	if (Toy_commandLine.verbose) {
+		if (type == TOY_TOKEN_LITERAL_INTEGER) {
+			printf("int:");
+		} else {
+			printf("flt:");
+		}
+		Toy_private_printToken(&token);
+	}
+#endif
+
+	return token;
+}
+
+static bool isEscapableCharacter(char c) {
+	switch (c) {
+		case 'n':
+		case 't':
+		case '\\':
+		case '"':
+			return true;
+
+		default:
+			return false;
+	}
+}
+
+static Toy_Token makeString(Toy_Lexer* lexer, char terminator) {
+	while (!isAtEnd(lexer)) {
+		//stop if you've hit the terminator
+		if (peek(lexer) == terminator) {
+			advance(lexer); //eat terminator
+			break;
+		}
+
+		//skip escaped control characters
+		if (peek(lexer) == '\\' && isEscapableCharacter(peekNext(lexer))) {
+			advance(lexer);
+			advance(lexer);
+			continue;
+		}
+
+		//otherwise
+		advance(lexer);
+	}
+
+	if (isAtEnd(lexer)) {
+		return makeErrorToken(lexer, "Unterminated string");
+	}
+
+	Toy_Token token;
+
+	token.type = TOY_TOKEN_LITERAL_STRING;
+	token.lexeme = &lexer->source[lexer->start + 1];
+	token.length = lexer->current - lexer->start - 2;
+	token.line = lexer->line;
+
+#ifndef TOY_EXPORT
+	if (Toy_commandLine.verbose) {
+		printf("str:");
+		Toy_private_printToken(&token);
+	}
+#endif
+
+	return token;
+}
+
+static Toy_Token makeKeywordOrIdentifier(Toy_Lexer* lexer) {
+	advance(lexer); //first letter can only be alpha
+
+	while(isDigit(lexer) || isAlpha(lexer)) {
+		advance(lexer);
+	}
+
+	//scan for a keyword
+	for (int i = 0; Toy_keywordTypes[i].keyword; i++) {
+		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;
+			token.lexeme = &lexer->source[lexer->start];
+			token.length = lexer->current - lexer->start;
+			token.line = lexer->line;
+
+#ifndef TOY_EXPORT
+			if (Toy_commandLine.verbose) {
+				printf("kwd:");
+				Toy_private_printToken(&token);
+			}
+#endif
+
+			return token;
+		}
+	}
+
+	//return an identifier
+	Toy_Token token;
+
+	token.type = TOY_TOKEN_IDENTIFIER;
+	token.lexeme = &lexer->source[lexer->start];
+	token.length = lexer->current - lexer->start;
+	token.line = lexer->line;
+
+#ifndef TOY_EXPORT
+	if (Toy_commandLine.verbose) {
+		printf("idf:");
+		Toy_private_printToken(&token);
+	}
+#endif
+
+	return token;
+}
+
+//exposed functions
+void Toy_initLexer(Toy_Lexer* lexer, const char* source) {
+	cleanLexer(lexer);
+
+	lexer->source = source;
+}
+
+Toy_Token Toy_private_scanLexer(Toy_Lexer* lexer) {
+	eatWhitespace(lexer);
+
+	lexer->start = lexer->current;
+
+	if (isAtEnd(lexer)) return makeToken(lexer, TOY_TOKEN_EOF);
+
+	if (isDigit(lexer)) return makeIntegerOrFloat(lexer);
+	if (isAlpha(lexer)) return makeKeywordOrIdentifier(lexer);
+
+	char c = advance(lexer);
+
+	switch(c) {
+		case '(': return makeToken(lexer, TOY_TOKEN_PAREN_LEFT);
+		case ')': return makeToken(lexer, TOY_TOKEN_PAREN_RIGHT);
+		case '{': return makeToken(lexer, TOY_TOKEN_BRACE_LEFT);
+		case '}': return makeToken(lexer, TOY_TOKEN_BRACE_RIGHT);
+		case '[': return makeToken(lexer, TOY_TOKEN_BRACKET_LEFT);
+		case ']': return makeToken(lexer, TOY_TOKEN_BRACKET_RIGHT);
+
+		case '+': return makeToken(lexer, match(lexer, '=') ? TOY_TOKEN_PLUS_ASSIGN : match(lexer, '+') ? TOY_TOKEN_PLUS_PLUS: TOY_TOKEN_PLUS);
+		case '-': return makeToken(lexer, match(lexer, '=') ? TOY_TOKEN_MINUS_ASSIGN : match(lexer, '-') ? TOY_TOKEN_MINUS_MINUS: TOY_TOKEN_MINUS);
+		case '*': return makeToken(lexer, match(lexer, '=') ? TOY_TOKEN_MULTIPLY_ASSIGN : TOY_TOKEN_MULTIPLY);
+		case '/': return makeToken(lexer, match(lexer, '=') ? TOY_TOKEN_DIVIDE_ASSIGN : TOY_TOKEN_DIVIDE);
+		case '%': return makeToken(lexer, match(lexer, '=') ? TOY_TOKEN_MODULO_ASSIGN : TOY_TOKEN_MODULO);
+
+		case '!': return makeToken(lexer, match(lexer, '=') ? TOY_TOKEN_NOT_EQUAL : TOY_TOKEN_NOT);
+		case '=': return makeToken(lexer, match(lexer, '=') ? TOY_TOKEN_EQUAL : TOY_TOKEN_ASSIGN);
+
+		case '<': return makeToken(lexer, match(lexer, '=') ? TOY_TOKEN_LESS_EQUAL : TOY_TOKEN_LESS);
+		case '>': return makeToken(lexer, match(lexer, '=') ? TOY_TOKEN_GREATER_EQUAL : TOY_TOKEN_GREATER);
+
+		case '&': //TOKEN_AND not used
+			if (advance(lexer) != '&') {
+				return makeErrorToken(lexer, "Unexpected '&'");
+			} else {
+				return makeToken(lexer, TOY_TOKEN_AND_AND);
+			}
+
+		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);
+		case ';': return makeToken(lexer, TOY_TOKEN_SEMICOLON);
+		case ',': return makeToken(lexer, TOY_TOKEN_COMMA);
+		case '.':
+			if (peek(lexer) == '.' && peekNext(lexer) == '.') {
+				advance(lexer);
+				advance(lexer);
+				return makeToken(lexer, TOY_TOKEN_REST);
+			}
+			return makeToken(lexer, TOY_TOKEN_DOT);
+
+		case '"':
+			return makeString(lexer, c);
+			//TODO: possibly support interpolated strings
+
+		default: {
+			char buffer[128];
+			snprintf(buffer, 128, "Unexpected token: %c", c);
+			return makeErrorToken(lexer, buffer);
+		}
+	}
+}
+
+static void trim(char** s, int* l) { //all this to remove a newline?
+	while( isspace(( (*((unsigned char**)(s)))[(*l) - 1] )) ) (*l)--;
+	while(**s && isspace( **(unsigned char**)(s)) ) { (*s)++; (*l)--; }
+}
+
+//for debugging
+void Toy_private_printToken(Toy_Token* token) {
+	if (token->type == TOY_TOKEN_ERROR) {
+		printf(TOY_CC_ERROR "Error\t%d\t%.*s\n" TOY_CC_RESET, token->line, token->length, token->lexeme);
+		return;
+	}
+
+	printf("\t%d\t%d\t", token->type, token->line);
+
+	if (token->type == TOY_TOKEN_IDENTIFIER || token->type == TOY_TOKEN_LITERAL_INTEGER || token->type == TOY_TOKEN_LITERAL_FLOAT || token->type == TOY_TOKEN_LITERAL_STRING) {
+		printf("%.*s\t", token->length, token->lexeme);
+	} else {
+		char* keyword = Toy_findKeywordByType(token->type);
+
+		if (keyword != NULL) {
+			printf("%s", keyword);
+		} else {
+			char* str = (char*)token->lexeme; //strip const-ness for trimming
+			int length = token->length;
+			trim(&str, &length);
+			printf("%.*s", length, str);
+		}
+	}
+
+	printf("\n");
+}
+
+void Toy_private_setComments(Toy_Lexer* lexer, bool enabled) {
+	lexer->commentsEnabled = enabled;
+}

source/toy_lexer.h

@@ -1,28 +1,65 @@
+#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"
+
+//lexers are bound to a string of code, and return a single token every time scan is called
+typedef struct {
+	const char* source;
+	int start; //start of the token
+	int current; //current position of the lexer
+	int line; //track this for error handling
+	bool commentsEnabled; //BUGFIX: enable comments (disabled in repl)
+} Toy_Lexer;
+
+//tokens are intermediaries between lexers and parsers
+typedef struct {
+	Toy_TokenType type;
+	const char* lexeme;
+	int length;
+	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);
 
+/*!
 ### 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.
+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);

source/toy_literal.c

@@ -0,0 +1,737 @@
+#include "toy_literal.h"
+#include "toy_memory.h"
+
+#include "toy_literal_array.h"
+#include "toy_literal_dictionary.h"
+#include "toy_scope.h"
+
+#include "toy_console_colors.h"
+
+#include <stdio.h>
+#include <string.h>
+
+//hash util functions
+static unsigned int hashString(const char* string, int length) {
+	unsigned int hash = 2166136261u;
+
+	for (int i = 0; i < length; i++) {
+		hash *= string[i];
+		hash ^= 16777619;
+	}
+
+	return hash;
+}
+
+static unsigned int hashUInt(unsigned int x) {
+    x = ((x >> 16) ^ x) * 0x45d9f3b;
+    x = ((x >> 16) ^ x) * 0x45d9f3b;
+    x = (x >> 16) ^ x;
+    return x;
+}
+
+//exposed functions
+void Toy_freeLiteral(Toy_Literal literal) {
+	//refstrings
+	if (TOY_IS_STRING(literal)) {
+		Toy_deleteRefString(TOY_AS_STRING(literal));
+		return;
+	}
+
+	if (TOY_IS_IDENTIFIER(literal)) {
+		Toy_deleteRefString(TOY_AS_IDENTIFIER(literal));
+		return;
+	}
+
+	//compounds
+	if (TOY_IS_ARRAY(literal) || literal.type == TOY_LITERAL_ARRAY_INTERMEDIATE || literal.type == TOY_LITERAL_DICTIONARY_INTERMEDIATE || literal.type == TOY_LITERAL_TYPE_INTERMEDIATE) {
+		Toy_freeLiteralArray(TOY_AS_ARRAY(literal));
+		TOY_FREE(Toy_LiteralArray, TOY_AS_ARRAY(literal));
+		return;
+	}
+
+	if (TOY_IS_DICTIONARY(literal)) {
+		Toy_freeLiteralDictionary(TOY_AS_DICTIONARY(literal));
+		TOY_FREE(Toy_LiteralDictionary, TOY_AS_DICTIONARY(literal));
+		return;
+	}
+
+	//complex literals
+	if (TOY_IS_FUNCTION(literal)) {
+		Toy_popScope(TOY_AS_FUNCTION(literal).scope);
+		TOY_AS_FUNCTION(literal).scope = NULL;
+		Toy_deleteRefFunction((Toy_RefFunction*)(TOY_AS_FUNCTION(literal).inner.ptr));
+	}
+
+	if (TOY_IS_TYPE(literal) && TOY_AS_TYPE(literal).capacity > 0) {
+		for (int i = 0; i < TOY_AS_TYPE(literal).count; i++) {
+			Toy_freeLiteral(((Toy_Literal*)(TOY_AS_TYPE(literal).subtypes))[i]);
+		}
+		TOY_FREE_ARRAY(Toy_Literal, TOY_AS_TYPE(literal).subtypes, TOY_AS_TYPE(literal).capacity);
+		return;
+	}
+}
+
+bool Toy_private_isTruthy(Toy_Literal x) {
+	if (TOY_IS_NULL(x)) {
+		fprintf(stderr, TOY_CC_ERROR "Null is neither true nor false\n" TOY_CC_RESET);
+		return false;
+	}
+
+	if (TOY_IS_BOOLEAN(x)) {
+		return TOY_AS_BOOLEAN(x);
+	}
+
+	return true;
+}
+
+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});
+}
+
+Toy_Literal* Toy_private_typePushSubtype(Toy_Literal* lit, Toy_Literal subtype) {
+	//grow the subtype array
+	if (TOY_AS_TYPE(*lit).count + 1 > TOY_AS_TYPE(*lit).capacity) {
+		int oldCapacity = TOY_AS_TYPE(*lit).capacity;
+
+		TOY_AS_TYPE(*lit).capacity = TOY_GROW_CAPACITY(oldCapacity);
+		TOY_AS_TYPE(*lit).subtypes = TOY_GROW_ARRAY(Toy_Literal, TOY_AS_TYPE(*lit).subtypes, oldCapacity, TOY_AS_TYPE(*lit).capacity);
+	}
+
+	//actually push
+	((Toy_Literal*)(TOY_AS_TYPE(*lit).subtypes))[ TOY_AS_TYPE(*lit).count++ ] = subtype;
+	return &((Toy_Literal*)(TOY_AS_TYPE(*lit).subtypes))[ TOY_AS_TYPE(*lit).count - 1 ];
+}
+
+Toy_Literal Toy_copyLiteral(Toy_Literal original) {
+	switch(original.type) {
+		case TOY_LITERAL_NULL:
+		case TOY_LITERAL_BOOLEAN:
+		case TOY_LITERAL_INTEGER:
+		case TOY_LITERAL_FLOAT:
+			//no copying needed
+			return original;
+
+		case TOY_LITERAL_STRING: {
+			return TOY_TO_STRING_LITERAL(Toy_copyRefString(TOY_AS_STRING(original)));
+		}
+
+		case TOY_LITERAL_ARRAY: {
+			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]);
+			}
+
+			return TOY_TO_ARRAY_LITERAL(array);
+		}
+
+		case TOY_LITERAL_DICTIONARY: {
+			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) ) {
+					Toy_setLiteralDictionary(dictionary, TOY_AS_DICTIONARY(original)->entries[i].key, TOY_AS_DICTIONARY(original)->entries[i].value);
+				}
+			}
+
+			return TOY_TO_DICTIONARY_LITERAL(dictionary);
+		}
+
+		case TOY_LITERAL_FUNCTION: {
+			Toy_Literal literal = TOY_TO_FUNCTION_LITERAL(Toy_copyRefFunction( TOY_AS_FUNCTION(original).inner.ptr ));
+
+			TOY_AS_FUNCTION(literal).scope = Toy_copyScope(TOY_AS_FUNCTION(original).scope);
+
+			return literal;
+		}
+
+		case TOY_LITERAL_IDENTIFIER: {
+			//NOTE: could optimise this by copying the hash manually, but it's a very small increase in performance
+			return TOY_TO_IDENTIFIER_LITERAL(Toy_copyRefString(TOY_AS_IDENTIFIER(original)));
+		}
+
+		case TOY_LITERAL_TYPE: {
+			Toy_Literal lit = TOY_TO_TYPE_LITERAL(TOY_AS_TYPE(original).typeOf, TOY_AS_TYPE(original).constant);
+
+			for (int i = 0; i < TOY_AS_TYPE(original).count; i++) {
+				TOY_TYPE_PUSH_SUBTYPE(&lit, Toy_copyLiteral( ((Toy_Literal*)(TOY_AS_TYPE(original).subtypes))[i] ));
+			}
+
+			return lit;
+		}
+
+		case TOY_LITERAL_OPAQUE: {
+			return original; //literally a shallow copy
+		}
+
+		case TOY_LITERAL_ARRAY_INTERMEDIATE: { //TODO: efficient preallocation?
+			Toy_LiteralArray* array = TOY_ALLOCATE(Toy_LiteralArray, 1);
+			Toy_initLiteralArray(array);
+
+			//copy each element
+			for (int i = 0; i < TOY_AS_ARRAY(original)->count; i++) {
+				Toy_Literal literal = Toy_copyLiteral(TOY_AS_ARRAY(original)->literals[i]);
+				Toy_pushLiteralArray(array, literal);
+				Toy_freeLiteral(literal);
+			}
+
+			Toy_Literal ret = TOY_TO_ARRAY_LITERAL(array);
+			ret.type = TOY_LITERAL_ARRAY_INTERMEDIATE;
+			return ret;
+		}
+
+		case TOY_LITERAL_DICTIONARY_INTERMEDIATE: { //TODO: efficient preallocation?
+			Toy_LiteralArray* array = TOY_ALLOCATE(Toy_LiteralArray, 1);
+			Toy_initLiteralArray(array);
+
+			//copy each element
+			for (int i = 0; i < TOY_AS_ARRAY(original)->count; i++) {
+				Toy_Literal literal = Toy_copyLiteral(TOY_AS_ARRAY(original)->literals[i]);
+				Toy_pushLiteralArray(array, literal);
+				Toy_freeLiteral(literal);
+			}
+
+			Toy_Literal ret = TOY_TO_ARRAY_LITERAL(array);
+			ret.type = TOY_LITERAL_DICTIONARY_INTERMEDIATE;
+			return ret;
+		}
+
+		case TOY_LITERAL_TYPE_INTERMEDIATE: { //TODO: efficient preallocation?
+			Toy_LiteralArray* array = TOY_ALLOCATE(Toy_LiteralArray, 1);
+			Toy_initLiteralArray(array);
+
+			//copy each element
+			for (int i = 0; i < TOY_AS_ARRAY(original)->count; i++) {
+				Toy_Literal literal =  Toy_copyLiteral(TOY_AS_ARRAY(original)->literals[i]);
+				Toy_pushLiteralArray(array, literal);
+				Toy_freeLiteral(literal);
+			}
+
+			Toy_Literal ret = TOY_TO_ARRAY_LITERAL(array);
+			ret.type = TOY_LITERAL_TYPE_INTERMEDIATE;
+			return ret;
+		}
+
+		case TOY_LITERAL_FUNCTION_INTERMEDIATE: //caries a compiler
+		case TOY_LITERAL_FUNCTION_NATIVE:
+		case TOY_LITERAL_FUNCTION_HOOK:
+		case TOY_LITERAL_INDEX_BLANK:
+			//no copying possible
+			return original;
+
+		default:
+			fprintf(stderr, TOY_CC_ERROR "Can't copy that literal type: %d\n" TOY_CC_RESET, original.type);
+			return TOY_TO_NULL_LITERAL;
+	}
+}
+
+bool Toy_literalsAreEqual(Toy_Literal lhs, Toy_Literal rhs) {
+	//utility for other things
+	if (lhs.type != rhs.type) {
+		// ints and floats are compatible
+		if ((TOY_IS_INTEGER(lhs) || TOY_IS_FLOAT(lhs)) && (TOY_IS_INTEGER(rhs) || TOY_IS_FLOAT(rhs))) {
+			if (TOY_IS_INTEGER(lhs)) {
+				return TOY_AS_INTEGER(lhs) == TOY_AS_FLOAT(rhs);
+			}
+			else {
+				return TOY_AS_FLOAT(lhs) == TOY_AS_INTEGER(rhs);
+			}
+		}
+
+		return false;
+	}
+
+	switch(lhs.type) {
+		case TOY_LITERAL_NULL:
+			return true; //can only be true because of the check above
+
+		case TOY_LITERAL_BOOLEAN:
+			return TOY_AS_BOOLEAN(lhs) == TOY_AS_BOOLEAN(rhs);
+
+		case TOY_LITERAL_INTEGER:
+			return TOY_AS_INTEGER(lhs) == TOY_AS_INTEGER(rhs);
+
+		case TOY_LITERAL_FLOAT:
+			return TOY_AS_FLOAT(lhs) == TOY_AS_FLOAT(rhs);
+
+		case TOY_LITERAL_STRING:
+			return Toy_equalsRefString(TOY_AS_STRING(lhs), TOY_AS_STRING(rhs));
+
+		case TOY_LITERAL_ARRAY:
+		case TOY_LITERAL_ARRAY_INTERMEDIATE:
+		case TOY_LITERAL_DICTIONARY_INTERMEDIATE: //BUGFIX
+		case TOY_LITERAL_TYPE_INTERMEDIATE: //BUGFIX: used for storing types as an array
+			//mismatched sizes
+			if (TOY_AS_ARRAY(lhs)->count != TOY_AS_ARRAY(rhs)->count) {
+				return false;
+			}
+
+			//mismatched elements (in order)
+			for (int i = 0; i < TOY_AS_ARRAY(lhs)->count; i++) {
+				if (!Toy_literalsAreEqual( TOY_AS_ARRAY(lhs)->literals[i], TOY_AS_ARRAY(rhs)->literals[i] )) {
+					return false;
+				}
+			}
+			return true;
+
+		case TOY_LITERAL_DICTIONARY:
+			//relatively slow, especially when nested
+			for (int i = 0; i < TOY_AS_DICTIONARY(lhs)->capacity; i++) {
+				if (!TOY_IS_NULL(TOY_AS_DICTIONARY(lhs)->entries[i].key)) { //only compare non-null keys
+					//check it exists in rhs
+					if (!Toy_existsLiteralDictionary(TOY_AS_DICTIONARY(rhs), TOY_AS_DICTIONARY(lhs)->entries[i].key)) {
+						return false;
+					}
+
+					//compare the values
+					Toy_Literal val = Toy_getLiteralDictionary(TOY_AS_DICTIONARY(rhs), TOY_AS_DICTIONARY(lhs)->entries[i].key); //TODO: could be more efficient
+					if (!Toy_literalsAreEqual(TOY_AS_DICTIONARY(lhs)->entries[i].value, val)) {
+						Toy_freeLiteral(val);
+						return false;
+					}
+					Toy_freeLiteral(val);
+				}
+			}
+
+			return true;
+
+		case TOY_LITERAL_FUNCTION:
+		case TOY_LITERAL_FUNCTION_NATIVE:
+		case TOY_LITERAL_FUNCTION_HOOK:
+			return false; //functions are never equal
+		break;
+
+		case TOY_LITERAL_IDENTIFIER:
+			//check shortcuts
+			if (TOY_HASH_I(lhs) != TOY_HASH_I(rhs)) {
+				return false;
+			}
+
+			return Toy_equalsRefString(TOY_AS_IDENTIFIER(lhs), TOY_AS_IDENTIFIER(rhs));
+
+		case TOY_LITERAL_TYPE:
+			//check types
+			if (TOY_AS_TYPE(lhs).typeOf != TOY_AS_TYPE(rhs).typeOf) {
+				return false;
+			}
+
+			//const don't match
+			if (TOY_AS_TYPE(lhs).constant != TOY_AS_TYPE(rhs).constant) {
+				return false;
+			}
+
+			//check subtypes
+			if (TOY_AS_TYPE(lhs).count != TOY_AS_TYPE(rhs).count) {
+				return false;
+			}
+
+			//check array|dictionary signatures are the same (in order)
+			if (TOY_AS_TYPE(lhs).typeOf == TOY_LITERAL_ARRAY || TOY_AS_TYPE(lhs).typeOf == TOY_LITERAL_DICTIONARY) {
+				for (int i = 0; i < TOY_AS_TYPE(lhs).count; i++) {
+					if (!Toy_literalsAreEqual(((Toy_Literal*)(TOY_AS_TYPE(lhs).subtypes))[i], ((Toy_Literal*)(TOY_AS_TYPE(rhs).subtypes))[i])) {
+						return false;
+					}
+				}
+			}
+			return true;
+
+		case TOY_LITERAL_OPAQUE:
+			return false; //IDK what this is!
+
+		case TOY_LITERAL_ANY:
+			return true;
+
+		case TOY_LITERAL_FUNCTION_INTERMEDIATE:
+			fprintf(stderr, TOY_CC_ERROR "[internal] Can't compare intermediate functions\n" TOY_CC_RESET);
+			return false;
+
+		case TOY_LITERAL_INDEX_BLANK:
+			return false;
+
+		default:
+			//should never be seen
+			fprintf(stderr, TOY_CC_ERROR "[internal] Unrecognized literal type in equality: %d\n" TOY_CC_RESET, lhs.type);
+			return false;
+	}
+
+	return false;
+}
+
+int Toy_hashLiteral(Toy_Literal lit) {
+	switch(lit.type) {
+		case TOY_LITERAL_NULL:
+			return 0;
+
+		case TOY_LITERAL_BOOLEAN:
+			return TOY_AS_BOOLEAN(lit) ? 1 : 0;
+
+		case TOY_LITERAL_INTEGER:
+			return hashUInt((unsigned int)TOY_AS_INTEGER(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)));
+
+		case TOY_LITERAL_ARRAY: {
+			unsigned int res = 0;
+			for (int i = 0; i < TOY_AS_ARRAY(lit)->count; i++) {
+				res += Toy_hashLiteral(TOY_AS_ARRAY(lit)->literals[i]);
+			}
+			return hashUInt(res);
+		}
+
+		case TOY_LITERAL_DICTIONARY: {
+			unsigned int res = 0;
+			for (int i = 0; i < TOY_AS_DICTIONARY(lit)->capacity; i++) {
+				if (!TOY_IS_NULL(TOY_AS_DICTIONARY(lit)->entries[i].key)) { //only hash non-null keys
+					res += Toy_hashLiteral(TOY_AS_DICTIONARY(lit)->entries[i].key);
+					res += Toy_hashLiteral(TOY_AS_DICTIONARY(lit)->entries[i].value);
+				}
+			}
+			return hashUInt(res);
+		}
+
+		case TOY_LITERAL_FUNCTION:
+		case TOY_LITERAL_FUNCTION_NATIVE:
+		case TOY_LITERAL_FUNCTION_HOOK:
+			return -1; //can't hash these
+
+		case TOY_LITERAL_IDENTIFIER:
+			return TOY_HASH_I(lit); //pre-computed
+
+		case TOY_LITERAL_TYPE:
+			return -1; //not much i can really do
+
+		case TOY_LITERAL_OPAQUE:
+		case TOY_LITERAL_ANY:
+			return -1;
+
+		default:
+			//should never be seen
+			fprintf(stderr, TOY_CC_ERROR "[internal] Unrecognized literal type in hash: %d\n" TOY_CC_RESET, lit.type);
+			return 0;
+	}
+}
+
+//utils
+static void stdoutWrapper(const char* output) {
+	printf("%s", output);
+}
+
+//buffer the prints
+static char* globalPrintBuffer = NULL;
+static size_t globalPrintCapacity = 0;
+static size_t globalPrintCount = 0;
+
+//BUGFIX: string quotes shouldn't show when just printing strings, but should show when printing them as members of something else
+static char quotes = 0; //set to 0 to not show string quotes
+
+static void printToBuffer(const char* str) {
+	while (strlen(str) + globalPrintCount + 1 > globalPrintCapacity) {
+		int oldCapacity = globalPrintCapacity;
+
+		globalPrintCapacity = TOY_GROW_CAPACITY(globalPrintCapacity);
+		globalPrintBuffer = TOY_GROW_ARRAY(char, globalPrintBuffer, oldCapacity, globalPrintCapacity);
+	}
+
+	size_t total = snprintf(globalPrintBuffer + globalPrintCount, strlen(str) + 1, "%s", str ? str : "\0");
+	globalPrintCount += total;
+}
+
+//exposed functions
+void Toy_printLiteral(Toy_Literal literal) {
+	Toy_printLiteralCustom(literal, stdoutWrapper);
+}
+
+void Toy_printLiteralCustom(Toy_Literal literal, Toy_PrintFn printFn) {
+	switch(literal.type) {
+		case TOY_LITERAL_NULL:
+			printFn("null");
+		break;
+
+		case TOY_LITERAL_BOOLEAN:
+			printFn(TOY_AS_BOOLEAN(literal) ? "true" : "false");
+		break;
+
+		case TOY_LITERAL_INTEGER: {
+			char buffer[256];
+			snprintf(buffer, 256, "%d", TOY_AS_INTEGER(literal));
+			printFn(buffer);
+		}
+		break;
+
+		case TOY_LITERAL_FLOAT: {
+			char buffer[256];
+
+			if (TOY_AS_FLOAT(literal) - (int)TOY_AS_FLOAT(literal)) {
+				snprintf(buffer, 256, "%g", TOY_AS_FLOAT(literal));
+			}
+			else {
+				snprintf(buffer, 256, "%.1f", TOY_AS_FLOAT(literal));
+			}
+
+			printFn(buffer);
+		}
+		break;
+
+		case TOY_LITERAL_STRING: {
+			char buffer[TOY_MAX_STRING_LENGTH];
+			if (!quotes) {
+				snprintf(buffer, TOY_MAX_STRING_LENGTH, "%.*s", (int)Toy_lengthRefString(TOY_AS_STRING(literal)), Toy_toCString(TOY_AS_STRING(literal)));
+			}
+			else {
+				snprintf(buffer, TOY_MAX_STRING_LENGTH, "%c%.*s%c", quotes, (int)Toy_lengthRefString(TOY_AS_STRING(literal)), Toy_toCString(TOY_AS_STRING(literal)), quotes);
+			}
+			printFn(buffer);
+		}
+		break;
+
+		case TOY_LITERAL_ARRAY: {
+			Toy_LiteralArray* ptr = TOY_AS_ARRAY(literal);
+
+			//hold potential parent-call buffers on the C stack
+			char* cacheBuffer = globalPrintBuffer;
+			globalPrintBuffer = NULL;
+			int cacheCapacity = globalPrintCapacity;
+			globalPrintCapacity = 0;
+			int cacheCount = globalPrintCount;
+			globalPrintCount = 0;
+
+			//print the contents to the global buffer
+			printToBuffer("[");
+			for (int i = 0; i < ptr->count; i++) {
+				quotes = '"';
+				Toy_printLiteralCustom(ptr->literals[i], printToBuffer);
+
+				if (i + 1 < ptr->count) {
+					printToBuffer(",");
+				}
+			}
+			printToBuffer("]");
+
+			//swap the parent-call buffer back into place
+			char* printBuffer = globalPrintBuffer;
+			int printCapacity = globalPrintCapacity;
+			int printCount = globalPrintCount;
+
+			globalPrintBuffer = cacheBuffer;
+			globalPrintCapacity = cacheCapacity;
+			globalPrintCount = cacheCount;
+
+			//finally, output and cleanup
+			printFn(printBuffer);
+			TOY_FREE_ARRAY(char, printBuffer, printCapacity);
+			quotes = 0;
+		}
+		break;
+
+		case TOY_LITERAL_DICTIONARY: {
+			Toy_LiteralDictionary* ptr = TOY_AS_DICTIONARY(literal);
+
+			//hold potential parent-call buffers on the C stack
+			char* cacheBuffer = globalPrintBuffer;
+			globalPrintBuffer = NULL;
+			int cacheCapacity = globalPrintCapacity;
+			globalPrintCapacity = 0;
+			int cacheCount = globalPrintCount;
+			globalPrintCount = 0;
+
+			//print the contents to the global buffer
+			int delimCount = 0;
+			printToBuffer("[");
+			for (int i = 0; i < ptr->capacity; i++) {
+				if (TOY_IS_NULL(ptr->entries[i].key)) {
+					continue;
+				}
+
+				if (delimCount++ > 0) {
+					printToBuffer(",");
+				}
+
+				quotes = '"';
+				Toy_printLiteralCustom(ptr->entries[i].key, printToBuffer);
+				printToBuffer(":");
+				quotes = '"';
+				Toy_printLiteralCustom(ptr->entries[i].value, printToBuffer);
+			}
+
+			//empty dicts MUST have a ":" printed
+			if (ptr->count == 0) {
+				printToBuffer(":");
+			}
+
+			printToBuffer("]");
+
+			//swap the parent-call buffer back into place
+			char* printBuffer = globalPrintBuffer;
+			int printCapacity = globalPrintCapacity;
+			int printCount = globalPrintCount;
+
+			globalPrintBuffer = cacheBuffer;
+			globalPrintCapacity = cacheCapacity;
+			globalPrintCount = cacheCount;
+
+			//finally, output and cleanup
+			printFn(printBuffer);
+			TOY_FREE_ARRAY(char, printBuffer, printCapacity);
+			quotes = 0;
+		}
+		break;
+
+		case TOY_LITERAL_FUNCTION:
+		case TOY_LITERAL_FUNCTION_NATIVE:
+		case TOY_LITERAL_FUNCTION_HOOK:
+			printFn("(function)");
+		break;
+
+		case TOY_LITERAL_IDENTIFIER: {
+			char buffer[256];
+			snprintf(buffer, 256, "%.*s", (int)Toy_lengthRefString(TOY_AS_IDENTIFIER(literal)), Toy_toCString(TOY_AS_IDENTIFIER(literal)));
+			printFn(buffer);
+		}
+		break;
+
+		case TOY_LITERAL_TYPE: {
+			//hold potential parent-call buffers on the C stack
+			char* cacheBuffer = globalPrintBuffer;
+			globalPrintBuffer = NULL;
+			int cacheCapacity = globalPrintCapacity;
+			globalPrintCapacity = 0;
+			int cacheCount = globalPrintCount;
+			globalPrintCount = 0;
+
+			//print the type correctly
+			printToBuffer("<");
+
+			switch(TOY_AS_TYPE(literal).typeOf) {
+				case TOY_LITERAL_NULL:
+					printToBuffer("null");
+				break;
+
+				case TOY_LITERAL_BOOLEAN:
+					printToBuffer("bool");
+				break;
+
+				case TOY_LITERAL_INTEGER:
+					printToBuffer("int");
+				break;
+
+				case TOY_LITERAL_FLOAT:
+					printToBuffer("float");
+				break;
+
+				case TOY_LITERAL_STRING:
+					printToBuffer("string");
+				break;
+
+				case TOY_LITERAL_ARRAY:
+					//print all in the array
+					printToBuffer("[");
+					for (int i = 0; i < TOY_AS_TYPE(literal).count; i++) {
+						Toy_printLiteralCustom(((Toy_Literal*)(TOY_AS_TYPE(literal).subtypes))[i], printToBuffer);
+					}
+					printToBuffer("]");
+				break;
+
+				case TOY_LITERAL_DICTIONARY:
+					printToBuffer("[");
+
+					for (int i = 0; i < TOY_AS_TYPE(literal).count; i += 2) {
+						Toy_printLiteralCustom(((Toy_Literal*)(TOY_AS_TYPE(literal).subtypes))[i], printToBuffer);
+						printToBuffer(":");
+						Toy_printLiteralCustom(((Toy_Literal*)(TOY_AS_TYPE(literal).subtypes))[i + 1], printToBuffer);
+					}
+					printToBuffer("]");
+				break;
+
+				case TOY_LITERAL_FUNCTION:
+					printToBuffer("function");
+				break;
+
+				case TOY_LITERAL_FUNCTION_NATIVE:
+					printToBuffer("native");
+				break;
+
+				case TOY_LITERAL_IDENTIFIER:
+					printToBuffer("identifier");
+				break;
+
+				case TOY_LITERAL_TYPE:
+					printToBuffer("type");
+				break;
+
+				case TOY_LITERAL_OPAQUE:
+					printToBuffer("opaque");
+				break;
+
+				case TOY_LITERAL_ANY:
+					printToBuffer("any");
+				break;
+
+				default:
+					//should never be seen
+					fprintf(stderr, TOY_CC_ERROR "[internal] Unrecognized literal type in print type: %d\n" TOY_CC_RESET, TOY_AS_TYPE(literal).typeOf);
+			}
+
+			//const (printed last)
+			if (TOY_AS_TYPE(literal).constant) {
+				printToBuffer(" const");
+			}
+
+			printToBuffer(">");
+
+			//swap the parent-call buffer back into place
+			char* printBuffer = globalPrintBuffer;
+			int printCapacity = globalPrintCapacity;
+			int printCount = globalPrintCount;
+
+			globalPrintBuffer = cacheBuffer;
+			globalPrintCapacity = cacheCapacity;
+			globalPrintCount = cacheCount;
+
+			//finally, output and cleanup
+			printFn(printBuffer);
+			TOY_FREE_ARRAY(char, printBuffer, printCapacity);
+			quotes = 0;
+		}
+		break;
+
+		case TOY_LITERAL_TYPE_INTERMEDIATE:
+		case TOY_LITERAL_FUNCTION_INTERMEDIATE:
+			printFn("Unprintable literal found");
+		break;
+
+		case TOY_LITERAL_OPAQUE:
+			printFn("(opaque)");
+		break;
+
+		case TOY_LITERAL_ANY:
+			printFn("(any)");
+		break;
+
+		default:
+			//should never be seen
+			fprintf(stderr, TOY_CC_ERROR "[internal] Unrecognized literal type in print: %d\n" TOY_CC_RESET, literal.type);
+	}
+}

source/toy_literal.h

@@ -0,0 +1,380 @@
+#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;
+struct Toy_Interpreter;
+struct Toy_LiteralArray;
+struct Toy_LiteralDictionary;
+struct Toy_Scope;
+typedef int (*Toy_NativeFn)(struct Toy_Interpreter* interpreter, struct Toy_LiteralArray* arguments);
+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,
+	TOY_LITERAL_INTEGER,
+	TOY_LITERAL_FLOAT,
+	TOY_LITERAL_STRING,
+	TOY_LITERAL_ARRAY,
+	TOY_LITERAL_DICTIONARY,
+	TOY_LITERAL_FUNCTION,
+	TOY_LITERAL_IDENTIFIER,
+	TOY_LITERAL_TYPE,
+	TOY_LITERAL_OPAQUE,
+	TOY_LITERAL_ANY,
+
+	//these are meta-level types - not for general use
+	TOY_LITERAL_TYPE_INTERMEDIATE, //used to process types in the compiler only
+	TOY_LITERAL_ARRAY_INTERMEDIATE, //used to process arrays in the compiler only
+	TOY_LITERAL_DICTIONARY_INTERMEDIATE, //used to process dictionaries in the compiler only
+	TOY_LITERAL_FUNCTION_INTERMEDIATE, //used to process functions in the compiler only
+	TOY_LITERAL_FUNCTION_ARG_REST, //used to process function rest parameters only
+	TOY_LITERAL_FUNCTION_NATIVE, //for handling native functions only
+	TOY_LITERAL_FUNCTION_HOOK, //for handling hook functions within literals only
+	TOY_LITERAL_INDEX_BLANK, //for blank indexing i.e. arr[:]
+} Toy_LiteralType;
+
+typedef struct Toy_Literal {
+	union {
+		bool boolean; //1
+		int integer; //4
+		float number;//4
+
+		struct {
+			Toy_RefString* ptr; //8
+			//string hash?
+		} string; //8
+
+		struct Toy_LiteralArray* array; //8
+		struct Toy_LiteralDictionary* dictionary; //8
+
+		struct {
+			union {
+				Toy_RefFunction* ptr;  //8
+				Toy_NativeFn native; //8
+				Toy_HookFn hook; //8
+			} inner;  //8
+			struct Toy_Scope* scope; //8
+		} function; //16
+
+		struct { //for variable names
+			Toy_RefString* ptr;  //8
+			int hash; //4
+		} identifier; //16
+
+		struct {
+			struct Toy_Literal* subtypes; //8
+			Toy_LiteralType typeOf;  //4
+			unsigned char capacity; //1
+			unsigned char count; //1
+			bool constant; //1
+		} type; //16
+
+		struct {
+			void* ptr; //8
+			int tag; //4
+		} opaque; //16
+
+		void* generic; //8
+	} as; //16
+
+	Toy_LiteralType type; //4
+	//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)
+#define TOY_IS_FLOAT(value)						((value).type == TOY_LITERAL_FLOAT)
+#define TOY_IS_STRING(value)					((value).type == TOY_LITERAL_STRING)
+#define TOY_IS_ARRAY(value)						((value).type == TOY_LITERAL_ARRAY)
+#define TOY_IS_DICTIONARY(value)				((value).type == TOY_LITERAL_DICTIONARY)
+#define TOY_IS_FUNCTION(value)					((value).type == TOY_LITERAL_FUNCTION)
+#define TOY_IS_FUNCTION_NATIVE(value)			((value).type == TOY_LITERAL_FUNCTION_NATIVE)
+#define TOY_IS_FUNCTION_HOOK(value)				((value).type == TOY_LITERAL_FUNCTION_HOOK)
+#define TOY_IS_IDENTIFIER(value)				((value).type == TOY_LITERAL_IDENTIFIER)
+#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)
+#define TOY_AS_STRING(value)					((value).as.string.ptr)
+#define TOY_AS_ARRAY(value)						((Toy_LiteralArray*)((value).as.array))
+#define TOY_AS_DICTIONARY(value)				((Toy_LiteralDictionary*)((value).as.dictionary))
+#define TOY_AS_FUNCTION(value)					((value).as.function)
+#define TOY_AS_FUNCTION_NATIVE(value)			((value).as.function.inner.native)
+#define TOY_AS_FUNCTION_HOOK(value)				((value).as.function.inner.hook)
+#define TOY_AS_IDENTIFIER(value)				((value).as.identifier.ptr)
+#define TOY_AS_TYPE(value)						((value).as.type)
+#define TOY_AS_OPAQUE(value)					((value).as.opaque.ptr)
+
+/*!
+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})
+#define TOY_TO_OPAQUE_LITERAL(value, t)			((Toy_Literal){{ .opaque = { .ptr = value, .tag = t }}, TOY_LITERAL_OPAQUE})
+
+//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})
+
+/*!
+## More Defined Macros
+
+The following macros are utilities used throughout Toy's internals, and are available for the user as well.
+!*/
+
+/*!
+### 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
+
+/*!
+## Defined Functions
+!*/
+
+/*!
+### 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);
+
+/*!
+### 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);

source/toy_literal_array.c

@@ -0,0 +1,100 @@
+#include "toy_literal_array.h"
+
+#include "toy_memory.h"
+
+#include <stdio.h>
+#include <string.h>
+
+//exposed functions
+void Toy_initLiteralArray(Toy_LiteralArray* array) {
+	array->capacity = 0;
+	array->count = 0;
+	array->literals = NULL;
+}
+
+void Toy_freeLiteralArray(Toy_LiteralArray* array) {
+	//clean up memory
+	for(int i = 0; i < array->count; i++) {
+		Toy_freeLiteral(array->literals[i]);
+	}
+
+	if (array->capacity > 0) {
+		TOY_FREE_ARRAY(Toy_Literal, array->literals, array->capacity);
+		Toy_initLiteralArray(array);
+	}
+}
+
+int Toy_pushLiteralArray(Toy_LiteralArray* array, Toy_Literal literal) {
+	if (array->capacity < array->count + 1) {
+		int oldCapacity = array->capacity;
+
+		array->capacity = TOY_GROW_CAPACITY(oldCapacity);
+		array->literals = TOY_GROW_ARRAY(Toy_Literal, array->literals, oldCapacity, array->capacity);
+	}
+
+	array->literals[array->count] = Toy_copyLiteral(literal);
+	return array->count++;
+}
+
+Toy_Literal Toy_popLiteralArray(Toy_LiteralArray* array) {
+	if (array->count <= 0) {
+		return TOY_TO_NULL_LITERAL;
+	}
+
+	//get the return
+	Toy_Literal ret = array->literals[array->count-1];
+
+	//null the existing data
+	array->literals[array->count-1] = TOY_TO_NULL_LITERAL;
+
+	array->count--;
+	return ret;
+}
+
+//find a literal in the array that matches the "literal" argument
+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) {
+			continue;
+		}
+
+		//types match?
+		if (Toy_literalsAreEqual(array->literals[i], literal)) {
+			return i;
+		}
+	}
+
+	return -1;
+}
+
+bool Toy_setLiteralArray(Toy_LiteralArray* array, Toy_Literal index, Toy_Literal value) {
+	if (!TOY_IS_INTEGER(index)) {
+		return false;
+	}
+
+	int idx = TOY_AS_INTEGER(index);
+
+	if (idx < 0 || idx >= array->count) {
+		return false;
+	}
+
+	Toy_freeLiteral(array->literals[idx]);
+	array->literals[idx] = Toy_copyLiteral(value);
+
+	return true;
+}
+
+Toy_Literal Toy_getLiteralArray(Toy_LiteralArray* array, Toy_Literal index) {
+	if (!TOY_IS_INTEGER(index)) {
+		return TOY_TO_NULL_LITERAL;
+	}
+
+	int idx = TOY_AS_INTEGER(index);
+
+	if (idx < 0 || idx >= array->count) {
+		return TOY_TO_NULL_LITERAL;
+	}
+
+	return Toy_copyLiteral(array->literals[idx]);
+}

source/toy_literal_array.h

@@ -1,41 +1,82 @@
+#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 fundamental data structures used throughout Toy - the other is the dictionary.
+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"
+
+typedef struct Toy_LiteralArray {
+	Toy_Literal* literals;
+	int capacity;
+	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_private_findLiteralIndex(Toy_LiteralArray* array, Toy_Literal literal)
 
 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

source/toy_literal_dictionary.c

@@ -0,0 +1,231 @@
+#include "toy_literal_dictionary.h"
+
+#include "toy_memory.h"
+
+#include "toy_console_colors.h"
+
+#include <stdio.h>
+
+//util functions
+static void setEntryValues(Toy_private_dictionary_entry* entry, Toy_Literal key, Toy_Literal value) {
+	//much simpler now
+	Toy_freeLiteral(entry->key);
+	entry->key = Toy_copyLiteral(key);
+
+	Toy_freeLiteral(entry->value);
+	entry->value = Toy_copyLiteral(value);
+}
+
+static Toy_private_dictionary_entry* getEntryArray(Toy_private_dictionary_entry* array, int capacity, Toy_Literal key, unsigned int hash, bool mustExist) {
+	if (!capacity) {
+		return NULL;
+	}
+
+	//find "key", starting at index
+	int index = hash % capacity;
+	int start = index;
+
+	//increment once, so it can't equal start
+	if (++index >= capacity) {
+		index = 0;
+	}
+
+	//literal probing and collision checking
+	while (index != start) { //WARNING: this is the only function allowed to retrieve an entry from the array
+		Toy_private_dictionary_entry* entry = &array[index];
+
+		if (TOY_IS_NULL(entry->key)) { //if key is empty, it's either empty or tombstone
+			if (TOY_IS_NULL(entry->value) && !mustExist) {
+				//found a truly empty bucket
+				return entry;
+			}
+			//else it's a tombstone - ignore
+		} else {
+			if (Toy_literalsAreEqual(key, entry->key)) {
+				return entry;
+			}
+		}
+
+		if (++index >= capacity) {
+			index = 0;
+		}
+		//index = (index + 1) % capacity;
+	}
+
+	return NULL;
+}
+
+static void adjustEntryCapacity(Toy_private_dictionary_entry** dictionaryHandle, int oldCapacity, int capacity) {
+	//new entry space
+	Toy_private_dictionary_entry* newEntries = TOY_ALLOCATE(Toy_private_dictionary_entry, capacity);
+
+	for (int i = 0; i < capacity; i++) {
+		newEntries[i].key = TOY_TO_NULL_LITERAL;
+		newEntries[i].value = TOY_TO_NULL_LITERAL;
+	}
+
+	//move the old array into the new one
+	for (int i = 0; i < oldCapacity; i++) {
+		if (TOY_IS_NULL((*dictionaryHandle)[i].key)) {
+			continue;
+		}
+
+		//place the key and value in the new array (reusing string memory)
+		Toy_private_dictionary_entry* entry = getEntryArray(newEntries, capacity, TOY_TO_NULL_LITERAL, Toy_hashLiteral((*dictionaryHandle)[i].key), false);
+
+		entry->key = (*dictionaryHandle)[i].key;
+		entry->value = (*dictionaryHandle)[i].value;
+	}
+
+	//clear the old array
+	if (oldCapacity > 0) {
+		TOY_FREE_ARRAY(Toy_private_dictionary_entry, *dictionaryHandle, oldCapacity);
+	}
+
+	*dictionaryHandle = newEntries;
+}
+
+static bool setEntryArray(Toy_private_dictionary_entry** dictionaryHandle, int* capacityPtr, int contains, Toy_Literal key, Toy_Literal value, int hash) {
+	//expand array if needed
+	if (contains + 1 > *capacityPtr * TOY_DICTIONARY_MAX_LOAD) {
+		int oldCapacity = *capacityPtr;
+		*capacityPtr = TOY_GROW_CAPACITY(*capacityPtr);
+		adjustEntryCapacity(dictionaryHandle, oldCapacity, *capacityPtr); //custom rather than automatic reallocation
+	}
+
+	Toy_private_dictionary_entry* entry = getEntryArray(*dictionaryHandle, *capacityPtr, key, hash, false);
+
+	//true = contains increase
+	if (TOY_IS_NULL(entry->key)) {
+		setEntryValues(entry, key, value);
+		return true;
+	}
+	else {
+		setEntryValues(entry, key, value);
+		return false;
+	}
+
+	return false;
+}
+
+static void freeEntry(Toy_private_dictionary_entry* entry) {
+	Toy_freeLiteral(entry->key);
+	Toy_freeLiteral(entry->value);
+	entry->key = TOY_TO_NULL_LITERAL;
+	entry->value = TOY_TO_NULL_LITERAL;
+}
+
+static void freeEntryArray(Toy_private_dictionary_entry* array, int capacity) {
+	if (array == NULL) {
+		return;
+	}
+
+	for (int i = 0; i < capacity; i++) {
+		if (!TOY_IS_NULL(array[i].key)) {
+			freeEntry(&array[i]);
+		}
+	}
+
+	TOY_FREE_ARRAY(Toy_private_dictionary_entry, array, capacity);
+}
+
+//exposed functions
+void Toy_initLiteralDictionary(Toy_LiteralDictionary* dictionary) {
+	dictionary->entries = NULL;
+	dictionary->capacity = 0;
+	dictionary->contains = 0;
+	dictionary->count = 0;
+	dictionary->capacity = 0;
+}
+
+void Toy_freeLiteralDictionary(Toy_LiteralDictionary* dictionary) {
+	if (dictionary->capacity > 0) {
+		freeEntryArray(dictionary->entries, dictionary->capacity);
+		dictionary->capacity = 0;
+		dictionary->contains = 0;
+	}
+}
+
+void Toy_setLiteralDictionary(Toy_LiteralDictionary* dictionary, Toy_Literal key, Toy_Literal value) {
+	if (TOY_IS_NULL(key)) {
+		fprintf(stderr, TOY_CC_ERROR "Dictionaries can't have null keys (set)\n" TOY_CC_RESET);
+		return;
+	}
+
+	//BUGFIX: Can't hash a function
+	if (TOY_IS_FUNCTION(key) || TOY_IS_FUNCTION_NATIVE(key) || TOY_IS_FUNCTION_HOOK(key)) {
+		fprintf(stderr, TOY_CC_ERROR "Dictionaries can't have function keys (set)\n" TOY_CC_RESET);
+		return;
+	}
+
+	if (TOY_IS_OPAQUE(key)) {
+		fprintf(stderr, TOY_CC_ERROR "Dictionaries can't have opaque keys (set)\n" TOY_CC_RESET);
+		return;
+	}
+
+	const int increment = setEntryArray(&dictionary->entries, &dictionary->capacity, dictionary->contains, key, value, Toy_hashLiteral(key));
+
+	if (increment) {
+		dictionary->contains++;
+		dictionary->count++;
+	}
+}
+
+Toy_Literal Toy_getLiteralDictionary(Toy_LiteralDictionary* dictionary, Toy_Literal key) {
+	if (TOY_IS_NULL(key)) {
+		fprintf(stderr, TOY_CC_ERROR "Dictionaries can't have null keys (get)\n" TOY_CC_RESET);
+		return TOY_TO_NULL_LITERAL;
+	}
+
+	//BUGFIX: Can't hash a function
+	if (TOY_IS_FUNCTION(key) || TOY_IS_FUNCTION_NATIVE(key) || TOY_IS_FUNCTION_HOOK(key)) {
+		fprintf(stderr, TOY_CC_ERROR "Dictionaries can't have function keys (get)\n" TOY_CC_RESET);
+		return TOY_TO_NULL_LITERAL;
+	}
+
+	if (TOY_IS_OPAQUE(key)) {
+		fprintf(stderr, TOY_CC_ERROR "Dictionaries can't have opaque keys (get)\n" TOY_CC_RESET);
+		return TOY_TO_NULL_LITERAL;
+	}
+
+	Toy_private_dictionary_entry* entry = getEntryArray(dictionary->entries, dictionary->capacity, key, Toy_hashLiteral(key), true);
+
+	if (entry != NULL) {
+		return Toy_copyLiteral(entry->value);
+	}
+	else {
+		return TOY_TO_NULL_LITERAL;
+	}
+}
+
+void Toy_removeLiteralDictionary(Toy_LiteralDictionary* dictionary, Toy_Literal key) {
+	if (TOY_IS_NULL(key)) {
+		fprintf(stderr, TOY_CC_ERROR "Dictionaries can't have null keys (remove)\n" TOY_CC_RESET);
+		return;
+	}
+
+	//BUGFIX: Can't hash a function
+	if (TOY_IS_FUNCTION(key) || TOY_IS_FUNCTION_NATIVE(key) || TOY_IS_FUNCTION_HOOK(key)) {
+		fprintf(stderr, TOY_CC_ERROR "Dictionaries can't have function keys (remove)\n" TOY_CC_RESET);
+		return;
+	}
+
+	if (TOY_IS_OPAQUE(key)) {
+		fprintf(stderr, TOY_CC_ERROR "Dictionaries can't have opaque keys (remove)\n" TOY_CC_RESET);
+		return;
+	}
+
+	Toy_private_dictionary_entry* entry = getEntryArray(dictionary->entries, dictionary->capacity, key, Toy_hashLiteral(key), true);
+
+	if (entry != NULL) {
+		freeEntry(entry);
+		entry->value = TOY_TO_BOOLEAN_LITERAL(true); //tombstone
+		dictionary->count--;
+	}
+}
+
+bool Toy_existsLiteralDictionary(Toy_LiteralDictionary* dictionary, Toy_Literal key) {
+	//null & not tombstoned
+	Toy_private_dictionary_entry* entry = getEntryArray(dictionary->entries, dictionary->capacity, key, Toy_hashLiteral(key), false);
+	return entry != NULL && !(TOY_IS_NULL(entry->key) && TOY_IS_NULL(entry->value));
+}

source/toy_literal_dictionary.h

@@ -1,31 +1,65 @@
+#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 fundamental data structures used throughout Toy - the other is the array.
+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 its capacity, then a new buffer is created, the old contents are copied over one-by-one, and the original buffer is freed.
+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 language.
+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
+
+typedef struct Toy_private_dictionary_entry {
+	Toy_Literal key;
+	Toy_Literal value;
+} Toy_private_dictionary_entry;
+
+typedef struct Toy_LiteralDictionary {
+	Toy_private_dictionary_entry* entries;
+	int capacity;
+	int count;
+	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.
@@ -33,19 +67,30 @@ This function inserts the given key-value pair of literals into `dictionary`, cr
 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);

source/toy_memory.c

@@ -0,0 +1,54 @@
+#include "toy_memory.h"
+#include "toy_refstring.h"
+#include "toy_reffunction.h"
+
+#include "toy_console_colors.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+
+//default allocator
+void* Toy_private_defaultMemoryAllocator(void* pointer, size_t oldSize, size_t newSize) {
+	//causes issues, so just skip out with a NO-OP (DISABLED for performance reasons)
+	// if (newSize == 0 && oldSize == 0) {
+	// 	return NULL;
+	// }
+
+	if (newSize == 0) {
+		free(pointer);
+		return NULL;
+	}
+
+	void* mem = realloc(pointer, newSize);
+
+	if (mem == NULL) {
+		fprintf(stderr, TOY_CC_ERROR "[internal] Memory allocation error (requested %d, replacing %d)\n" TOY_CC_RESET, (int)newSize, (int)oldSize);
+		return NULL;
+	}
+
+	return mem;
+}
+
+//static variables
+static Toy_MemoryAllocatorFn allocator = Toy_private_defaultMemoryAllocator;
+
+//exposed API
+void* Toy_reallocate(void* pointer, size_t oldSize, size_t newSize) {
+	return allocator(pointer, oldSize, newSize);
+}
+
+void Toy_setMemoryAllocator(Toy_MemoryAllocatorFn fn) {
+	if (fn == NULL) {
+		fprintf(stderr, TOY_CC_ERROR "[internal] Memory allocator error (can't be null)\n" TOY_CC_RESET);
+		exit(-1);
+	}
+
+	if (fn == Toy_reallocate) {
+		fprintf(stderr, TOY_CC_ERROR "[internal] Memory allocator error (can't loop the Toy_reallocate function)\n" TOY_CC_RESET);
+		exit(-1);
+	}
+
+	allocator = fn;
+	Toy_setRefStringAllocatorFn(fn);
+	Toy_setRefFunctionAllocatorFn(fn);
+}

source/toy_memory.h

@@ -1,43 +1,79 @@
+#pragma once
 
-
+/*!
 # toy_memory.h
 
-This header defines all the memory management utilities. Any and all heap-based memory management goes through these utilities.
+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))
 
+/*!
 ## 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.
@@ -46,20 +82,31 @@ 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 allocated, in bytes (`newSize` 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);
 
+/*!
 ### 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);

source/toy_opcodes.h

@@ -0,0 +1,94 @@
+#pragma once
+
+typedef enum Toy_Opcode {
+	TOY_OP_EOF,
+
+	//do nothing
+	TOY_OP_PASS,
+
+	//basic statements
+	TOY_OP_ASSERT,
+	TOY_OP_PRINT,
+
+	//data
+	TOY_OP_LITERAL,
+	TOY_OP_LITERAL_LONG, //for more than 256 literals in a chunk
+	TOY_OP_LITERAL_RAW, //forcibly get the raw value of the literal
+
+	//arithmetic operators
+	TOY_OP_NEGATE,
+	TOY_OP_ADDITION,
+	TOY_OP_SUBTRACTION,
+	TOY_OP_MULTIPLICATION,
+	TOY_OP_DIVISION,
+	TOY_OP_MODULO,
+	TOY_OP_GROUPING_BEGIN,
+	TOY_OP_GROUPING_END,
+
+	//variable stuff
+	TOY_OP_SCOPE_BEGIN,
+	TOY_OP_SCOPE_END,
+
+	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)
+
+	TOY_OP_FN_DECL,			//declare a function to be used (as a literal)
+	TOY_OP_FN_DECL_LONG,	//declare a function to be used (as a long literal)
+
+	TOY_OP_VAR_ASSIGN,		//assign to a literal
+	TOY_OP_VAR_ADDITION_ASSIGN,
+	TOY_OP_VAR_SUBTRACTION_ASSIGN,
+	TOY_OP_VAR_MULTIPLICATION_ASSIGN,
+	TOY_OP_VAR_DIVISION_ASSIGN,
+	TOY_OP_VAR_MODULO_ASSIGN,
+
+	TOY_OP_TYPE_CAST,		//temporarily change a type of an atomic value
+	TOY_OP_TYPE_OF,			//get the type of a variable
+
+	TOY_OP_IMPORT,
+	TOY_OP_EXPORT_removed,
+
+	//for indexing
+	TOY_OP_INDEX,
+	TOY_OP_INDEX_ASSIGN,
+	TOY_OP_INDEX_ASSIGN_INTERMEDIATE,
+	TOY_OP_DOT,
+
+	//comparison of values
+	TOY_OP_COMPARE_EQUAL,
+	TOY_OP_COMPARE_NOT_EQUAL,
+	TOY_OP_COMPARE_LESS,
+	TOY_OP_COMPARE_LESS_EQUAL,
+	TOY_OP_COMPARE_GREATER,
+	TOY_OP_COMPARE_GREATER_EQUAL,
+	TOY_OP_INVERT, //for booleans
+
+	//logical operators
+	TOY_OP_AND,
+	TOY_OP_OR,
+
+	//jumps, and conditional jumps (absolute)
+	TOY_OP_JUMP,
+	TOY_OP_IF_FALSE_JUMP,
+	TOY_OP_FN_CALL,
+	TOY_OP_FN_RETURN,
+
+	//pop the stack at the end of a complex statement
+	TOY_OP_POP_STACK,
+
+	//ternary shorthand
+	TOY_OP_TERNARY,
+
+	//meta
+	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;
+

source/toy_parser.h

@@ -1,4 +1,6 @@
+#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.
@@ -48,25 +50,54 @@ const unsigned char* Toy_compileString(const char* source, size_t* size) {
 	return tb;
 }
 ```
+!*/
 
+#include "toy_common.h"
+#include "toy_lexer.h"
+#include "toy_ast_node.h"
+
+//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
+	bool panic; //I am processing an error
+
+	//track the last two outputs from the lexer
+	Toy_Token current;
+	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 passed to `Toy_writeCompiler`, or when the node is an error 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.
+!*/

source/toy_reffunction.c

@@ -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);
+}

source/toy_reffunction.h

@@ -1,49 +1,88 @@
+#pragma once
 
-
+/*!
 # toy_reffunction.h
 
-This header defines the Toy_RefFunction structure, as well as all the related utilities.
+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);