Removed spec.md, use https://toylang.com

Well, it should work without issues...

.github/FUNDING.yml

@@ -1,5 +0,0 @@
-# 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

@@ -1,29 +0,0 @@
----
-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

@@ -1,17 +0,0 @@
----
-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

@@ -1,10 +0,0 @@
----
-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-v2.yml

@@ -1,42 +0,0 @@
-name: Continuous Integration v2.x
-
-#trigger when these occur
-on:
-  push:
-    branches:
-      - v2
-  pull_request:
-    types:
-      - opened
-      - edited
-      - reopened
-    branches:
-      - v2
-  workflow_dispatch:
-
-jobs:
-  #CI workflows across all supported platforms
-  standard:
-    strategy:
-      fail-fast: false
-      matrix:
-        platforms:
-          - ubuntu-latest
-          - windows-latest
-          - macos-latest
-    runs-on: ${{ matrix.platforms }}
-    steps:
-      - uses: actions/checkout@v6
-      - name: Run all tests
-        run: make tests
-
-  gdb:
-    strategy:
-      fail-fast: false
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v6
-      - name: Install GDB if not present
-        run: sudo apt update && sudo apt install gdb
-      - name: Run all tests under gdb
-        run: make tests-gdb

.gitignore

@@ -1,57 +1,31 @@
-# Prerequisites
-*.d
+#Editor generated files
+*.sln
+*.vcproj
+*.suo
+*.ncb
+*.user
+compile_commands.json
 
-# Object files
+#Directories
+Release/
+Debug/
+Out/
+release/
+debug/
+out/
+.cache/
+
+#Project generated files
+*.db
 *.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
+*.meta
 *.log
+out
+*.stackdump
+*.tb
 
-# Kernel Module Compile Results
-*.mod*
-*.cmd
-.tmp_versions/
-modules.order
-Module.symvers
-Mkfile.old
-dkms.conf
-
-#mdbook files
-book
-mdbook
+#Shell files
+*.bat
+*.sh

.notes/README.md

@@ -1,2 +0,0 @@
-This folder is full of development notes, and are probably out of date. Check the actual docs for the correct info.
-

.notes/SECD-concept.txt

@@ -1,152 +0,0 @@
-This file is messy and confusing, and makes sense to nobody but me - so don't worry about understanding it too much - better docs will come later.
-
-===
-
-SECD = State, Environment, Control, Dump
-
-The idea of "Landin's SECD Machine" is to store the working memory in S, the variable-value bindings in E, the code/instructions in C, and the program stack in D.
-
-Notes:
-	DEFINE = DECLARE + SET
-
-	The environment, denoted with an E, is created on routine start, and destroyed on routine end - however, it uses the parent routine's environment as the starting point for it's creation, so closures work as expected
-
-	unlike version 1, identifiers are not a valid datatype - they're just an index representing a symbol, like "standard::clock"
-
-	meta opcodes - EOF, PASS, ERROR,
-
-	a "value" can be of any valid datatype, and may point to various parts of memory to define it's value
-
-	Symbols will be awkward... I suspect the symbol table might need to be rebuilt on startup, as the order of the modules will not necessarily be the same each time
-
-	The various instances of S could be the same array in memory, simply marked as "unused"? You could stick C on there as a value before "pushing" for a new routine
-
-Things to consider later:
-	type cast?
-	rest parameter?
-	index access and assign?
-
-===
-
-//variable instructions
-READ
-	read one value from C onto S
-LOAD
-	read one value from .data onto S
-DECLARE
-	read two words from C, create a new entry in E with the key E[SYMBOL(word1)], the type defined by word2, the value 'null'
-DEFINE
-	read one word from C, saves the pre-existing key E[SYMBOL(word)] to the value S(0), popping S(0)
-ACCESS
-	read one word from C, finds the pre-existing value of E[SYMBOL(word)], leaves the value on S
-
-//arithmetic instructions
-ADD
-	performs the specified operation on S(-1) and S(0), popping both, leaving the result on S
-SUBTRACT
-	performs the specified operation on S(-1) and S(0), popping both, leaving the result on S
-MULTIPLY
-	performs the specified operation on S(-1) and S(0), popping both, leaving the result on S
-DIVIDE
-	performs the specified operation on S(-1) and S(0), popping both, leaving the result on S
-MODULO
-	performs the specified operation on S(-1) and S(0), popping both, leaving the result on S
-
-
-//comparison instructions
-COMPARE_EQUAL
-	pops S(-1) and S(0), replacing it with TRUE or FALSE, depending on equality
-COMPARE_LESS
-	pops S(-1) and S(0), replacing it with TRUE or FALSE, depending on comparison
-COMPARE_LESS_EQUAL
-	pops S(-1) and S(0), replacing it with TRUE or FALSE, depending on comparison
-COMPARE_GREATER
-	pops S(-1) and S(0), replacing it with TRUE or FALSE, depending on comparison
-COMPARE_GREATER_EQUAL
-	pops S(-1) and S(0), replacing it with TRUE or FALSE, depending on comparison
-
-
-//logical instructions
-AND
-	pops S(-1) and S(0), replacing it with TRUE or FALSE, depending on truthiness
-OR
-	pops S(-1) and S(0), replacing it with TRUE or FALSE, depending on truthiness
-TRUTHY
-	pops S(0), replacing it with TRUE or FALSE, depending on truthiness
-NEGATE
-	pops S(0), replacing it with TRUE or FALSE, depending on truthiness
-
-
-//control instructions
-JUMP
-	read one value from C, and move the program counter to that location (relative to the current position)
-JUMP_IF_FALSE
-	read one value from C, pops S(0), and move the program counter to that location (relative to the current position) if the popped value is falsy
-FN_CALL
-	*read a list of arguments specified in C into 'A', store (S, E, C, D) as D, push S, move the stack pointer to the specified routine, push a new E based on the contents of 'A'
-FN_RETURN
-	*read a list of return values specified in C into 'R', pop S, restore (S, E, C, D) from D(0) popping it, store the contents of 'R' in E or S based on the next few parts of C
-
-//various action instructions
-ASSERT
-	if S(-1) is falsy, print S(0) and exit
-PRINT
-	pop S(0), and print the output
-IMPORT
-	//invoke an external library into the current scope
-CONCAT
-	//combine two strings
-SCOPE_BEGIN
-	//push an inner environment to E, which should be automatically popped at the routine's end
-SCOPE_END
-	//pop an inner environment from E, only if it was created with SCOPE_BEGIN
-
-===
-
-FN_CALL
-	read word: read the following N arguments
-
-		for 0 to N do:
-			read word as match: # this allows literals and identifiers as arguments
-				stack: then pop S(0) into 'A'
-				**env: then read word, load E[SYMBOL(word)] into 'A'
-
-	read word:
-		determine where the routine is (is it new or is it a value?) and hold it for a moment
-		push E and C into a frame marker on S
-		jump C to the routine
-
-	read word:
-		read the following N parameter names, storing each member of 'A' as their value in E[SYMBOL(name)]
-
-	continue
-
-FN_RETURN
-	read word: read the following N return values
-
-		for 0 to N do:
-			read word as match: # this allows literals and identifiers as arguments
-				stack: then pop S(0) into 'R'
-				**env: then read word, load E[SYMBOL(word)] into 'R'
-
-	pop E and S
-	extract and restore E and C from the frame marker on S
-
-	read word: read the following N storage locations for the values within `R`
-
-		for 0 to N do:
-			read word as match: # you're effectively reversing the prior reads
-				stack: then push from 'R' onto S
-				**env: then read word, save 'R' into E[SYMBOL(word)]
-
-**This could work by listing the sources as e.g. "SSSExS" - three stacks and one environment variable loaded onto the stack, then one more stack for a total of four values
-
-Notes:
-	the bytecode of a funtion call would look like:
-	
-		FN_CALL N [stack|env word]... N [stack|env word]...
-	
-	the value of C stored in D points to the second N, while it waits to pick up where it left off
-
-===
-

.notes/bytecode-format.txt

@@ -1,64 +0,0 @@
-The bytecode format
-
-===
-
-NOTE: This datestamp header is currently not implemented
-
-There are four components in the datestamp header:
-
-TOY_VERSION_MAJOR
-TOY_VERSION_MINOR
-TOY_VERSION_PATCH
-TOY_VERSION_BUILD
-
-The first three are each one unsigned byte, and the fourth is a null terminated C-string.
-
- * Under no circumstance, should you ever run bytecode whose major version is different
- * Under no circumstance, should you ever run bytecode whose minor version is above the interpreter’s minor version
- * You may, at your own risk, attempt to run bytecode whose patch version is different from the interpreter’s patch version
- * You may, at your own risk, attempt to run bytecode whose build version is different from the interpreter’s build version
-
-An additional note: The contents of the build string may be anything, such as:
-
- * the compilation date and time of the interpreter
- * a marker identifying the current fork and/or branch
- * identification information, such as the developer's copyright
- * a link to Risk Astley's "Never Gonna Give You Up" on YouTube
-
-Please note that in the final bytecode, if the null terminator of TOY_VERSION_BUILD is not 4-byte aligned, extra space will be allocated to round out the header's size to a multiple of 4. The contents of the extra bytes are undefined.
-
-===
-
-Bytecode Format Structure
-
-.header:
-	N total size       # size of this routine, including all data and subroutines
-	N .jumps count     # the number of entries in the jump table (should be data count + routine count)
-	N .param count     # the number of parameter fields expected (a secondary jump table, used for subroutine parameters)
-	N .data count      # the number of data fields present
-	N .subs count      # the number of subroutines present
-	.code start        # absolute address of .code;      mandatory
-	.param start       # absolute addess of .param;      omitted if not needed
-	.datatable start   # absolute address of .datatable; omitted if not needed
-	.data start        # absolute address of .data;      omitted if not needed
-	.subs start        # absolute address of .subs;      omitted if not needed
-	# additional metadata fields can be added later
-
-.code:
-	# opcode instructions read and 'executed' by the interpreter (aligned to 4-byte widths)
-	[READ, TOY_VALUE_STRING, Toy_StringType, stringLength] [jumpIndex]
-
-.jumps:
-	# a layer of indirection for quickly looking up values in .data and .subs
-	0 -> {string, 0x00}
-	4 -> {fn, 0xFF}
-
-.param:
-	# a list of names, stored in .data, to be used for any provided function arguments
-
-.data:
-	# data that can't be cleanly embedded into .code, such as strings
-	"Hello world\0"
-
-.subs:
-	# an extension of .data, used exclusively for subroutines (they also follow this spec, recursively)

.notes/hash.c

@@ -1,23 +0,0 @@
-#include <stdio.h>
-#include <stdint.h>
-
-uint32_t hash (uint32_t x) {
-	x = ((x >> 16) ^ x) * 0x45d9f3b;
-	x = ((x >> 16) ^ x) * 0x45d9f3b;
-	x = ((x >> 16) ^ x);
-	return x;
-}
-
-uint32_t unhash ( uint32_t x ) {
-	x = (( x >> 16) ^ x) * 0x119de1f3;
-	x = (( x >> 16) ^ x) * 0x119de1f3;
-	x = (( x >> 16) ^ x);
-	return x;
-}
-
-int main() {
-	//I legit didn't know this algorithm could be reversed. Neat.
-	uint32_t value = 42;
-	printf("%u %u %u", value, hash(value), unhash(hash(value)));
-	return 0;
-}

.notes/raspberry-pi-issues.txt

@@ -1,8 +0,0 @@
-The default version of GCC that ships on Raspian has an issue. The file '/usr/lib/arm-linux-gnueabihf/libarmmem-v7l.so' has a faulty implementation of 'memcpy()' and possibly 'memset()'. Changing to the newer versions doens't work, as they're just symlinks to v7.
-
-To resolve this, download and build this shared object:
-
-https://github.com/simonjhall/copies-and-fills
-
-Then, set the linker's preload value to point to that '.so' file (You may need to edit '/etc/ld.so.preload')
-

.vscode/extensions.json

@@ -1,5 +0,0 @@
-{
-	"recommendations": [
-		"gruntfuggly.todo-tree"
-	]
-}

.vscode/settings.json

@@ -1,66 +0,0 @@
-{
-	"todo-tree.filtering.includeGlobs": [
-		"**/repl/**",
-		"**/scripts/**",
-		"**/source/**",
-		"**/tests/**",
-		"**/tools/**",
-	],
-	"todo-tree.filtering.excludeGlobs": [
-		"**/obj/**",
-		"**/out/**",
-	],
-	"todo-tree.general.tags": [
-		"URGENT",
-		"BUG",
-		"TODO",
-		"WARN",
-		"BUGFIX",
-		"WONTFIX",
-		"NOTE"
-	],
-	"todo-tree.highlights.customHighlight": {
-		"URGENT": {
-			"icon": "alert",
-			"type": "text",
-			"iconColour": "#FF0000",
-			"foreground": "#FF0000"
-		},
-		"BUG": {
-			"icon": "bug",
-			"type": "text",
-			"iconColour": "#FF0000",
-			"foreground": "#FF0000"
-		},
-		"TODO": {
-			"icon": "alert",
-			"type": "text",
-			"iconColour": "#FFFF00",
-			"foreground": "#FFFF00"
-		},
-		"WARN": {
-			"icon": "alert",
-			"type": "text",
-			"iconColour": "#FFA500",
-			"foreground": "#FFA500"
-		},
-		"BUGFIX": {
-			"icon": "bug",
-			"type": "text",
-			"iconColour": "#00A000",
-			"foreground": "#00A000"
-		},
-		"WONTFIX": {
-			"icon": "bug",
-			"type": "text",
-			"iconColour": "#B64949",
-			"foreground": "#B64949"
-		},
-		"NOTE": {
-			"icon": "alert",
-			"type": "text",
-			"iconColour": "#00A000",
-			"foreground": "#00A000"
-		},
-	}
-}

CODE_OF_CONDUCT.md

@@ -1 +0,0 @@
-No hating on other people, OK?

LICENSE

@@ -1,17 +0,0 @@
-Copyright (c) 2020-2026 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.  

LICENSE.md

@@ -0,0 +1,13 @@
+# License
+
+Copyright (c) 2020-2022 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

@@ -1,75 +1,65 @@
 <p align="center">
-	<image src="toylogo.png" alt="The Toy Logo" />
+  <image src="toylogo.png" />
 </p>
 
-# Toy v2.x
+# Toy 0.6.0
 
-The Toy Programming Language is an imperative, bytecode-interpreted, embeddable scripting language. Rather than functioning independently, it serves as part of another program, the "host". This design allows for straightforward customization by both the host's developers and end users, achieved by exposing program logic through external scripts.
+This is the Toy programming language interpreter, written in C.
 
-This repository holds the reference implementation for Toy version 2.x, written in C - alpha testing is currently underway.
+Special thanks to http://craftinginterpreters.com/ for their fantastic book that set me on this path.
 
 # Nifty Features
 
 * Simple C-like syntax
-* Intermediate AST and bytecode representations
-* Strong, but optional type system
-* First-class functions and closures
-* Extensible with native C-bindings
-* Can re-direct output, error and assertion messages
-* Open-Source under the zlib license
+* Bytecode intermediate compilation
+* Optional, but robust type system (including `opaque` for arbitrary data)
+* Functions and types are first-class citizens
+* `import` and `export` variables from the host program
+* Fancy slice notation for strings, arrays and dictionaries
+* Can re-direct output, error and assertion failure messages
+* Open source under the zlib license
 
-# Syntax
+## Building
 
-```toy
-fn makeCounter() {
-	var counter: Int = 0;
+For Windows, Linux and MacOS, simply run `make` in the root directory.
 
-	fn increment() {
-		return ++counter;
+Note: For Linux, you may need to `cd` into the `out` directory before running.
+
+Note: MacOS is not officially supported (no machines for testing), but we'll do our best!
+
+## 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 increment;
+	return counter; //closures are explicitly supported
 }
 
 var tally = makeCounter();
 
-while (true) {
-	var result = tally();
+print tally(); //1
+print tally(); //2
+print tally(); //3
 
-	print result; //prints 1 to 10
-
-	if (result >= 10) {
-		break;
-	}
-}
+export tally; //export this variable to the host program
 ```
 
-# Building
-
-This project requires `gcc` and `make` by default, but should also work in other environments. Officially supported platforms include `linux`, `windows` and `macOS`, see `source/toy_common.h` for implementation details.
-
-Run `make` in the root directory to build the shared library named `libToy.so` and a useable REPL named `repl.out`.
-
-# Documentation
-
-The contents of `docs/` is also available on the official website [toylang.com](https://toylang.com/).
-
 # License
 
-This source code is covered by the Zlib license (see [LICENSE](LICENSE) for details).
-
-# Contributors and Special Thanks
-
-@NishiOwO - Unofficial NetBSD support  
-@Gipson62 - v1 docs spell checking  
-@8051Enthusiast - `fixAlignment()` trick  
-@hiperiondev - v1 Disassembler, v1 porting support and feedback  
-@add00 - v1 Library support  
-@gruelingpine185 - Unofficial v1 MacOS support  
-@solar-mist - v1 Minor bugfixes  
-Various Anons - Feedback  
-@munificent - For [writing the book](http://craftinginterpreters.com/) that sparked my interest in langdev  
-
-# Patreon Supporters
-
-You can show your support and be listed here by joining my [Patreon](https://patreon.com/krgamestudios).
+This source code is covered by the zlib license (see [LICENSE.md](LICENSE.md)).

docs/TODO.txt

@@ -0,0 +1,51 @@
+DONE: rework type system
+DONE: var decl with a type, but no value
+DONE: type casting
+DONE: remove optimization option
+DONE: conditionals
+DONE: if-then-else
+DONE: chained if-then-else
+DONE: optional block around a path if it's only one statement
+DONE: while-then
+DONE: for-then
+DONE: break and continue statements
+DONE: truthiness rethink
+DONE: string concat with the + operator
+DONE: increment & decrement operators
+DONE: store compound types in variables
+DONE: +=  -=  *=  /=  %= operators
+DONE: && and || operators
+DONE: functions are invoked by calling their names
+DONE: function arguments can have specified types
+DONE: function returns can have specified types
+DONE: closures are explicitly supported
+DONE: functions are first-class citizens
+DONE: functions take a set number of parameters
+DONE: functions last argument can be a rest parameter
+DONE: assert needs to kill the whole script, not just functions
+DONE: native functions
+DONE: global functions _get, _set, _push, _pop, _length, clear available
+DONE: change comma to colon in dictionary definition
+DONE: Address circular references
+DONE: are compounds shallow or deep copies? Deep copies
+DONE: third output stream, for lexer/parser/compiler/interpreter errors
+DONE: Assertion-based test scripts
+DONE: Import/export keywords
+DONE: A way to check the type of a variable (typeOf keyword)
+DONE: slice and dot notation around the builtin _index and _dot functions
+DONE: maximum recursion/function depth
+DONE: better sugar for _push, _pop, _length
+DONE: nested compound assignment bug
+DONE: hooks on the external libraries, triggered on import
+
+
+TODO: standard library
+TODO: external script runner library
+TODO: document how it all works
+TODO: packaging for release?
+TODO: test embedding in a game
+
+NOPE: a = b = c = 1;
+NOPE: functions return a set number of values
+NOPE: ternary operator?
+NOPE: Nullish types?

docs/book.toml

@@ -1,9 +0,0 @@
-[book]
-title = "The Toy Programming Language"
-authors = ["Kayne Ruse (Ratstail91)"]
-description = "Documentation For The Toy Programming Language"
-language = "en"
-
-[output.html]
-git-repository-url = "https://github.com/krgamestudios/Toy"
-git-repository-icon = "fab-github"

docs/src/404.md

@@ -1,3 +0,0 @@
-# 404
-
-Nobody here but us chickens!

docs/src/README.md

@@ -1,47 +0,0 @@
-<p align="center">
-	<image src="img/toylogo.png" alt="The Toy Logo" />
-</p>
-
-The Toy Programming Language is an imperative, bytecode-interpreted, embeddable scripting language. Rather than functioning independently, it serves as part of another program, the "host". This design allows for straightforward customization by both the host's developers and end users, achieved by exposing program logic through external scripts.
-
-## Nifty Features
-
-* Simple C-like syntax
-* Intermediate AST and bytecode representations
-* Strong, but optional type system
-* First-class functions and closures
-* Extensible with native C-bindings
-* Can re-direct output, error and assertion messages
-* Open-Source under the zlib license
-
-## Syntax
-
-```toy
-fn makeCounter() {
-	var counter: Int = 0;
-
-	fn increment() {
-		return ++counter;
-	}
-
-	return increment;
-}
-
-var tally = makeCounter();
-
-while (true) {
-	var result = tally();
-
-	print result; //prints 1 to 10
-
-	if (result >= 10) {
-		break;
-	}
-}
-```
-
-## Further Reading
-
-This website is a work in progress - for further info, see the official repository: [https://gitea.krgamestudios.com/krgamestudios/Toy](https://gitea.krgamestudios.com/krgamestudios/Toy), or the GitHub mirror: [https://github.com/krgamestudios/Toy](https://github.com/krgamestudios/Toy).
-
-An example of Toy in action: [Vampire Toyvivors](https://gitea.krgamestudios.com/krgamestudios/VampireToyvivors) (a simple "game" used for testing).

docs/src/SUMMARY.md

@@ -1,5 +0,0 @@
-# Summary
-
-- [Front Page](./README.md)
-- [Quick Start](./quickstart.md)
-- [Cheat Sheet](./cheatsheet.md)

docs/src/cheatsheet.md

@@ -1,144 +0,0 @@
-# Cheat Sheet
-
-## Compile and Run A Snippet Of Code
-
-```c
-#include "toy_lexer.h"
-#include "toy_parser.h"
-#include "toy_compiler.h"
-#include "toy_vm.h"
-#include <stdlib.h>
-
-int main() {
-	//example code
-	const char* source = "print \"Hello world!\";";
-
-	//buckets use the arena pattern for memory allocation
-	Toy_Bucket* bucket = Toy_allocateBucket(TOY_BUCKET_IDEAL);
-
-	//compile the code
-	Toy_Lexer lexer;
-	Toy_bindLexer(&lexer, (char*)source);
-
-	Toy_Parser parser;
-	Toy_bindParser(&parser, &lexer);
-
-	Toy_Ast* ast = Toy_scanParser(&bucket, &parser);
-	unsigned char* bytecode = Toy_compileToBytecode(ast);
-
-	//the ast, which is stored in this bucket, is no longer needed
-	Toy_freeBucket(&bucket);
-
-	//the virtual machine used at runtime
-	Toy_VM vm;
-	Toy_initVM(&vm);
-	Toy_bindVM(&vm, bytecode, NULL);
-
-	//execute the given code
-	Toy_runVM(&vm);
-
-	//cleanup after ourselves
-	Toy_freeVM(&vm);
-	free(bytecode);
-}
-```
-
-## Quick and Dirty Compilation
-
-```c
-unsigned char* compileSource(const char* source) {
-	Toy_Bucket* bucket = Toy_allocateBucket(TOY_BUCKET_IDEAL);
-
-	Toy_Lexer lexer;
-	Toy_bindLexer(&lexer, source);
-
-	Toy_Parser parser;
-	Toy_bindParser(&parser, &lexer);
-
-	Toy_Ast* ast = Toy_scanParser(&bucket, &parser);
-	unsigned char* bytecode = Toy_compileToBytecode(ast);
-
-	Toy_freeBucket(&bucket);
-	return bytecode;
-}
-```
-
-## API Functions
-
-This is a rough outline of all API functions declared in Toy's headers. As a rule, functions that begin with `TOY_API` are useable and begin with `Toy_`, while functions that begin with `Toy_private_` are generally not intended for use, and only exposed for technical reasons.
-
-*Note: This list is updated manually, if something is outdated let me know.*
-
-```c
-TOY_API Toy_Array* Toy_resizeArray(Toy_Array* array, unsigned int capacity);
-TOY_API void Toy_setOpaqueAttributeHandler(Toy_OpaqueAttributeHandler cb);
-TOY_API void Toy_collectBucketGarbage(Toy_Bucket** bucketHandle) {
-TOY_API Toy_Bucket* Toy_allocateBucket(unsigned int capacity);
-TOY_API unsigned char* Toy_partitionBucket(Toy_Bucket** bucketHandle, unsigned int amount);
-TOY_API void Toy_releaseBucketPartition(unsigned char* ptr);
-TOY_API void Toy_freeBucket(Toy_Bucket** bucketHandle);
-TOY_API void Toy_collectBucketGarbage(Toy_Bucket** bucketHandle);
-TOY_API unsigned char* Toy_compileToBytecode(Toy_Ast* ast);
-TOY_API void Toy_freeFunction(Toy_Function* fn) {
-TOY_API Toy_Function* Toy_createFunctionFromBytecode(Toy_Bucket** bucketHandle, unsigned char* bytecode, Toy_Scope* parentScope);
-TOY_API Toy_Function* Toy_createFunctionFromCallback(Toy_Bucket** bucketHandle, Toy_nativeCallback callback);
-TOY_API Toy_Function* Toy_copyFunction(Toy_Bucket** bucketHandle, Toy_Function* fn);
-TOY_API void Toy_freeFunction(Toy_Function* fn);
-TOY_API void Toy_bindLexer(Toy_Lexer* lexer, const char* source);
-TOY_API void Toy_bindParser(Toy_Parser* parser, Toy_Lexer* lexer);
-TOY_API Toy_Ast* Toy_scanParser(Toy_Bucket** bucketHandle, Toy_Parser* parser);
-TOY_API void Toy_resetParser(Toy_Parser* parser);
-TOY_API void Toy_print(const char* msg);
-TOY_API void Toy_error(const char* msg);
-TOY_API void Toy_assertFailure(const char* msg);
-TOY_API void Toy_setPrintCallback(Toy_callbackType cb);
-TOY_API void Toy_setErrorCallback(Toy_callbackType cb);
-TOY_API void Toy_setAssertFailureCallback(Toy_callbackType cb);
-TOY_API void Toy_resetPrintCallback(void);
-TOY_API void Toy_resetErrorCallback(void);
-TOY_API void Toy_resetAssertFailureCallback(void);
-TOY_API Toy_Scope* Toy_pushScope(Toy_Bucket** bucketHandle, Toy_Scope* scope);
-TOY_API Toy_Scope* Toy_popScope(Toy_Scope* scope);
-TOY_API void Toy_declareScope(Toy_Scope* scope, Toy_String* key, Toy_ValueType type, Toy_Value value, bool constant);
-TOY_API void Toy_assignScope(Toy_Scope* scope, Toy_String* key, Toy_Value value);
-TOY_API Toy_Value* Toy_accessScopeAsPointer(Toy_Scope* scope, Toy_String* key);
-TOY_API bool Toy_isDeclaredScope(Toy_Scope* scope, Toy_String* key);
-TOY_API Toy_Stack* Toy_allocateStack(void);
-TOY_API void Toy_freeStack(Toy_Stack* stack);
-TOY_API void Toy_resetStack(Toy_Stack** stackHandle);
-TOY_API void Toy_pushStack(Toy_Stack** stackHandle, Toy_Value value);
-TOY_API Toy_Value Toy_peekStack(Toy_Stack** stackHandle);
-TOY_API Toy_Value Toy_popStack(Toy_Stack** stackHandle);
-TOY_API Toy_String* Toy_toString(Toy_Bucket** bucketHandle, const char* cstring);
-TOY_API Toy_String* Toy_toStringLength(Toy_Bucket** bucketHandle, const char* cstring, unsigned int length);
-TOY_API Toy_String* Toy_createStringLength(Toy_Bucket** bucketHandle, const char* cstring, unsigned int length);
-TOY_API Toy_String* Toy_copyString(Toy_String* str);
-TOY_API Toy_String* Toy_concatStrings(Toy_Bucket** bucketHandle, Toy_String* left, Toy_String* right);
-TOY_API void Toy_freeString(Toy_String* str);
-TOY_API unsigned int Toy_getStringLength(Toy_String* str);
-TOY_API unsigned int Toy_getStringRefCount(Toy_String* str);
-TOY_API char* Toy_getStringRaw(Toy_String* str);
-TOY_API int Toy_compareStrings(Toy_String* left, Toy_String* right);
-TOY_API unsigned int Toy_hashString(Toy_String* string);
-TOY_API Toy_Table* Toy_allocateTable(unsigned int minCapacity);
-TOY_API void Toy_freeTable(Toy_Table* table);
-TOY_API void Toy_insertTable(Toy_Table** tableHandle, Toy_Value key, Toy_Value value);
-TOY_API Toy_Value Toy_lookupTable(Toy_Table** tableHandle, Toy_Value key);
-TOY_API void Toy_removeTable(Toy_Table** tableHandle, Toy_Value key);
-TOY_API Toy_Value Toy_unwrapValue(Toy_Value value);
-TOY_API unsigned int Toy_hashValue(Toy_Value value);
-TOY_API Toy_Value Toy_copyValue(struct Toy_Bucket** bucketHandle, Toy_Value value);
-TOY_API void Toy_freeValue(Toy_Value value);
-TOY_API bool Toy_checkValueIsTruthy(Toy_Value value);
-TOY_API bool Toy_checkValuesAreEqual(Toy_Value left, Toy_Value right);
-TOY_API bool Toy_checkValuesAreComparable(Toy_Value left, Toy_Value right);
-TOY_API int Toy_compareValues(Toy_Value left, Toy_Value right);
-TOY_API union Toy_String_t* Toy_stringifyValue(struct Toy_Bucket** bucketHandle, Toy_Value value);
-TOY_API const char* Toy_getValueTypeAsCString(Toy_ValueType type);
-TOY_API void Toy_resetVM(Toy_VM* vm, bool preserveScope, bool preserveStack);
-TOY_API void Toy_initVM(Toy_VM* vm);
-TOY_API void Toy_inheritVM(Toy_VM* parentVM, Toy_VM* subVM);
-TOY_API unsigned int Toy_runVM(Toy_VM* vm);
-TOY_API void Toy_freeVM(Toy_VM* vm);
-TOY_API Toy_Value Toy_getReturnValueFromVM(Toy_VM* parentVM, Toy_VM* subVM);
-```

docs/src/quickstart.md

@@ -1,186 +0,0 @@
-# Toy v2 Quick-Start Guide
-
-To help you start using Toy as fast as possible, here are the most useful elements of the language. Not everything available is listed, but this should let you start coding right away.
-
-## Keyword 'print'
-
-The `print` keyword prints a given value to stdout (or elsewhere if configured with the API).
-
-```
-print "Hello World!";
-```
-
-## Keyword 'assert'
-
-The `assert` keyword takes two values separated by a comma. If the first value is falsy or `null` the optional second parameter is printed to stderr (or elsewhere if configured with the API). If no second parameter is provided a generic error message is used instead.
-
-```
-//nothing happens
-assert 1 < 2;
-
-//this assert will fail, and output the second parameter
-assert null, "Hello world!";
-```
-
-## Variables and Types
-
-Variables are declared with the `var` keyword with and an optional type from the list below. If no type is specified `Any` is used instead.
-
-```
-var answer = 42;
-
-var question: String = "How many roads must a man walk down?";
-```
-
-To make a variable immutable put the `const` keyword after the type. If you do, it must be assigned a value.
-
-```
-var quote: String const = "War. War never changes.";
-```
-
-Toy's types are:
-
-| type | name | description |
-| --- | --- | --- |
-| `Bool` | Boolean | Either `true` or `false`. |
-| `Int` | Integer | Any signed whole number (32-bits). |
-| `Float` | Float | Any signed decimal number (32-bits), using floating point arithmatic. |
-| `String` | String | Normal text, effectively utf-8. |
-| `Array` | Array | A series of values stored sequentially in memory. |
-| `Table` | Table | A series key-value pairs stored in a hash table. Booleans, functions, opaques and `null` can't be used as keys. |
-| `Function` | Function | A chunk of reusable code that takes zero or more parameters, and may return a result. Functions are declared with the `fn` keyword, or in the API. |
-| `Opaque` | Opaque | This value is unusable in Toy, but allows you to pass data between C bindings provided with the API. |
-| `Any` | Any | The default type when nothing is specified. It can hold any value. |
-
-## Control Flow
-
-Making a decision, or repeating a chunk of code multiple times, is essential for any language. Choosing between multiple options can be done with the `if-then-else` statement - if the condition is truthy, the 'then-branch' will be executed. Otherwise, the optional 'else-branch' is executed instead.
-
-```
-var answer = 42;
-
-if (answer < 56) {
-    print "Cod dang it!";
-}
-else {
-    print "Something's fishy here...";
-}
-```
-
-```
-var challenge = "hard";
-
-if (challenge == "hard") {
-    print "I choose to build a scripting language, not because it's easy, but because it's hard!";
-}
-
-//the else-branch is optional
-```
-
-To repeat a certain action, use the `while-then` loop, which repeats the body as long as the given condition remains true on each loop.
-
-```
-var loops = 0;
-
-while (loops++ < 8) {
-    print "These episodes are endless.";
-}
-```
-
-To break out of a loop, you can use the `break` keyword. Alternatively, to restart the loop early, use the `continue` keyword.
-
-```
-var loops = 0;
-
-while (true) {
-    if (++loops < 15532) {
-        continue;
-    }
-
-    break; //poor yuki ;_;
-}
-```
-
-*Note: The `for` loop is coming soon, and will allow for iteration over an array or table, but isn't vital right now.*
-
-## Arrays and Tables
-
-Arrays are defined with a pair of brackets, and can contain a list of comma-separated values.
-
-```
-//define an array
-var array = [1,2,3];
-
-//specify the type
-var bray: Array = [4,5,6];
-
-//define an empty array
-var craycray: Array = [];
-
-//arrays are zero-indexed
-print array[0]; //'1'
-```
-
-Tables are also defined with brackets, and contain a comma-separated list of key-value pairs defined by colons:
-
-```
-//most types can be used as keys
-var table = ["alpha": 1, "beta": 2, "gamma": 3];
-
-//the 'Table' keyword can define the type, and an empty table still has a colon
-var under: Table = [:];
-
-//printing the whole table does NOT guarantee internal order
-print table["beta"];
-```
-
-## Attributes
-
-Some values, including Strings, Arrays and Tables, have "attributes" which are accessible with the dot `.` operator. These can expose internal values or components for manipulating said values.
-
-```
-var string = "Hello World";
-print string.length; //11
-print string.asUpper; //HELLO WORLD
-print string.asLower; //hello world
-
-var array = [1,2,3];
-array.pushBack(4); //array = [1,2,3,4]
-var element = array.popBack(); //element = 4
-var emptyArray = [];
-
-var table = ["alpha": 1, "beta":2];
-print table.length; //2
-table.insert("key",element); //table["key"] = 4
-print table.hasKey("alpha"); //true
-table.remove("alpha"); //table = ["beta":2,"key":4]
-var emptyTable = [:];
-```
-
-Opaques can also be given attributes, but this requires some in-depth understanding of the API, so won't be covered here.
-
-## Functions
-
-Functions are defined with the `fn` keyword, and follow a c-like syntax, with optional types on each parameter:
-
-```toy
-fn fib(n: Int) {
-	if (n < 2) return n;
-	return fib(n-1) + fib(n-2);
-}
-
-print fib(12); //144
-```
-
-```toy
-fn isLeapYear(n: Int) {
-	if (n % 400 == 0) return true;
-	if (n % 100 == 0) return false;
-	return n % 4 == 0;
-}
-```
-
-## External API and Extending Toy
-
-*Note: Watch this space, docs for the C API are coming soon. For now, the [Cheat Sheet](/cheatsheet) can get you started.*
-

docs/theme/head.hbs

@@ -1,14 +0,0 @@
-<!-- open graph protocol -->
-<meta property="og:url" content="{{ url }}" />
-<meta property="og:type" content="website" />
-<meta property="og:image" content="{{ base_url }}/img/toypreview.png" />
-<meta property="og:title" content="{{ title }}" />
-<meta property="og:description" content="{{ description }}" />
-
-<!-- twitter has to be special -->
-<meta name="twitter:card" content="{{ title }}" />
-<meta name="twitter:url" content="{{ url}}" />
-<meta name="twitter:type" content="website" />
-<meta name="twitter:image" content="{{ base_url }}/img/toypreview.png" />
-<meta name="twitter:title" content="{{ title }}" />
-<meta name="twitter:description" content="{{ description }}" />

makefile

@@ -1,83 +1,62 @@
-#compiler settings reference
-#CC=gcc
-#CFLAGS+=-std=c17 -g -Wall -Werror -Wextra -Wpedantic -Wformat=2 -Wno-newline-eof
-#LIBS+=-lm
-#LDFLAGS+=
+# Optimisation Options
+# export CFLAGS+=-O2 -mtune=native -march=native
 
-#TODO: release builds should define the NDEBUG flag; double check it works
+export TOY_OUTDIR = out
 
-#directories
-export TOY_SOURCEDIR=source
-export TOY_REPLDIR=repl
-export TOY_OUTDIR=out
-export TOY_OBJDIR=obj
+all: $(TOY_OUTDIR) repl
 
-#targets
-all: source repl
+repl: $(TOY_OUTDIR) library
+	$(MAKE) -C repl
 
-.PHONY: source
-source:
-	$(MAKE) -C source -k
+repl-static: $(TOY_OUTDIR) static
+	$(MAKE) -C repl
 
-.PHONY: repl
-repl: source
-	$(MAKE) -C repl -k
+library: $(TOY_OUTDIR)
+	$(MAKE) -C source library
 
-.PHONY: tests tests-ci
-tests: clean
-	$(MAKE) -C tests -k
+static: $(TOY_OUTDIR)
+	$(MAKE) -C source static
 
-tests-gdb: clean
-	$(MAKE) -C tests -k gdb
+test: clean $(TOY_OUTDIR)
+	$(MAKE) -C test
 
-#util targets
 $(TOY_OUTDIR):
 	mkdir $(TOY_OUTDIR)
 
-$(TOY_OBJDIR):
-	mkdir $(TOY_OBJDIR)
-
-#util commands
 .PHONY: clean
+
 clean:
-ifeq ($(shell uname),Linux)
-	find . -type f -name '*.o' -delete
-	find . -type f -name '*.a' -delete
-	find . -type f -name '*.out' -delete
-	find . -type f -name '*.exe' -delete
-	find . -type f -name '*.dll' -delete
-	find . -type f -name '*.lib' -delete
-	find . -type f -name '*.so' -delete
-	find . -type f -name '*.dylib' -delete
-	find . -type d -name 'out' -delete
-	find . -type d -name 'obj' -delete
-else ifeq ($(shell uname),NetBSD)
-	find . -type f -name '*.o' -delete
-	find . -type f -name '*.a' -delete
-	find . -type f -name '*.out' -delete
-	find . -type f -name '*.exe' -delete
-	find . -type f -name '*.dll' -delete
-	find . -type f -name '*.lib' -delete
-	find . -type f -name '*.so' -delete
-	find . -type f -name '*.dylib' -delete
-	find . -type d -name 'out' -delete
-	find . -type d -name 'obj' -delete
+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 *.dll *.lib *.so *.dylib
-	$(RM) out
-	$(RM) obj
+	$(RM) *.o *.a *.exe 
 else ifeq ($(shell uname),Darwin)
-	find . -type f -name '*.o' -delete
-	find . -type f -name '*.a' -delete
-	find . -type f -name '*.out' -delete
-	find . -type f -name '*.exe' -delete
-	find . -type f -name '*.dll' -delete
-	find . -type f -name '*.lib' -delete
-	find . -type f -name '*.so' -delete
-	find . -type f -name '*.dylib' -delete
-	find . -type d -name 'out' -delete
-	find . -type d -name 'obj' -delete
+	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/ast_inspector.c

@@ -1,100 +0,0 @@
-#include "ast_inspector.h"
-#include "toy_console_colors.h"
-#include "toy_bucket.h"
-#include "toy_string.h"
-#include "toy_value.h"
-
-#include <stdio.h>
-#include <stdlib.h>
-
-void inspect_by_type(Toy_Ast* ast, int depth);
-
-void inspect_block(Toy_Ast* ast, int depth);
-void inspect_value(Toy_Ast* ast, int depth);
-void inspect_print(Toy_Ast* ast, int depth);
-
-#define PRINTSTR(x) printf("%*s%s", depth*4, "", x);
-
-static Toy_Bucket* bucket = NULL; //lazy
-
-void inspect_ast(Toy_Ast* ast) {
-	bucket = Toy_allocateBucket(TOY_BUCKET_IDEAL);
-	inspect_by_type(ast, 0);
-	Toy_freeBucket(&bucket);
-}
-
-void inspect_by_type(Toy_Ast* ast, int depth) {
-	switch(ast->type) {
-		case TOY_AST_BLOCK:
-			inspect_block(ast, depth);
-			return;
-
-		case TOY_AST_VALUE:
-			inspect_value(ast, depth);
-			return;
-		// case TOY_AST_UNARY:
-		// case TOY_AST_BINARY:
-		// case TOY_AST_BINARY_SHORT_CIRCUIT:
-		// case TOY_AST_COMPARE:
-		// case TOY_AST_GROUP:
-		// case TOY_AST_COMPOUND:
-		// case TOY_AST_AGGREGATE:
-
-		// case TOY_AST_ASSERT:
-		// case TOY_AST_IF_THEN_ELSE:
-		// case TOY_AST_WHILE_THEN:
-		// case TOY_AST_BREAK:
-		// case TOY_AST_CONTINUE:
-		// case TOY_AST_RETURN:
-		case TOY_AST_PRINT:
-			inspect_print(ast, depth);
-			return;
-
-		// case TOY_AST_VAR_DECLARE:
-		// case TOY_AST_VAR_ASSIGN:
-		// case TOY_AST_VAR_ACCESS:
-
-		// case TOY_AST_FN_DECLARE:
-		// case TOY_AST_FN_INVOKE:
-
-		// case TOY_AST_STACK_POP:
-
-		default:
-			printf(TOY_CC_WARN "%*sAST %s (unhandled by inspector)" TOY_CC_RESET "\n", depth*4, "", Toy_private_getAstTypeAsCString(ast->type));
-	}
-}
-
-void inspect_block(Toy_Ast* ast, int depth) {
-	//show the block braces
-	PRINTSTR("{\n");
-
-	if (ast->block.child) {
-		inspect_by_type(ast->block.child, depth + 1);
-
-		if (ast->block.next) {
-			inspect_block(ast->block.next, depth + 0);
-		}
-	}
-
-	PRINTSTR("}\n");
-}
-
-void inspect_value(Toy_Ast* ast, int depth) {
-	(void)depth;
-	Toy_String* str = Toy_stringifyValue(&bucket, ast->value.value);
-
-	char* buffer = Toy_getStringRaw(str); //SLOW
-	printf("%s '%s'", Toy_getValueTypeAsCString(ast->value.value.type), buffer);
-	free(buffer);
-
-	Toy_freeString(str);
-}
-
-void inspect_print(Toy_Ast* ast, int depth) {
-	(void)depth;
-	PRINTSTR("PRINT ");
-
-	inspect_by_type(ast->print.child, depth);
-
-	printf(";\n");
-}

repl/ast_inspector.h

@@ -1,5 +0,0 @@
-#pragma once
-
-#include "toy_ast.h"
-
-void inspect_ast(Toy_Ast* astHandle);

repl/bucket_inspector.c

@@ -1,47 +0,0 @@
-#include "bucket_inspector.h"
-#include <toy_string.h>
-
-#include <stdio.h>
-
-int inspect_bucket(Toy_Bucket** bucketHandle) {
-	int depth = 0;
-
-	//for each bucket
-	for (Toy_Bucket* iter = (*bucketHandle); iter != NULL; iter = iter->next) {
-		int occupied = 0;
-		int released = 0;
-		unsigned char* ptr = iter->data;
-
-
-		while ((ptr - iter->data < iter->count) && *((int*)ptr) != 0) { //for each partition
-			if ( ( *((int*)ptr) & 1) == 0) { //is this partition still in use?
-				occupied++;
-
-				//try to print as a string if possible
-				Toy_String* str = (void*)(ptr + 4);
-
-				if (str->info.type == TOY_STRING_LEAF && str->info.length < 255) {
-					printf("String Leaf (%d bytes, %d refCount): %.*s\n", *((int*)ptr), str->info.refCount, str->info.length, str->leaf.data);
-				}
-				else if (str->info.type == TOY_STRING_NODE) {
-					printf("String Node (%d bytes, %d refCount): ...\n", *((int*)ptr), str->info.refCount);
-				}
-			}
-			else {
-				released++;
-			}
-
-			//jump distance:   ((*((int*)ptr) | 1) ^ 1) + 4
-			// printf(" jump %d, ", ((*((int*)ptr) | 1) ^ 1) + 4);
-			ptr += ((*((int*)ptr) | 1) ^ 1) + 4; //OR + XOR to remove the 'free' flag from the size
-		}
-
-		printf("Bucket link %d: count %u, %d occupied, %d released\n", depth, iter->count, occupied, released);
-
-		depth++;
-	}
-
-	printf("\n");
-
-	return depth;
-}

repl/bucket_inspector.h

@@ -1,5 +0,0 @@
-#pragma once
-
-#include "toy_bucket.h"
-
-int inspect_bucket(Toy_Bucket** bucketHandle);

repl/bytecode_inspector.c

@@ -1,387 +0,0 @@
-#include "bytecode_inspector.h"
-#include "toy_console_colors.h"
-#include "toy_opcodes.h"
-#include "toy_value.h"
-#include "toy_string.h"
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <ctype.h>
-
-int inspect_instruction(unsigned char* bytecode, unsigned int pc, unsigned int jumps_addr, unsigned int data_addr);
-int inspect_read(unsigned char* bytecode, unsigned int pc, unsigned int jumps_addr, unsigned int data_addr);
-
-#define ISPRINT_SANITIZE(x) (isprint((int)x) > 0 ? (x) : '_')
-
-#define MARKER_VALUE(pc, type) \
-	((unsigned int)(pc * sizeof(type)))
-
-#define MARKER "\t\033[" TOY_CC_FONT_BLACK "m" " %u\t" TOY_CC_RESET
-#define FONT_BLACK "\033[" TOY_CC_FONT_BLACK "m"
-
-//exposed functions
-int inspect_bytecode(unsigned char* bytecode) {
-	//TODO: handle version info
-
-	unsigned int const bytecodeSize = ((unsigned int*)(bytecode))[0];
-	unsigned int const jumpsSize = ((unsigned int*)(bytecode))[1];
-	unsigned int const paramSize = ((unsigned int*)(bytecode))[2];
-	unsigned int const dataSize = ((unsigned int*)(bytecode))[3];
-	unsigned int const subsSize = ((unsigned int*)(bytecode))[4];
-
-	printf(FONT_BLACK ".header:\r" TOY_CC_RESET);
-
-	//bytecode size
-	printf(MARKER TOY_CC_NOTICE "Bytecode Size: \t\t%u" TOY_CC_RESET "\n", MARKER_VALUE(0, unsigned int), bytecodeSize);
-
-	//header counts
-	printf(MARKER TOY_CC_NOTICE "Jumps Size:\t\t%u" TOY_CC_RESET "\n", MARKER_VALUE(1, unsigned int), jumpsSize);
-	printf(MARKER TOY_CC_NOTICE "Param Size:\t\t%u" TOY_CC_RESET "\n", MARKER_VALUE(2, unsigned int), paramSize);
-	printf(MARKER TOY_CC_NOTICE "Data Size:\t\t%u" TOY_CC_RESET "\n", MARKER_VALUE(3, unsigned int), dataSize);
-	printf(MARKER TOY_CC_NOTICE "Subs Size:\t\t%u" TOY_CC_RESET "\n", MARKER_VALUE(4, unsigned int), subsSize);
-
-	//some addresses may be absent
-	unsigned int addr_pc = 4;
-	unsigned int code_addr = 0;
-	unsigned int jumps_addr = 0;
-	unsigned int param_addr = 0;
-	unsigned int data_addr = 0;
-	unsigned int subs_addr = 0;
-
-	//bugfix
-	unsigned int code_end = 0;
-
-	//header addresses
-	if (true) {
-		addr_pc++;
-		printf(MARKER TOY_CC_NOTICE "Code Address:\t\t%u" TOY_CC_RESET "\n", MARKER_VALUE(addr_pc, unsigned int), ((unsigned int*)(bytecode))[addr_pc]);
-		code_addr = ((unsigned int*)(bytecode))[addr_pc];
-	}
-
-	if (jumpsSize > 0) {
-		addr_pc++;
-		printf(MARKER TOY_CC_NOTICE "Jumps Address:\t\t%u" TOY_CC_RESET "\n", MARKER_VALUE(addr_pc, unsigned int), ((unsigned int*)(bytecode))[addr_pc]);
-		jumps_addr = ((unsigned int*)(bytecode))[addr_pc];
-		if (code_end == 0) code_end = jumps_addr;
-	}
-
-	if (paramSize > 0) {
-		addr_pc++;
-		printf(MARKER TOY_CC_NOTICE "Param Address:\t\t%u" TOY_CC_RESET "\n", MARKER_VALUE(addr_pc, unsigned int), ((unsigned int*)(bytecode))[addr_pc]);
-		param_addr = ((unsigned int*)(bytecode))[addr_pc];
-		if (code_end == 0) code_end = param_addr;
-	}
-
-	if (dataSize > 0) {
-		addr_pc++;
-		printf(MARKER TOY_CC_NOTICE "Data Address:\t\t%u" TOY_CC_RESET "\n", MARKER_VALUE(addr_pc, unsigned int), ((unsigned int*)(bytecode))[addr_pc]);
-		data_addr = ((unsigned int*)(bytecode))[addr_pc];
-		if (code_end == 0) code_end = data_addr;
-	}
-
-	if (subsSize > 0) {
-		addr_pc++;
-		printf(MARKER TOY_CC_NOTICE "Subs Address:\t\t%u" TOY_CC_RESET "\n", MARKER_VALUE(addr_pc, unsigned int), ((unsigned int*)(bytecode))[addr_pc]);
-		subs_addr = ((unsigned int*)(bytecode))[addr_pc];
-		if (code_end == 0) code_end = subs_addr;
-	}
-
-	if (code_end == 0) code_end = bytecodeSize; //very hacky
-
-	printf(FONT_BLACK ".code:\r" TOY_CC_RESET);
-
-	unsigned int pc = code_addr;
-	while(pc < code_end) {
-		pc += inspect_instruction(bytecode, pc, jumps_addr, data_addr);
-	}
-
-	//jumps
-	if (jumpsSize > 0) {
-		printf(FONT_BLACK ".jumps:\r" TOY_CC_RESET);
-
-		for (unsigned int i = 0; (i*4) < jumpsSize; i++) {
-			printf(MARKER TOY_CC_NOTICE "%u (data %u)" TOY_CC_RESET "\n", MARKER_VALUE(jumps_addr + i, unsigned int),
-				i,
-				((unsigned int*)(bytecode + jumps_addr))[i] + data_addr
-			);
-		}
-	}
-
-	//param
-	if (paramSize > 0) {
-		printf(FONT_BLACK ".param:\r" TOY_CC_RESET);
-
-		for (unsigned int i = 0; (i*4) < paramSize; i += 2) {
-			printf(MARKER TOY_CC_NOTICE "%u (type %s, data %u)" TOY_CC_RESET "\n", MARKER_VALUE(param_addr + i, unsigned int),
-				i,
-				Toy_getValueTypeAsCString(((unsigned int*)(bytecode + param_addr))[i + 1]),
-				((unsigned int*)(bytecode + param_addr))[i] + data_addr
-			);
-		}
-	}
-
-	//data; assume there's only strings for now
-	if (dataSize > 0) {
-		printf(FONT_BLACK ".data:\r" TOY_CC_RESET);
-
-		for (unsigned int i = 0; (i*4) < dataSize; i++) {
-			printf(MARKER TOY_CC_NOTICE "%c %c %c %c" TOY_CC_RESET "\n", MARKER_VALUE(data_addr + i, unsigned int),
-				ISPRINT_SANITIZE(((char*)(bytecode + data_addr + (i*4)))[0]),
-				ISPRINT_SANITIZE(((char*)(bytecode + data_addr + (i*4)))[1]),
-				ISPRINT_SANITIZE(((char*)(bytecode + data_addr + (i*4)))[2]),
-				ISPRINT_SANITIZE(((char*)(bytecode + data_addr + (i*4)))[3])
-			);
-		}
-	}
-
-	//subs
-	if (subsSize > 0) {
-		printf(FONT_BLACK ".subs:\n" TOY_CC_RESET);
-
-		unsigned int i = 0;
-		while (i < subsSize) {
-			i += inspect_bytecode(bytecode + subs_addr + i);
-		}
-	}
-
-	return bytecodeSize;
-}
-
-int inspect_instruction(unsigned char* bytecode, unsigned int pc, unsigned int jumps_addr, unsigned int data_addr) {
-	//read and print the opcode instruction at 'pc'
-
-	Toy_OpcodeType opcode = bytecode[pc];
-
-	switch(opcode) {
-		case TOY_OPCODE_READ:
-			return inspect_read(bytecode, pc, jumps_addr, data_addr);
-
-		case TOY_OPCODE_DECLARE: {
-			unsigned int indexValue = *((unsigned int*)(bytecode + pc + 4));
-			unsigned int jumpValue = *((unsigned int*)(bytecode + jumps_addr + indexValue));
-			char* cstr = ((char*)(bytecode + data_addr + jumpValue));
-			printf(MARKER "DECLARE %s: %s%s\n", MARKER_VALUE(pc, unsigned char),
-				cstr,
-				Toy_getValueTypeAsCString(bytecode[pc + 1]),
-				bytecode[pc + 3] ? " const" : ""
-			);
-			return 8;
-		}
-
-		case TOY_OPCODE_ASSIGN:
-			printf(MARKER "ASSIGN %s\n", MARKER_VALUE(pc, unsigned char), bytecode[pc + 1] ? "(chained)" : "");
-			return 4;
-
-		case TOY_OPCODE_ASSIGN_COMPOUND:
-			printf(MARKER "ASSIGN COMPOUND %s\n", MARKER_VALUE(pc, unsigned char), bytecode[pc + 1] ? "(chained)" : "");
-			return 4;
-
-		case TOY_OPCODE_ACCESS:
-			printf(MARKER "ACCESS\n", MARKER_VALUE(pc, unsigned char));
-			return 4;
-
-		case TOY_OPCODE_INVOKE:
-			printf(MARKER "INVOKE as '%s' (%d parameters)\n", MARKER_VALUE(pc, unsigned char),
-			Toy_getValueTypeAsCString(bytecode[pc + 1]),
-			bytecode[pc + 2]);
-			return 4;
-
-		case TOY_OPCODE_ATTRIBUTE:
-			printf(MARKER "ATTRIBUTE (accessed from a compound)\n", MARKER_VALUE(pc, unsigned char));
-			return 4;
-
-		case TOY_OPCODE_DUPLICATE:
-			printf(MARKER "DUPLICATE %s\n", MARKER_VALUE(pc, unsigned char), bytecode[pc + 1] ? "and ACCESS" : "");
-			return 4;
-
-		case TOY_OPCODE_ELIMINATE:
-			printf(MARKER "ELIMINATE\n", MARKER_VALUE(pc, unsigned char));
-			return 4;
-
-		case TOY_OPCODE_ADD:
-			printf(MARKER "ADD %s\n", MARKER_VALUE(pc, unsigned char), bytecode[pc + 1] == TOY_OPCODE_ASSIGN ? "and ASSIGN" : "");
-			return 4;
-
-		case TOY_OPCODE_SUBTRACT:
-			printf(MARKER "SUBTRACT %s\n", MARKER_VALUE(pc, unsigned char), bytecode[pc + 1] == TOY_OPCODE_ASSIGN ? "and ASSIGN" : "");
-			return 4;
-
-		case TOY_OPCODE_MULTIPLY:
-			printf(MARKER "MULTIPLY %s\n", MARKER_VALUE(pc, unsigned char), bytecode[pc + 1] == TOY_OPCODE_ASSIGN ? "and ASSIGN" : "");
-			return 4;
-
-		case TOY_OPCODE_DIVIDE:
-			printf(MARKER "DIVIDE %s\n", MARKER_VALUE(pc, unsigned char), bytecode[pc + 1] == TOY_OPCODE_ASSIGN ? "and ASSIGN" : "");
-			return 4;
-
-		case TOY_OPCODE_MODULO:
-			printf(MARKER "MODULO %s\n", MARKER_VALUE(pc, unsigned char), bytecode[pc + 1] == TOY_OPCODE_ASSIGN ? "and ASSIGN" : "");
-			return 4;
-
-		case TOY_OPCODE_COMPARE_EQUAL:
-			printf(MARKER "COMPARE %s\n", MARKER_VALUE(pc, unsigned char), bytecode[pc + 1] != TOY_OPCODE_NEGATE ? "==" : "!=");
-			return 4;
-
-		case TOY_OPCODE_COMPARE_LESS:
-			printf(MARKER "COMPARE '<'\n", MARKER_VALUE(pc, unsigned char));
-			return 4;
-
-		case TOY_OPCODE_COMPARE_LESS_EQUAL:
-			printf(MARKER "COMPARE '<='\n", MARKER_VALUE(pc, unsigned char));
-			return 4;
-
-		case TOY_OPCODE_COMPARE_GREATER:
-			printf(MARKER "COMPARE '>'\n", MARKER_VALUE(pc, unsigned char));
-			return 4;
-
-		case TOY_OPCODE_COMPARE_GREATER_EQUAL:
-			printf(MARKER "COMPARE '>='\n", MARKER_VALUE(pc, unsigned char));
-			return 4;
-
-		case TOY_OPCODE_AND:
-			printf(MARKER "LOGICAL '&&'\n", MARKER_VALUE(pc, unsigned char));
-			return 4;
-
-		case TOY_OPCODE_OR:
-			printf(MARKER "LOGICAL '||'\n", MARKER_VALUE(pc, unsigned char));
-			return 4;
-
-		case TOY_OPCODE_TRUTHY:
-			printf(MARKER "LOGICAL TRUTHY\n", MARKER_VALUE(pc, unsigned char));
-			return 4;
-
-		case TOY_OPCODE_NEGATE:
-			printf(MARKER "LOGICAL NEGATE\n", MARKER_VALUE(pc, unsigned char));
-			return 4;
-
-		case TOY_OPCODE_RETURN:
-			printf(MARKER "Keyword RETURN (%u)\n", MARKER_VALUE(pc, unsigned char), bytecode[pc + 1]);
-			return 4;
-
-		case TOY_OPCODE_JUMP:
-			printf(MARKER  TOY_CC_DEBUG "JUMP %s%s (%s%d) (GOTO %u)\n" TOY_CC_RESET, MARKER_VALUE(pc, unsigned char),
-				bytecode[pc + 1] == TOY_OP_PARAM_JUMP_ABSOLUTE ? "absolute" : "relative",
-				bytecode[pc + 2] == TOY_OP_PARAM_JUMP_ALWAYS ? "" :
-					bytecode[pc + 2] == TOY_OP_PARAM_JUMP_IF_TRUE ? " if true" : " if false",
-				bytecode[pc + 4] > 0 ? "+" : "", //show a + sign when positive
-				bytecode[pc + 4],
-				bytecode[pc + 4] + pc + 8
-				);
-			return 8;
-
-		case TOY_OPCODE_ESCAPE:
-			printf(MARKER  TOY_CC_DEBUG "ESCAPE relative %s%d (GOTO %u) and pop %d\n" TOY_CC_RESET, MARKER_VALUE(pc, unsigned char),
-				bytecode[pc + 4] > 0 ? "+" : "", //show a + sign when positive
-				bytecode[pc + 4],
-				bytecode[pc + 4] + pc + 12,
-				bytecode[pc + 8]
-			);
-			return 12;
-
-		case TOY_OPCODE_SCOPE_PUSH:
-			printf(MARKER "SCOPE PUSH\n", MARKER_VALUE(pc, unsigned char));
-			return 4;
-
-		case TOY_OPCODE_SCOPE_POP:
-			printf(MARKER "SCOPE POP\n", MARKER_VALUE(pc, unsigned char));
-			return 4;
-
-		case TOY_OPCODE_ASSERT:
-			printf(MARKER TOY_CC_WARN "Keyword ASSERT (cond%s)\n" TOY_CC_RESET, MARKER_VALUE(pc, unsigned char), bytecode[pc + 1] > 1 ? ",msg" : "");
-			return 4;
-
-		case TOY_OPCODE_PRINT:
-			printf(MARKER TOY_CC_NOTICE "Keyword PRINT\n" TOY_CC_RESET, MARKER_VALUE(pc, unsigned char));
-			return 4;
-
-		case TOY_OPCODE_CONCAT:
-			printf(MARKER "CONCATENATE strings\n", MARKER_VALUE(pc, unsigned char));
-			return 4;
-
-		case TOY_OPCODE_INDEX:
-			printf(MARKER "INDEX (%d elements)\n", MARKER_VALUE(pc, unsigned char), bytecode[pc + 1]);
-			return 4;
-
-		// case TOY_OPCODE_UNUSED:
-		// case TOY_OPCODE_PASS:
-		// case TOY_OPCODE_ERROR:
-		// case TOY_OPCODE_EOF:
-
-		default:
-			printf(MARKER TOY_CC_WARN "Unknown Word: [%u, %u, %u, %u]" TOY_CC_RESET "\n", MARKER_VALUE(pc, unsigned char), bytecode[pc], bytecode[pc+1], bytecode[pc+2], bytecode[pc+3]);
-			return 4;
-	}
-}
-
-int inspect_read(unsigned char* bytecode, unsigned int pc, unsigned int jumps_addr, unsigned int data_addr) {
-	Toy_ValueType type = bytecode[pc + 1];
-
-	switch(type) {
-		case TOY_VALUE_NULL: {
-			printf(MARKER "READ NULL\n", MARKER_VALUE(pc, unsigned char));
-			return 4;
-		}
-
-		case TOY_VALUE_BOOLEAN: {
-			if (bytecode[pc + 2]) {
-				printf(MARKER "READ BOOL true\n", MARKER_VALUE(pc, unsigned char));
-			}
-			else {
-				
-			}
-			return 4;
-		}
-
-		case TOY_VALUE_INTEGER: {
-			int i = *(int*)(bytecode + pc + 4);
-			printf(MARKER "READ INTEGER %d\n", MARKER_VALUE(pc, unsigned char), i);
-			return 8;
-		}
-
-		case TOY_VALUE_FLOAT: {
-			float i = *(float*)(bytecode + pc + 4);
-			printf(MARKER "READ FLOAT %f\n", MARKER_VALUE(pc, unsigned char), i);
-			return 8;
-		}
-
-		case TOY_VALUE_STRING: {
-			Toy_StringType stringType = (Toy_StringType)(*(bytecode + pc + 2)); //Probably not needed
-			int len = bytecode[pc + 3]; //only used for names?
-			(void)len;
-
-			(void)stringType;
-
-			unsigned int indexValue = *((unsigned int*)(bytecode + pc + 4));
-			unsigned int jumpValue = *((unsigned int*)(bytecode + jumps_addr + indexValue));
-			char* cstr = ((char*)(bytecode + data_addr + jumpValue));
-
-			printf(MARKER "READ STRING [%u] '%s'\n", MARKER_VALUE(pc, unsigned char), indexValue, cstr);
-
-			return 8;
-		}
-
-		case TOY_VALUE_FUNCTION:
-			printf(MARKER "READ FUNCTION '%u' (%d params)\n", MARKER_VALUE(pc, unsigned char), *((unsigned int*)(bytecode + pc + 4)), bytecode[pc + 2]);
-			return 8;
-
-		case TOY_VALUE_ARRAY: {
-			unsigned int count = *((unsigned int*)(bytecode + pc + 4));
-			printf(MARKER "READ ARRAY %u elements\n", MARKER_VALUE(pc, unsigned char), count);
-			return 8;
-		}
-
-		case TOY_VALUE_TABLE: {
-			unsigned int count = *((unsigned int*)(bytecode + pc + 4));
-			printf(MARKER "READ TABLE %u elements (consuming %u values)\n", MARKER_VALUE(pc, unsigned char), count / 2, count);
-			return 8;
-		}
-
-		case TOY_VALUE_OPAQUE:
-		case TOY_VALUE_ANY:
-		case TOY_VALUE_UNKNOWN:
-		default: {
-			printf(MARKER TOY_CC_WARN "READ %s (unhandled by inspector)" TOY_CC_RESET "\n", MARKER_VALUE(pc, unsigned char), Toy_getValueTypeAsCString(type));
-			return 4;
-		}
-	}
-}

repl/bytecode_inspector.h

@@ -1,3 +0,0 @@
-#pragma once
-
-int inspect_bytecode(unsigned char* bytecode);

repl/lib_standard.c

@@ -0,0 +1,94 @@
+#include "lib_standard.h"
+
+#include "memory.h"
+
+#include <time.h>
+
+static int nativeClock(Interpreter* interpreter, LiteralArray* arguments) {
+	//no arguments
+	if (arguments->count != 0) {
+		interpreter->errorOutput("Incorrect number of arguments to clock\n");
+		return -1;
+	}
+
+	//get the time from C (what a pain)
+	time_t rawtime = time(NULL);
+	struct tm* timeinfo = localtime( &rawtime );
+	char* timestr = asctime(timeinfo);
+
+	//push to the stack
+	int len = strlen(timestr) - 1; //-1 for the newline
+	Literal timeLiteral = TO_STRING_LITERAL(copyString(timestr, len), len);
+
+	//push to the stack
+	pushLiteralArray(&interpreter->stack, timeLiteral);
+
+	//cleanup
+	freeLiteral(timeLiteral);
+
+	return 1;
+}
+
+//call the hook
+typedef struct Natives {
+	char* name;
+	NativeFn fn;
+} Natives;
+
+int hookStandard(Interpreter* interpreter, Literal identifier, Literal alias) {
+	//build the natives list
+	Natives natives[] = {
+		{"clock", nativeClock},
+		{NULL, NULL}
+	};
+
+	//store the library in an aliased dictionary
+	if (!IS_NULL(alias)) {
+		//make sure the name isn't taken
+		if (isDelcaredScopeVariable(interpreter->scope, alias)) {
+			interpreter->errorOutput("Can't override an existing variable\n");
+			freeLiteral(alias);
+			return false;
+		}
+
+		//create the dictionary to load up with functions
+		LiteralDictionary* dictionary = ALLOCATE(LiteralDictionary, 1);
+		initLiteralDictionary(dictionary);
+
+		//load the dict with functions
+		for (int i = 0; natives[i].name; i++) {
+			Literal name = TO_STRING_LITERAL(copyString(natives[i].name, strlen(natives[i].name)), strlen(natives[i].name));
+			Literal func = TO_FUNCTION_LITERAL((void*)natives[i].fn, 0);
+			func.type = LITERAL_FUNCTION_NATIVE;
+
+			setLiteralDictionary(dictionary, name, func);
+
+			freeLiteral(name);
+			freeLiteral(func);
+		}
+
+		//build the type
+		Literal type = TO_TYPE_LITERAL(LITERAL_DICTIONARY, true);
+		Literal strType = TO_TYPE_LITERAL(LITERAL_STRING, true);
+		Literal fnType = TO_TYPE_LITERAL(LITERAL_FUNCTION_NATIVE, true);
+		TYPE_PUSH_SUBTYPE(&type, strType);
+		TYPE_PUSH_SUBTYPE(&type, fnType);
+
+		//set scope
+		Literal dict = TO_DICTIONARY_LITERAL(dictionary);
+		declareScopeVariable(interpreter->scope, alias, type);
+		setScopeVariable(interpreter->scope, alias, dict, false);
+
+		//cleanup
+		freeLiteral(dict);
+		freeLiteral(type);
+		return 0;
+	}
+
+	//default
+	for (int i = 0; natives[i].name; i++) {
+		injectNativeFn(interpreter, natives[i].name, natives[i].fn);
+	}
+
+	return 0;
+}

repl/lib_standard.h

@@ -0,0 +1,6 @@
+#pragma once
+
+#include "interpreter.h"
+
+int hookStandard(Interpreter* interpreter, Literal identifier, Literal alias);
+

repl/main.c

@@ -1,532 +0,0 @@
-#include "ast_inspector.h"
-#include "bytecode_inspector.h"
-#include "bucket_inspector.h"
-
-#include "toy_console_colors.h"
-
-#include "toy_lexer.h"
-#include "toy_parser.h"
-#include "toy_compiler.h"
-#include "toy_vm.h"
-
-//NOTE: for testing
-#include "standard_library.h"
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-unsigned char* readFile(char* path, int* size) {
-	//open the file
-	FILE* file = fopen(path, "rb");
-	if (file == NULL) {
-		*size = -1; //missing file error
-		return NULL;
-	}
-
-	//determine the file's length
-	fseek(file, 0L, SEEK_END);
-	*size = ftell(file);
-	rewind(file);
-
-	//make some space
-	unsigned char* buffer = malloc(*size + 1);
-	if (buffer == NULL) {
-		fclose(file);
-		return NULL;
-	}
-
-	//read the file
-	if (fread(buffer, sizeof(unsigned char), *size, file) < (unsigned int)(*size)) {
-		fclose(file);
-		free(buffer);
-		*size = -2; //singal a read error
-		return NULL;
-	}
-
-	buffer[(*size)++] = '\0';
-
-	//clean up and return
-	fclose(file);
-	return buffer;
-}
-
-int getFileName(char* dest, const char* src, size_t destLength) {
-#define MIN(a, b) ((a) < (b) ? (a) : (b))
-	char* p = NULL;
-
-	//find the last slash, regardless of platform
-	p = strrchr(src, '\\');
-	if (p == NULL) {
-		p = strrchr(src, '/');
-	}
-	if (p == NULL) {
-		int len = MIN(strlen(src), destLength-1);
-		strncpy(dest, src, len);
-		dest[len] = '\0';
-		return len;
-	}
-
-	p++; //skip the slash
-
-	//determine length of the file name
-	int len = MIN(strlen(src), destLength-1);
-
-	//copy to the dest
-	strncpy(dest, p, len);
-	dest[len] = '\0';
-
-	return len;
-#undef MIN
-}
-
-//error callbacks
-static int errorAndExitCallback(const char* msg) {
-	fprintf(stderr, TOY_CC_ERROR "Error: %s" TOY_CC_RESET "\n", msg);
-	exit(-1);
-}
-
-static int errorAndContinueCallback(const char* msg) {
-	return fprintf(stderr, TOY_CC_ERROR "Error: %s" TOY_CC_RESET "\n", msg);
-}
-
-static int assertFailureAndExitCallback(const char* msg) {
-	fprintf(stderr, TOY_CC_ASSERT "Assert Failure: %s" TOY_CC_RESET "\n", msg);
-	exit(-1);
-}
-
-static int assertFailureAndContinueCallback(const char* msg) {
-	return fprintf(stderr, TOY_CC_ASSERT "Assert Failure: %s" TOY_CC_RESET "\n", msg);
-}
-
-static int noOpCallback(const char* msg) {
-	//NO-OP
-	(void)msg;
-	return 0;
-}
-
-static int silentExitCallback(const char* msg) {
-	//NO-OP
-	(void)msg;
-	exit(-1);
-}
-
-//handle command line arguments
-typedef struct CmdLine {
-	bool error;
-	bool help;
-	bool version;
-	char* infile;
-	int infileLength;
-	bool silentPrint;
-	bool silentAssert;
-	bool removeAssert;
-	bool verbose;
-} CmdLine;
-
-void usageCmdLine(int argc, const char* argv[]) {
-	(void)argc;
-	printf("Usage: %s [ -h | -v | -f source.toy ]\n\n", argv[0]);
-}
-
-void helpCmdLine(int argc, const char* argv[]) {
-	usageCmdLine(argc, argv);
-
-	printf("The Toy Programming Language, leave arguments blank for an interactive REPL.\n\n");
-
-	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("  -f, --file infile\t\tParse, compile and execute the source file then exit.\n");
-	printf("      --silent-print\t\tSuppress output from the print keyword.\n");
-	printf("      --silent-assert\t\tSuppress output from the assert keyword.\n");
-	printf("      --remove-assert\t\tDo not include the assert statement in the bytecode.\n");
-	printf("  -d, --verbose\t\tPrint debugging information about Toy's internals.\n");
-}
-
-void versionCmdLine(int argc, const char* argv[]) {
-	(void)argc;
-	(void)argv;
-	printf("The Toy Programming Language, Version %d.%d.%d %s\n\n", TOY_VERSION_MAJOR, TOY_VERSION_MINOR, TOY_VERSION_PATCH, TOY_VERSION_BUILD);
-
-	//copy/pasted from the license file - there's a way to include it directly, but it's too finnicky to bother
-	const char* license = 
-		"Copyright (c) 2020-2026 Kayne Ruse, KR Game Studios\n"
-		"\n"
-		"This software is provided 'as-is', without any express or implied\n"
-		"warranty. In no event will the authors be held liable for any damages\n"
-		"arising from the use of this software.\n"
-		"\n"
-		"Permission is granted to anyone to use this software for any purpose,\n"
-		"including commercial applications, and to alter it and redistribute it\n"
-		"freely, subject to the following restrictions:\n"
-		"\n"
-		"1. The origin of this software must not be misrepresented; you must not\n"
-		"claim that you wrote the original software. If you use this software\n"
-		"in a product, an acknowledgment in the product documentation would be\n"
-		"appreciated but is not required.\n"
-		"2. Altered source versions must be plainly marked as such, and must not be\n"
-		"misrepresented as being the original software.\n"
-		"3. This notice may not be removed or altered from any source distribution.\n"
-		"\n"
-	;
-
-	printf("%s",license);
-}
-
-CmdLine parseCmdLine(int argc, const char* argv[]) {
-	CmdLine cmd = {
-		.error = false,
-		.help = false,
-		.version = false,
-		.infile = NULL,
-		.infileLength = 0,
-		.silentPrint = false,
-		.silentAssert = false,
-		.removeAssert = false,
-		.verbose = false,
-	};
-
-	for (int i = 1; i < argc; i++) {
-		if (!strcmp(argv[i], "-h") || !strcmp(argv[i], "--help")) {
-			cmd.help = true;
-		}
-
-		else if (!strcmp(argv[i], "-v") || !strcmp(argv[i], "--version")) {
-			cmd.version = true;
-		}
-
-		else if (!strcmp(argv[i], "-f") || !strcmp(argv[i], "--file")) {
-			if (argc <= i + 1) {
-				cmd.error = true;
-			}
-			else {
-				if (cmd.infile != NULL) { //don't leak
-					free(cmd.infile);
-				}
-
-				i++;
-
-				//total space to reserve
-				cmd.infileLength = strlen(argv[i]) + 1;
-				cmd.infileLength = (cmd.infileLength + 3) & ~3; //BUGFIX: align to  word size
-				cmd.infile = malloc(cmd.infileLength);
-
-				if (cmd.infile == NULL) {
-					fprintf(stderr, TOY_CC_ERROR "ERROR: Failed to allocate space while parsing the command line, exiting\n" TOY_CC_RESET);
-					exit(-1);
-				}
-
-				int len = strlen(argv[i]);
-				strncpy(cmd.infile, argv[i], len);
-				cmd.infile[len] = '\0';
-			}
-		}
-
-		else if (!strcmp(argv[i], "--silent-print")) {
-			cmd.silentPrint = true;
-		}
-
-		else if (!strcmp(argv[i], "--silent-assert")) {
-			cmd.silentAssert = true;
-		}
-
-		else if (!strcmp(argv[i], "--remove-assert")) {
-			cmd.removeAssert = true;
-		}
-
-		else if (!strcmp(argv[i], "-d") || !strcmp(argv[i], "--verbose")) {
-			cmd.verbose = true;
-		}
-
-		else {
-			cmd.error = true;
-		}
-	}
-
-	return cmd;
-}
-
-//debugging
-static void debugStackPrint(Toy_Stack* stack) {
-	//DEBUG: if there's anything on the stack, print it
-	if (stack->count > 0) {
-		Toy_Bucket* stringBucket = Toy_allocateBucket(TOY_BUCKET_IDEAL);
-
-		printf("\n" TOY_CC_NOTICE "Stack Dump" TOY_CC_RESET "\n" TOY_CC_NOTICE "%-20s%-20s" TOY_CC_RESET "\n", "type", "value");
-		for (unsigned int i = 0; i < stack->count; i++) {
-			Toy_Value v = ((Toy_Value*)(stack + 1))[i]; //'stack + 1' is a naughty trick
-
-			//print type
-			printf("%-20s", Toy_getValueTypeAsCString(v.type));
-
-			//print value
-			Toy_String* string = Toy_stringifyValue(&stringBucket, Toy_unwrapValue(v));
-			char* buffer = Toy_getStringRaw(string);
-			printf("%-20s", buffer);
-			free(buffer);
-			Toy_freeString(string);
-
-			printf("\n");
-		}
-
-		Toy_freeBucket(&stringBucket);
-	}
-}
-
-static void debugScopePrint(Toy_Scope* scope, int depth) {
-	//DEBUG: if there's anything in the scope, print it
-	if (scope->count > 0) {
-		Toy_Bucket* stringBucket = Toy_allocateBucket(TOY_BUCKET_IDEAL);
-
-		printf("\n" TOY_CC_NOTICE "Scope Dump [%d]" TOY_CC_RESET "\n" TOY_CC_NOTICE "%-20s%-20s%-20s" TOY_CC_RESET "\n", depth, "type", "name", "value");
-		for (unsigned int i = 0; i < scope->capacity; i++) {
-			if (scope->data[i].key == NULL || scope->data[i].key->info.length == 0) {
-				continue;
-			}
-
-			Toy_String* k = scope->data[i].key;
-			Toy_Value v = scope->data[i].value;
-
-			printf("%-10s%-10s%-20s", Toy_getValueTypeAsCString(scope->data[i].type), scope->data[i].constant ? "const" : "", k != NULL ? k->leaf.data : "");
-
-			//print value
-			Toy_String* string = Toy_stringifyValue(&stringBucket, Toy_unwrapValue(v));
-			char* buffer = Toy_getStringRaw(string);
-			printf("%-20s", buffer);
-			free(buffer);
-			Toy_freeString(string);
-
-			printf("\n");
-		}
-
-		Toy_freeBucket(&stringBucket);
-	}
-
-	if (scope->next != NULL) {
-		debugScopePrint(scope->next, depth + 1);
-	}
-}
-
-//repl function
-int repl(const char* filepath, bool verbose) {
-	//output options
-	Toy_setPrintCallback(puts);
-	Toy_setErrorCallback(errorAndContinueCallback);
-	Toy_setAssertFailureCallback(assertFailureAndContinueCallback);
-
-	//vars to use
-	char prompt[256];
-	getFileName(prompt, filepath, 256);
-	unsigned int INPUT_BUFFER_SIZE = 4096;
-	char inputBuffer[INPUT_BUFFER_SIZE];
-	memset(inputBuffer, 0, INPUT_BUFFER_SIZE);
-
-	Toy_VM vm;
-	Toy_initVM(&vm);
-
-	printf("%s> ", prompt); //shows the terminal prompt and begin
-
-	//read from the terminal
-	while(fgets(inputBuffer, INPUT_BUFFER_SIZE, stdin)) {
-		//work around fgets() adding a newline
-		unsigned int length = strlen(inputBuffer);
-		if (inputBuffer[length - 1] == '\n') {
-			inputBuffer[--length] = '\0';
-		}
-
-		if (length == 0 || !inputBuffer[ strspn(inputBuffer, " \r\n\t") ]) {
-			printf("%s> ", prompt); //shows the terminal prompt and restart
-			continue;
-		}
-
-		//end
-		if (strlen(inputBuffer) == 4 && (strncmp(inputBuffer, "exit", 4) == 0 || strncmp(inputBuffer, "quit", 4) == 0)) {
-			break;
-		}
-
-		//parse the input, prep the VM for execution
-		Toy_Bucket* bucket = Toy_allocateBucket(TOY_BUCKET_IDEAL);
-		Toy_Lexer lexer;
-		Toy_bindLexer(&lexer, inputBuffer);
-		Toy_Parser parser;
-		Toy_bindParser(&parser, &lexer);
-		Toy_Ast* ast = Toy_scanParser(&bucket, &parser);
-
-		//parsing error, retry
-		if (parser.error || ast == NULL) {
-			Toy_freeBucket(&bucket);
-			printf("%s> ", prompt); //shows the terminal prompt
-			continue;
-		}
-
-		if (verbose) {
-			inspect_ast(ast);
-		}
-
-		unsigned char* bytecode = Toy_compileToBytecode(ast);
-		Toy_freeBucket(&bucket); //no need to for the GC here
-
-		if (bytecode == NULL) {
-			printf("%s> ", prompt);
-			continue;
-		}
-
-		if (verbose) {
-			inspect_bytecode(bytecode);
-		}
-
-		//WARN: Hacky debugging
-		if (vm.scope == NULL) {
-			Toy_bindVM(&vm, bytecode, NULL);
-			initStandardLibrary(&vm);
-		}
-		else {
-			Toy_bindVM(&vm, bytecode, NULL);
-		}
-
-		//run
-		Toy_runVM(&vm);
-
-		int depthBeforeGC = 0;
-		int depthAfterGC = 0;
-
-		//print the debug info
-		if (verbose) {
-			debugStackPrint(vm.stack);
-			debugScopePrint(vm.scope, 0);
-
-			depthBeforeGC = inspect_bucket(&vm.memoryBucket);
-		}
-
-		//free the memory, and leave the VM ready for the next loop
-		Toy_resetVM(&vm, true, true);
-
-		if (verbose) {
-			depthAfterGC = inspect_bucket(&vm.memoryBucket);
-
-			printf("GC Report: %d -> %d\n", depthBeforeGC, depthAfterGC);
-		}
-
-		free(bytecode);
-
-		printf("%s> ", prompt); //shows the terminal prompt
-	}
-
-	//cleanup all memory
-	Toy_freeVM(&vm);
-
-	return 0;
-}
-
-//main file
-int main(int argc, const char* argv[]) {
-	Toy_setPrintCallback(puts);
-	Toy_setErrorCallback(errorAndExitCallback);
-	Toy_setAssertFailureCallback(assertFailureAndExitCallback);
-
-	//if there's args, process them
-	CmdLine cmd = parseCmdLine(argc, argv);
-
-	//output options
-	if (cmd.silentPrint) {
-		Toy_setPrintCallback(noOpCallback);
-	}
-
-	if (cmd.silentAssert) {
-		Toy_setAssertFailureCallback(silentExitCallback);
-	}
-
-	//process
-	if (cmd.error) {
-		usageCmdLine(argc, argv);
-	}
-	else if (cmd.help) {
-		helpCmdLine(argc, argv);
-	}
-	else if (cmd.version) {
-		versionCmdLine(argc, argv);
-	}
-	else if (cmd.infile != NULL) {
-		//read the source file
-		int size;
-		unsigned char* source = readFile(cmd.infile, &size);
-
-		//check the file
-		if (source == NULL) {
-			if (size == 0) {
-				fprintf(stderr, TOY_CC_ERROR "ERROR: Could not parse an empty file '%s', exiting\n" TOY_CC_RESET, cmd.infile);
-				return -1;
-			}
-
-			else if (size == -1) {
-				fprintf(stderr, TOY_CC_ERROR "ERROR: File not found '%s', exiting\n" TOY_CC_RESET, cmd.infile);
-				return -1;
-			}
-
-			else {
-				fprintf(stderr, TOY_CC_ERROR "ERROR: Unknown error while reading file '%s', exiting\n" TOY_CC_RESET, cmd.infile);
-				return -1;
-			}
-		}
-
-		free(cmd.infile);
-
-		cmd.infile = NULL;
-		cmd.infileLength = 0;
-
-		//compile the source code
-		Toy_Lexer lexer;
-		Toy_bindLexer(&lexer, (char*)source);
-
-		Toy_Parser parser;
-		Toy_bindParser(&parser, &lexer);
-
-		Toy_Bucket* bucket = Toy_allocateBucket(TOY_BUCKET_IDEAL);
-		Toy_Ast* ast = Toy_scanParser(&bucket, &parser);
-
-		if (ast == NULL) {
-			Toy_freeBucket(&bucket);
-			free(source);
-			return -1;
-		}
-
-		if (cmd.verbose) {
-			inspect_ast(ast);
-		}
-
-		unsigned char* bytecode = Toy_compileToBytecode(ast);
-		Toy_freeBucket(&bucket);
-		free(source);
-
-		if (bytecode == NULL) {
-			return -1;
-		}
-
-		if (cmd.verbose) {
-			inspect_bytecode(bytecode);
-		}
-
-		//run the compiled code
-		Toy_VM vm;
-		Toy_initVM(&vm);
-		Toy_bindVM(&vm, bytecode, NULL);
-		initStandardLibrary(&vm); //WARN: Hacky debugging
-
-		Toy_runVM(&vm);
-
-		//print the debug info
-		if (cmd.verbose) {
-			debugStackPrint(vm.stack);
-			debugScopePrint(vm.scope, 0);
-		}
-
-		//cleanup
-		Toy_freeVM(&vm);
-		free(bytecode);
-	}
-	else {
-		repl(argv[0], cmd.verbose);
-	}
-
-	return 0;
-}

repl/makefile

@@ -1,63 +1,33 @@
-#compiler settings
 CC=gcc
-CFLAGS+=-std=c17 -g -Wall -Werror -Wextra -Wpedantic -Wformat=2 -Wno-newline-eof
-LIBS+=-lm -lToy
-LDFLAGS+=-Wl,-rpath,'$$ORIGIN'
 
-ifeq ($(shell uname),Darwin) #make sure there's enough space for the dylib fix
-	LDFLAGS+=-Wl,-headerpad_max_install_names
-endif
+IDIR+=. ../source
+CFLAGS+=$(addprefix -I,$(IDIR)) -g -Wall -W -Wno-unused-parameter -Wno-unused-function -Wno-unused-variable
+LIBS+=-ltoy
 
+ODIR = obj
+SRC = $(wildcard *.c)
+OBJ = $(addprefix $(ODIR)/,$(SRC:.c=.o))
+OUTNAME=toy
+OUT=../$(TOY_OUTDIR)/toyrepl
 
-#directories
-REPL_ROOTDIR=..
-REPL_REPLDIR=.
-REPL_SOURCEDIR=$(REPL_ROOTDIR)/$(TOY_SOURCEDIR)
-
-REPL_OUTDIR=$(REPL_ROOTDIR)/$(TOY_OUTDIR)
-REPL_OBJDIR=$(TOY_OBJDIR)
-
-#file names
-REPL_REPLFILES=$(wildcard $(REPL_REPLDIR)/*.c)
-REPL_OBJFILES=$(addprefix $(REPL_OBJDIR)/,$(notdir $(REPL_REPLFILES:.c=.o)))
-REPL_TARGETNAME=repl
-
-#file extensions
-ifeq ($(OS),Windows_NT)
-	REPL_TARGETEXT=.exe
+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
-	REPL_TARGETEXT=.out
+	$(CC) -DTOY_IMPORT $(CFLAGS) -o $(OUT) $(OBJ) -Wl,-rpath,. -L$(realpath $(shell pwd)/../$(TOY_OUTDIR)) $(LIBS)
 endif
 
-#linker fix
-LDFLAGS+=-L$(realpath $(REPL_OUTDIR))
+$(OBJ): | $(ODIR)
 
-#build the object files, compile the test cases, and run
-all: build link
+$(ODIR):
+	mkdir $(ODIR)
 
-#targets for each step
-.PHONY: build
-build: $(REPL_OBJDIR) $(REPL_OBJFILES)
+$(ODIR)/%.o: %.c
+	$(CC) -c -o $@ $< $(CFLAGS)
 
-.PHONY: link
-link: $(REPL_OUTDIR) $(REPL_OUTDIR)/$(REPL_TARGETNAME)$(REPL_TARGETEXT)
+.PHONY: clean
 
-#util targets
-$(REPL_OUTDIR):
-	mkdir $(REPL_OUTDIR)
-
-$(REPL_OBJDIR):
-	mkdir $(REPL_OBJDIR)
-
-#compilation steps
-$(REPL_OBJDIR)/%.o: $(REPL_REPLDIR)/%.c
-	$(CC) -c -o $@ $< $(addprefix -I,$(REPL_REPLDIR)) $(addprefix -I,$(REPL_SOURCEDIR)) $(CFLAGS)
-
-$(REPL_OUTDIR)/$(REPL_TARGETNAME)$(REPL_TARGETEXT): $(REPL_OBJFILES)
-	$(CC) -DTOY_IMPORT $(CFLAGS) -o $@ $(REPL_OBJFILES) $(LDFLAGS) $(LIBS)
-ifeq ($(shell uname),Darwin) #dylib fix
-	otool -L $@
-	install_name_tool -add_rpath @executable_path/. $@
-	install_name_tool -change $(REPL_OUTDIR)/libToy.dylib @executable_path/libToy.dylib $@
-	otool -L $@
-endif
+clean:
+	$(RM) $(ODIR)
+	rm /usr/local/lib/lib$(OUTNAME).dylib

repl/repl_main.c

@@ -0,0 +1,139 @@
+#include "repl_tools.h"
+#include "lib_standard.h"
+
+#include "console_colors.h"
+
+#include "lexer.h"
+#include "parser.h"
+#include "compiler.h"
+#include "interpreter.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+void repl() {
+	//repl does it's own thing for now
+	bool error = false;
+
+	const int size = 2048;
+	char input[size];
+	memset(input, 0, size);
+
+	Interpreter interpreter; //persist the interpreter for the scopes
+	initInterpreter(&interpreter);
+
+	//inject the libs
+	injectNativeHook(&interpreter, "standard", hookStandard);
+
+	for(;;) {
+		printf("> ");
+		fgets(input, size, stdin);
+
+		//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
+		Lexer lexer;
+		Parser parser;
+		Compiler compiler;
+
+		initLexer(&lexer, input);
+		initParser(&parser, &lexer);
+		initCompiler(&compiler);
+
+		//run this iteration
+		ASTNode* node = scanParser(&parser);
+		while(node != NULL) {
+			//pack up and restart
+			if (node->type == AST_NODEERROR) {
+				printf(ERROR "error node detected\n" RESET);
+				error = true;
+				freeNode(node);
+				break;
+			}
+
+			writeCompiler(&compiler, node);
+			freeNode(node);
+			node = scanParser(&parser);
+		}
+
+		if (!error) {
+			//get the bytecode dump
+			int size = 0;
+			unsigned char* tb = collateCompiler(&compiler, &size);
+
+			//run the bytecode
+			runInterpreter(&interpreter, tb, size);
+		}
+
+		//clean up this iteration
+		freeCompiler(&compiler);
+		freeParser(&parser);
+		error = false;
+	}
+
+	freeInterpreter(&interpreter);
+}
+
+//entry point
+int main(int argc, const char* argv[]) {
+	initCommand(argc, argv);
+
+	//command specific actions
+	if (command.error) {
+		usageCommand(argc, argv);
+		return 0;
+	}
+
+	if (command.help) {
+		helpCommand(argc, argv);
+		return 0;
+	}
+
+	if (command.version) {
+		copyrightCommand(argc, argv);
+		return 0;
+	}
+
+	//TODO: remove this when the interpreter meets the specification
+	if (command.verbose) {
+		printf(NOTICE "Toy Programming Language Version %d.%d.%d\n" RESET, TOY_VERSION_MAJOR, TOY_VERSION_MINOR, TOY_VERSION_PATCH);
+	}
+
+	//run source file
+	if (command.sourcefile) {
+		runSourceFile(command.sourcefile);
+		return 0;
+	}
+
+	//run from stdin
+	if (command.source) {
+		runSource(command.source);
+		return 0;
+	}
+
+	//compile source file
+	if (command.compilefile && command.outfile) {
+		size_t size = 0;
+		char* source = readFile(command.compilefile, &size);
+		unsigned char* tb = compileString(source, &size);
+		if (!tb) {
+			return 1;
+		}
+		writeFile(command.outfile, tb, size);
+		return 0;
+	}
+
+	//run binary
+	if (command.binaryfile) {
+		runBinaryFile(command.binaryfile);
+		return 0;
+	}
+
+	repl();
+
+	return 0;
+}

repl/repl_tools.c

@@ -0,0 +1,141 @@
+#include "repl_tools.h"
+#include "lib_standard.h"
+
+#include "console_colors.h"
+
+#include "lexer.h"
+#include "parser.h"
+#include "compiler.h"
+#include "interpreter.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+
+//IO functions
+char* readFile(char* path, size_t* fileSize) {
+	FILE* file = fopen(path, "rb");
+
+	if (file == NULL) {
+		fprintf(stderr, ERROR "Could not open file \"%s\"\n" RESET, path);
+		exit(-1);
+	}
+
+	fseek(file, 0L, SEEK_END);
+	*fileSize = ftell(file);
+	rewind(file);
+
+	char* buffer = (char*)malloc(*fileSize + 1);
+
+	if (buffer == NULL) {
+		fprintf(stderr, ERROR "Not enough memory to read \"%s\"\n" RESET, path);
+		exit(-1);
+	}
+
+	size_t bytesRead = fread(buffer, sizeof(char), *fileSize, file);
+
+	buffer[*fileSize] = '\0'; //NOTE: fread doesn't append this
+
+	if (bytesRead < *fileSize) {
+		fprintf(stderr, ERROR "Could not read file \"%s\"\n" RESET, path);
+		exit(-1);
+	}
+
+	fclose(file);
+
+	return buffer;
+}
+
+void writeFile(char* path, unsigned char* bytes, size_t size) {
+	FILE* file = fopen(path, "wb");
+
+	if (file == NULL) {
+		fprintf(stderr, ERROR "Could not open file \"%s\"\n" RESET, path);
+		exit(-1);
+	}
+
+	int written = fwrite(bytes, size, 1, file);
+
+	if (written != 1) {
+		fprintf(stderr, ERROR "Could not write file \"%s\"\n" RESET, path);
+		exit(-1);
+	}
+
+	fclose(file);
+}
+
+//repl functions
+unsigned char* compileString(char* source, size_t* size) {
+	Lexer lexer;
+	Parser parser;
+	Compiler compiler;
+
+	initLexer(&lexer, source);
+	initParser(&parser, &lexer);
+	initCompiler(&compiler);
+
+	//run the parser until the end of the source
+	ASTNode* node = scanParser(&parser);
+	while(node != NULL) {
+		//pack up and leave
+		if (node->type == AST_NODEERROR) {
+			printf(ERROR "error node detected\n" RESET);
+			freeNode(node);
+			freeCompiler(&compiler);
+			freeParser(&parser);
+			return NULL;
+		}
+
+		writeCompiler(&compiler, node);
+		freeNode(node);
+		node = scanParser(&parser);
+	}
+
+	//get the bytecode dump
+	unsigned char* tb = collateCompiler(&compiler, (int*)(size));
+
+	//cleanup
+	freeCompiler(&compiler);
+	freeParser(&parser);
+	//no lexer to clean up
+
+	//finally
+	return tb;
+}
+
+void runBinary(unsigned char* tb, size_t size) {
+	Interpreter interpreter;
+	initInterpreter(&interpreter);
+
+	//inject the libs
+	injectNativeHook(&interpreter, "standard", hookStandard);
+
+	runInterpreter(&interpreter, tb, size);
+	freeInterpreter(&interpreter);
+}
+
+void runBinaryFile(char* fname) {
+	size_t size = 0; //not used
+	unsigned char* tb = (unsigned char*)readFile(fname, &size);
+	if (!tb) {
+		return;
+	}
+	runBinary(tb, size);
+	//interpreter takes ownership of the binary data
+}
+
+void runSource(char* source) {
+	size_t size = 0;
+	unsigned char* tb = compileString(source, &size);
+	if (!tb) {
+		return;
+	}
+
+	runBinary(tb, size);
+}
+
+void runSourceFile(char* fname) {
+	size_t size = 0; //not used
+	char* source = readFile(fname, &size);
+	runSource(source);
+	free((void*)source);
+}

repl/repl_tools.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "common.h"
+
+char* readFile(char* path, size_t* fileSize);
+void writeFile(char* path, unsigned char* bytes, size_t size);
+
+unsigned char* compileString(char* source, size_t* size);
+
+void runBinary(unsigned char* tb, size_t size);
+void runBinaryFile(char* fname);
+void runSource(char* source);
+void runSourceFile(char* fname);
+

repl/standard_library.c

@@ -1,106 +0,0 @@
-#include "standard_library.h"
-#include "toy_console_colors.h"
-
-#include "toy_print.h"
-#include "toy_scope.h"
-#include "toy_stack.h"
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-typedef struct CallbackPairs {
-	const char* name;
-	Toy_nativeCallback callback;
-} CallbackPairs;
-
-//example callbacks
-static void answer(Toy_VM* vm, Toy_FunctionNative* self) {
-	(void)vm;
-	(void)self;
-	Toy_print(TOY_CC_DEBUG "This function returns the integer '42' to the calling scope." TOY_CC_RESET);
-	Toy_pushStack(&vm->stack, TOY_VALUE_FROM_INTEGER(42));
-}
-
-static void identity(Toy_VM* vm, Toy_FunctionNative* self) {
-	//does nothing, but any arguements are left on the stack as results
-	(void)vm;
-	(void)self;
-}
-
-static void echo(Toy_VM* vm, Toy_FunctionNative* self) {
-	(void)self;
-	//pops one argument, and prints it
-	Toy_Value value = Toy_popStack(&vm->stack);
-	Toy_String* string = Toy_stringifyValue(&vm->memoryBucket, value);
-	char* cstr = Toy_getStringRaw(string);
-
-	Toy_print(cstr);
-
-	free(cstr);
-	Toy_freeString(string);
-	Toy_freeValue(value);
-}
-
-static void next(Toy_VM* vm, Toy_FunctionNative* self) {
-	//used by 'range'
-	if (self->meta2 < self->meta1) {
-		Toy_Value result = TOY_VALUE_FROM_INTEGER(self->meta2);
-		Toy_pushStack(&vm->stack, result);
-		self->meta2++;
-	}
-	else {
-		Toy_pushStack(&vm->stack, TOY_VALUE_FROM_NULL());
-	}
-}
-
-static void range(Toy_VM* vm, Toy_FunctionNative* self) {
-	(void)self;
-
-	//one arg to represent the number of iterations
-	Toy_Value value = Toy_popStack(&vm->stack);
-
-	//check types
-	if (!TOY_VALUE_IS_INTEGER(value)) {
-		char buffer[256];
-		snprintf(buffer, 256, "Expected Integer argument in 'range', found '%s'", Toy_getValueTypeAsCString(value.type));
-		Toy_error(buffer);
-		Toy_freeValue(value);
-		return;
-	}
-
-	//make the callback
-	Toy_Function* fn = Toy_createFunctionFromCallback(&vm->memoryBucket, next);
-	fn->native.meta1 = TOY_VALUE_AS_INTEGER(value); //fake a closure
-	fn->native.meta2 = 0; //counter
-
-	Toy_Value result = TOY_VALUE_FROM_FUNCTION(fn);
-
-	Toy_pushStack(&vm->stack, result);
-}
-
-
-CallbackPairs callbackPairs[] = {
-	{"dbg_answer", answer},
-	{"dbg_identity", identity},
-	{"dbg_echo", echo},
-	{"range", range},
-
-	{NULL, NULL},
-};
-
-//exposed functions
-void initStandardLibrary(Toy_VM* vm) {
-	if (vm == NULL || vm->scope == NULL || vm->memoryBucket == NULL) {
-		fprintf(stderr, TOY_CC_ERROR "ERROR: Can't initialize standard library, exiting\n" TOY_CC_RESET);
-		exit(-1);
-	}
-
-	//declare each pair
-	for (int i = 0; callbackPairs[i].name; i++) {
-		Toy_String* key = Toy_createStringLength(&vm->memoryBucket, callbackPairs[i].name, strlen(callbackPairs[i].name));
-		Toy_Function* fn = Toy_createFunctionFromCallback(&(vm->memoryBucket), callbackPairs[i].callback);
-
-		Toy_declareScope(vm->scope, key, TOY_VALUE_FUNCTION, TOY_VALUE_FROM_FUNCTION(fn), true);
-	}
-}

repl/standard_library.h

@@ -1,5 +0,0 @@
-#pragma once
-
-#include "toy_vm.h"
-
-void initStandardLibrary(Toy_VM*);

scripts/benchpress.toy

@@ -1,16 +0,0 @@
-//calculate the nth fibonacci number, and print it
-
-var counter: Int = 0;
-
-var first: Int = 1;
-var second: Int = 0;
-
-while (counter < 100_000) {
-	var third: Int = first + second;
-	first = second;
-	second = third;
-
-	print third;
-
-	++counter;
-}

scripts/blockhead.toy

@@ -1,11 +0,0 @@
-
-fn output(arg) {
-	print arg;
-}
-
-var array = ["alpha", "bravo", "charlie"];
-
-
-
-array.forEach(echo);
-array.forEach(output);

scripts/example.toy

@@ -0,0 +1,89 @@
+//single line comment
+
+/*
+multi line comment
+*/
+
+//test primitive literals
+print "hello world";
+print null;
+print true;
+print false;
+print 42;
+print 3.14;
+print -69;
+print -4.20;
+print 2 + (3 * 3);
+
+//test operators (integers)
+print 1 + 1;
+print 1 - 1;
+print 2 * 2;
+print 1 / 2;
+print 4 % 2;
+
+//test operators (floats)
+print 1.0 + 1.0;
+print 1.0 - 1.0;
+print 2.0 * 2.0;
+print 1.0 / 2.0;
+
+//test scopes
+{
+	print "This statement is within a scope.";
+	{
+		print "This is a deeper scope.";
+	}
+}
+print "Back to the outer scope.";
+
+//test scope will delegate to higher scope
+var a = 1;
+{
+	a = 2;
+	print a;
+}
+print a;
+
+//test scope will shadow higher scope on redefine
+var b: int = 3;
+{
+	var b = 4;
+	print b;
+}
+print b;
+
+//test compounds, repeatedly
+print [1, 2, 3];
+print [4, 5];
+print ["key":"value"];
+print [1, 2, 3];
+print [4, 5];
+print ["key":"value"];
+
+//test empties
+print [];
+print [:];
+
+//test nested compounds
+print [[1, 2, 3], [4, 5, 6], [7, 8, 9]];
+
+//var declarations
+var x = 31;
+var y : int = 42;
+var arr : [int] = [1, 2, 3, 42];
+var dict : [string:int] = ["hello": 1, "world":2];
+
+//printing expressions
+print x;
+print x + y;
+print arr;
+print dict;
+
+//test asserts at the end of the file
+assert x, "This won't be seen";
+assert true, "This won't be seen";
+assert false, "This is a failed assert, and will end execution";
+
+print "This will not be printed because of the above assert";
+

scripts/fib.toy

@@ -1,13 +1,12 @@
-//tentatively functional
+fn fib(n : int) {
+    if (n < 2) {
+        return n;
+    }
 
-//fibonacci sequence
-fn fib(n) {
-	if (n < 2) return n;
-	return fib(n-1) + fib(n-2);
+    return fib(n-1) + fib(n-2);
 }
 
-print fib(12);
-
-//Note to my future self: yes, the base case in 'fib()' is 'n < 2', stop second guessing yourself!
-//Note to my past self: don't tell me what to do!
-//Note to both of you: keep it down you young whipper snappers!
+for (var i = 0; i < 40; i++) {
+	var res = fib(i);
+	print (string)i + ": " + (string)res;
+}

scripts/fizzbuzz.toy

@@ -1,24 +0,0 @@
-//standard example, using 'while' instead of 'for', because it's not ready yet
-
-var counter: Int = 0;
-
-while (++counter <= 100) {
-	var result: String = "";
-
-	if (counter % 3 == 0) {
-		result = result .. "fizz";
-	}
-
-	if (counter % 5 == 0) {
-		result = result .. "buzz";
-	}
-
-	//finally
-	if (result != "") {
-		print result;
-	}
-	else {
-		print counter;
-	}
-}
-

scripts/for-theory.toy

@@ -1,35 +0,0 @@
-//WARN: This is just a scratch pad, don't use it
-//TODO: table.hasValue or table.getKeyFromValue?
-
-
-//for (var i in array) print i;
-//for (var i in table) print i;
-//for (var i in range(10)) print i;
-//for (range(10)) print "ha";
-
-
-//example of a `range`-like function
-fn range(limit: Int) {
-	var counter: Int = 0;
-
-	fn next() {
-		if (counter >= limit) {
-			return null;
-		}
-		else return counter++;
-	}
-
-	return next;
-}
-
-var next = range(10);
-
-
-fn log(x) {
-	if (x == null) return;
-	print x;
-}
-
-while (true) {
-	log(next());
-}

scripts/hello_world.toy

@@ -1,12 +0,0 @@
-
-
-
-fn a(x) {
-	print x;
-}
-
-fn b() {
-	return 42;
-}
-
-a(b(), b());

scripts/leapyear.toy

@@ -1,19 +0,0 @@
-//find the leap years
-fn isLeapYear(n: Int) {
-	if (n % 400 == 0) return true;
-	if (n % 100 == 0) return false;
-	return n % 4 == 0;
-}
-
-//check for string reuse
-{
-	print isLeapYear(1999);
-}
-
-{
-	print isLeapYear(2000);
-}
-
-{
-	print isLeapYear(2004);
-}

scripts/randi.toy

@@ -1,12 +0,0 @@
-
-
-
-var randi: Int = 69420;
-fn rand() {
-	return randi = randi * 1664525 + 1013904223;
-}
-
-
-var a  = rand();
-
-

scripts/rule110.toy

@@ -0,0 +1,66 @@
+var size: int const = 100;
+
+var prev = [];
+for (var i = 0; i < size; i++) {
+	prev.push(false);
+}
+
+prev.set(size - 1, true);
+
+
+fn calc(p, i) {
+	if (p[i-1] && p[i] && p[i+1]) {
+		return false;
+	}
+
+	if (p[i-1] && p[i] && !p[i+1]) {
+		return true;
+	}
+
+	if (p[i-1] && !p[i] && p[i+1]) {
+		return true;
+	}
+
+	if (p[i-1] && !p[i] && !p[i+1]) {
+		return false;
+	}
+
+	if (!p[i-1] && p[i] && p[i+1]) {
+		return true;
+	}
+
+	if (!p[i-1] && p[i] && !p[i+1]) {
+		return true;
+	}
+
+	if (!p[i-1] && !p[i] && p[i+1]) {
+		return true;
+	}
+
+	if (!p[i-1] && !p[i] && !p[i+1]) {
+		return false;
+	}
+}
+
+
+
+for (var iteration = 0; iteration < 100; iteration++) {
+	var line = [false];
+	for (var i = 1; i < size-1; i++) {
+		line.push(calc(prev, i));
+	}
+	line.push(false);
+
+	var output = "";
+	for (var i = 0; i < line.length(); i++) {
+		if (line[i]) {
+			output += "*";
+		}
+		else {
+			output += " ";
+		}
+	}
+
+	print output;
+	prev = line;
+}

scripts/small.toy

@@ -0,0 +1,56 @@
+
+
+fn _b(self) {
+	print "running _b";
+	print self;
+	return self;
+}
+
+fn _c(self) {
+	print "running _c";
+	print self;
+	return self;
+}
+
+fn _d(self) {
+	print "running _d";
+	print self;
+	return self;
+}
+
+fn _e(self) {
+	print "running _e";
+	print self;
+	return self;
+}
+
+fn _f(self) {
+	print "running _f";
+	print self;
+	return self;
+}
+
+
+fn b() {
+	print "running b";
+}
+
+fn c() {
+	print "running c";
+}
+
+fn d() {
+	print "running d";
+}
+
+fn e() {
+	print "running e";
+}
+
+fn f() {
+	print "running f";
+}
+
+var a = 42;
+
+print a.b().c().d().e().f();

scripts/tally.toy

@@ -1,21 +0,0 @@
-fn makeCounter() {
-	var counter: Int = 0;
-
-	fn increment() {
-		return ++counter;
-	}
-
-	return increment;
-}
-
-var tally = makeCounter();
-
-while (true) {
-	var result = tally();
-
-	print result;
-
-	if (result >= 10) {
-		break;
-	}
-}

scripts/test/arithmetic.toy

@@ -0,0 +1,31 @@
+//test operators (integers)
+assert 1 + 1 == 2, "1 + 1 == 2";
+assert 1 - 1 == 0, "1 - 1 == 0";
+assert 2 * 2 == 4, "2 * 2 == 4";
+assert 1 / 2 == 0, "1 / 2 == 0"; //integer division
+assert 5 % 2 == 1, "5 % 2 == 1";
+
+//test operators (floats)
+assert 1.0 + 1.0 == 2.0, "1.0 + 1.0 == 2.0";
+assert 1.0 - 1.0 == 0.0, "1.0 - 1.0 == 0.0";
+assert 2.0 * 2.0 == 4.0, "2.0 * 2.0 == 4.0";
+assert 1.0 / 2.0 == 0.5, "1.0 / 2.0 == 0.5";
+
+
+var a = 10;
+
+a += 20;
+a -= 25;
+
+assert a == 5, "+= or -= failed";
+
+a *= 5;
+a /= 2;
+
+assert a == 12, "*= or /= failed";
+
+a %= 8;
+
+assert a == 4, "%= failed";
+
+print "All good";

scripts/test/call-from-host.toy

@@ -0,0 +1,23 @@
+//create a bunch of toy functions as literals to be called from C
+
+fn answer() {
+	return 42;
+}
+
+fn identity(x) {
+	return x;
+}
+
+fn makeCounter() {
+	var total = 0;
+
+	fn counter() {
+		return ++total;
+	}
+
+	return counter;
+}
+
+fn fail() {
+	assert false, "Failed correctly";
+}

scripts/test/casting.toy

@@ -0,0 +1,37 @@
+//boolean origin
+var b: bool = true;
+
+assert bool b == true, "bool -> bool";
+assert int b == 1, "bool -> int";
+assert float b == 1, "bool -> float";
+assert string b == "true", "bool -> string";
+
+
+//integer origin
+var i: int = 42;
+
+assert bool i == true, "int -> bool";
+assert int i == 42, "int -> int";
+assert float i == 42, "int -> float";
+assert string i == "42", "int -> string";
+
+
+//float origin
+var f: float = 3.14;
+
+assert bool f == true, "float -> bool";
+assert int f == 3, "float -> int";
+assert float f == 3.14, "float -> float";
+assert string f == "3.14", "float -> string";
+
+
+//string origin
+var s: string = "78.9";
+
+assert bool s == true, "string -> bool";
+assert int s == 78, "string -> int";
+assert float s == 78.9, "string -> float";
+assert string s == "78.9", "string -> string";
+
+
+print "All good";

scripts/test/coercions.toy

@@ -0,0 +1,13 @@
+//test int -> float coercion
+{
+	var f: float = 0;
+
+	assert typeof f == float, "coercion on decl failed";
+
+	f = 42;
+
+	assert typeof f == float, "coercion on assign failed";
+}
+
+
+print "All good";

scripts/test/comparisons.toy

@@ -0,0 +1,27 @@
+//test numbers
+assert 1 < 2, "1 < 2";
+assert 1 == 1, "1 == 1";
+assert 2 > 1, "2 > 1";
+assert 1 <= 2, "1 <= 2";
+assert 2 >= 1, "2 >= 1";
+
+
+//test variables
+var a = 1;
+var b = 2;
+
+assert a < b, "a < b";
+assert a == a, "a == a";
+assert b > a, "b > a";
+assert a <= b, "a <= b";
+assert b >= a, "b >= a";
+
+
+//test negation
+assert !false, "!false";
+
+var c = false;
+assert !c, "!c";
+
+
+print "All good";

scripts/test/dot-and-matrix.toy

@@ -0,0 +1,68 @@
+//dot product
+var a = [1, 2, 3];
+var b = [4, 5, 6];
+
+assert _length(a) == _length(b), "a and b lengths are wrong";
+
+var acc = 0;
+for (var i = 0; i < _length(a); i++) {
+	acc += _get(a, i) * _get(b, i);
+}
+
+assert acc == 32, "dot product failed";
+
+
+//assume the args are matrices
+fn matrix(first, second) {
+	//get the matrix size
+	var l1 = _length(first); //rows
+	var l2 = _length(_get(first, 0)); //cols
+
+	var l3 = _length(second); //rows
+	var l4 = _length(_get(second, 0)); //cols
+
+	//pre-allocate the matrix
+	var row = [];
+	for (var j = 0; j < l4; j++) {
+		_push(row, 0);
+	}
+
+	var result = [];
+	for (var i = 0; i < l1; i++) {
+		_push(result, row);
+	}
+
+	//assign the values
+	for (var i = 0; i < _length(first); i++) {
+		//select each element of "first"
+		var firstElement = _get(first, i);
+
+		//for each element of second
+		for (var i2 = 0; i2 < _length(second); i2++) {
+			for (var j2 = 0; j2 < _length(_get(second, 0)); j2++) {
+
+				var val = _get(_get(first, i), i2) * _get(_get(second, i2), j2);
+
+				//TODO: needs better notation than this tmpRow variable
+				var tmpRow = _get(result, i);
+				_set(tmpRow, j2, val);
+				_set(result, i, tmpRow);
+
+				//result[ i ][ j2 ] += first[i][i2] * second[i2][j2]
+			}
+		}
+	}
+
+	return result;
+}
+
+//matrix multiply
+var c = [[4], [5], [6]]; //this is a 3x1
+var d = [[1, 2, 3]]; //this is a 1x3
+
+// c x d = 3x3
+// d x c = 1x1
+
+assert matrix(c, d) == [[4,8,12],[5,10,15],[6,12,18]], "Matrix multiplication failed";
+
+print "All good";

scripts/test/dot-chaining.toy

@@ -0,0 +1,30 @@
+//test function chaining with the dot operator
+
+fn _identity(self) {
+	return self;
+}
+
+fn _check(self) {
+	assert self == 42, "dot chaining failed";
+	return self;
+}
+
+var val = 42;
+
+val
+	.identity()
+	.check()
+	.identity()
+	.check()
+	;
+
+
+//test the value is actually altered
+fn _increment(self) {
+	return self + 1;
+}
+
+assert 3.increment().increment() == 5, "dot chaining increment failed";
+
+
+print "All good";

scripts/test/functions.toy

@@ -0,0 +1,77 @@
+//test function return
+fn testFourtyTwo() {
+	return 42;
+}
+
+assert testFourtyTwo() == 42, "function returns failed";
+
+
+//test function parameters
+fn identity(x) {
+	return x;
+}
+
+assert identity("hello world") == "hello world", "identity function failed";
+
+
+//test closures
+fn make() {
+	var counter = 0;
+
+	fn count() {
+		return ++counter;
+	}
+
+	return count;
+}
+
+var tally = make();
+
+assert tally() == 1 && tally() == 2, "Closures failed";
+
+
+//test closures self-capture
+fn capture(count: int) {
+	if (count > 5) {
+		return count;
+	}
+
+	return capture(count + 1);
+}
+
+assert capture(0) == 6, "Self capture failed";
+
+
+//test expressions as arguments
+fn argFn() {
+	return 42;
+}
+
+fn outerFn(val) {
+	assert val == 42, "expression as argument failed";
+}
+
+outerFn(argFn());
+
+
+//test extra parameters
+fn extra(one, two, ...rest) {
+	assert rest == ["three", "four", "five", "six", "seven"], "rest parameters failed";
+}
+
+extra("one", "two", "three", "four", "five", "six", "seven");
+
+
+//test underscore functions
+fn _example(self, a, b, c) {
+	assert a == "a", "underscore failed (a)";
+	assert b == "b", "underscore failed (b)";
+	assert c == "c", "underscore failed (c)";
+	return self;
+}
+
+assert "hello world".example("a", "b", "c") == "hello world", "underscore call failed";
+
+
+
+print "All good";

scripts/test/imports-and-exports.toy

@@ -0,0 +1,52 @@
+//test basic import/export
+{
+	var variable: int = 42;
+	export variable as field;
+}
+
+{
+	import field as value;
+	assert value == 42, "import/export failed";
+}
+
+
+//test functions using import/export
+{
+	fn f() {
+		import field;
+
+		assert field == 42, "import in function failed";
+	}
+}
+
+
+//test importing/exporting of functions
+{
+	fn func() {
+		return 69;
+	}
+
+	export func;
+}
+
+{
+	import func;
+	assert func() == 69, "import/export of functions failed";
+}
+
+
+//test that variables retain their types with the typeof keyword
+{
+	var t: type = int;
+
+	export t;
+}
+
+{
+	import t;
+
+	assert typeof t == type, "type retention failed";
+}
+
+
+print "All good";

scripts/test/index-arrays.toy

@@ -0,0 +1,85 @@
+
+//test basic indexing
+{
+	var week = ["monday", "tuesday", "wednesday", "thursday", "friday", "saturday", "sunday"];
+
+	assert week[1] == "tuesday", "basic indexing failed (single element)";
+
+	assert week[1:1] == ["tuesday"], "basic indexing failed (single element as array)";
+
+	assert week[:] == ["monday", "tuesday", "wednesday", "thursday", "friday", "saturday", "sunday"], "basic default indexing failed (first and second)";
+	assert week[::] == ["monday", "tuesday", "wednesday", "thursday", "friday", "saturday", "sunday"], "basic default indexing failed (first, second and third)";
+}
+
+
+//test basic replacement
+{
+	var week = ["monday", "tuesday", "wednesday", "thursday", "friday", "saturday", "sunday"];
+
+	week[3:3] = "Holiday";
+
+	assert week == ["monday", "tuesday", "wednesday", "Holiday", "friday", "saturday", "sunday"], "basic replacement failed";
+}
+
+
+//test backwards
+{
+	var week = ["monday", "tuesday", "wednesday", "thursday", "friday", "saturday", "sunday"];
+
+	assert week[::-1] == ["sunday", "saturday", "friday", "thursday", "wednesday", "tuesday", "monday"], "backwards failed";
+}
+
+
+//test array weird manipulation
+{
+	var week = ["monday", "tuesday", "wednesday", "thursday", "friday", "saturday", "sunday"];
+
+	week[::-2] = ["first", "second", "third"];
+
+	assert week == ["monday", "tuesday", "third", "thursday", "second", "saturday", "first"], "array weird manipulation failed";
+}
+
+
+//test index arithmetic
+{
+	var a = [1, 2, 3];
+
+	a[1] *= 3;
+
+	assert a == [1, 6, 3], "index arithmetic failed";
+}
+
+
+//test indexing with variables
+{
+	var week = ["monday", "tuesday", "wednesday", "thursday", "friday", "saturday", "sunday"];
+
+	var first = 1;
+	var second = 2;
+	var third = -1;
+
+	assert week[first:second:third] == ["wednesday", "tuesday"], "indexing with variables failed";
+}
+
+
+//test nested indexing
+{
+	var a = [[[0]]];
+
+	a[0][0][0] = 42;
+
+	assert a[0][0] == [42], "nested indexing failed";
+}
+
+
+//test combine example
+{
+	fn combine(a, b, c) {
+		return [a, b, c];
+	}
+
+	assert combine(1, 2, 3) == [1, 2, 3], "combine example failed";
+}
+
+
+print "All good";

scripts/test/index-dictionaries.toy

@@ -0,0 +1,43 @@
+//test basic insertion
+{
+	var d = [:];
+
+	d["foo"] = "bar";
+
+	assert d == ["foo":"bar"], "basic insertion failed";
+}
+
+
+//test index arithmetic
+{
+	var d = ["one":1, "two":2, "three":3];
+
+	d["three"] *= 3;
+
+	assert d == ["one":1, "two":2, "three":9], "index arithmetic failed";
+}
+
+
+//test indexing with variables
+{
+	var d = ["one":1, "two":2, "three":3];
+
+	var first = "two";
+
+	assert d[first] == 2, "indexing with variables failed";
+}
+
+
+//test nested indexing
+{
+	var d = ["foo": ["bar": 0]];
+
+	d["foo"]["bar"] = 42;
+
+	print d;
+
+	assert d == ["foo": ["bar": 42]], "nested indexing failed";
+}
+
+
+print "All good";

scripts/test/index-strings.toy

@@ -0,0 +1,40 @@
+//test basic indexing
+var greeting: string = "hello world";
+
+assert greeting[1] == "e", "basic default index failed (first)";
+
+assert greeting[:] == "hello world", "basic default index failed (first and second)";
+
+assert greeting[::] == "hello world", "basic default index failed (first, second & third)";
+
+assert greeting[0:4] == "hello", "basic indexing failed";
+
+
+
+//test basic replacement
+greeting[0:4] = "goodnight";
+
+assert greeting == "goodnight world", "basic replacement failed";
+
+//test backwards string
+assert greeting[::-1] == "dlrow thgindoog", "backwards string failed";
+assert greeting[11:15:-1] == "dlrow", "backwards indexed string failed";
+
+
+//test string weird manipulation
+var numbers = "0123456789";
+
+numbers[::-2] = "abc";
+
+assert numbers == "01234c6b8a", "string weird manipulation failed";
+
+
+//test indexing with variables
+var first = 11;
+var second = 15;
+var third = -1;
+
+assert greeting[first:second:third] == "dlrow", "indexing with variables failed";
+
+
+print "All good";

scripts/test/jumps-in-functions.toy

@@ -0,0 +1,87 @@
+fn sanity() {
+	//test true jump
+	if (true) {
+		assert true, "if-then failed (1)";
+	}
+	else {
+		assert false, "if-then failed (2)";
+	}
+
+
+	//test false jump
+	if (false) {
+		assert false, "if-then failed (3)";
+	}
+	else {
+		assert true, "if-then failed (4)";
+	}
+
+
+	//test while loop
+	var whileCounter = 0;
+	while (whileCounter < 10) {
+		whileCounter = whileCounter + 1;
+	}
+
+	assert whileCounter == 10, "while-loop failed";
+
+
+	//test for loop
+	var forCache = 0;
+	for (var i = 0; i < 20; i++) {
+		forCache = i;
+	}
+
+	assert forCache == 19, "for-loop failed";
+
+
+	//test break - while
+	var breakWhileCache = 0;
+	while(true) {
+		breakWhileCache = breakWhileCache + 1;
+
+		if (breakWhileCache >= 7) {
+			break;
+		}
+	}
+
+	assert breakWhileCache == 7, "break-while failed";
+
+
+	//test continue - while
+	var continueWhileCache = 0;
+	while (continueWhileCache < 10) {
+		continueWhileCache = continueWhileCache + 1;
+
+		if (continueWhileCache >= 7) {
+			continue;
+		}
+
+		assert continueWhileCache < 7, "continue-while failed";
+	}
+
+
+	//test break - for
+	for (var i = 0; i < 10; i++) {
+		if (i >= 7) {
+			break;
+		}
+
+		assert i < 7, "break-for failed";
+	}
+
+
+	//test break - continue
+	for (var i = 0; i < 10; i++) {
+		if (i >= 7) {
+			continue;
+		}
+
+		assert i < 7, "continue-for failed";
+	}
+
+	print "All good";
+}
+
+//invoke the test
+sanity();

scripts/test/jumps.toy

@@ -0,0 +1,82 @@
+//test true jump
+if (true) {
+	assert true, "if-then failed (1)";
+}
+else {
+	assert false, "if-then failed (2)";
+}
+
+
+//test false jump
+if (false) {
+	assert false, "if-then failed (3)";
+}
+else {
+	assert true, "if-then failed (4)";
+}
+
+
+//test while loop
+var whileCounter = 0;
+while (whileCounter < 10) {
+	whileCounter = whileCounter + 1;
+}
+
+assert whileCounter == 10, "while-loop failed";
+
+
+//test for loop
+var forCache = 0;
+for (var i = 0; i < 20; i++) {
+	forCache = i;
+}
+
+assert forCache == 19, "for-loop failed";
+
+
+//test break - while
+var breakWhileCache = 0;
+while(true) {
+	breakWhileCache = breakWhileCache + 1;
+
+	if (breakWhileCache >= 7) {
+		break;
+	}
+}
+
+assert breakWhileCache == 7, "break-while failed";
+
+
+//test continue - while
+var continueWhileCache = 0;
+while (continueWhileCache < 10) {
+	continueWhileCache = continueWhileCache + 1;
+
+	if (continueWhileCache >= 7) {
+		continue;
+	}
+
+	assert continueWhileCache < 7, "continue-while failed";
+}
+
+
+//test break - for
+for (var i = 0; i < 10; i++) {
+	if (i >= 7) {
+		break;
+	}
+
+	assert i < 7, "break-for failed";
+}
+
+
+//test break - continue
+for (var i = 0; i < 10; i++) {
+	if (i >= 7) {
+		continue;
+	}
+
+	assert i < 7, "continue-for failed";
+}
+
+print "All good";

scripts/test/lib/interactions.toy

@@ -0,0 +1,50 @@
+//test the standard library, under a number of different circumstances
+
+//test basic import
+{
+	import standard;
+
+	//this depends on external factors, so only check the length
+	assert clock().length() == 24, "import library failed";
+}
+
+
+//test import within a function
+{
+	fn f() {
+		import standard;
+
+		assert clock != null, "import library within function failed";
+
+		return clock;
+	}
+
+	//invoke
+	assert f()().length() == 24, "import library within function and return failed";
+}
+
+
+//test closing over standard library element
+{
+	import standard;
+
+	fn f() {
+		assert clock != null, "import library outside function failed";
+
+		return clock;
+	}
+
+	//invoke
+	assert f()().length() == 24, "import library outside function and return failed";
+}
+
+
+//test importing as an alias
+{
+	import standard as std;
+
+	assert std["clock"]().length() == 24, "import library as alias failed";
+}
+
+
+print "All good";

scripts/test/lib/standard.toy

@@ -0,0 +1,10 @@
+//test the standard library
+{
+	import standard;
+
+	//this depends on external factors, so only check the length
+	assert clock().length() == 24, "clock() import failed";
+}
+
+
+print "All good";

scripts/test/logicals.toy

@@ -0,0 +1,6 @@
+assert true && true, "boolean and failed";
+assert true || true, "boolean or failed";
+
+assert false || true && true, "boolen precedence failed";
+
+print "All good";

scripts/test/long-array.toy

@@ -0,0 +1,339 @@
+var arr: [string] = [
+
+"0",
+"1",
+"2",
+"3",
+"4",
+"5",
+"6",
+"7",
+"8",
+"9",
+
+"10",
+"11",
+"12",
+"13",
+"14",
+"15",
+"16",
+"17",
+"18",
+"19",
+
+"20",
+"21",
+"22",
+"23",
+"24",
+"25",
+"26",
+"27",
+"28",
+"29",
+
+"30",
+"31",
+"32",
+"33",
+"34",
+"35",
+"36",
+"37",
+"38",
+"39",
+
+"40",
+"41",
+"42",
+"43",
+"44",
+"45",
+"46",
+"47",
+"48",
+"49",
+
+"50",
+"51",
+"52",
+"53",
+"54",
+"55",
+"56",
+"57",
+"58",
+"59",
+
+"60",
+"61",
+"62",
+"63",
+"64",
+"65",
+"66",
+"67",
+"68",
+"69",
+
+"70",
+"71",
+"72",
+"73",
+"74",
+"75",
+"76",
+"77",
+"78",
+"79",
+
+"80",
+"81",
+"82",
+"83",
+"84",
+"85",
+"86",
+"87",
+"88",
+"89",
+
+"90",
+"91",
+"92",
+"93",
+"94",
+"95",
+"96",
+"97",
+"98",
+"99",
+
+//-------------------------
+
+"100",
+"101",
+"102",
+"103",
+"104",
+"105",
+"106",
+"107",
+"108",
+"109",
+
+"110",
+"111",
+"112",
+"113",
+"114",
+"115",
+"116",
+"117",
+"118",
+"119",
+
+"120",
+"121",
+"122",
+"123",
+"124",
+"125",
+"126",
+"127",
+"128",
+"129",
+
+"130",
+"131",
+"132",
+"133",
+"134",
+"135",
+"136",
+"137",
+"138",
+"139",
+
+"140",
+"141",
+"142",
+"143",
+"144",
+"145",
+"146",
+"147",
+"148",
+"149",
+
+"150",
+"151",
+"152",
+"153",
+"154",
+"155",
+"156",
+"157",
+"158",
+"159",
+
+"160",
+"161",
+"162",
+"163",
+"164",
+"165",
+"166",
+"167",
+"168",
+"169",
+
+"170",
+"171",
+"172",
+"173",
+"174",
+"175",
+"176",
+"177",
+"178",
+"179",
+
+"180",
+"181",
+"182",
+"183",
+"184",
+"185",
+"186",
+"187",
+"188",
+"189",
+
+"190",
+"191",
+"192",
+"193",
+"194",
+"195",
+"196",
+"197",
+"198",
+"199",
+
+//-------------------------
+
+"200",
+"201",
+"202",
+"203",
+"204",
+"205",
+"206",
+"207",
+"208",
+"209",
+
+"210",
+"211",
+"212",
+"213",
+"214",
+"215",
+"216",
+"217",
+"218",
+"219",
+
+"220",
+"221",
+"222",
+"223",
+"224",
+"225",
+"226",
+"227",
+"228",
+"229",
+
+"230",
+"231",
+"232",
+"233",
+"234",
+"235",
+"236",
+"237",
+"238",
+"239",
+
+"240",
+"241",
+"242",
+"243",
+"244",
+"245",
+"246",
+"247",
+"248",
+"249",
+
+"250",
+"251",
+"252",
+"253",
+"254",
+"255",
+"256",
+"257",
+"258",
+"259",
+
+"260",
+"261",
+"262",
+"263",
+"264",
+"265",
+"266",
+"267",
+"268",
+"269",
+
+"270",
+"271",
+"272",
+"273",
+"274",
+"275",
+"276",
+"277",
+"278",
+"279",
+
+"280",
+"281",
+"282",
+"283",
+"284",
+"285",
+"286",
+"287",
+"288",
+"289",
+
+"290",
+"291",
+"292",
+"293",
+"294",
+"295",
+"296",
+"297",
+"298",
+"299"
+
+];
+
+print arr;

scripts/test/long-dictionary.toy

@@ -0,0 +1,4 @@
+//NOTE: dictionaries are NOT stored in order
+var dict: [string : string] = ["0":"0","1":"1","2":"2","3":"3","4":"4","5":"5","6":"6","7":"7","8":"8","9":"9","10":"10","11":"11","12":"12","13":"13","14":"14","15":"15","16":"16","17":"17","18":"18","19":"19","20":"20","21":"21","22":"22","23":"23","24":"24","25":"25","26":"26","27":"27","28":"28","29":"29","30":"30","31":"31","32":"32","33":"33","34":"34","35":"35","36":"36","37":"37","38":"38","39":"39","40":"40","41":"41","42":"42","43":"43","44":"44","45":"45","46":"46","47":"47","48":"48","49":"49","50":"50","51":"51","52":"52","53":"53","54":"54","55":"55","56":"56","57":"57","58":"58","59":"59","60":"60","61":"61","62":"62","63":"63","64":"64","65":"65","66":"66","67":"67","68":"68","69":"69","70":"70","71":"71","72":"72","73":"73","74":"74","75":"75","76":"76","77":"77","78":"78","79":"79","80":"80","81":"81","82":"82","83":"83","84":"84","85":"85","86":"86","87":"87","88":"88","89":"89","90":"90","91":"91","92":"92","93":"93","94":"94","95":"95","96":"96","97":"97","98":"98","99":"99","100":"100","101":"101","102":"102","103":"103","104":"104","105":"105","106":"106","107":"107","108":"108","109":"109","110":"110","111":"111","112":"112","113":"113","114":"114","115":"115","116":"116","117":"117","118":"118","119":"119","120":"120","121":"121","122":"122","123":"123","124":"124","125":"125","126":"126","127":"127","128":"128","129":"129","130":"130","131":"131","132":"132","133":"133","134":"134","135":"135","136":"136","137":"137","138":"138","139":"139","140":"140","141":"141","142":"142","143":"143","144":"144","145":"145","146":"146","147":"147","148":"148","149":"149","150":"150","151":"151","152":"152","153":"153","154":"154","155":"155","156":"156","157":"157","158":"158","159":"159","160":"160","161":"161","162":"162","163":"163","164":"164","165":"165","166":"166","167":"167","168":"168","169":"169","170":"170","171":"171","172":"172","173":"173","174":"174","175":"175","176":"176","177":"177","178":"178","179":"179","180":"180","181":"181","182":"182","183":"183","184":"184","185":"185","186":"186","187":"187","188":"188","189":"189","190":"190","191":"191","192":"192","193":"193","194":"194","195":"195","196":"196","197":"197","198":"198","199":"199","200":"200","201":"201","202":"202","203":"203","204":"204","205":"205","206":"206","207":"207","208":"208","209":"209","210":"210","211":"211","212":"212","213":"213","214":"214","215":"215","216":"216","217":"217","218":"218","219":"219","220":"220","221":"221","222":"222","223":"223","224":"224","225":"225","226":"226","227":"227","228":"228","229":"229","230":"230","231":"231","232":"232","233":"233","234":"234","235":"235","236":"236","237":"237","238":"238","239":"239","240":"240","241":"241","242":"242","243":"243","244":"244","245":"245","246":"246","247":"247","248":"248","249":"249","250":"250","251":"251","252":"252","253":"253","254":"254","255":"255","256":"256","257":"257","258":"258","259":"259","260":"260","261":"261","262":"262","263":"263","264":"264","265":"265","266":"266","267":"267","268":"268","269":"269","270":"270","271":"271","272":"272","273":"273","274":"274","275":"275","276":"276","277":"277","278":"278","279":"279","280":"280","281":"281","282":"282","283":"283","284":"284","285":"285","286":"286","287":"287","288":"288","289":"289","290":"290","291":"291","292":"292","293":"293","294":"294","295":"295","296":"296","297":"297","298":"298","299":"299"];
+
+print dict;

scripts/test/long-literals.toy

@@ -0,0 +1,335 @@
+print 0;
+print 1;
+print 2;
+print 3;
+print 4;
+print 5;
+print 6;
+print 7;
+print 8;
+print 9;
+
+print 10;
+print 11;
+print 12;
+print 13;
+print 14;
+print 15;
+print 16;
+print 17;
+print 18;
+print 19;
+
+print 20;
+print 21;
+print 22;
+print 23;
+print 24;
+print 25;
+print 26;
+print 27;
+print 28;
+print 29;
+
+print 30;
+print 31;
+print 32;
+print 33;
+print 34;
+print 35;
+print 36;
+print 37;
+print 38;
+print 39;
+
+print 40;
+print 41;
+print 42;
+print 43;
+print 44;
+print 45;
+print 46;
+print 47;
+print 48;
+print 49;
+
+print 50;
+print 51;
+print 52;
+print 53;
+print 54;
+print 55;
+print 56;
+print 57;
+print 58;
+print 59;
+
+print 60;
+print 61;
+print 62;
+print 63;
+print 64;
+print 65;
+print 66;
+print 67;
+print 68;
+print 69;
+
+print 70;
+print 71;
+print 72;
+print 73;
+print 74;
+print 75;
+print 76;
+print 77;
+print 78;
+print 79;
+
+print 80;
+print 81;
+print 82;
+print 83;
+print 84;
+print 85;
+print 86;
+print 87;
+print 88;
+print 89;
+
+print 90;
+print 91;
+print 92;
+print 93;
+print 94;
+print 95;
+print 96;
+print 97;
+print 98;
+print 99;
+
+//-------------------------
+
+print 100;
+print 101;
+print 102;
+print 103;
+print 104;
+print 105;
+print 106;
+print 107;
+print 108;
+print 109;
+
+print 110;
+print 111;
+print 112;
+print 113;
+print 114;
+print 115;
+print 116;
+print 117;
+print 118;
+print 119;
+
+print 120;
+print 121;
+print 122;
+print 123;
+print 124;
+print 125;
+print 126;
+print 127;
+print 128;
+print 129;
+
+print 130;
+print 131;
+print 132;
+print 133;
+print 134;
+print 135;
+print 136;
+print 137;
+print 138;
+print 139;
+
+print 140;
+print 141;
+print 142;
+print 143;
+print 144;
+print 145;
+print 146;
+print 147;
+print 148;
+print 149;
+
+print 150;
+print 151;
+print 152;
+print 153;
+print 154;
+print 155;
+print 156;
+print 157;
+print 158;
+print 159;
+
+print 160;
+print 161;
+print 162;
+print 163;
+print 164;
+print 165;
+print 166;
+print 167;
+print 168;
+print 169;
+
+print 170;
+print 171;
+print 172;
+print 173;
+print 174;
+print 175;
+print 176;
+print 177;
+print 178;
+print 179;
+
+print 180;
+print 181;
+print 182;
+print 183;
+print 184;
+print 185;
+print 186;
+print 187;
+print 188;
+print 189;
+
+print 190;
+print 191;
+print 192;
+print 193;
+print 194;
+print 195;
+print 196;
+print 197;
+print 198;
+print 199;
+
+//-------------------------
+
+print 200;
+print 201;
+print 202;
+print 203;
+print 204;
+print 205;
+print 206;
+print 207;
+print 208;
+print 209;
+
+print 210;
+print 211;
+print 212;
+print 213;
+print 214;
+print 215;
+print 216;
+print 217;
+print 218;
+print 219;
+
+print 220;
+print 221;
+print 222;
+print 223;
+print 224;
+print 225;
+print 226;
+print 227;
+print 228;
+print 229;
+
+print 230;
+print 231;
+print 232;
+print 233;
+print 234;
+print 235;
+print 236;
+print 237;
+print 238;
+print 239;
+
+print 240;
+print 241;
+print 242;
+print 243;
+print 244;
+print 245;
+print 246;
+print 247;
+print 248;
+print 249;
+
+print 250;
+print 251;
+print 252;
+print 253;
+print 254;
+print 255;
+print 256;
+print 257;
+print 258;
+print 259;
+
+print 260;
+print 261;
+print 262;
+print 263;
+print 264;
+print 265;
+print 266;
+print 267;
+print 268;
+print 269;
+
+print 270;
+print 271;
+print 272;
+print 273;
+print 274;
+print 275;
+print 276;
+print 277;
+print 278;
+print 279;
+
+print 280;
+print 281;
+print 282;
+print 283;
+print 284;
+print 285;
+print 286;
+print 287;
+print 288;
+print 289;
+
+print 290;
+print 291;
+print 292;
+print 293;
+print 294;
+print 295;
+print 296;
+print 297;
+print 298;
+print 299;
+
+//-------------------------

scripts/test/native-functions.toy

@@ -0,0 +1,91 @@
+
+{
+	//test arrays without types
+	var array = [];
+
+	assert _length(array) == 0, "_length failed with array";
+
+	_push(array, 1);
+	_push(array, 2);
+	_push(array, 3);
+	_push(array, 4);
+	_push(array, "foo");
+
+	assert _length(array) == 5, "_push failed with array";
+	assert _pop(array) == "foo", "_pop failed with array";
+
+	_set(array, 2, "bar");
+	assert array == [1, 2, "bar", 4], "_set failed with array";
+	assert _get(array, 3) == 4, "_get failed with array";
+
+
+	//test dictionaries without types
+	var dict = [:];
+
+	_set(dict, "key", "value");
+	_set(dict, 1, 2);
+
+	assert dict == ["key":"value", 1:2], "_set failed with dictionaries";
+	assert _get(dict, "key") == "value", "_get failed with dictionaries";
+
+
+	//test _length
+	assert _length(array) == 4 && _length(dict) == 2, "_length failed with array or dictionaries";
+
+
+	//test clear
+	_clear(array);
+	_clear(dict);
+
+	assert _length(array) == 0 && _length(dict) == 0, "_clear failed with array or dictionaries";
+}
+
+
+{
+	//test arrays with types
+	var array: [int] = [];
+
+	assert _length(array) == 0, "_length failed with array (+ types)";
+
+	_push(array, 1);
+	_push(array, 2);
+	_push(array, 3);
+	_push(array, 4);
+	_push(array, 10);
+
+	assert _length(array) == 5, "_push or failed with array (+ types)";
+	assert _pop(array) == 10, "_pop failed with array (+ types)";
+
+	_set(array, 2, 70);
+	assert array == [1, 2, 70, 4], "_set failed with array (+ types)";
+	assert _get(array, 3) == 4, "_get failed with array (+ types)";
+
+
+	//test dictionaries with types
+	var dict: [string : string] = [:];
+
+	_set(dict, "key", "value");
+
+	assert dict == ["key":"value"], "_set failed with dictionaries (+ types)";
+	assert _get(dict, "key") == "value", "_get failed with dictionaries (+ types)";
+
+
+	//test length with types
+	assert _length(array) == 4 && _length(dict) == 1, "_length failed with array or dictionaries (+ types)";
+
+
+	//test clear with types
+	_clear(array);
+	_clear(dict);
+
+	assert _length(array) == 0 && _length(dict) == 0, "_clear failed with array or dictionaries (+ types)";
+}
+
+{
+	var str = "hello world";
+
+	assert _length(str) == 11, "_length failed with string";
+}
+
+
+print "All good";

scripts/test/opaque-data-type.toy

@@ -0,0 +1,5 @@
+//test the opaque data type works
+
+var o: opaque = produce();
+
+consume(o);

scripts/test/panic-within-functions.toy

@@ -0,0 +1,8 @@
+
+
+fn panic() {
+	assert false, "This should only be seen once";
+}
+
+panic();
+panic();

scripts/test/separate-exports.toy

@@ -0,0 +1,11 @@
+//test exports
+var field: int = 42;
+
+fn function() {
+	return 69;
+}
+
+export field;
+export function;
+
+print "All good";

scripts/test/separate-imports.toy

@@ -0,0 +1,10 @@
+//test imports
+import field;
+//import function;
+
+//assert field == 42, "import field failed";
+
+//assert function() == 69, "import function failed";
+
+print "All good";
+

scripts/test/types.toy

@@ -0,0 +1,25 @@
+//basic types
+var t: type = int;
+var u: t = 42;
+
+assert t == int, "types are not first class";
+assert u == 42, "first-class types are screwing with values";
+
+
+//differentiate by the "type" value
+var v: type = astype [int];
+var w = [int];
+var x = v;
+
+assert w == [int], "defining an array of types failed";
+assert x == astype [int], "re-assigning a type value failed";
+
+//complex type
+var complex: type = astype [string : [int]];
+var dict: complex = [
+	"first array": [1, 2, 3],
+	"second array": [4, 5, 6],
+	"third array": [7, 8, 9]
+];
+
+print "All good";

source/ast_node.c

@@ -0,0 +1,294 @@
+#include "ast_node.h"
+
+#include "memory.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+
+void freeNodeCustom(ASTNode* node, bool freeSelf) {
+	//don't free a NULL node
+	if (node == NULL) {
+		return;
+	}
+
+	switch(node->type) {
+		case AST_NODEERROR:
+			//NO-OP
+		break;
+
+		case AST_NODELITERAL:
+			freeLiteral(node->atomic.literal);
+		break;
+
+		case AST_NODEUNARY:
+			freeNode(node->unary.child);
+		break;
+
+		case AST_NODEBINARY:
+			freeNode(node->binary.left);
+			freeNode(node->binary.right);
+		break;
+
+		case AST_NODEGROUPING:
+			freeNode(node->grouping.child);
+		break;
+
+		case AST_NODEBLOCK:
+			for (int i = 0; i < node->block.count; i++) {
+				freeNodeCustom(node->block.nodes + i, false);
+			}
+			FREE_ARRAY(ASTNode, node->block.nodes, node->block.capacity);
+		break;
+
+		case AST_NODECOMPOUND:
+			for (int i = 0; i < node->compound.count; i++) {
+				freeNodeCustom(node->compound.nodes + i, false);
+			}
+			FREE_ARRAY(ASTNode, node->compound.nodes, node->compound.capacity);
+		break;
+
+		case AST_NODEPAIR:
+			freeNode(node->pair.left);
+			freeNode(node->pair.right);
+		break;
+
+		case AST_NODEVAR_DECL:
+			freeLiteral(node->varDecl.identifier);
+			freeLiteral(node->varDecl.typeLiteral);
+			freeNode(node->varDecl.expression);
+		break;
+
+		case AST_NODEFN_DECL:
+			freeLiteral(node->fnDecl.identifier);
+			freeNode(node->fnDecl.arguments);
+			freeNode(node->fnDecl.returns);
+			freeNode(node->fnDecl.block);
+		break;
+
+		case AST_NODEFN_COLLECTION:
+			for (int i = 0; i < node->fnCollection.count; i++) {
+				freeNodeCustom(node->fnCollection.nodes + i, false);
+			}
+			FREE_ARRAY(ASTNode, node->fnCollection.nodes, node->fnCollection.capacity);
+		break;
+
+		case AST_NODEFN_CALL:
+			freeNode(node->fnCall.arguments);
+		break;
+
+		case AST_NODEPATH_IF:
+		case AST_NODEPATH_WHILE:
+		case AST_NODEPATH_FOR:
+		case AST_NODEPATH_BREAK:
+		case AST_NODEPATH_CONTINUE:
+		case AST_NODEPATH_RETURN:
+			freeNode(node->path.preClause);
+			freeNode(node->path.postClause);
+			freeNode(node->path.condition);
+			freeNode(node->path.thenPath);
+			freeNode(node->path.elsePath);
+		break;
+
+		case AST_NODEINCREMENT_PREFIX:
+		case AST_NODEINCREMENT_POSTFIX:
+			freeLiteral(node->increment.identifier);
+		break;
+
+		case AST_NODEIMPORT:
+		case AST_NODEEXPORT:
+			freeLiteral(node->import.identifier);
+			freeLiteral(node->import.alias);
+		break;
+
+		case AST_NODEINDEX:
+		case AST_NODEDOT:
+			freeNode(node->index.first);
+			freeNode(node->index.second);
+			freeNode(node->index.third);
+		break;
+	}
+
+	if (freeSelf) {
+		FREE(ASTNode, node);
+	}
+}
+
+void freeNode(ASTNode* node) {
+	freeNodeCustom(node, true);
+}
+
+void emitASTNodeLiteral(ASTNode** nodeHandle, Literal literal) {
+	//allocate a new node
+	*nodeHandle = ALLOCATE(ASTNode, 1);
+
+	(*nodeHandle)->type = AST_NODELITERAL;
+	(*nodeHandle)->atomic.literal = copyLiteral(literal);
+}
+
+void emitASTNodeUnary(ASTNode** nodeHandle, Opcode opcode, ASTNode* child) {
+	//allocate a new node
+	*nodeHandle = ALLOCATE(ASTNode, 1);
+
+	(*nodeHandle)->type = AST_NODEUNARY;
+	(*nodeHandle)->unary.opcode = opcode;
+	(*nodeHandle)->unary.child = child;
+}
+
+void emitASTNodeBinary(ASTNode** nodeHandle, ASTNode* rhs, Opcode opcode) {
+	ASTNode* tmp = ALLOCATE(ASTNode, 1);
+
+	tmp->type = AST_NODEBINARY;
+	tmp->binary.opcode = opcode;
+	tmp->binary.left = *nodeHandle;
+	tmp->binary.right = rhs;
+
+	*nodeHandle = tmp;
+}
+
+void emitASTNodeGrouping(ASTNode** nodeHandle) {
+	ASTNode* tmp = ALLOCATE(ASTNode, 1);
+
+	tmp->type = AST_NODEGROUPING;
+	tmp->grouping.child = *nodeHandle;
+
+	*nodeHandle = tmp;
+}
+
+void emitASTNodeBlock(ASTNode** nodeHandle) {
+	ASTNode* tmp = ALLOCATE(ASTNode, 1);
+
+	tmp->type = AST_NODEBLOCK;
+	tmp->block.nodes = NULL;
+	tmp->block.capacity = 0;
+	tmp->block.count = 0;
+
+	*nodeHandle = tmp;
+}
+
+void emitASTNodeCompound(ASTNode** nodeHandle, LiteralType literalType) {
+	ASTNode* tmp = ALLOCATE(ASTNode, 1);
+
+	tmp->type = AST_NODECOMPOUND;
+	tmp->compound.literalType = literalType;
+	tmp->compound.nodes = NULL;
+	tmp->compound.capacity = 0;
+	tmp->compound.count = 0;
+
+	*nodeHandle = tmp;
+}
+
+void setASTNodePair(ASTNode* node, ASTNode* left, ASTNode* right) {
+	//assume the node has already been allocated
+	node->type = AST_NODEPAIR;
+	node->pair.left = left;
+	node->pair.right = right;
+}
+
+void emitASTNodeVarDecl(ASTNode** nodeHandle, Literal identifier, Literal typeLiteral, ASTNode* expression) {
+	ASTNode* tmp = ALLOCATE(ASTNode, 1);
+
+	tmp->type = AST_NODEVAR_DECL;
+	tmp->varDecl.identifier = identifier;
+	tmp->varDecl.typeLiteral = typeLiteral;
+	tmp->varDecl.expression = expression;
+
+	*nodeHandle = tmp;
+}
+
+void emitASTNodeFnDecl(ASTNode** nodeHandle, Literal identifier, ASTNode* arguments, ASTNode* returns, ASTNode* block) {
+	ASTNode* tmp = ALLOCATE(ASTNode, 1);
+
+	tmp->type = AST_NODEFN_DECL;
+	tmp->fnDecl.identifier = identifier;
+	tmp->fnDecl.arguments = arguments;
+	tmp->fnDecl.returns = returns;
+	tmp->fnDecl.block = block;
+
+	*nodeHandle = tmp;
+}
+
+void emitASTFnCall(ASTNode** nodeHandle, ASTNode* arguments, int argumentCount) {
+	ASTNode* tmp = ALLOCATE(ASTNode, 1);
+
+	tmp->type = AST_NODEFN_CALL;
+	tmp->fnCall.arguments = arguments;
+	tmp->fnCall.argumentCount = argumentCount;
+
+	*nodeHandle = tmp;
+}
+
+void emitASTNodeFnCollection(ASTNode** nodeHandle) { //a collection of nodes, intended for use with functions
+	ASTNode* tmp = ALLOCATE(ASTNode, 1);
+
+	tmp->type = AST_NODEFN_COLLECTION;
+	tmp->fnCollection.nodes = NULL;
+	tmp->fnCollection.capacity = 0;
+	tmp->fnCollection.count = 0;
+
+	*nodeHandle = tmp;
+}
+
+void emitASTNodePath(ASTNode** nodeHandle, ASTNodeType type, ASTNode* preClause, ASTNode* postClause, ASTNode* condition, ASTNode* thenPath, ASTNode* elsePath) {
+	ASTNode* tmp = ALLOCATE(ASTNode, 1);
+
+	tmp->type = type;
+	tmp->path.preClause = preClause;
+	tmp->path.postClause = postClause;
+	tmp->path.condition = condition;
+	tmp->path.thenPath = thenPath;
+	tmp->path.elsePath = elsePath;
+
+	*nodeHandle = tmp;
+}
+
+void emitASTNodePrefixIncrement(ASTNode** nodeHandle, Literal identifier, int increment) {
+	ASTNode* tmp = ALLOCATE(ASTNode, 1);
+
+	tmp->type = AST_NODEINCREMENT_PREFIX;
+	tmp->increment.identifier = copyLiteral(identifier);
+	tmp->increment.increment = increment;
+
+	*nodeHandle = tmp;
+}
+
+void emitASTNodePostfixIncrement(ASTNode** nodeHandle, Literal identifier, int increment) {
+	ASTNode* tmp = ALLOCATE(ASTNode, 1);
+
+	tmp->type = AST_NODEINCREMENT_POSTFIX;
+	tmp->increment.identifier = copyLiteral(identifier);
+	tmp->increment.increment = increment;
+
+	*nodeHandle = tmp;
+}
+
+void emitASTNodeImport(ASTNode** nodeHandle, ASTNodeType mode, Literal identifier, Literal alias) {
+	ASTNode* tmp = ALLOCATE(ASTNode, 1);
+
+	tmp->type = mode;
+	tmp->import.identifier = copyLiteral(identifier);
+	tmp->import.alias = copyLiteral(alias);
+
+	*nodeHandle = tmp;
+}
+
+void emitASTNodeIndex(ASTNode** nodeHandle, ASTNode* first, ASTNode* second, ASTNode* third) {
+	ASTNode* tmp = ALLOCATE(ASTNode, 1);
+
+	tmp->type = AST_NODEINDEX;
+	tmp->index.first = first;
+	tmp->index.second = second;
+	tmp->index.third = third;
+
+	*nodeHandle = tmp;
+}
+
+void emitASTNodeDot(ASTNode** nodeHandle, ASTNode* first) {
+	ASTNode* tmp = ALLOCATE(ASTNode, 1);
+
+	tmp->type = AST_NODEDOT;
+	tmp->index.first = first;
+	tmp->index.second = NULL;
+	tmp->index.third = NULL;
+
+	*nodeHandle = tmp;
+}

source/ast_node.h

@@ -0,0 +1,175 @@
+#pragma once
+
+#include "common.h"
+#include "literal.h"
+#include "opcodes.h"
+#include "token_types.h"
+
+//nodes are the intermediaries between parsers and compilers
+typedef union _node ASTNode;
+
+typedef enum ASTNodeType {
+	AST_NODEERROR,
+	AST_NODELITERAL, //a simple value
+	AST_NODEUNARY, //one child + opcode
+	AST_NODEBINARY, //two children, left and right + opcode
+	AST_NODEGROUPING, //one child
+	AST_NODEBLOCK, //contains a sub-node array
+	AST_NODECOMPOUND, //contains a sub-node array
+	AST_NODEPAIR, //contains a left and right
+	AST_NODEVAR_DECL, //contains identifier literal, typenode, expression definition
+	AST_NODEFN_DECL, //containd identifier literal, arguments node, returns node, block node
+	AST_NODEFN_COLLECTION, //parts of a function
+	AST_NODEFN_CALL,
+	AST_NODEPATH_IF, //for control flow
+	AST_NODEPATH_WHILE, //for control flow
+	AST_NODEPATH_FOR, //for control flow
+	AST_NODEPATH_BREAK, //for control flow
+	AST_NODEPATH_CONTINUE, //for control flow
+	AST_NODEPATH_RETURN,
+	AST_NODEINCREMENT_PREFIX,
+	AST_NODEINCREMENT_POSTFIX,
+	AST_NODEIMPORT,
+	AST_NODEEXPORT,
+	AST_NODEINDEX,
+	AST_NODEDOT,
+} ASTNodeType;
+
+typedef struct NodeLiteral {
+	ASTNodeType type;
+	Literal literal;
+} NodeLiteral;
+
+typedef struct NodeUnary {
+	ASTNodeType type;
+	Opcode opcode;
+	ASTNode* child;
+} NodeUnary;
+
+typedef struct NodeBinary {
+	ASTNodeType type;
+	Opcode opcode;
+	ASTNode* left;
+	ASTNode* right;
+} NodeBinary;
+
+typedef struct NodeGrouping {
+	ASTNodeType type;
+	ASTNode* child;
+} NodeGrouping;
+
+typedef struct NodeBlock {
+	ASTNodeType type;
+	ASTNode* nodes;
+	int capacity;
+	int count;
+} NodeBlock;
+
+typedef struct NodeCompound {
+	ASTNodeType type;
+	LiteralType literalType;
+	ASTNode* nodes;
+	int capacity;
+	int count;
+} NodeCompound;
+
+typedef struct NodePair {
+	ASTNodeType type;
+	ASTNode* left;
+	ASTNode* right;
+} NodePair;
+
+typedef struct NodeVarDecl {
+	ASTNodeType type;
+	Literal identifier;
+	Literal typeLiteral;
+	ASTNode* expression;
+} NodeVarDecl;
+
+typedef struct NodeFnDecl {
+	ASTNodeType type;
+	Literal identifier;
+	ASTNode* arguments;
+	ASTNode* returns;
+	ASTNode* block;
+} NodeFnDecl;
+
+typedef struct NodeFnCollection {
+	ASTNodeType type;
+	ASTNode* nodes;
+	int capacity;
+	int count;
+} NodeFnCollection;
+
+typedef struct NodeFnCall {
+	ASTNodeType type;
+	ASTNode* arguments;
+	int argumentCount;
+} NodeFnCall;
+
+typedef struct NodePath {
+	ASTNodeType type;
+	ASTNode* preClause;
+	ASTNode* postClause;
+	ASTNode* condition;
+	ASTNode* thenPath;
+	ASTNode* elsePath;
+} NodePath;
+
+typedef struct NodeIncrement {
+	ASTNodeType type;
+	Literal identifier;
+	int increment;
+} NodeIncrement;
+
+typedef struct NodeImport {
+	ASTNodeType type;
+	Literal identifier;
+	Literal alias;
+} NodeImport;
+
+typedef struct NodeIndex {
+	ASTNodeType type;
+	ASTNode* first;
+	ASTNode* second;
+	ASTNode* third;
+} NodeIndex;
+
+union _node {
+	ASTNodeType type;
+	NodeLiteral atomic;
+	NodeUnary unary;
+	NodeBinary binary;
+	NodeGrouping grouping;
+	NodeBlock block;
+	NodeCompound compound;
+	NodePair pair;
+	NodeVarDecl varDecl;
+	NodeFnDecl fnDecl;
+	NodeFnCollection fnCollection;
+	NodeFnCall fnCall;
+	NodePath path;
+	NodeIncrement increment;
+	NodeImport import;
+	NodeIndex index;
+};
+
+TOY_API void freeNode(ASTNode* node);
+
+void emitASTNodeLiteral(ASTNode** nodeHandle, Literal literal);
+void emitASTNodeUnary(ASTNode** nodeHandle, Opcode opcode, ASTNode* child);
+void emitASTNodeBinary(ASTNode** nodeHandle, ASTNode* rhs, Opcode opcode); //handled node becomes lhs
+void emitASTNodeGrouping(ASTNode** nodeHandle);
+void emitASTNodeBlock(ASTNode** nodeHandle);
+void emitASTNodeCompound(ASTNode** nodeHandle, LiteralType literalType);
+void setASTNodePair(ASTNode* node, ASTNode* left, ASTNode* right);
+void emitASTNodeVarDecl(ASTNode** nodeHandle, Literal identifier, Literal type, ASTNode* expression);
+void emitASTNodeFnDecl(ASTNode** nodeHandle, Literal identifier, ASTNode* arguments, ASTNode* returns, ASTNode* block);
+void emitASTFnCall(ASTNode** nodeHandle, ASTNode* arguments, int argumentCount);
+void emitASTNodeFnCollection(ASTNode** nodeHandle);
+void emitASTNodePath(ASTNode** nodeHandle, ASTNodeType type, ASTNode* preClause, ASTNode* postClause, ASTNode* condition, ASTNode* thenPath, ASTNode* elsePath);
+void emitASTNodePrefixIncrement(ASTNode** nodeHandle, Literal identifier, int increment);
+void emitASTNodePostfixIncrement(ASTNode** nodeHandle, Literal identifier, int increment);
+void emitASTNodeImport(ASTNode** nodeHandle, ASTNodeType mode, Literal identifier, Literal alias);
+void emitASTNodeIndex(ASTNode** nodeHandle, ASTNode* first, ASTNode* second, ASTNode* third);
+void emitASTNodeDot(ASTNode** nodeHandle, ASTNode* first);

source/builtin.h

@@ -0,0 +1,11 @@
+#pragma once
+
+#include "interpreter.h"
+
+int _index(Interpreter* interpreter, LiteralArray* arguments);
+int _set(Interpreter* interpreter, LiteralArray* arguments);
+int _get(Interpreter* interpreter, LiteralArray* arguments);
+int _push(Interpreter* interpreter, LiteralArray* arguments);
+int _pop(Interpreter* interpreter, LiteralArray* arguments);
+int _length(Interpreter* interpreter, LiteralArray* arguments);
+int _clear(Interpreter* interpreter, LiteralArray* arguments);

source/common.c

@@ -0,0 +1,125 @@
+#include "common.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <assert.h>
+
+//test variable sizes based on platform
+#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);
+
+#ifndef TOY_EXPORT
+
+//declare the singleton
+Command command;
+
+void initCommand(int argc, const char* argv[]) {
+	//default values
+	command.error = false;
+	command.help = false;
+	command.version = false;
+	command.binaryfile = NULL;
+	command.sourcefile = NULL;
+	command.compilefile = NULL;
+	command.outfile = "out.tb";
+	command.source = NULL;
+	command.verbose = false;
+
+	for (int i = 1; i < argc; i++) { //start at 1 to skip the program name
+		command.error = true; //error state by default, set to false by successful flags
+
+		if (!strcmp(argv[i], "-h") || !strcmp(argv[i], "--help")) {
+			command.help = true;
+			command.error = false;
+			continue;
+		}
+
+		if (!strcmp(argv[i], "-v") || !strcmp(argv[i], "--version")) {
+			command.version = true;
+			command.error = false;
+			continue;
+		}
+
+		if (!strcmp(argv[i], "-d") || !strcmp(argv[i], "--debug")) {
+			command.verbose = true;
+			command.error = false;
+			continue;
+		}
+
+		if ((!strcmp(argv[i], "-f") || !strcmp(argv[i], "--sourcefile")) && i + 1 < argc) {
+			command.sourcefile = (char*)argv[i + 1];
+			i++;
+			command.error = false;
+			continue;
+		}
+
+		if ((!strcmp(argv[i], "-i") || !strcmp(argv[i], "--input")) && i + 1 < argc) {
+			command.source = (char*)argv[i + 1];
+			i++;
+			command.error = false;
+			continue;
+		}
+
+		if ((!strcmp(argv[i], "-c") || !strcmp(argv[i], "--compile")) && i + 1 < argc) {
+			command.compilefile = (char*)argv[i + 1];
+			i++;
+			command.error = false;
+			continue;
+		}
+
+		if ((!strcmp(argv[i], "-o") || !strcmp(argv[i], "--output")) && i + 1 < argc) {
+			command.outfile = (char*)argv[i + 1];
+			i++;
+			command.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) {
+				command.binaryfile = (char*)argv[i];
+				command.error = false;
+				continue;
+			}
+		}
+
+		//don't keep reading in an error state
+		return;
+	}
+}
+
+void usageCommand(int argc, const char* argv[]) {
+	printf("Usage: %s [<file.tb> | -h | -v | [-d][-f file | -i source | -c file [-o outfile]]]\n\n", argv[0]);
+}
+
+void helpCommand(int argc, const char* argv[]) {
+	usageCommand(argc, argv);
+
+	printf("<file.tb>\t\t\tBinary input file in tb format, must be version %d.%d.%d.\n\n", TOY_VERSION_MAJOR, TOY_VERSION_MINOR, TOY_VERSION_PATCH);
+	printf("-h\t| --help\t\tShow this help then exit.\n\n");
+	printf("-v\t| --version\t\tShow version and copyright information then exit.\n\n");
+	printf("-d\t| --debug\t\tBe verbose when operating.\n\n");
+	printf("-f\t| --file filename\tParse, compile and execute the source file.\n\n");
+	printf("-i\t| --input source\tParse, compile and execute this given string of source code.\n\n");
+	printf("-c\t| --compile filename\tParse and compile the specified source file into an output file.\n\n");
+	printf("-o\t| --output outfile\tName of the output file built with --compile (default: out.tb).\n\n");
+}
+
+void copyrightCommand(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-2022 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");
+}
+
+#endif

source/common.h

@@ -0,0 +1,43 @@
+#pragma once
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#define TOY_VERSION_MAJOR 0
+#define TOY_VERSION_MINOR 6
+#define TOY_VERSION_PATCH 0
+#define TOY_VERSION_BUILD __DATE__ " " __TIME__
+
+//platform exports/imports
+#if defined(__linux__)
+#define TOY_API extern
+#else
+#define TOY_API
+#endif
+
+#ifndef TOY_EXPORT
+//for processing the command line arguments
+typedef struct {
+	bool error;
+	bool help;
+	bool version;
+	char* binaryfile;
+	char* sourcefile;
+	char* compilefile;
+	char* outfile; //defaults to out.tb
+	char* source;
+	bool verbose;
+} Command;
+
+extern Command command;
+
+void initCommand(int argc, const char* argv[]);
+
+void usageCommand(int argc, const char* argv[]);
+void helpCommand(int argc, const char* argv[]);
+void copyrightCommand(int argc, const char* argv[]);
+#endif
+
+//NOTE: assigning to a byte from a short loses data
+#define AS_USHORT(value) (*(unsigned short*)(&(value)))

source/compiler.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "common.h"
+#include "opcodes.h"
+#include "ast_node.h"
+#include "literal_array.h"
+
+//the compiler takes the nodes, and turns them into sequential chunks of bytecode, saving literals to an external array
+typedef struct Compiler {
+	LiteralArray literalCache;
+	unsigned char* bytecode;
+	int capacity;
+	int count;
+} Compiler;
+
+TOY_API void initCompiler(Compiler* compiler);
+TOY_API void writeCompiler(Compiler* compiler, ASTNode* node);
+TOY_API void freeCompiler(Compiler* compiler);
+
+//embed the header, data section, code section, function section, etc.
+TOY_API unsigned char* collateCompiler(Compiler* compiler, int* size);

source/console_colors.h

@@ -0,0 +1,30 @@
+#pragma once
+
+//NOTE: you need both font AND background for these to work
+
+//fonts color
+#define FONT_BLACK      "\033[30;"
+#define FONT_RED        "\033[31;"
+#define FONT_GREEN      "\033[32;"
+#define FONT_YELLOW     "\033[33;"
+#define FONT_BLUE       "\033[34;"
+#define FONT_PURPLE     "\033[35;"
+#define FONT_DGREEN     "\033[6;"
+#define FONT_WHITE      "\033[7;"
+#define FONT_CYAN       "\x1b[36m"
+
+//background color
+#define BACK_BLACK      "40m"
+#define BACK_RED        "41m"
+#define BACK_GREEN      "42m"
+#define BACK_YELLOW     "43m"
+#define BACK_BLUE       "44m"
+#define BACK_PURPLE     "45m"
+#define BACK_DGREEN     "46m"
+#define BACK_WHITE      "47m"
+
+//useful
+#define NOTICE FONT_GREEN BACK_BLACK
+#define WARN FONT_YELLOW BACK_BLACK   
+#define ERROR FONT_RED BACK_BLACK   
+#define RESET "\033[0m"

source/interpreter.h

@@ -0,0 +1,57 @@
+#pragma once
+
+#include "common.h"
+#include "literal.h"
+#include "literal_array.h"
+#include "literal_dictionary.h"
+#include "scope.h"
+
+typedef void (*PrintFn)(const char*);
+
+//the interpreter acts depending on the bytecode instructions
+typedef struct Interpreter {
+	//input
+	unsigned char* bytecode;
+	int length;
+	int count;
+	int codeStart; //BUGFIX: for jumps, must be initialized to -1
+	LiteralArray literalCache; //read-only - built from the bytecode, refreshed each time new bytecode is provided
+
+	//operation
+	Scope* scope;
+	LiteralArray stack;
+
+	LiteralDictionary* exports; //read-write - interface with Toy from C - this is a pointer, since it works at a script-level
+	LiteralDictionary* exportTypes;
+	LiteralDictionary* hooks;
+
+	//debug outputs
+	PrintFn printOutput;
+	PrintFn assertOutput;
+	PrintFn errorOutput;
+
+	int depth; //don't overflow
+	bool panic;
+} Interpreter;
+
+//native API
+typedef int (*NativeFn)(Interpreter* interpreter, LiteralArray* arguments);
+TOY_API bool injectNativeFn(Interpreter* interpreter, char* name, NativeFn func);
+
+typedef int (*HookFn)(Interpreter* interpreter, Literal identifier, Literal alias);
+TOY_API bool injectNativeHook(Interpreter* interpreter, char* name, HookFn hook);
+
+TOY_API bool callLiteralFn(Interpreter* interpreter, Literal func, LiteralArray* arguments, LiteralArray* returns);
+TOY_API bool callFn(Interpreter* interpreter, char* name, LiteralArray* arguments, LiteralArray* returns);
+
+//utilities for the host program
+TOY_API bool parseIdentifierToValue(Interpreter* interpreter, Literal* literalPtr);
+TOY_API void setInterpreterPrint(Interpreter* interpreter, PrintFn printOutput);
+TOY_API void setInterpreterAssert(Interpreter* interpreter, PrintFn assertOutput);
+TOY_API void setInterpreterError(Interpreter* interpreter, PrintFn errorOutput);
+
+//main access
+TOY_API void initInterpreter(Interpreter* interpreter); //start of program
+TOY_API void runInterpreter(Interpreter* interpreter, unsigned char* bytecode, int length); //run the code
+TOY_API void resetInterpreter(Interpreter* interpreter); //use this to reset the interpreter's environment between runs
+TOY_API void freeInterpreter(Interpreter* interpreter); //end of program

source/keyword_types.c

@@ -0,0 +1,77 @@
+#include "keyword_types.h"
+
+#include "common.h"
+
+#include <string.h>
+
+KeywordType keywordTypes[] = {
+	//type keywords
+	{TOKEN_NULL,       "null"},
+	{TOKEN_BOOLEAN,    "bool"},
+	{TOKEN_INTEGER,    "int"},
+	{TOKEN_FLOAT,      "float"},
+	{TOKEN_STRING,     "string"},
+	{TOKEN_FUNCTION,   "fn"},
+	{TOKEN_OPAQUE,     "opaque"},
+	{TOKEN_ANY,        "any"},
+
+	//other keywords
+	{TOKEN_AS,         "as"},
+	{TOKEN_ASSERT,     "assert"},
+	{TOKEN_BREAK,      "break"},
+	{TOKEN_CLASS,      "class"},
+	{TOKEN_CONST,      "const"},
+	{TOKEN_CONTINUE,   "continue"},
+	{TOKEN_DO,         "do"},
+	{TOKEN_ELSE,       "else"},
+	{TOKEN_EXPORT,     "export"},
+	{TOKEN_FOR,        "for"},
+	{TOKEN_FOREACH,    "foreach"},
+	{TOKEN_IF,         "if"},
+	{TOKEN_IMPORT,     "import"},
+	{TOKEN_IN,         "in"},
+	{TOKEN_OF,         "of"},
+	{TOKEN_PRINT,      "print"},
+	{TOKEN_RETURN,     "return"},
+	{TOKEN_TYPE,       "type"},
+	{TOKEN_ASTYPE,     "astype"},
+	{TOKEN_TYPEOF,     "typeof"},
+	{TOKEN_VAR,        "var"},
+	{TOKEN_WHILE,      "while"},
+
+	//literal values
+	{TOKEN_LITERAL_TRUE,   "true"},
+	{TOKEN_LITERAL_FALSE,  "false"},
+
+	//meta tokens
+	{TOKEN_PASS,       NULL},
+	{TOKEN_ERROR,      NULL},
+
+	{TOKEN_EOF, NULL},
+};
+
+char* findKeywordByType(TokenType type) {
+	if (type == TOKEN_EOF) {
+		return "EOF";
+	}
+
+	for(int i = 0; keywordTypes[i].keyword; i++) {
+		if (keywordTypes[i].type == type) {
+			return keywordTypes[i].keyword;
+		}
+	}
+
+	return NULL;
+}
+
+TokenType findTypeByKeyword(const char* keyword) {
+	const int length = strlen(keyword);
+
+	for (int i = 0; keywordTypes[i].keyword; i++) {
+		if (!strncmp(keyword, keywordTypes[i].keyword, length)) {
+			return keywordTypes[i].type;
+		}
+	}
+
+	return TOKEN_EOF;
+}

source/keyword_types.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "token_types.h"
+
+typedef struct {
+	TokenType type;
+	char* keyword;
+} KeywordType;
+
+extern KeywordType keywordTypes[];
+
+char* findKeywordByType(TokenType type);
+
+TokenType findTypeByKeyword(const char* keyword);

source/lexer.c

@@ -0,0 +1,348 @@
+#include "lexer.h"
+#include "console_colors.h"
+#include "keyword_types.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+
+//static generic utility functions
+static void cleanLexer(Lexer* lexer) {
+	lexer->source = NULL;
+	lexer->start = 0;
+	lexer->current = 0;
+	lexer->line = 1;
+}
+
+static bool isAtEnd(Lexer* lexer) {
+	return lexer->source[lexer->current] == '\0';
+}
+
+static char peek(Lexer* lexer) {
+	return lexer->source[lexer->current];
+}
+
+static char peekNext(Lexer* lexer) {
+	if (isAtEnd(lexer)) return '\0';
+	return lexer->source[lexer->current + 1];
+}
+
+static char advance(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(Lexer* lexer) {
+	const char c = peek(lexer);
+
+	switch(c) {
+		case ' ':
+		case '\r':
+		case '\n':
+		case '\t':
+			advance(lexer);
+			break;
+
+		//comments
+		case '/':
+			//eat the line
+			if (peekNext(lexer) == '/') {
+				while (advance(lexer) != '\n' && !isAtEnd(lexer));
+				break;
+			}
+
+			//eat the block
+			if (peekNext(lexer) == '*') {
+				advance(lexer);
+				advance(lexer);
+				while(!(peek(lexer) == '*' && peekNext(lexer) == '/')) advance(lexer);
+				advance(lexer);
+				advance(lexer);
+				break;
+			}
+		return;
+
+		default:
+			return;
+	}
+
+	//tail recursion
+	eatWhitespace(lexer);
+}
+
+static bool isDigit(Lexer* lexer) {
+	return peek(lexer) >= '0' && peek(lexer) <= '9';
+}
+
+static bool isAlpha(Lexer* lexer) {
+	return
+		(peek(lexer) >= 'A' && peek(lexer) <= 'Z') ||
+		(peek(lexer) >= 'a' && peek(lexer) <= 'z') ||
+		peek(lexer) == '_'
+	;
+}
+
+static bool match(Lexer* lexer, char c) {
+	if (peek(lexer) == c) {
+		advance(lexer);
+		return true;
+	}
+
+	return false;
+}
+
+//token generators
+static Token makeErrorToken(Lexer* lexer, char* msg) {
+	Token token;
+
+	token.type = TOKEN_ERROR;
+	token.lexeme = msg;
+	token.length = strlen(msg);
+	token.line = lexer->line;
+
+#ifndef TOY_EXPORT
+	if (command.verbose) {
+		printf("err:");
+		printToken(&token);
+	}
+#endif
+
+	return token;
+}
+
+static Token makeToken(Lexer* lexer, TokenType type) {
+	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 (command.verbose) {
+		printf("tok:");
+		printToken(&token);
+	}
+#endif
+
+	return token;
+}
+
+static Token makeIntegerOrFloat(Lexer* lexer) {
+	TokenType type = TOKEN_LITERAL_INTEGER; //what am I making?
+
+	while(isDigit(lexer)) advance(lexer);
+
+	if (peek(lexer) == '.' && (peekNext(lexer) >= '0' && peekNext(lexer) <= '9')) { //BUGFIX: peekNext == digit
+		type = TOKEN_LITERAL_FLOAT;
+		advance(lexer);
+		while(isDigit(lexer)) advance(lexer);
+	}
+
+	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 (command.verbose) {
+		if (type == TOKEN_LITERAL_INTEGER) {
+			printf("int:");
+		} else {
+			printf("flt:");
+		}
+		printToken(&token);
+	}
+#endif
+
+	return token;
+}
+
+static Token makeString(Lexer* lexer, char terminator) {
+	while (!isAtEnd(lexer) && peek(lexer) != terminator) {
+		advance(lexer);
+	}
+
+	advance(lexer); //eat terminator
+
+	if (isAtEnd(lexer)) {
+		return makeErrorToken(lexer, "Unterminated string");
+	}
+
+	Token token;
+
+	token.type = 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 (command.verbose) {
+		printf("str:");
+		printToken(&token);
+	}
+#endif
+
+	return token;
+}
+
+static Token makeKeywordOrIdentifier(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; keywordTypes[i].keyword; i++) {
+		if (strlen(keywordTypes[i].keyword) == (long unsigned int)(lexer->current - lexer->start) && !strncmp(keywordTypes[i].keyword, &lexer->source[lexer->start], lexer->current - lexer->start)) {
+			Token token;
+
+			token.type = keywordTypes[i].type;
+			token.lexeme = &lexer->source[lexer->start];
+			token.length = lexer->current - lexer->start;
+			token.line = lexer->line;
+
+#ifndef TOY_EXPORT
+			if (command.verbose) {
+				printf("kwd:");
+				printToken(&token);
+			}
+#endif
+
+			return token;
+		}
+	}
+
+	//return an identifier
+	Token token;
+
+	token.type = TOKEN_IDENTIFIER;
+	token.lexeme = &lexer->source[lexer->start];
+	token.length = lexer->current - lexer->start;
+	token.line = lexer->line;
+
+#ifndef TOY_EXPORT
+	if (command.verbose) {
+		printf("idf:");
+		printToken(&token);
+	}
+#endif
+
+	return token;
+}
+
+//exposed functions
+void initLexer(Lexer* lexer, char* source) {
+	cleanLexer(lexer);
+
+	lexer->source = source;
+}
+
+Token scanLexer(Lexer* lexer) {
+	eatWhitespace(lexer);
+
+	lexer->start = lexer->current;
+
+	if (isAtEnd(lexer)) return makeToken(lexer, TOKEN_EOF);
+
+	if (isDigit(lexer)) return makeIntegerOrFloat(lexer);
+	if (isAlpha(lexer)) return makeKeywordOrIdentifier(lexer);
+
+	char c = advance(lexer);
+
+	switch(c) {
+		case '(': return makeToken(lexer, TOKEN_PAREN_LEFT);
+		case ')': return makeToken(lexer, TOKEN_PAREN_RIGHT);
+		case '{': return makeToken(lexer, TOKEN_BRACE_LEFT);
+		case '}': return makeToken(lexer, TOKEN_BRACE_RIGHT);
+		case '[': return makeToken(lexer, TOKEN_BRACKET_LEFT);
+		case ']': return makeToken(lexer, TOKEN_BRACKET_RIGHT);
+
+		case '+': return makeToken(lexer, match(lexer, '=') ? TOKEN_PLUS_ASSIGN : match(lexer, '+') ? TOKEN_PLUS_PLUS: TOKEN_PLUS);
+		case '-': return makeToken(lexer, match(lexer, '=') ? TOKEN_MINUS_ASSIGN : match(lexer, '-') ? TOKEN_MINUS_MINUS: TOKEN_MINUS);
+		case '*': return makeToken(lexer, match(lexer, '=') ? TOKEN_MULTIPLY_ASSIGN : TOKEN_MULTIPLY);
+		case '/': return makeToken(lexer, match(lexer, '=') ? TOKEN_DIVIDE_ASSIGN : TOKEN_DIVIDE);
+		case '%': return makeToken(lexer, match(lexer, '=') ? TOKEN_MODULO_ASSIGN : TOKEN_MODULO);
+
+		case '!': return makeToken(lexer, match(lexer, '=') ? TOKEN_NOT_EQUAL : TOKEN_NOT);
+		case '=': return makeToken(lexer, match(lexer, '=') ? TOKEN_EQUAL : TOKEN_ASSIGN);
+
+		case '<': return makeToken(lexer, match(lexer, '=') ? TOKEN_LESS_EQUAL : TOKEN_LESS);
+		case '>': return makeToken(lexer, match(lexer, '=') ? TOKEN_GREATER_EQUAL : TOKEN_GREATER);
+
+		case '&': //TOKEN_AND not used
+			if (advance(lexer) != '&') {
+				return makeErrorToken(lexer, "Unexpected '&'");
+			} else {
+				return makeToken(lexer, TOKEN_AND);
+			}
+
+		case '|':  return makeToken(lexer, match(lexer, '|') ? TOKEN_OR : TOKEN_PIPE);
+
+		case ':': return makeToken(lexer, TOKEN_COLON);
+		case ';': return makeToken(lexer, TOKEN_SEMICOLON);
+		case ',': return makeToken(lexer, TOKEN_COMMA);
+		case '.':
+			if (peek(lexer) == '.' && peekNext(lexer) == '.') {
+				advance(lexer);
+				advance(lexer);
+				return makeToken(lexer, TOKEN_REST);
+			}
+			return makeToken(lexer, 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 printToken(Token* token) {
+	if (token->type == TOKEN_ERROR) {
+		printf(ERROR "Error\t%d\t%.*s\n" RESET, token->line, token->length, token->lexeme);
+		return;
+	}
+
+	printf("\t%d\t%d\t", token->type, token->line);
+
+	if (token->type == TOKEN_IDENTIFIER || token->type == TOKEN_LITERAL_INTEGER || token->type == TOKEN_LITERAL_FLOAT || token->type == TOKEN_LITERAL_STRING) {
+		printf("%.*s\t", token->length, token->lexeme);
+	} else {
+		char* keyword = findKeywordByType(token->type);
+
+		if (keyword != NULL) {
+			printf("%s", keyword);
+		} else {
+			char* str = token->lexeme;
+			int length = token->length;
+			trim(&str, &length);
+			printf("%.*s", length, str);
+		}
+	}
+
+	printf("\n");
+}

source/lexer.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#include "common.h"
+#include "token_types.h"
+
+//lexers are bound to a string of code, and return a single token every time scan is called
+typedef struct {
+	char* source;
+	int start; //start of the token
+	int current; //current position of the lexer
+	int line; //track this for error handling
+} Lexer;
+
+//tokens are intermediaries between lexers and parsers
+typedef struct {
+	TokenType type;
+	char* lexeme;
+	int length;
+	int line;
+} Token;
+
+TOY_API void initLexer(Lexer* lexer, char* source);
+Token scanLexer(Lexer* lexer);
+
+//for debugging
+void printToken(Token* token);

source/literal.c

@@ -0,0 +1,703 @@
+#include "literal.h"
+#include "memory.h"
+
+#include "literal_array.h"
+#include "literal_dictionary.h"
+#include "scope.h"
+
+#include "console_colors.h"
+
+#include <stdio.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 hash(unsigned int x) {
+    x = ((x >> 16) ^ x) * 0x45d9f3b;
+    x = ((x >> 16) ^ x) * 0x45d9f3b;
+    x = (x >> 16) ^ x;
+    return x;
+}
+
+//exposed functions
+void freeLiteral(Literal literal) {
+	if (IS_STRING(literal)) {
+		FREE_ARRAY(char, AS_STRING(literal), literal.as.string.length + 1);
+		return;
+	}
+
+	if (IS_ARRAY(literal) || literal.type == LITERAL_DICTIONARY_INTERMEDIATE || literal.type == LITERAL_TYPE_INTERMEDIATE) {
+		freeLiteralArray(AS_ARRAY(literal));
+		FREE(LiteralArray, AS_ARRAY(literal));
+		return;
+	}
+
+	if (IS_DICTIONARY(literal)) {
+		freeLiteralDictionary(AS_DICTIONARY(literal));
+		FREE(LiteralDictionary, AS_DICTIONARY(literal));
+		return;
+	}
+
+	if (IS_FUNCTION(literal)) {
+		popScope(AS_FUNCTION(literal).scope);
+		AS_FUNCTION(literal).scope = NULL;
+		FREE_ARRAY(unsigned char, AS_FUNCTION(literal).bytecode, AS_FUNCTION(literal).length);
+	}
+
+	if (IS_IDENTIFIER(literal)) {
+		FREE_ARRAY(char, AS_IDENTIFIER(literal), literal.as.identifier.length + 1);
+		return;
+	}
+
+	if (IS_TYPE(literal)) {
+		for (int i = 0; i < AS_TYPE(literal).count; i++) {
+			freeLiteral(((Literal*)(AS_TYPE(literal).subtypes))[i]);
+		}
+		FREE_ARRAY(Literal, AS_TYPE(literal).subtypes, AS_TYPE(literal).capacity);
+		return;
+	}
+}
+
+bool _isTruthy(Literal x) {
+	if (IS_NULL(x)) {
+		fprintf(stderr, ERROR "ERROR: Null is neither true nor false\n" RESET);
+		return false;
+	}
+
+	if (IS_BOOLEAN(x)) {
+		return AS_BOOLEAN(x);
+	}
+
+	return true;
+}
+
+Literal _toStringLiteral(char* str, int length) {
+	return ((Literal){LITERAL_STRING, { .string.ptr = (char*)str, .string.length = length }});
+}
+
+Literal _toIdentifierLiteral(char* str, int length) {
+	return ((Literal){LITERAL_IDENTIFIER,{ .identifier.ptr = (char*)str, .identifier.length = length, .identifier.hash = hashString(str, length) }});
+}
+
+Literal* _typePushSubtype(Literal* lit, Literal subtype) {
+	//grow the subtype array
+	if (AS_TYPE(*lit).count + 1 > AS_TYPE(*lit).capacity) {
+		int oldCapacity = AS_TYPE(*lit).capacity;
+
+		AS_TYPE(*lit).capacity = GROW_CAPACITY(oldCapacity);
+		AS_TYPE(*lit).subtypes = GROW_ARRAY(Literal, AS_TYPE(*lit).subtypes, oldCapacity, AS_TYPE(*lit).capacity);
+	}
+
+	//actually push
+	((Literal*)(AS_TYPE(*lit).subtypes))[ AS_TYPE(*lit).count++ ] = subtype;
+	return &((Literal*)(AS_TYPE(*lit).subtypes))[ AS_TYPE(*lit).count - 1 ];
+}
+
+Literal copyLiteral(Literal original) {
+	switch(original.type) {
+		case LITERAL_NULL:
+		case LITERAL_BOOLEAN:
+		case LITERAL_INTEGER:
+		case LITERAL_FLOAT:
+			//no copying needed
+			return original;
+
+		case LITERAL_STRING: {
+			return TO_STRING_LITERAL(copyString(AS_STRING(original), original.as.string.length), original.as.string.length);
+		}
+
+		case LITERAL_ARRAY: {
+			LiteralArray* array = ALLOCATE(LiteralArray, 1);
+			initLiteralArray(array);
+
+			//copy each element
+			for (int i = 0; i < AS_ARRAY(original)->count; i++) {
+				pushLiteralArray(array, AS_ARRAY(original)->literals[i]);
+			}
+
+			return TO_ARRAY_LITERAL(array);
+		}
+
+		case LITERAL_DICTIONARY: {
+			LiteralDictionary* dictionary = ALLOCATE(LiteralDictionary, 1);
+			initLiteralDictionary(dictionary);
+
+			//copy each entry
+			for (int i = 0; i < AS_DICTIONARY(original)->capacity; i++) {
+				if ( !IS_NULL(AS_DICTIONARY(original)->entries[i].key) ) {
+					setLiteralDictionary(dictionary, AS_DICTIONARY(original)->entries[i].key, AS_DICTIONARY(original)->entries[i].value);
+				}
+			}
+
+			return TO_DICTIONARY_LITERAL(dictionary);
+		}
+
+		case LITERAL_FUNCTION: {
+			unsigned char* buffer = ALLOCATE(unsigned char, AS_FUNCTION(original).length);
+			memcpy(buffer, AS_FUNCTION(original).bytecode, AS_FUNCTION(original).length);
+
+			Literal literal = TO_FUNCTION_LITERAL(buffer, AS_FUNCTION(original).length);
+			AS_FUNCTION(literal).scope = copyScope(AS_FUNCTION(original).scope);
+
+			return literal;
+		}
+
+		case LITERAL_IDENTIFIER: {
+			 return TO_IDENTIFIER_LITERAL(copyString(AS_IDENTIFIER(original), original.as.identifier.length), original.as.identifier.length);
+		}
+
+		case LITERAL_TYPE: {
+			Literal lit = TO_TYPE_LITERAL(AS_TYPE(original).typeOf, AS_TYPE(original).constant);
+
+			for (int i = 0; i < AS_TYPE(original).count; i++) {
+				TYPE_PUSH_SUBTYPE(&lit, copyLiteral( ((Literal*)(AS_TYPE(original).subtypes))[i] ));
+			}
+
+			return lit;
+		}
+
+		case LITERAL_OPAQUE: {
+			return original; //literally a shallow copy
+		}
+
+		case LITERAL_DICTIONARY_INTERMEDIATE: {
+			LiteralArray* array = ALLOCATE(LiteralArray, 1);
+			initLiteralArray(array);
+
+			//copy each element
+			for (int i = 0; i < AS_ARRAY(original)->count; i++) {
+				Literal literal = copyLiteral(AS_ARRAY(original)->literals[i]);
+				pushLiteralArray(array, literal);
+				freeLiteral(literal);
+			}
+
+			Literal ret = TO_ARRAY_LITERAL(array);
+			ret.type = LITERAL_DICTIONARY_INTERMEDIATE;
+			return ret;
+		}
+
+		case LITERAL_TYPE_INTERMEDIATE: {
+			LiteralArray* array = ALLOCATE(LiteralArray, 1);
+			initLiteralArray(array);
+
+			//copy each element
+			for (int i = 0; i < AS_ARRAY(original)->count; i++) {
+				Literal literal =  copyLiteral(AS_ARRAY(original)->literals[i]);
+				pushLiteralArray(array, literal);
+				freeLiteral(literal);
+			}
+
+			Literal ret = TO_ARRAY_LITERAL(array);
+			ret.type = LITERAL_TYPE_INTERMEDIATE;
+			return ret;
+		}
+
+		case LITERAL_FUNCTION_INTERMEDIATE: //caries a compiler
+		case LITERAL_FUNCTION_NATIVE:
+			//no copying possible
+			return original;
+
+		default:
+			fprintf(stderr, ERROR "ERROR: Can't copy that literal type: %d\n" RESET, original.type);
+			return TO_NULL_LITERAL;
+	}
+}
+
+char* copyString(char* original, int length) {
+	//make a local copy of the char array
+	char* buffer = ALLOCATE(char, length + 1);
+	strncpy(buffer, original, length);
+	buffer[length] = '\0';
+	return buffer;
+}
+
+bool literalsAreEqual(Literal lhs, Literal rhs) {
+	//utility for other things
+	if (lhs.type != rhs.type) {
+		// ints and floats are compatible
+		if ((IS_INTEGER(lhs) || IS_FLOAT(lhs)) && (IS_INTEGER(rhs) || IS_FLOAT(rhs))) {
+			if (IS_INTEGER(lhs)) {
+				return AS_INTEGER(lhs) + AS_FLOAT(rhs);
+			}
+			else {
+				return AS_FLOAT(lhs) + AS_INTEGER(rhs);
+			}
+		}
+
+		return false;
+	}
+
+	switch(lhs.type) {
+		case LITERAL_NULL:
+			return true; //can only be true because of the check above
+
+		case LITERAL_BOOLEAN:
+			return AS_BOOLEAN(lhs) == AS_BOOLEAN(rhs);
+
+		case LITERAL_INTEGER:
+			return AS_INTEGER(lhs) == AS_INTEGER(rhs);
+
+		case LITERAL_FLOAT:
+			return AS_FLOAT(lhs) == AS_FLOAT(rhs);
+
+		case LITERAL_STRING:
+			if (lhs.as.string.length != rhs.as.string.length) {
+				return false;
+			}
+			return !strncmp(AS_STRING(lhs), AS_STRING(rhs), lhs.as.string.length);
+
+		case LITERAL_ARRAY:
+		case LITERAL_DICTIONARY_INTERMEDIATE: //BUGFIX
+		case LITERAL_TYPE_INTERMEDIATE: //BUGFIX: used for storing types as an array
+			//mismatched sizes
+			if (AS_ARRAY(lhs)->count != AS_ARRAY(rhs)->count) {
+				return false;
+			}
+
+			//mismatched elements (in order)
+			for (int i = 0; i < AS_ARRAY(lhs)->count; i++) {
+				if (!literalsAreEqual( AS_ARRAY(lhs)->literals[i], AS_ARRAY(rhs)->literals[i] )) {
+					return false;
+				}
+			}
+			return true;
+
+		case LITERAL_DICTIONARY:
+			//relatively slow, especially when nested
+			for (int i = 0; i < AS_DICTIONARY(lhs)->capacity; i++) {
+				if (!IS_NULL(AS_DICTIONARY(lhs)->entries[i].key)) { //only compare non-null keys
+					//check it exists in rhs
+					if (!existsLiteralDictionary(AS_DICTIONARY(rhs), AS_DICTIONARY(lhs)->entries[i].key)) {
+						return false;
+					}
+
+					//compare the values
+					Literal val = getLiteralDictionary(AS_DICTIONARY(rhs), AS_DICTIONARY(lhs)->entries[i].key); //TODO: could be more efficient
+					if (!literalsAreEqual(AS_DICTIONARY(lhs)->entries[i].value, val)) {
+						freeLiteral(val);
+						return false;
+					}
+					freeLiteral(val);
+				}
+			}
+
+			return true;
+
+		case LITERAL_FUNCTION:
+		case LITERAL_FUNCTION_NATIVE:
+			return false; //functions are never equal
+		break;
+
+		case LITERAL_IDENTIFIER:
+			//check shortcuts
+			if (HASH_I(lhs) != HASH_I(rhs) && lhs.as.identifier.length != rhs.as.identifier.length) {
+				return false;
+			}
+
+			return !strncmp(AS_IDENTIFIER(lhs), AS_IDENTIFIER(rhs), lhs.as.identifier.length);
+
+		case LITERAL_TYPE:
+			//check types
+			if (AS_TYPE(lhs).typeOf != AS_TYPE(rhs).typeOf) {
+				return false;
+			}
+
+			//const don't match
+			if (AS_TYPE(lhs).constant != AS_TYPE(rhs).constant) {
+				return false;
+			}
+
+			//check subtypes
+			if (AS_TYPE(lhs).count != AS_TYPE(rhs).count) {
+				return false;
+			}
+
+			//check array|dictionary signatures are the same (in order)
+			if (AS_TYPE(lhs).typeOf == LITERAL_ARRAY || AS_TYPE(lhs).typeOf == LITERAL_DICTIONARY) {
+				for (int i = 0; i < AS_TYPE(lhs).count; i++) {
+					if (!literalsAreEqual(((Literal*)(AS_TYPE(lhs).subtypes))[i], ((Literal*)(AS_TYPE(rhs).subtypes))[i])) {
+						return false;
+					}
+				}
+			}
+			return true;
+
+		case LITERAL_OPAQUE:
+			return false; //IDK what this is!
+
+		case LITERAL_ANY:
+			return true;
+
+		case LITERAL_FUNCTION_INTERMEDIATE:
+			fprintf(stderr, ERROR "[internal] Can't compare intermediate functions\n" RESET);
+			return false;
+
+		default:
+			//should never be seen
+			fprintf(stderr, ERROR "[internal] Unrecognized literal type in equality: %d\n" RESET, lhs.type);
+			return false;
+	}
+
+	return false;
+}
+
+int hashLiteral(Literal lit) {
+	switch(lit.type) {
+		case LITERAL_NULL:
+			return 0;
+
+		case LITERAL_BOOLEAN:
+			return AS_BOOLEAN(lit) ? 1 : 0;
+
+		case LITERAL_INTEGER:
+			return hash((unsigned int)AS_INTEGER(lit));
+
+		case LITERAL_FLOAT:
+			return hash(*(unsigned int*)(&AS_FLOAT(lit)));
+
+		case LITERAL_STRING:
+			return hashString(AS_STRING(lit), strlen(AS_STRING(lit)));
+
+		case LITERAL_ARRAY: {
+			unsigned int res = 0;
+			for (int i = 0; i < AS_ARRAY(lit)->count; i++) {
+				res += hashLiteral(AS_ARRAY(lit)->literals[i]);
+			}
+			return hash(res);
+		}
+
+		case LITERAL_DICTIONARY: {
+			unsigned int res = 0;
+			for (int i = 0; i < AS_DICTIONARY(lit)->capacity; i++) {
+				if (!IS_NULL(AS_DICTIONARY(lit)->entries[i].key)) { //only hash non-null keys
+					res += hashLiteral(AS_DICTIONARY(lit)->entries[i].key);
+					res += hashLiteral(AS_DICTIONARY(lit)->entries[i].value);
+				}
+			}
+			return hash(res);
+		}
+
+		case LITERAL_FUNCTION:
+		case LITERAL_FUNCTION_NATIVE:
+			return 0; //TODO: find a way to hash these properly
+
+		case LITERAL_IDENTIFIER:
+			return HASH_I(lit); //pre-computed
+
+		case LITERAL_TYPE:
+			return AS_TYPE(lit).typeOf; //nothing else I can do
+
+		case LITERAL_OPAQUE:
+		case LITERAL_ANY:
+			return -1;
+
+		default:
+			//should never bee seen
+			fprintf(stderr, ERROR "[internal] Unrecognized literal type in hash: %d\n" 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 = GROW_CAPACITY(globalPrintCapacity);
+		globalPrintBuffer = GROW_ARRAY(char, globalPrintBuffer, oldCapacity, globalPrintCapacity);
+	}
+
+	snprintf(globalPrintBuffer + globalPrintCount, strlen(str) + 1, "%s", str);
+	globalPrintCount += strlen(str);
+}
+
+//exposed functions
+void printLiteral(Literal literal) {
+	printLiteralCustom(literal, stdoutWrapper);
+}
+
+void printLiteralCustom(Literal literal, void (printFn)(const char*)) {
+	switch(literal.type) {
+		case LITERAL_NULL:
+			printFn("null");
+		break;
+
+		case LITERAL_BOOLEAN:
+			printFn(AS_BOOLEAN(literal) ? "true" : "false");
+		break;
+
+		case LITERAL_INTEGER: {
+			char buffer[256];
+			snprintf(buffer, 256, "%d", AS_INTEGER(literal));
+			printFn(buffer);
+		}
+		break;
+
+		case LITERAL_FLOAT: {
+			char buffer[256];
+			snprintf(buffer, 256, "%g", AS_FLOAT(literal));
+			printFn(buffer);
+		}
+		break;
+
+		case LITERAL_STRING: {
+			char buffer[MAX_STRING_LENGTH];
+			if (!quotes) {
+				snprintf(buffer, MAX_STRING_LENGTH, "%.*s", (int)strlen(AS_STRING(literal)), AS_STRING(literal));
+			}
+			else {
+				snprintf(buffer, MAX_STRING_LENGTH, "%c%.*s%c", quotes, (int)strlen(AS_STRING(literal)), AS_STRING(literal), quotes);
+			}
+			printFn(buffer);
+		}
+		break;
+
+		case LITERAL_ARRAY: {
+			LiteralArray* ptr = 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 = '"';
+				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);
+			FREE_ARRAY(char, printBuffer, printCapacity);
+			quotes = 0;
+		}
+		break;
+
+		case LITERAL_DICTIONARY: {
+			LiteralDictionary* ptr = 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 (IS_NULL(ptr->entries[i].key)) {
+					continue;
+				}
+
+				if (delimCount++ > 0) {
+					printToBuffer(",");
+				}
+
+				quotes = '"';
+				printLiteralCustom(ptr->entries[i].key, printToBuffer);
+				printToBuffer(":");
+				quotes = '"';
+				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);
+			FREE_ARRAY(char, printBuffer, printCapacity);
+			quotes = 0;
+		}
+		break;
+
+		//TODO: functions
+		case LITERAL_FUNCTION:
+		case LITERAL_FUNCTION_NATIVE:
+			printFn("(function)");
+		break;
+
+		case LITERAL_IDENTIFIER: {
+			char buffer[256];
+			snprintf(buffer, 256, "%.*s", (int)strlen( AS_IDENTIFIER(literal) ), AS_IDENTIFIER(literal));
+			printFn(buffer);
+		}
+		break;
+
+		case 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(AS_TYPE(literal).typeOf) {
+				case LITERAL_NULL:
+					printToBuffer("null");
+				break;
+
+				case LITERAL_BOOLEAN:
+					printToBuffer("bool");
+				break;
+
+				case LITERAL_INTEGER:
+					printToBuffer("int");
+				break;
+
+				case LITERAL_FLOAT:
+					printToBuffer("float");
+				break;
+
+				case LITERAL_STRING:
+					printToBuffer("string");
+				break;
+
+				case LITERAL_ARRAY:
+					//print all in the array
+					printToBuffer("[");
+					for (int i = 0; i < AS_TYPE(literal).count; i++) {
+						printLiteralCustom(((Literal*)(AS_TYPE(literal).subtypes))[i], printToBuffer);
+					}
+					printToBuffer("]");
+				break;
+
+				case LITERAL_DICTIONARY:
+					printToBuffer("[");
+
+					for (int i = 0; i < AS_TYPE(literal).count; i += 2) {
+						printLiteralCustom(((Literal*)(AS_TYPE(literal).subtypes))[i], printToBuffer);
+						printToBuffer(":");
+						printLiteralCustom(((Literal*)(AS_TYPE(literal).subtypes))[i + 1], printToBuffer);
+					}
+					printToBuffer("]");
+				break;
+
+				case LITERAL_FUNCTION:
+					printToBuffer("function");
+				break;
+
+				case LITERAL_FUNCTION_NATIVE:
+					printToBuffer("native");
+				break;
+
+				case LITERAL_IDENTIFIER:
+					printToBuffer("identifier");
+				break;
+
+				case LITERAL_TYPE:
+					printToBuffer("type");
+				break;
+
+				case LITERAL_OPAQUE:
+					printToBuffer("opaque");
+				break;
+
+				case LITERAL_ANY:
+					printToBuffer("any");
+				break;
+
+				default:
+					//should never be seen
+					fprintf(stderr, ERROR "[internal] Unrecognized literal type in print type: %d\n" RESET, AS_TYPE(literal).typeOf);
+			}
+
+			//const (printed last)
+			if (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);
+			FREE_ARRAY(char, printBuffer, printCapacity);
+			quotes = 0;
+		}
+		break;
+
+		case LITERAL_TYPE_INTERMEDIATE:
+		case LITERAL_FUNCTION_INTERMEDIATE:
+			printFn("Unprintable literal found");
+		break;
+
+		case LITERAL_OPAQUE:
+			printFn("(opaque)");
+		break;
+
+		case LITERAL_ANY:
+			printFn("(any)");
+		break;
+
+		default:
+			//should never be seen
+			fprintf(stderr, ERROR "[internal] Unrecognized literal type in print: %d\n" RESET, literal.type);
+	}
+}

source/literal.h

@@ -0,0 +1,128 @@
+#pragma once
+
+#include "common.h"
+
+#include <string.h>
+
+typedef enum {
+	LITERAL_NULL,
+	LITERAL_BOOLEAN,
+	LITERAL_INTEGER,
+	LITERAL_FLOAT,
+	LITERAL_STRING,
+	LITERAL_ARRAY,
+	LITERAL_DICTIONARY,
+	LITERAL_FUNCTION,
+	LITERAL_IDENTIFIER,
+	LITERAL_TYPE,
+	LITERAL_OPAQUE,
+	LITERAL_ANY,
+
+	//these are meta-level types - not for general use
+	LITERAL_TYPE_INTERMEDIATE, //used to process types in the compiler only
+	LITERAL_DICTIONARY_INTERMEDIATE, //used to process dictionaries in the compiler only
+	LITERAL_FUNCTION_INTERMEDIATE, //used to process functions in the compiler only
+	LITERAL_FUNCTION_ARG_REST, //used to process function rest parameters only
+	LITERAL_FUNCTION_NATIVE, //for handling native functions only
+} LiteralType;
+
+typedef struct {
+	LiteralType type;
+	union {
+		bool boolean;
+		int integer;
+		float number;
+		struct {
+			char* ptr;
+			int length;
+		} string;
+
+		void* array;
+		void* dictionary;
+
+		struct {
+			void* bytecode;
+			void* scope;
+			int length;
+		} function;
+
+		struct { //for variable names
+            char* ptr;
+            int length;
+			int hash;
+        } identifier;
+
+		struct {
+			LiteralType typeOf; //no longer a mask
+			bool constant;
+			void* subtypes; //for nested types caused by compounds
+			int capacity;
+			int count;
+		} type;
+
+		struct {
+			void* ptr;
+			int tag;
+		} opaque;
+	} as;
+} Literal;
+
+#define IS_NULL(value)						((value).type == LITERAL_NULL)
+#define IS_BOOLEAN(value)					((value).type == LITERAL_BOOLEAN)
+#define IS_INTEGER(value)					((value).type == LITERAL_INTEGER)
+#define IS_FLOAT(value)						((value).type == LITERAL_FLOAT)
+#define IS_STRING(value)					((value).type == LITERAL_STRING)
+#define IS_ARRAY(value)						((value).type == LITERAL_ARRAY)
+#define IS_DICTIONARY(value)				((value).type == LITERAL_DICTIONARY)
+#define IS_FUNCTION(value)					((value).type == LITERAL_FUNCTION)
+#define IS_FUNCTION_NATIVE(value)			((value).type == LITERAL_FUNCTION_NATIVE)
+#define IS_IDENTIFIER(value)				((value).type == LITERAL_IDENTIFIER)
+#define IS_TYPE(value)						((value).type == LITERAL_TYPE)
+#define IS_OPAQUE(value)					((value).type == LITERAL_OPAQUE)
+
+#define AS_BOOLEAN(value)					((value).as.boolean)
+#define AS_INTEGER(value)					((value).as.integer)
+#define AS_FLOAT(value)						((value).as.number)
+#define AS_STRING(value)					((value).as.string.ptr)
+#define AS_ARRAY(value)						((LiteralArray*)((value).as.array))
+#define AS_DICTIONARY(value)				((LiteralDictionary*)((value).as.dictionary))
+#define AS_FUNCTION(value)					((value).as.function)
+#define AS_IDENTIFIER(value)				((value).as.identifier.ptr)
+#define AS_TYPE(value)						((value).as.type)
+#define AS_OPAQUE(value)					((value).as.opaque.ptr)
+
+#define TO_NULL_LITERAL						((Literal){LITERAL_NULL,		{ .integer = 0 }})
+#define TO_BOOLEAN_LITERAL(value)			((Literal){LITERAL_BOOLEAN,		{ .boolean = value }})
+#define TO_INTEGER_LITERAL(value)			((Literal){LITERAL_INTEGER,		{ .integer = value }})
+#define TO_FLOAT_LITERAL(value)				((Literal){LITERAL_FLOAT,		{ .number = value }})
+#define TO_STRING_LITERAL(value, l)			_toStringLiteral(value, l)
+#define TO_ARRAY_LITERAL(value)				((Literal){LITERAL_ARRAY,		{ .array = value }})
+#define TO_DICTIONARY_LITERAL(value)		((Literal){LITERAL_DICTIONARY,	{ .dictionary = value }})
+#define TO_FUNCTION_LITERAL(value, l)		((Literal){LITERAL_FUNCTION,	{ .function.bytecode = value, .function.scope = NULL, .function.length = l }})
+#define TO_IDENTIFIER_LITERAL(value, l)		_toIdentifierLiteral(value, l)
+#define TO_TYPE_LITERAL(value, c)			((Literal){ LITERAL_TYPE,		{ .type.typeOf = value, .type.constant = c, .type.subtypes = NULL, .type.capacity = 0, .type.count = 0 }})
+#define TO_OPAQUE_LITERAL(value, t)			((Literal){ LITERAL_OPAQUE,		{ .opaque.ptr = value, .opaque.tag = t }})
+
+TOY_API void freeLiteral(Literal literal);
+
+#define IS_TRUTHY(x) _isTruthy(x)
+
+#define MAX_STRING_LENGTH					4096
+#define HASH_I(lit)							((lit).as.identifier.hash)
+#define TYPE_PUSH_SUBTYPE(lit, subtype)		_typePushSubtype(lit, subtype)
+#define OPAQUE_TAG(o)						o.as.opaque.tag
+
+//BUGFIX: macros are not functions
+TOY_API bool _isTruthy(Literal x);
+TOY_API Literal _toStringLiteral(char* str, int length);
+TOY_API Literal _toIdentifierLiteral(char* str, int length);
+TOY_API Literal* _typePushSubtype(Literal* lit, Literal subtype);
+
+//utils
+TOY_API Literal copyLiteral(Literal original);
+TOY_API char* copyString(char* original, int length);
+TOY_API bool literalsAreEqual(Literal lhs, Literal rhs);
+TOY_API int hashLiteral(Literal lit);
+
+TOY_API void printLiteral(Literal literal);
+TOY_API void printLiteralCustom(Literal literal, void (printFn)(const char*));