The any type is now recognized as a type properly

TOY_OP_INDEX_ASSIGN_INTERMEDIATE was being used when it shouldn't have.

Now the check runs down the whole binary->right branch to ensure the given
node doesn't exist in that tree.

.gitignore

@@ -19,6 +19,8 @@ bin/
 *.db
 *.o
 *.a
+*.so
+*.dll
 *.exe
 *.meta
 *.log

README.md

@@ -4,9 +4,11 @@
 
 # Toy
 
-This is the Toy programming language interpreter, written in C.
+The Toy programming language is an imperative bytecode-intermediate embedded scripting language. It isn't intended to operate on its own, but rather as part of another program, the "host". This process is intended to allow a decent amount of easy customisation by the host's end user, by exposing logic in script files. Alternatively, binary files in a custom format can be used as well.
 
-Special thanks to http://craftinginterpreters.com/ for their fantastic book that set me on this path.
+The host will provide all of the extensions needed on a case-by-case basis. Script files have the `.toy` file extension, while binary files have the `.tb` file extension.
+
+This is the Toy programming language interpreter, written in C.
 
 # Nifty Features
 
@@ -14,7 +16,7 @@ Special thanks to http://craftinginterpreters.com/ for their fantastic book that
 * Bytecode intermediate compilation
 * Optional, but robust type system (including `opaque` for arbitrary data)
 * Functions and types are first-class citizens
-* Import external libraries
+* Import native libraries from the host
 * Fancy slice notation for strings, arrays and dictionaries
 * Can re-direct output, error and assertion failure messages
 * Open source under the zlib license
@@ -71,3 +73,4 @@ This source code is covered by the zlib license (see [LICENSE.md](LICENSE.md)).
 
 * Seth A. Robinson
 
+Special thanks to http://craftinginterpreters.com/ for their fantastic book that set me on this path.

Repl.vcxproj

@@ -74,6 +74,10 @@
     <OutDir>$(SolutionDir)out\$(Configuration)\</OutDir>
     <IntDir>$(Platform)\$(ProjectName)\$(Configuration)\</IntDir>
   </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <OutDir>$(SolutionDir)out\$(Configuration)\</OutDir>
+    <IntDir>$(Platform)\$(ProjectName)\$(Configuration)\</IntDir>
+  </PropertyGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
     <ClCompile>
       <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
@@ -109,12 +113,25 @@
       <AdditionalLibraryDirectories>$(SolutionDir)out\$(Configuration)</AdditionalLibraryDirectories>
     </Link>
     <ClCompile>
-      <AdditionalIncludeDirectories>C:\Users\kayne\Desktop\Toy\source;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>$(SolutionDir)/source;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <LanguageStandard_C>stdc17</LanguageStandard_C>
+      <PreprocessorDefinitions>%(PreprocessorDefinitions)</PreprocessorDefinitions>
     </ClCompile>
   </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <LanguageStandard_C>stdc17</LanguageStandard_C>
+      <PreprocessorDefinitions>%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>$(SolutionDir)/source;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <AdditionalLibraryDirectories>$(SolutionDir)out\$(Configuration)</AdditionalLibraryDirectories>
+      <AdditionalDependencies>Toy.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
   <ItemGroup>
     <ClCompile Include="repl\lib_about.c" />
-    <ClCompile Include="repl\lib_compound.c" />
+    <ClCompile Include="repl\lib_random.c" />
     <ClCompile Include="repl\lib_runner.c" />
     <ClCompile Include="repl\lib_standard.c" />
     <ClCompile Include="repl\repl_main.c" />
@@ -122,11 +139,16 @@
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="repl\lib_about.h" />
-    <ClInclude Include="repl\lib_compound.h" />
+    <ClInclude Include="repl\lib_random.h" />
     <ClInclude Include="repl\lib_runner.h" />
     <ClInclude Include="repl\lib_standard.h" />
     <ClInclude Include="repl\repl_tools.h" />
   </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="Toy.vcxproj">
+      <Project>{26360002-cc2a-469a-9b28-ba0c1af41657}</Project>
+    </ProjectReference>
+  </ItemGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <ImportGroup Label="ExtensionTargets">
   </ImportGroup>

Toy.vcxproj

@@ -41,7 +41,7 @@
     <PlatformToolset>v143</PlatformToolset>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
-    <ConfigurationType>Application</ConfigurationType>
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
     <PlatformToolset>v143</PlatformToolset>
   </PropertyGroup>
@@ -73,6 +73,10 @@
     <OutDir>$(SolutionDir)out\$(Configuration)\</OutDir>
     <IntDir>$(Platform)\$(ProjectName)\$(Configuration)\</IntDir>
   </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <OutDir>$(SolutionDir)out\$(Configuration)\</OutDir>
+    <IntDir>$(Platform)\$(ProjectName)\$(Configuration)\</IntDir>
+  </PropertyGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
     <ClCompile>
       <PreprocessorDefinitions>WIN32;_DEBUG;_WINDOWS;_USRDLL;TOY_EXPORTS;TOY_EXPORT;%(PreprocessorDefinitions)</PreprocessorDefinitions>
@@ -105,6 +109,13 @@
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
     <ClCompile>
       <PreprocessorDefinitions>TOY_EXPORT;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <LanguageStandard_C>stdc17</LanguageStandard_C>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <LanguageStandard_C>stdc17</LanguageStandard_C>
+      <PreprocessorDefinitions>TOY_EXPORT;%(PreprocessorDefinitions)</PreprocessorDefinitions>
     </ClCompile>
   </ItemDefinitionGroup>
   <ItemGroup>
@@ -112,6 +123,7 @@
     <ClCompile Include="source\toy_builtin.c" />
     <ClCompile Include="source\toy_common.c" />
     <ClCompile Include="source\toy_compiler.c" />
+    <ClCompile Include="source\toy_drive_system.c" />
     <ClCompile Include="source\toy_interpreter.c" />
     <ClCompile Include="source\toy_keyword_types.c" />
     <ClCompile Include="source\toy_lexer.c" />
@@ -120,15 +132,18 @@
     <ClCompile Include="source\toy_literal_dictionary.c" />
     <ClCompile Include="source\toy_memory.c" />
     <ClCompile Include="source\toy_parser.c" />
+    <ClCompile Include="source\toy_reffunction.c" />
     <ClCompile Include="source\toy_refstring.c" />
     <ClCompile Include="source\toy_scope.c" />
   </ItemGroup>
   <ItemGroup>
+    <ClInclude Include="source\toy.h" />
     <ClInclude Include="source\toy_ast_node.h" />
     <ClInclude Include="source\toy_builtin.h" />
     <ClInclude Include="source\toy_common.h" />
     <ClInclude Include="source\toy_compiler.h" />
     <ClInclude Include="source\toy_console_colors.h" />
+    <ClInclude Include="source\toy_drive_system.h" />
     <ClInclude Include="source\toy_interpreter.h" />
     <ClInclude Include="source\toy_keyword_types.h" />
     <ClInclude Include="source\toy_lexer.h" />
@@ -138,6 +153,7 @@
     <ClInclude Include="source\toy_memory.h" />
     <ClInclude Include="source\toy_opcodes.h" />
     <ClInclude Include="source\toy_parser.h" />
+    <ClInclude Include="source\toy_reffunction.h" />
     <ClInclude Include="source\toy_refstring.h" />
     <ClInclude Include="source\toy_scope.h" />
     <ClInclude Include="source\toy_token_types.h" />

makefile

@@ -1,7 +1,3 @@
-# Optimisation Options
-# export CFLAGS+=-O2 -mtune=native -march=native
-# export CFLAGS+=-fsanitize=address,undefined
-
 export CFLAGS+=-std=c18 -pedantic -Werror
 
 export TOY_OUTDIR = out
@@ -28,12 +24,16 @@ library: $(TOY_OUTDIR)
 static: $(TOY_OUTDIR)
 	$(MAKE) -j8 -C source static
 
-library-release: $(TOY_OUTDIR)
+library-release: clean $(TOY_OUTDIR)
 	$(MAKE) -j8 -C source library-release
 
-static-release: $(TOY_OUTDIR)
+static-release: clean $(TOY_OUTDIR)
 	$(MAKE) -j8 -C source static-release
 
+#distribution
+dist: export CFLAGS+=-O2 -mtune=native -march=native
+dist: repl-release
+
 #utils
 test: clean $(TOY_OUTDIR)
 	$(MAKE) -C test

repl/lib_random.c

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

repl/lib_random.h

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

repl/lib_runner.c

@@ -1,11 +1,11 @@
 #include "lib_runner.h"
 
 #include "toy_memory.h"
+#include "toy_drive_system.h"
 #include "toy_interpreter.h"
 
 #include "repl_tools.h"
 
-#include <stdio.h>
 #include <stdlib.h>
 
 typedef struct Toy_Runner {
@@ -32,7 +32,12 @@ static int nativeLoadScript(Toy_Interpreter* interpreter, Toy_LiteralArray* argu
 		Toy_freeLiteral(drivePathLiteralIdn);
 	}
 
-	Toy_Literal filePathLiteral = Toy_getFilePathLiteral(interpreter, &drivePathLiteral);
+	if (TOY_IS_IDENTIFIER(drivePathLiteral)) {
+		Toy_freeLiteral(drivePathLiteral);
+		return -1;
+	}
+
+	Toy_Literal filePathLiteral = Toy_getDrivePathLiteral(interpreter, &drivePathLiteral);
 
 	if (TOY_IS_NULL(filePathLiteral)) {
 		Toy_freeLiteral(filePathLiteral);
@@ -48,7 +53,7 @@ static int nativeLoadScript(Toy_Interpreter* interpreter, Toy_LiteralArray* argu
 
 	//load and compile the bytecode
 	size_t fileSize = 0;
-	const char* source = Toy_readFile(filePath, &fileSize);
+	const char* source = (const char*)Toy_readFile(filePath, &fileSize);
 
 	if (!source) {
 		interpreter->errorOutput("Failed to load source file\n");
@@ -102,70 +107,24 @@ static int nativeLoadScriptBytecode(Toy_Interpreter* interpreter, Toy_LiteralArr
 		Toy_freeLiteral(drivePathLiteralIdn);
 	}
 
-	Toy_RefString* drivePath = Toy_copyRefString(TOY_AS_STRING(drivePathLiteral));
-
-	//get the drive and path as a string (can't trust that pesky strtok - custom split) TODO: move this to refstring library
-	size_t driveLength = 0;
-	while (Toy_toCString(drivePath)[driveLength] != ':') {
-		if (driveLength >= Toy_lengthRefString(drivePath)) {
-			interpreter->errorOutput("Incorrect drive path format given to loadScriptBytecode\n");
-			Toy_deleteRefString(drivePath);
-			Toy_freeLiteral(drivePathLiteral);
-			return -1;
-		}
-
-		driveLength++;
-	}
-
-	Toy_RefString* drive = Toy_createRefStringLength(Toy_toCString(drivePath), driveLength);
-	Toy_RefString* path = Toy_createRefStringLength( &Toy_toCString(drivePath)[driveLength + 1], Toy_lengthRefString(drivePath) - driveLength );
-
-	//get the real drive file path
-	Toy_Literal driveLiteral = TOY_TO_STRING_LITERAL(drive); //NOTE: driveLiteral takes ownership of the refString
-	Toy_Literal realDriveLiteral = Toy_getLiteralDictionary(Toy_getDriveDictionary(), driveLiteral);
-
-	if (!TOY_IS_STRING(realDriveLiteral)) {
-		interpreter->errorOutput("Incorrect literal type found for drive: ");
-		Toy_printLiteralCustom(realDriveLiteral, interpreter->errorOutput);
-		interpreter->errorOutput("\n");
-		Toy_freeLiteral(realDriveLiteral);
-		Toy_freeLiteral(driveLiteral);
-		Toy_deleteRefString(path);
-		Toy_deleteRefString(drivePath);
+	if (TOY_IS_IDENTIFIER(drivePathLiteral)) {
 		Toy_freeLiteral(drivePathLiteral);
 		return -1;
 	}
 
-	//get the final real file path (concat) TODO: move this concat to refstring library
-	Toy_RefString* realDrive = Toy_copyRefString(TOY_AS_STRING(realDriveLiteral));
-	size_t realLength = Toy_lengthRefString(realDrive) + Toy_lengthRefString(path);
+	Toy_Literal filePathLiteral = Toy_getDrivePathLiteral(interpreter, &drivePathLiteral);
 
-	char* filePath = TOY_ALLOCATE(char, realLength + 1); //+1 for null
-	snprintf(filePath, realLength, "%s%s", Toy_toCString(realDrive), Toy_toCString(path));
-
-	//clean up the drivepath stuff
-	Toy_deleteRefString(realDrive);
-	Toy_freeLiteral(realDriveLiteral);
-	Toy_freeLiteral(driveLiteral);
-	Toy_deleteRefString(path);
-	Toy_deleteRefString(drivePath);
-	Toy_freeLiteral(drivePathLiteral);
-
-	//check for file extensions
-	if (!(filePath[realLength - 4] == '.' && filePath[realLength - 3] == 't' && filePath[realLength - 2] == 'b')) {
-		interpreter->errorOutput("Bad binary file extension (expected .tb)\n");
-		TOY_FREE_ARRAY(char, filePath, realLength);
+	if (TOY_IS_NULL(filePathLiteral)) {
+		Toy_freeLiteral(filePathLiteral);
+		Toy_freeLiteral(drivePathLiteral);
 		return -1;
 	}
 
-	//check for break-out attempts
-	for (size_t i = 0; i < realLength - 1; i++) {
-		if (filePath[i] == '.' && filePath[i + 1] == '.') {
-			interpreter->errorOutput("Parent directory access not allowed\n");
-			TOY_FREE_ARRAY(char, filePath, realLength);
-			return -1;
-		}
-	}
+	Toy_freeLiteral(drivePathLiteral);
+
+	//use raw types - easier
+	const char* filePath = Toy_toCString(TOY_AS_STRING(filePathLiteral));
+	size_t filePathLength = Toy_lengthRefString(TOY_AS_STRING(filePathLiteral));
 
 	//load the bytecode
 	size_t fileSize = 0;
@@ -192,7 +151,8 @@ static int nativeLoadScriptBytecode(Toy_Interpreter* interpreter, Toy_LiteralArr
 	Toy_Literal runnerLiteral = TOY_TO_OPAQUE_LITERAL(runner, TOY_OPAQUE_TAG_RUNNER);
 	Toy_pushLiteralArray(&interpreter->stack, runnerLiteral);
 
-	TOY_FREE_ARRAY(char, filePath, realLength);
+	//free the drive path
+	Toy_freeLiteral(filePathLiteral);
 
 	return 1;
 }
@@ -200,7 +160,7 @@ static int nativeLoadScriptBytecode(Toy_Interpreter* interpreter, Toy_LiteralArr
 static int nativeRunScript(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments) {
 	//no arguments
 	if (arguments->count != 1) {
-		interpreter->errorOutput("Incorrect number of arguments to _runScript\n");
+		interpreter->errorOutput("Incorrect number of arguments to runScript\n");
 		return -1;
 	}
 
@@ -212,8 +172,13 @@ static int nativeRunScript(Toy_Interpreter* interpreter, Toy_LiteralArray* argum
 		Toy_freeLiteral(runnerIdn);
 	}
 
+	if (TOY_IS_IDENTIFIER(runnerLiteral)) {
+		Toy_freeLiteral(runnerLiteral);
+		return -1;
+	}
+
 	if (TOY_GET_OPAQUE_TAG(runnerLiteral) != TOY_OPAQUE_TAG_RUNNER) {
-		interpreter->errorOutput("Unrecognized opaque literal in _runScript\n");
+		interpreter->errorOutput("Unrecognized opaque literal in runScript\n");
 		return -1;
 	}
 
@@ -241,7 +206,7 @@ static int nativeRunScript(Toy_Interpreter* interpreter, Toy_LiteralArray* argum
 static int nativeGetScriptVar(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments) {
 	//no arguments
 	if (arguments->count != 2) {
-		interpreter->errorOutput("Incorrect number of arguments to _getScriptVar\n");
+		interpreter->errorOutput("Incorrect number of arguments to getScriptVar\n");
 		return -1;
 	}
 
@@ -259,8 +224,14 @@ static int nativeGetScriptVar(Toy_Interpreter* interpreter, Toy_LiteralArray* ar
 		Toy_freeLiteral(runnerIdn);
 	}
 
+	if (TOY_IS_IDENTIFIER(varName) || TOY_IS_IDENTIFIER(runnerLiteral)) {
+		Toy_freeLiteral(varName);
+		Toy_freeLiteral(runnerLiteral);
+		return -1;
+	}
+
 	if (TOY_GET_OPAQUE_TAG(runnerLiteral) != TOY_OPAQUE_TAG_RUNNER) {
-		interpreter->errorOutput("Unrecognized opaque literal in _runScript\n");
+		interpreter->errorOutput("Unrecognized opaque literal in getScriptVar\n");
 		return -1;
 	}
 
@@ -292,7 +263,7 @@ static int nativeGetScriptVar(Toy_Interpreter* interpreter, Toy_LiteralArray* ar
 static int nativeCallScriptFn(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments) {
 	//no arguments
 	if (arguments->count < 2) {
-		interpreter->errorOutput("Incorrect number of arguments to _callScriptFn\n");
+		interpreter->errorOutput("Incorrect number of arguments to callScriptFn\n");
 		return -1;
 	}
 
@@ -309,7 +280,7 @@ static int nativeCallScriptFn(Toy_Interpreter* interpreter, Toy_LiteralArray* ar
 	Toy_LiteralArray rest;
 	Toy_initLiteralArray(&rest);
 
-	while (tmp.count) { //correct the order of the rest args
+	while (tmp.count > 0) { //correct the order of the rest args
 		Toy_Literal lit = Toy_popLiteralArray(&tmp);
 		Toy_pushLiteralArray(&rest, lit);
 		Toy_freeLiteral(lit);
@@ -317,7 +288,6 @@ static int nativeCallScriptFn(Toy_Interpreter* interpreter, Toy_LiteralArray* ar
 
 	Toy_freeLiteralArray(&tmp);
 
-
 	//get the runner object
 	Toy_Literal varName = Toy_popLiteralArray(arguments);
 	Toy_Literal runnerLiteral = Toy_popLiteralArray(arguments);
@@ -332,8 +302,14 @@ static int nativeCallScriptFn(Toy_Interpreter* interpreter, Toy_LiteralArray* ar
 		Toy_freeLiteral(runnerIdn);
 	}
 
+	if (TOY_IS_IDENTIFIER(varName) || TOY_IS_IDENTIFIER(runnerLiteral)) {
+		Toy_freeLiteral(varName);
+		Toy_freeLiteral(runnerLiteral);
+		return -1;
+	}
+
 	if (TOY_GET_OPAQUE_TAG(runnerLiteral) != TOY_OPAQUE_TAG_RUNNER) {
-		interpreter->errorOutput("Unrecognized opaque literal in _runScript\n");
+		interpreter->errorOutput("Unrecognized opaque literal in callScriptFn\n");
 		return -1;
 	}
 
@@ -389,7 +365,7 @@ static int nativeCallScriptFn(Toy_Interpreter* interpreter, Toy_LiteralArray* ar
 static int nativeResetScript(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments) {
 	//no arguments
 	if (arguments->count != 1) {
-		interpreter->errorOutput("Incorrect number of arguments to _resetScript\n");
+		interpreter->errorOutput("Incorrect number of arguments to resetScript\n");
 		return -1;
 	}
 
@@ -401,8 +377,13 @@ static int nativeResetScript(Toy_Interpreter* interpreter, Toy_LiteralArray* arg
 		Toy_freeLiteral(runnerIdn);
 	}
 
+	if (TOY_IS_IDENTIFIER(runnerLiteral)) {
+		Toy_freeLiteral(runnerLiteral);
+		return -1;
+	}
+
 	if (TOY_GET_OPAQUE_TAG(runnerLiteral) != TOY_OPAQUE_TAG_RUNNER) {
-		interpreter->errorOutput("Unrecognized opaque literal in _runScript\n");
+		interpreter->errorOutput("Unrecognized opaque literal in resetScript\n");
 		return -1;
 	}
 
@@ -425,7 +406,7 @@ static int nativeResetScript(Toy_Interpreter* interpreter, Toy_LiteralArray* arg
 static int nativeFreeScript(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments) {
 	//no arguments
 	if (arguments->count != 1) {
-		interpreter->errorOutput("Incorrect number of arguments to _freeScript\n");
+		interpreter->errorOutput("Incorrect number of arguments to freeScript\n");
 		return -1;
 	}
 
@@ -437,8 +418,13 @@ static int nativeFreeScript(Toy_Interpreter* interpreter, Toy_LiteralArray* argu
 		Toy_freeLiteral(runnerIdn);
 	}
 
+	if (TOY_IS_IDENTIFIER(runnerLiteral)) {
+		Toy_freeLiteral(runnerLiteral);
+		return -1;
+	}
+
 	if (TOY_GET_OPAQUE_TAG(runnerLiteral) != TOY_OPAQUE_TAG_RUNNER) {
-		interpreter->errorOutput("Unrecognized opaque literal in _freeScript\n");
+		interpreter->errorOutput("Unrecognized opaque literal in freeScript\n");
 		return -1;
 	}
 
@@ -459,7 +445,7 @@ static int nativeFreeScript(Toy_Interpreter* interpreter, Toy_LiteralArray* argu
 static int nativeCheckScriptDirty(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments) {
 	//no arguments
 	if (arguments->count != 1) {
-		interpreter->errorOutput("Incorrect number of arguments to _runScript\n");
+		interpreter->errorOutput("Incorrect number of arguments to checkScriptDirty\n");
 		return -1;
 	}
 
@@ -471,8 +457,13 @@ static int nativeCheckScriptDirty(Toy_Interpreter* interpreter, Toy_LiteralArray
 		Toy_freeLiteral(runnerIdn);
 	}
 
+	if (TOY_IS_IDENTIFIER(runnerLiteral)) {
+		Toy_freeLiteral(runnerLiteral);
+		return -1;
+	}
+
 	if (TOY_GET_OPAQUE_TAG(runnerLiteral) != TOY_OPAQUE_TAG_RUNNER) {
-		interpreter->errorOutput("Unrecognized opaque literal in _runScript\n");
+		interpreter->errorOutput("Unrecognized opaque literal in checkScriptDirty\n");
 		return -1;
 	}
 
@@ -501,12 +492,12 @@ int Toy_hookRunner(Toy_Interpreter* interpreter, Toy_Literal identifier, Toy_Lit
 	Natives natives[] = {
 		{"loadScript", nativeLoadScript},
 		{"loadScriptBytecode", nativeLoadScriptBytecode},
-		{"_runScript", nativeRunScript},
-		{"_getScriptVar", nativeGetScriptVar},
-		{"_callScriptFn", nativeCallScriptFn},
-		{"_resetScript", nativeResetScript},
-		{"_freeScript", nativeFreeScript},
-		{"_checkScriptDirty", nativeCheckScriptDirty},
+		{"runScript", nativeRunScript},
+		{"getScriptVar", nativeGetScriptVar},
+		{"callScriptFn", nativeCallScriptFn},
+		{"resetScript", nativeResetScript},
+		{"freeScript", nativeFreeScript},
+		{"checkScriptDirty", nativeCheckScriptDirty},
 		{NULL, NULL}
 	};
 
@@ -560,87 +551,3 @@ int Toy_hookRunner(Toy_Interpreter* interpreter, Toy_Literal identifier, Toy_Lit
 	return 0;
 }
 
-//file system API
-static Toy_LiteralDictionary Toy_driveDictionary;
-
-void Toy_initDriveDictionary() {
-	Toy_initLiteralDictionary(&Toy_driveDictionary);
-}
-
-void Toy_freeDriveDictionary() {
-	Toy_freeLiteralDictionary(&Toy_driveDictionary);
-}
-
-Toy_LiteralDictionary* Toy_getDriveDictionary() {
-	return &Toy_driveDictionary;
-}
-
-Toy_Literal Toy_getFilePathLiteral(Toy_Interpreter* interpreter, Toy_Literal* drivePathLiteral) {
-	//check argument types
-	if (!TOY_IS_STRING(*drivePathLiteral)) {
-		interpreter->errorOutput("Incorrect argument type passed to Toy_getFilePathLiteral\n");
-		return TOY_TO_NULL_LITERAL;
-	}
-
-	Toy_RefString* drivePath = Toy_copyRefString(TOY_AS_STRING(*drivePathLiteral));
-
-	//get the drive and path as a string (can't trust that pesky strtok - custom split) TODO: move this to refstring library
-	size_t driveLength = 0;
-	while (Toy_toCString(drivePath)[driveLength] != ':') {
-		if (driveLength >= Toy_lengthRefString(drivePath)) {
-			interpreter->errorOutput("Incorrect drive path format given to Toy_getFilePathLiteral\n");
-
-			return TOY_TO_NULL_LITERAL;
-		}
-
-		driveLength++;
-	}
-
-	Toy_RefString* drive = Toy_createRefStringLength(Toy_toCString(drivePath), driveLength);
-	Toy_RefString* path = Toy_createRefStringLength( &Toy_toCString(drivePath)[driveLength + 1], Toy_lengthRefString(drivePath) - driveLength );
-
-	//get the real drive file path
-	Toy_Literal driveLiteral = TOY_TO_STRING_LITERAL(drive); //NOTE: driveLiteral takes ownership of the refString
-	Toy_Literal realDriveLiteral = Toy_getLiteralDictionary(Toy_getDriveDictionary(), driveLiteral);
-
-	if (!TOY_IS_STRING(realDriveLiteral)) {
-		interpreter->errorOutput("Incorrect literal type found for drive: ");
-		Toy_printLiteralCustom(realDriveLiteral, interpreter->errorOutput);
-		interpreter->errorOutput("\n");
-		Toy_freeLiteral(realDriveLiteral);
-		Toy_freeLiteral(driveLiteral);
-		Toy_deleteRefString(path);
-		Toy_deleteRefString(drivePath);
-
-		return TOY_TO_NULL_LITERAL;
-	}
-
-	//get the final real file path (concat) TODO: move this concat to refstring library
-	Toy_RefString* realDrive = Toy_copyRefString(TOY_AS_STRING(realDriveLiteral));
-	size_t realLength = Toy_lengthRefString(realDrive) + Toy_lengthRefString(path);
-
-	char* filePath = TOY_ALLOCATE(char, realLength + 1); //+1 for null
-	snprintf(filePath, realLength, "%s%s", Toy_toCString(realDrive), Toy_toCString(path));
-
-	//clean up the drivepath stuff
-	Toy_deleteRefString(realDrive);
-	Toy_freeLiteral(realDriveLiteral);
-	Toy_freeLiteral(driveLiteral);
-	Toy_deleteRefString(path);
-	Toy_deleteRefString(drivePath);
-
-	//check for break-out attempts
-	for (size_t i = 0; i < realLength - 1; i++) {
-		if (filePath[i] == '.' && filePath[i + 1] == '.') {
-			interpreter->errorOutput("Parent directory access not allowed\n");
-			TOY_FREE_ARRAY(char, filePath, realLength + 1);
-			return TOY_TO_NULL_LITERAL;
-		}
-	}
-
-	Toy_Literal result = TOY_TO_STRING_LITERAL(Toy_createRefStringLength(filePath, realLength));
-
-	TOY_FREE_ARRAY(char, filePath, realLength + 1);
-
-	return result;
-}

repl/lib_runner.h

@@ -4,12 +4,5 @@
 
 int Toy_hookRunner(Toy_Interpreter* interpreter, Toy_Literal identifier, Toy_Literal alias);
 
-//file system API - these need to be set by the host
-void Toy_initDriveDictionary();
-void Toy_freeDriveDictionary();
-Toy_LiteralDictionary* Toy_getDriveDictionary();
-
 #define TOY_OPAQUE_TAG_RUNNER 100
 
-//file system API - for use with other libs
-Toy_Literal Toy_getFilePathLiteral(Toy_Interpreter* interpreter, Toy_Literal* drivePathLiteral);

repl/repl_main.c

@@ -1,14 +1,12 @@
 #include "repl_tools.h"
 #include "lib_about.h"
 #include "lib_standard.h"
+#include "lib_random.h"
 #include "lib_runner.h"
 
 #include "toy_console_colors.h"
 
-#include "toy_lexer.h"
-#include "toy_parser.h"
-#include "toy_compiler.h"
-#include "toy_interpreter.h"
+#include "toy.h"
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -29,6 +27,7 @@ void repl(const char* initialInput) {
 	//inject the libs
 	Toy_injectNativeHook(&interpreter, "about", Toy_hookAbout);
 	Toy_injectNativeHook(&interpreter, "standard", Toy_hookStandard);
+	Toy_injectNativeHook(&interpreter, "random", Toy_hookRandom);
 	Toy_injectNativeHook(&interpreter, "runner", Toy_hookRunner);
 
 	for(;;) {
@@ -75,7 +74,7 @@ void repl(const char* initialInput) {
 
 		if (!error) {
 			//get the bytecode dump
-			int size = 0;
+			size_t size = 0;
 			unsigned char* tb = Toy_collateCompiler(&compiler, &size);
 
 			//run the bytecode
@@ -104,16 +103,9 @@ void repl(const char* initialInput) {
 int main(int argc, const char* argv[]) {
 	Toy_initCommandLine(argc, argv);
 
-	//lib setup (hacky - only really for this program)
-	Toy_initDriveDictionary();
-
-	Toy_Literal driveLiteral = TOY_TO_STRING_LITERAL(Toy_createRefString("scripts"));
-	Toy_Literal pathLiteral = TOY_TO_STRING_LITERAL(Toy_createRefString("scripts"));
-
-	Toy_setLiteralDictionary(Toy_getDriveDictionary(), driveLiteral, pathLiteral);
-
-	Toy_freeLiteral(driveLiteral);
-	Toy_freeLiteral(pathLiteral);
+	//setup the drive system (for filesystem access)
+	Toy_initDriveSystem();
+	Toy_setDrivePath("scripts", "scripts");
 
 	//command line specific actions
 	if (Toy_commandLine.error) {
@@ -149,7 +141,7 @@ int main(int argc, const char* argv[]) {
 		Toy_runSourceFile(Toy_commandLine.sourcefile);
 
 		//lib cleanup
-		Toy_freeDriveDictionary();
+		Toy_freeDriveSystem();
 
 		return 0;
 	}
@@ -159,7 +151,7 @@ int main(int argc, const char* argv[]) {
 		Toy_runSource(Toy_commandLine.source);
 
 		//lib cleanup
-		Toy_freeDriveDictionary();
+		Toy_freeDriveSystem();
 
 		return 0;
 	}
@@ -180,7 +172,7 @@ int main(int argc, const char* argv[]) {
 
 		//compile and save
 		size_t size = 0;
-		const char* source = Toy_readFile(Toy_commandLine.compilefile, &size);
+		const char* source = (const char*)Toy_readFile(Toy_commandLine.compilefile, &size);
 		if (!source) {
 			return 1;
 		}
@@ -201,11 +193,17 @@ int main(int argc, const char* argv[]) {
 			return -1;
 		}
 
-		//run the binary file
-		Toy_runBinaryFile(Toy_commandLine.binaryfile);
+		if (Toy_commandLine.parseBytecodeHeader) {
+			//only parse the bytecode header
+			Toy_parseBinaryFileHeader(Toy_commandLine.binaryfile);
+		}
+		else {
+			//run the binary file
+			Toy_runBinaryFile(Toy_commandLine.binaryfile);
+		}
 
 		//lib cleanup
-		Toy_freeDriveDictionary();
+		Toy_freeDriveSystem();
 
 		return 0;
 	}
@@ -220,13 +218,13 @@ int main(int argc, const char* argv[]) {
 		}
 
 		size_t size;
-		initialSource = Toy_readFile(Toy_commandLine.initialfile, &size);
+		initialSource = (const char*)Toy_readFile(Toy_commandLine.initialfile, &size);
 	}
 
 	repl(initialSource);
 
 	//lib cleanup
-	Toy_freeDriveDictionary();
+	Toy_freeDriveSystem();
 
 	return 0;
 }

repl/repl_tools.c

@@ -1,6 +1,7 @@
 #include "repl_tools.h"
 #include "lib_about.h"
 #include "lib_standard.h"
+#include "lib_random.h"
 #include "lib_runner.h"
 
 #include "toy_console_colors.h"
@@ -14,7 +15,7 @@
 #include <stdlib.h>
 
 //IO functions
-const char* Toy_readFile(const char* path, size_t* fileSize) {
+const unsigned char* Toy_readFile(const char* path, size_t* fileSize) {
 	FILE* file = fopen(path, "rb");
 
 	if (file == NULL) {
@@ -26,14 +27,14 @@ const char* Toy_readFile(const char* path, size_t* fileSize) {
 	*fileSize = ftell(file);
 	rewind(file);
 
-	char* buffer = (char*)malloc(*fileSize + 1);
+	unsigned char* buffer = (unsigned char*)malloc(*fileSize + 1);
 
 	if (buffer == NULL) {
 		fprintf(stderr, TOY_CC_ERROR "Not enough memory to read \"%s\"\n" TOY_CC_RESET, path);
 		return NULL;
 	}
 
-	size_t bytesRead = fread(buffer, sizeof(char), *fileSize, file);
+	size_t bytesRead = fread(buffer, sizeof(unsigned char), *fileSize, file);
 
 	buffer[*fileSize] = '\0'; //NOTE: fread doesn't append this
 
@@ -77,10 +78,10 @@ const unsigned char* Toy_compileString(const char* source, size_t* size) {
 	Toy_initParser(&parser, &lexer);
 	Toy_initCompiler(&compiler);
 
-	//run the parser until the end of the source
+	//step 1 - run the parser until the end of the source
 	Toy_ASTNode* node = Toy_scanParser(&parser);
 	while(node != NULL) {
-		//pack up and leave
+		//on error, pack up and leave
 		if (node->type == TOY_AST_NODE_ERROR) {
 			Toy_freeASTNode(node);
 			Toy_freeCompiler(&compiler);
@@ -93,8 +94,8 @@ const unsigned char* Toy_compileString(const char* source, size_t* size) {
 		node = Toy_scanParser(&parser);
 	}
 
-	//get the bytecode dump
-	const unsigned char* tb = Toy_collateCompiler(&compiler, (int*)(size));
+	//step 2 - get the bytecode dump
+	const unsigned char* tb = Toy_collateCompiler(&compiler, size);
 
 	//cleanup
 	Toy_freeCompiler(&compiler);
@@ -112,6 +113,7 @@ void Toy_runBinary(const unsigned char* tb, size_t size) {
 	//inject the libs
 	Toy_injectNativeHook(&interpreter, "about", Toy_hookAbout);
 	Toy_injectNativeHook(&interpreter, "standard", Toy_hookStandard);
+	Toy_injectNativeHook(&interpreter, "random", Toy_hookRandom);
 	Toy_injectNativeHook(&interpreter, "runner", Toy_hookRunner);
 
 	Toy_runInterpreter(&interpreter, tb, (int)size);
@@ -120,7 +122,7 @@ void Toy_runBinary(const unsigned char* tb, size_t size) {
 
 void Toy_runBinaryFile(const char* fname) {
 	size_t size = 0; //not used
-	const unsigned char* tb = (const unsigned char*)Toy_readFile(fname, &size);
+	const unsigned char* tb = Toy_readFile(fname, &size);
 	if (!tb) {
 		return;
 	}
@@ -140,10 +142,66 @@ void Toy_runSource(const char* source) {
 
 void Toy_runSourceFile(const char* fname) {
 	size_t size = 0; //not used
-	const char* source = Toy_readFile(fname, &size);
+	const char* source = (const char*)Toy_readFile(fname, &size);
 	if (!source) {
 		return;
 	}
 	Toy_runSource(source);
 	free((void*)source);
 }
+
+//utils for debugging the header
+static unsigned char readByte(const unsigned char* tb, int* count) {
+	unsigned char ret = *(unsigned char*)(tb + *count);
+	*count += 1;
+	return ret;
+}
+
+static const char* readString(const unsigned char* tb, int* count) {
+	const unsigned char* ret = tb + *count;
+	*count += strlen((char*)ret) + 1; //+1 for null character
+	return (const char*)ret;
+}
+
+void Toy_parseBinaryFileHeader(const char* fname) {
+	size_t size = 0; //not used
+	const unsigned char* tb = Toy_readFile(fname, &size);
+	if (!tb || size < 4) {
+		return;
+	}
+
+	int count = 0;
+
+	//header section
+	const unsigned char major = readByte(tb, &count);
+	const unsigned char minor = readByte(tb, &count);
+	const unsigned char patch = readByte(tb, &count);
+
+	const char* build = readString(tb, &count);
+
+	printf("Toy Programming Language Interpreter Version %d.%d.%d (interpreter built on %s)\n\n", TOY_VERSION_MAJOR, TOY_VERSION_MINOR, TOY_VERSION_PATCH, TOY_VERSION_BUILD);
+
+	printf("Toy Programming Language Bytecode Version ");
+
+	//print the output
+	if (major == TOY_VERSION_MAJOR && minor == TOY_VERSION_MINOR && patch == TOY_VERSION_PATCH) {
+		printf("%d.%d.%d", major, minor, patch);
+	}
+	else {
+		printf(TOY_CC_FONT_YELLOW TOY_CC_BACK_BLACK "%d.%d.%d" TOY_CC_RESET, major, minor, patch);
+	}
+
+	printf(" (interpreter built on ");
+
+	if (strncmp(build, TOY_VERSION_BUILD, strlen(TOY_VERSION_BUILD)) == 0) {
+		printf("%s", build);
+	}
+	else {
+		printf(TOY_CC_FONT_YELLOW TOY_CC_BACK_BLACK "%s" TOY_CC_RESET, build);
+	}
+
+	printf(")\n");
+
+	//cleanup
+	free((void*)tb);
+}

repl/repl_tools.h

@@ -2,7 +2,7 @@
 
 #include "toy_common.h"
 
-const char* Toy_readFile(const char* path, size_t* fileSize);
+const unsigned char* Toy_readFile(const char* path, size_t* fileSize);
 int Toy_writeFile(const char* path, const unsigned char* bytes, size_t size);
 
 const unsigned char* Toy_compileString(const char* source, size_t* size);
@@ -12,3 +12,4 @@ void Toy_runBinaryFile(const char* fname);
 void Toy_runSource(const char* source);
 void Toy_runSourceFile(const char* fname);
 
+void Toy_parseBinaryFileHeader(const char* fname);

scripts/example-entity.toy

@@ -1,125 +0,0 @@
-import node;
-
-//constants
-var SPEED: int const = 10;
-
-//variables
-var parent: opaque = null;
-var posX: int = 50;
-var posY: int = 50;
-var WIDTH: int const = 100;
-var HEIGHT: int const = 100;
-
-var xspeed: int = 0;
-var yspeed: int = 0;
-
-//accessors - variables are private, functions are public
-fn getX(node: opaque) {
-	return posX;
-}
-
-fn getY(node: opaque) {
-	return posY;
-}
-
-//lifecycle functions
-fn onInit(node: opaque) {
-	print "render.toy:onInit() called\n";
-
-	node.loadTexture("sprites:/character.png");
-	parent = node.getNodeParent();
-}
-
-fn onStep(node: opaque) {
-	posX += xspeed;
-	posY += yspeed;
-}
-
-fn onFree(node: opaque) {
-	print "render.toy:onFree() called\n";
-
-	node.freeTexture();
-}
-
-fn onDraw(node: opaque) {
-//	print "render.toy:onDraw() called\n";
-
-	var px = parent.callNode("getX");
-	var py = parent.callNode("getY");
-
-	if (px == null) {
-		px = 0;
-	}
-
-	if (py == null) {
-		py = 0;
-	}
-
-	node.drawNode(posX + px, posY + py, WIDTH, HEIGHT);
-}
-
-//event functions
-fn onKeyDown(node: opaque, event: string) {
-	if (event == "character_up") {
-		yspeed -= SPEED;
-		return;
-	}
-
-	if (event == "character_down") {
-		yspeed += SPEED;
-		return;
-	}
-
-	if (event == "character_left") {
-		xspeed -= SPEED;
-		return;
-	}
-
-	if (event == "character_right") {
-		xspeed += SPEED;
-		return;
-	}
-}
-
-fn onKeyUp(node: opaque, event: string) {
-	if (event == "character_up" && yspeed < 0) {
-		yspeed = 0;
-		return;
-	}
-
-	if (event == "character_down" && yspeed > 0) {
-		yspeed = 0;
-		return;
-	}
-
-	if (event == "character_left" && xspeed < 0) {
-		xspeed = 0;
-		return;
-	}
-
-	if (event == "character_right" && xspeed > 0) {
-		xspeed = 0;
-		return;
-	}
-}
-
-fn onMouseMotion(node: opaque, x: int, y: int, xrel: int, yrel: int) {
-	// print "entity.toy:onMouseMotion(" + string x + ", " + string y + ", " + string xrel + ", " + string yrel + ")\n";
-}
-
-fn onMouseButtonDown(node: opaque, x: int, y: int, button: string) {
-	// print "entity.toy:onMouseButtonDown(" + string x + ", " + string y + ", " + button + ")\n";
-
-	//jump to pos
-	posX = x - WIDTH / 2;
-	posY = y - HEIGHT / 2;
-}
-
-fn onMouseButtonUp(node: opaque, x: int, y: int, button: string) {
-	// print "entity.toy:onMouseButtonUp(" + string x + ", " + string y + ", " + button + ")\n";
-}
-
-fn onMouseWheel(node: opaque, xrel: int, yrel: int) {
-	// print "entity.toy:onMouseWheel(" + string xrel + ", " + string yrel + ")\n";
-}
-

scripts/example.toy

@@ -1,89 +0,0 @@
-//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-memo.toy

@@ -17,5 +17,5 @@ fn fib(n : int) {
 
 for (var i = 0; i < 40; i++) {
 	var res = fib(i);
-	print string i + ": " + string res + "\n";
+	print string i + ": " + string res;
 }

scripts/fib.toy

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

scripts/level.toy

@@ -1,3 +1,18 @@
+/*
+
+How to run this program:
+
+	toyrepl -n -t scripts/level.toy
+
+How to move around:
+
+	move(up);
+	move(down);
+	move(left);
+	move(right);
+
+*/
+
 //constants
 var WIDTH: int const = 12;
 var HEIGHT: int const = 12;
@@ -19,8 +34,8 @@ var tiles: [[int]] const = [
 ];
 
 var tileset: [int: string] const = [
-	0: "   ",
-	1: " X "
+	0: "  ",
+	1: "X "
 ];
 
 //variables
@@ -33,7 +48,7 @@ fn draw() {
 		for (var i: int = 0; i < WIDTH; i++) {
 			//draw the player pos
 			if (i == posX && j == posY) {
-				print " O ";
+				print "O ";
 				continue;
 			}
 

scripts/roguelike-seeds.toy

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

scripts/rule110.toy

@@ -1,5 +1,5 @@
 //number of iterations
-var SIZE: int const = 260;
+var SIZE: int const = 100;
 
 //lookup table
 var lookup = [
@@ -29,7 +29,7 @@ for (var i = 0; i < SIZE -1; i++) {
 	prev += " ";
 }
 prev += "*"; //initial
-print prev + "\n";
+print prev;
 
 //run
 for (var iteration = 0; iteration < SIZE -1; iteration++) {
@@ -44,6 +44,6 @@ for (var iteration = 0; iteration < SIZE -1; iteration++) {
 	//right
 	output += (lookup[prev[SIZE-2]][prev[SIZE-1]][" "]);
 
-	print output + "\n";
+	print output;
 	prev = output;
 }

scripts/small.toy

@@ -1,27 +0,0 @@
-import compound;
-
-fn less(a, b) {
-	return a < b;
-}
-
-fn greater(a, b) {
-	return a > b;
-}
-
-var a = [7, 2, 1, 8, 6, 3, 5, 4];
-var b = [7, 2, 1, 4, 6, 3, 5, 8];
-var c = [1, 2, 3, 4, 5, 6, 7, 8];
-var d = [7, 2, 1, 8, 6, 3, 5, 4];
-
-a = a.sort(less);
-b = b.sort(less);
-c = c.sort(less);
-d = d.sort(greater);
-
-assert a == [1, 2, 3, 4, 5, 6, 7, 8], "array.sort(less) failed";
-assert b == [1, 2, 3, 4, 5, 6, 7, 8], "array.sort(less) with pivot high failed";
-assert c == [1, 2, 3, 4, 5, 6, 7, 8], "array.sort(less) pre-sorted array failed";
-assert d == [8, 7, 6, 5, 4, 3, 2, 1], "array.sort(greater) failed";
-
-
-print "All good";

source/toy.h

@@ -0,0 +1,70 @@
+#pragma once
+
+/* toy.h - A Toy Programming Language
+
+If you're looking how to use Toy directly, try https://toylang.com/
+Otherwise, these headers may help learn how Toy works internally.
+
+*/
+
+/* utilities - these define a bunch of useful macros based on platform.
+
+The most important one is `TOY_API`, which highlights functions intended for the end user.
+
+*/
+
+#include "toy_common.h"
+#include "toy_console_colors.h"
+#include "toy_memory.h"
+#include "toy_drive_system.h"
+
+/* core pipeline - from source to execution
+
+Each step is as follows:
+
+source   -> lexer       -> token
+token    -> parser      -> AST
+AST      -> compiler    -> bytecode
+bytecode -> interpreter -> result
+
+I should note that the parser -> compiler phase is actually made up of two steps - the write step
+and the collate step. See `Toy_compileString()` in `repl/repl_tools.c` for an example of how to compile
+properly.
+
+*/
+
+#include "toy_lexer.h"
+#include "toy_parser.h"
+#include "toy_compiler.h"
+#include "toy_interpreter.h"
+
+/* building block structures - the basic units of operation
+
+Literals represent any value within the language, including some internal ones that you never see.
+Literal Arrays are literally arrays within memory, and are the most heavily used structure in Toy.
+Literal Dictionaries are unordered key-value hashmaps, that use a running strategy for collisions.
+
+*/
+
+#include "toy_literal.h"
+#include "toy_literal_array.h"
+#include "toy_literal_dictionary.h"
+
+/* other components - you probably won't use these directly, but they're a good learning opportunity.
+
+`Toy_Scope` holds the variables of a specific scope within Toy - be it a script, a function, a block, etc.
+Scopes are also where the type system lives at runtime. They use identifier literals as keys, exclusively.
+
+`Toy_RefString` is a utility class that wraps traditional C strings, making them less memory intensive and
+faster to copy and move. In reality, since strings are considered immutable, multiple variables can point
+to the same string to save memory, and you can just create a new one of these vars pointing to the original
+rather than copying entirely for a speed boost. This module has it's own memory allocator system that is
+plugged into the main memory allocator.
+
+`Toy_RefFunction` acts similarly to `Toy_RefString`, but instead operates on function bytecode.
+
+*/
+
+#include "toy_scope.h"
+#include "toy_refstring.h"
+#include "toy_reffunction.h"

source/toy_ast_node.c

@@ -40,17 +40,21 @@ static void freeASTNodeCustom(Toy_ASTNode* node, bool freeSelf) {
 		break;
 
 		case TOY_AST_NODE_BLOCK:
-			for (int i = 0; i < node->block.count; i++) {
-				freeASTNodeCustom(node->block.nodes + i, false);
+			if (node->block.capacity > 0) {
+				for (int i = 0; i < node->block.count; i++) {
+					freeASTNodeCustom(node->block.nodes + i, false);
+				}
+				TOY_FREE_ARRAY(Toy_ASTNode, node->block.nodes, node->block.capacity);
 			}
-			TOY_FREE_ARRAY(Toy_ASTNode, node->block.nodes, node->block.capacity);
 		break;
 
 		case TOY_AST_NODE_COMPOUND:
-			for (int i = 0; i < node->compound.count; i++) {
-				freeASTNodeCustom(node->compound.nodes + i, false);
+			if (node->compound.capacity > 0) {
+				for (int i = 0; i < node->compound.count; i++) {
+					freeASTNodeCustom(node->compound.nodes + i, false);
+				}
+				TOY_FREE_ARRAY(Toy_ASTNode, node->compound.nodes, node->compound.capacity);
 			}
-			TOY_FREE_ARRAY(Toy_ASTNode, node->compound.nodes, node->compound.capacity);
 		break;
 
 		case TOY_AST_NODE_PAIR:
@@ -71,10 +75,12 @@ static void freeASTNodeCustom(Toy_ASTNode* node, bool freeSelf) {
 		break;
 
 		case TOY_AST_NODE_FN_COLLECTION:
-			for (int i = 0; i < node->fnCollection.count; i++) {
-				freeASTNodeCustom(node->fnCollection.nodes + i, false);
+			if (node->fnCollection.capacity > 0) {
+				for (int i = 0; i < node->fnCollection.count; i++) {
+					freeASTNodeCustom(node->fnCollection.nodes + i, false);
+				}
+				TOY_FREE_ARRAY(Toy_ASTNode, node->fnCollection.nodes, node->fnCollection.capacity);
 			}
-			TOY_FREE_ARRAY(Toy_ASTNode, node->fnCollection.nodes, node->fnCollection.capacity);
 		break;
 
 		case TOY_AST_NODE_FN_DECL:
@@ -135,6 +141,10 @@ static void freeASTNodeCustom(Toy_ASTNode* node, bool freeSelf) {
 			Toy_freeLiteral(node->import.identifier);
 			Toy_freeLiteral(node->import.alias);
 		break;
+
+		case TOY_AST_NODE_PASS:
+			//EMPTY
+		break;
 	}
 
 	if (freeSelf) {
@@ -383,3 +393,11 @@ void Toy_emitASTNodeImport(Toy_ASTNode** nodeHandle, Toy_Literal identifier, Toy
 
 	*nodeHandle = tmp;
 }
+
+void Toy_emitASTNodePass(Toy_ASTNode** nodeHandle) {
+	Toy_ASTNode* tmp = TOY_ALLOCATE(Toy_ASTNode, 1);
+
+	tmp->type = TOY_AST_NODE_PASS;
+
+	*nodeHandle = tmp;
+}

source/toy_ast_node.h

@@ -34,6 +34,7 @@ typedef enum Toy_ASTNodeType {
 	TOY_AST_NODE_PREFIX_DECREMENT, //decrement a variable
 	TOY_AST_NODE_POSTFIX_DECREMENT, //decrement a variable
 	TOY_AST_NODE_IMPORT, //import a library
+	TOY_AST_NODE_PASS, //for doing nothing
 } Toy_ASTNodeType;
 
 //literals
@@ -238,6 +239,9 @@ typedef struct Toy_NodeImport {
 	Toy_Literal alias;
 } Toy_NodeImport;
 
+//for doing nothing
+void Toy_emitASTNodePass(Toy_ASTNode** nodeHandle);
+
 union Toy_private_node {
 	Toy_ASTNodeType type;
 	Toy_NodeLiteral atomic;

source/toy_builtin.c

@@ -4,6 +4,7 @@
 #include "toy_literal.h"
 
 #include <stdio.h>
+#include <string.h>
 
 //static math utils, copied from the interpreter
 static Toy_Literal addition(Toy_Interpreter* interpreter, Toy_Literal lhs, Toy_Literal rhs) {
@@ -278,6 +279,17 @@ int Toy_private_index(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments)
 			Toy_freeLiteral(idn);
 		}
 
+		if (TOY_IS_IDENTIFIER(first) || TOY_IS_IDENTIFIER(second) || TOY_IS_IDENTIFIER(third)) {
+			Toy_freeLiteral(op);
+			Toy_freeLiteral(assign);
+			Toy_freeLiteral(third);
+			Toy_freeLiteral(second);
+			Toy_freeLiteral(first);
+			Toy_freeLiteral(compound);
+
+			return -1;
+		}
+
 		//second and third are bad args to dictionaries
 		if (!TOY_IS_NULL(second) || !TOY_IS_NULL(third)) {
 			interpreter->errorOutput("Index slicing not allowed for dictionaries\n");
@@ -400,6 +412,17 @@ int Toy_private_index(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments)
 				Toy_freeLiteral(idn);
 			}
 
+			if (TOY_IS_IDENTIFIER(first) || TOY_IS_IDENTIFIER(second) || TOY_IS_IDENTIFIER(third)) {
+				Toy_freeLiteral(op);
+				Toy_freeLiteral(assign);
+				Toy_freeLiteral(third);
+				Toy_freeLiteral(second);
+				Toy_freeLiteral(first);
+				Toy_freeLiteral(compound);
+
+				return -1;
+			}
+
 			//handle each error case
 			if (!TOY_IS_INTEGER(first) || TOY_AS_INTEGER(first) < 0 || TOY_AS_INTEGER(first) >= TOY_AS_ARRAY(compound)->count) {
 				interpreter->errorOutput("Bad first indexing\n");
@@ -542,6 +565,17 @@ int Toy_private_index(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments)
 				Toy_freeLiteral(idn);
 			}
 
+			if (TOY_IS_IDENTIFIER(first) || TOY_IS_IDENTIFIER(second) || TOY_IS_IDENTIFIER(third)) {
+				Toy_freeLiteral(op);
+				Toy_freeLiteral(assign);
+				Toy_freeLiteral(third);
+				Toy_freeLiteral(second);
+				Toy_freeLiteral(first);
+				Toy_freeLiteral(compound);
+
+				return -1;
+			}
+
 			//handle each error case
 			if (!TOY_IS_INTEGER(first) || TOY_AS_INTEGER(first) < 0 || TOY_AS_INTEGER(first) >= TOY_AS_ARRAY(compound)->count) {
 				interpreter->errorOutput("Bad first indexing assignment\n");
@@ -587,7 +621,7 @@ int Toy_private_index(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments)
 
 			//simple indexing assignment if second is null
 			if (TOY_IS_NULL(second)) {
-				bool ret = -1;
+				int ret = -1;
 
 				if (!Toy_setLiteralArray(TOY_AS_ARRAY(compound), first, assign)) {
 					interpreter->errorOutput("Array index out of bounds in assignment");
@@ -595,6 +629,7 @@ int Toy_private_index(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments)
 				}
 				else {
 					Toy_pushLiteralArray(&interpreter->stack, compound); //leave the array on the stack
+					//...
 					ret = 1;
 				}
 
@@ -704,6 +739,17 @@ int Toy_private_index(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments)
 			Toy_freeLiteral(idn);
 		}
 
+		if (TOY_IS_IDENTIFIER(first)) {
+			Toy_freeLiteral(op);
+			Toy_freeLiteral(assign);
+			Toy_freeLiteral(third);
+			Toy_freeLiteral(second);
+			Toy_freeLiteral(first);
+			Toy_freeLiteral(compound);
+
+			return -1;
+		}
+
 		Toy_Literal value = Toy_getLiteralArray(TOY_AS_ARRAY(compound), first);
 
 		if (TOY_IS_STRING(op) && Toy_equalsRefStringCString(TOY_AS_STRING(op), "+=")) {
@@ -792,6 +838,17 @@ int Toy_private_index(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments)
 				Toy_freeLiteral(idn);
 			}
 
+			if (TOY_IS_IDENTIFIER(first) || TOY_IS_IDENTIFIER(second) || TOY_IS_IDENTIFIER(third)) {
+				Toy_freeLiteral(op);
+				Toy_freeLiteral(assign);
+				Toy_freeLiteral(third);
+				Toy_freeLiteral(second);
+				Toy_freeLiteral(first);
+				Toy_freeLiteral(compound);
+
+				return -1;
+			}
+
 			//handle each error case
 			if (!TOY_IS_INTEGER(first) || TOY_AS_INTEGER(first) < 0 || TOY_AS_INTEGER(first) >= (int)Toy_lengthRefString(TOY_AS_STRING(compound))) {
 				interpreter->errorOutput("Bad first indexing in string\n");
@@ -936,6 +993,17 @@ int Toy_private_index(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments)
 				Toy_freeLiteral(idn);
 			}
 
+			if (TOY_IS_IDENTIFIER(first) || TOY_IS_IDENTIFIER(second) || TOY_IS_IDENTIFIER(third)) {
+				Toy_freeLiteral(op);
+				Toy_freeLiteral(assign);
+				Toy_freeLiteral(third);
+				Toy_freeLiteral(second);
+				Toy_freeLiteral(first);
+				Toy_freeLiteral(compound);
+
+				return -1;
+			}
+
 			//handle each error case
 			if (!TOY_IS_INTEGER(first) || TOY_AS_INTEGER(first) < 0 || TOY_AS_INTEGER(first) >= (int)Toy_lengthRefString(TOY_AS_STRING(compound))) {
 				interpreter->errorOutput("Bad first indexing in string assignment\n");
@@ -1063,7 +1131,7 @@ int Toy_private_index(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments)
 int Toy_private_set(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments) {
 	//if wrong number of arguments, fail
 	if (arguments->count != 3) {
-		interpreter->errorOutput("Incorrect number of arguments to _set\n");
+		interpreter->errorOutput("Incorrect number of arguments to set\n");
 		return -1;
 	}
 
@@ -1073,12 +1141,16 @@ int Toy_private_set(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments) {
 	Toy_Literal val = arguments->literals[2];
 
 	if (!TOY_IS_IDENTIFIER(idn)) {
-		interpreter->errorOutput("Expected identifier in _set\n");
+		interpreter->errorOutput("Expected identifier in set\n");
 		return -1;
 	}
 
 	Toy_parseIdentifierToValue(interpreter, &obj);
 
+	if (TOY_IS_IDENTIFIER(obj)) {
+		return -1;
+	}
+
 	bool freeKey = false;
 	if (TOY_IS_IDENTIFIER(key)) {
 		Toy_parseIdentifierToValue(interpreter, &key);
@@ -1091,26 +1163,40 @@ int Toy_private_set(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments) {
 		freeVal = true;
 	}
 
+	if (TOY_IS_IDENTIFIER(key) || TOY_IS_IDENTIFIER(val)) {
+		if (freeKey) {
+			Toy_freeLiteral(key);
+		}
+		if (freeVal) {
+			Toy_freeLiteral(val);
+		}
+		return -1;
+	}
+
 	switch(obj.type) {
 		case TOY_LITERAL_ARRAY: {
-			Toy_Literal typeLiteral = Toy_getScopeType(interpreter->scope, key);
+			//check the subtype of the array, if there is one, against the given argument
+			Toy_Literal typeLiteral = Toy_getScopeType(interpreter->scope, idn);
 
 			if (TOY_AS_TYPE(typeLiteral).typeOf == TOY_LITERAL_ARRAY) {
 				Toy_Literal subtypeLiteral = ((Toy_Literal*)(TOY_AS_TYPE(typeLiteral).subtypes))[0];
 
 				if (TOY_AS_TYPE(subtypeLiteral).typeOf != TOY_LITERAL_ANY && TOY_AS_TYPE(subtypeLiteral).typeOf != val.type) {
-					interpreter->errorOutput("Bad argument type in _set\n");
+					interpreter->errorOutput("Bad argument type in set\n");
+					Toy_freeLiteral(typeLiteral);
 					return -1;
 				}
 			}
 
+			Toy_freeLiteral(typeLiteral);
+
 			if (!TOY_IS_INTEGER(key)) {
-				interpreter->errorOutput("Expected integer index in _set\n");
+				interpreter->errorOutput("Expected integer index in set\n");
 				return -1;
 			}
 
-			if (TOY_AS_ARRAY(obj)->count <= TOY_AS_INTEGER(key) || TOY_AS_INTEGER(key) < 0) {
-				interpreter->errorOutput("Index out of bounds in _set\n");
+			if (TOY_AS_INTEGER(key) >= TOY_AS_ARRAY(obj)->count || TOY_AS_INTEGER(key) < 0) {
+				interpreter->errorOutput("Index out of bounds in set\n");
 				return -1;
 			}
 
@@ -1119,7 +1205,7 @@ int Toy_private_set(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments) {
 			TOY_AS_ARRAY(obj)->literals[TOY_AS_INTEGER(key)] = Toy_copyLiteral(val);
 
 			if (!Toy_setScopeVariable(interpreter->scope, idn, obj, true)) {
-				interpreter->errorOutput("Incorrect type assigned to array in _set: \"");
+				interpreter->errorOutput("Incorrect type assigned to array in set: \"");
 				Toy_printLiteralCustom(val, interpreter->errorOutput);
 				interpreter->errorOutput("\"\n");
 				return -1;
@@ -1136,12 +1222,12 @@ int Toy_private_set(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments) {
 				Toy_Literal valSubtypeLiteral = ((Toy_Literal*)(TOY_AS_TYPE(typeLiteral).subtypes))[1];
 
 				if (TOY_AS_TYPE(keySubtypeLiteral).typeOf != TOY_LITERAL_ANY && TOY_AS_TYPE(keySubtypeLiteral).typeOf != key.type) {
-					interpreter->printOutput("bad argument type in _set\n");
+					interpreter->printOutput("bad argument type in set\n");
 					return -1;
 				}
 
 				if (TOY_AS_TYPE(valSubtypeLiteral).typeOf != TOY_LITERAL_ANY && TOY_AS_TYPE(valSubtypeLiteral).typeOf != val.type) {
-					interpreter->printOutput("bad argument type in _set\n");
+					interpreter->printOutput("bad argument type in set\n");
 					return -1;
 				}
 			}
@@ -1149,7 +1235,7 @@ int Toy_private_set(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments) {
 			Toy_setLiteralDictionary(TOY_AS_DICTIONARY(obj), key, val);
 
 			if (!Toy_setScopeVariable(interpreter->scope, idn, obj, true)) {
-				interpreter->errorOutput("Incorrect type assigned to dictionary in _set: \"");
+				interpreter->errorOutput("Incorrect type assigned to dictionary in set: \"");
 				Toy_printLiteralCustom(val, interpreter->errorOutput);
 				interpreter->errorOutput("\"\n");
 				return -1;
@@ -1159,7 +1245,7 @@ int Toy_private_set(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments) {
 		}
 
 		default:
-			interpreter->errorOutput("Incorrect compound type in _set: ");
+			interpreter->errorOutput("Incorrect compound type in set: ");
 			Toy_printLiteralCustom(obj, interpreter->errorOutput);
 			interpreter->errorOutput("\"\n");
 			return -1;
@@ -1181,7 +1267,7 @@ int Toy_private_set(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments) {
 int Toy_private_get(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments) {
 	//if wrong number of arguments, fail
 	if (arguments->count != 2) {
-		interpreter->errorOutput("Incorrect number of arguments to _get");
+		interpreter->errorOutput("Incorrect number of arguments to get");
 		return -1;
 	}
 
@@ -1200,15 +1286,25 @@ int Toy_private_get(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments) {
 		freeKey = true;
 	}
 
+	if (TOY_IS_IDENTIFIER(obj) || TOY_IS_IDENTIFIER(key)) {
+		if (freeObj) {
+			Toy_freeLiteral(obj);
+		}
+		if (freeKey) {
+			Toy_freeLiteral(key);
+		}
+		return -1;
+	}
+
 	switch(obj.type) {
 		case TOY_LITERAL_ARRAY: {
 			if (!TOY_IS_INTEGER(key)) {
-				interpreter->errorOutput("Expected integer index in _get\n");
+				interpreter->errorOutput("Expected integer index in get\n");
 				return -1;
 			}
 
-			if (TOY_AS_ARRAY(obj)->count <= TOY_AS_INTEGER(key) || TOY_AS_INTEGER(key) < 0) {
-				interpreter->errorOutput("Index out of bounds in _get\n");
+			if (TOY_AS_INTEGER(key) >= TOY_AS_ARRAY(obj)->count || TOY_AS_INTEGER(key) < 0) {
+				interpreter->errorOutput("Index out of bounds in get\n");
 				return -1;
 			}
 
@@ -1242,7 +1338,7 @@ int Toy_private_get(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments) {
 		}
 
 		default:
-			interpreter->errorOutput("Incorrect compound type in _get \"");
+			interpreter->errorOutput("Incorrect compound type in get \"");
 			Toy_printLiteralCustom(obj, interpreter->errorOutput);
 			interpreter->errorOutput("\"\n");
 			return -1;
@@ -1252,7 +1348,7 @@ int Toy_private_get(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments) {
 int Toy_private_push(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments) {
 	//if wrong number of arguments, fail
 	if (arguments->count != 2) {
-		interpreter->errorOutput("Incorrect number of arguments to _push\n");
+		interpreter->errorOutput("Incorrect number of arguments to push\n");
 		return -1;
 	}
 
@@ -1261,35 +1357,47 @@ int Toy_private_push(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments)
 	Toy_Literal val = arguments->literals[1];
 
 	if (!TOY_IS_IDENTIFIER(idn)) {
-		interpreter->errorOutput("Expected identifier in _push\n");
+		interpreter->errorOutput("Expected identifier in push\n");
 		return -1;
 	}
 
 	Toy_parseIdentifierToValue(interpreter, &obj);
 
+	if (TOY_IS_IDENTIFIER(obj)) {
+		return -1;
+	}
+
 	bool freeVal = false;
 	if (TOY_IS_IDENTIFIER(val)) {
 		Toy_parseIdentifierToValue(interpreter, &val);
 		freeVal = true;
 	}
 
+	if (TOY_IS_IDENTIFIER(val)) {
+		return -1;
+	}
+
 	switch(obj.type) {
 		case TOY_LITERAL_ARRAY: {
-			Toy_Literal typeLiteral = Toy_getScopeType(interpreter->scope, val);
+			//check the subtype of the array, if there is one, against the given argument
+			Toy_Literal typeLiteral = Toy_getScopeType(interpreter->scope, idn);
 
 			if (TOY_AS_TYPE(typeLiteral).typeOf == TOY_LITERAL_ARRAY) {
 				Toy_Literal subtypeLiteral = ((Toy_Literal*)(TOY_AS_TYPE(typeLiteral).subtypes))[0];
 
 				if (TOY_AS_TYPE(subtypeLiteral).typeOf != TOY_LITERAL_ANY && TOY_AS_TYPE(subtypeLiteral).typeOf != val.type) {
-					interpreter->errorOutput("Bad argument type in _push");
+					interpreter->errorOutput("Bad argument type in push\n");
+					Toy_freeLiteral(typeLiteral);
 					return -1;
 				}
 			}
 
+			Toy_freeLiteral(typeLiteral);
+
 			Toy_pushLiteralArray(TOY_AS_ARRAY(obj), val);
 
 			if (!Toy_setScopeVariable(interpreter->scope, idn, obj, true)) { //TODO: could definitely be more efficient than overwriting the whole original object
-				interpreter->errorOutput("Incorrect type assigned to array in _push: \"");
+				interpreter->errorOutput("Incorrect type assigned to array in push: \"");
 				Toy_printLiteralCustom(val, interpreter->errorOutput);
 				interpreter->errorOutput("\"\n");
 				return -1;
@@ -1305,7 +1413,7 @@ int Toy_private_push(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments)
 		}
 
 		default:
-			interpreter->errorOutput("Incorrect compound type in _push: ");
+			interpreter->errorOutput("Incorrect compound type in push: ");
 			Toy_printLiteralCustom(obj, interpreter->errorOutput);
 			interpreter->errorOutput("\n");
 			return -1;
@@ -1315,7 +1423,7 @@ int Toy_private_push(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments)
 int Toy_private_pop(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments) {
 	//if wrong number of arguments, fail
 	if (arguments->count != 1) {
-		interpreter->errorOutput("Incorrect number of arguments to _pop\n");
+		interpreter->errorOutput("Incorrect number of arguments to pop\n");
 		return -1;
 	}
 
@@ -1323,12 +1431,16 @@ int Toy_private_pop(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments) {
 	Toy_Literal obj = arguments->literals[0];
 
 	if (!TOY_IS_IDENTIFIER(idn)) {
-		interpreter->errorOutput("Expected identifier in _pop\n");
+		interpreter->errorOutput("Expected identifier in pop\n");
 		return -1;
 	}
 
 	Toy_parseIdentifierToValue(interpreter, &obj);
 
+	if (TOY_IS_IDENTIFIER(obj)) {
+		return -1;
+	}
+
 	switch(obj.type) {
 		case TOY_LITERAL_ARRAY: {
 			Toy_Literal lit = Toy_popLiteralArray(TOY_AS_ARRAY(obj));
@@ -1336,7 +1448,7 @@ int Toy_private_pop(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments) {
 			Toy_freeLiteral(lit);
 
 			if (!Toy_setScopeVariable(interpreter->scope, idn, obj, true)) { //TODO: could definitely be more efficient than overwriting the whole original object
-				interpreter->errorOutput("Incorrect type assigned to array in _pop: ");
+				interpreter->errorOutput("Incorrect type assigned to array in pop: ");
 				Toy_printLiteralCustom(obj, interpreter->errorOutput);
 				interpreter->errorOutput("\n");
 				return -1;
@@ -1348,7 +1460,7 @@ int Toy_private_pop(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments) {
 		}
 
 		default:
-			interpreter->errorOutput("Incorrect compound type in _pop: ");
+			interpreter->errorOutput("Incorrect compound type in pop: ");
 			Toy_printLiteralCustom(obj, interpreter->errorOutput);
 			interpreter->errorOutput("\n");
 			return -1;
@@ -1358,7 +1470,7 @@ int Toy_private_pop(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments) {
 int Toy_private_length(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments) {
 	//if wrong number of arguments, fail
 	if (arguments->count != 1) {
-		interpreter->errorOutput("Incorrect number of arguments to _length\n");
+		interpreter->errorOutput("Incorrect number of arguments to length\n");
 		return -1;
 	}
 
@@ -1370,6 +1482,10 @@ int Toy_private_length(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments
 		freeObj = true;
 	}
 
+	if (TOY_IS_IDENTIFIER(obj)) {
+		return -1;
+	}
+
 	switch(obj.type) {
 		case TOY_LITERAL_ARRAY: {
 			Toy_Literal lit = TOY_TO_INTEGER_LITERAL( TOY_AS_ARRAY(obj)->count );
@@ -1393,7 +1509,7 @@ int Toy_private_length(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments
 		}
 
 		default:
-			interpreter->errorOutput("Incorrect compound type in _length: ");
+			interpreter->errorOutput("Incorrect compound type in length: ");
 			Toy_printLiteralCustom(obj, interpreter->errorOutput);
 			interpreter->errorOutput("\n");
 			return -1;
@@ -1409,7 +1525,7 @@ int Toy_private_length(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments
 int Toy_private_clear(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments) {
 	//if wrong number of arguments, fail
 	if (arguments->count != 1) {
-		interpreter->errorOutput("Incorrect number of arguments to _clear\n");
+		interpreter->errorOutput("Incorrect number of arguments to clear\n");
 		return -1;
 	}
 
@@ -1417,12 +1533,16 @@ int Toy_private_clear(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments)
 	Toy_Literal obj = arguments->literals[0];
 
 	if (!TOY_IS_IDENTIFIER(idn)) {
-		interpreter->errorOutput("expected identifier in _clear\n");
+		interpreter->errorOutput("expected identifier in clear\n");
 		return -1;
 	}
 
 	Toy_parseIdentifierToValue(interpreter, &obj);
 
+	if (TOY_IS_IDENTIFIER(obj)) {
+		return -1;
+	}
+
 	//NOTE: just pass in new compounds
 
 	switch(obj.type) {
@@ -1433,7 +1553,7 @@ int Toy_private_clear(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments)
 			Toy_Literal obj = TOY_TO_ARRAY_LITERAL(array);
 
 			if (!Toy_setScopeVariable(interpreter->scope, idn, obj, true)) {
-				interpreter->errorOutput("Incorrect type assigned to array in _clear: ");
+				interpreter->errorOutput("Incorrect type assigned to array in clear: ");
 				Toy_printLiteralCustom(obj, interpreter->errorOutput);
 				interpreter->errorOutput("\n");
 				return -1;
@@ -1451,7 +1571,7 @@ int Toy_private_clear(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments)
 			Toy_Literal obj = TOY_TO_DICTIONARY_LITERAL(dictionary);
 
 			if (!Toy_setScopeVariable(interpreter->scope, idn, obj, true)) {
-				interpreter->errorOutput("Incorrect type assigned to dictionary in _clear: ");
+				interpreter->errorOutput("Incorrect type assigned to dictionary in clear: ");
 				Toy_printLiteralCustom(obj, interpreter->errorOutput);
 				interpreter->errorOutput("\n");
 				return -1;
@@ -1463,7 +1583,7 @@ int Toy_private_clear(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments)
 		}
 
 		default:
-			interpreter->errorOutput("Incorrect compound type in _clear: ");
+			interpreter->errorOutput("Incorrect compound type in clear: ");
 			Toy_printLiteralCustom(obj, interpreter->errorOutput);
 			interpreter->errorOutput("\n");
 			return -1;

source/toy_common.c

@@ -4,7 +4,7 @@
 #include <string.h>
 #include <assert.h>
 
-//test variable sizes based on platform
+//test variable sizes based on platform - see issue #35
 #define STATIC_ASSERT(test_for_true) static_assert((test_for_true), "(" #test_for_true ") failed")
 
 STATIC_ASSERT(sizeof(char) == 1);
@@ -15,22 +15,29 @@ STATIC_ASSERT(sizeof(unsigned char) == 1);
 STATIC_ASSERT(sizeof(unsigned short) == 2);
 STATIC_ASSERT(sizeof(unsigned int) == 4);
 
-//declare the singleton
-Toy_CommandLine Toy_commandLine;
+static const char* build = __DATE__ " " __TIME__;
+
+const char* Toy_private_version_build() {
+	return build;
+}
+
+//declare the singleton with default values
+Toy_CommandLine Toy_commandLine = {
+	.error = false,
+	.help = false,
+	.version = false,
+	.binaryfile = NULL,
+	.sourcefile = NULL,
+	.compilefile = NULL,
+	.outfile = "out.tb",
+	.source = NULL,
+	.initialfile = NULL,
+	.enablePrintNewline = true,
+	.parseBytecodeHeader = false,
+	.verbose = false
+};
 
 void Toy_initCommandLine(int argc, const char* argv[]) {
-	//default values
-	Toy_commandLine.error = false;
-	Toy_commandLine.help = false;
-	Toy_commandLine.version = false;
-	Toy_commandLine.binaryfile = NULL;
-	Toy_commandLine.sourcefile = NULL;
-	Toy_commandLine.compilefile = NULL;
-	Toy_commandLine.outfile = "out.tb";
-	Toy_commandLine.source = NULL;
-	Toy_commandLine.initialfile = NULL;
-	Toy_commandLine.verbose = false;
-
 	for (int i = 1; i < argc; i++) { //start at 1 to skip the program name
 		Toy_commandLine.error = true; //error state by default, set to false by successful flags
 
@@ -87,6 +94,22 @@ void Toy_initCommandLine(int argc, const char* argv[]) {
 			continue;
 		}
 
+		if (!strcmp(argv[i], "-p")) {
+			Toy_commandLine.parseBytecodeHeader = true;
+
+			if (Toy_commandLine.binaryfile) {
+				Toy_commandLine.error = false;
+			}
+
+			continue;
+		}
+
+		if (!strcmp(argv[i], "-n")) {
+			Toy_commandLine.enablePrintNewline = false;
+			Toy_commandLine.error = false;
+			continue;
+		}
+
 		//option without a flag + ending in .tb = binary input
 		if (i < argc) {
 			if (strncmp(&(argv[i][strlen(argv[i]) - 3]), ".tb", 3) == 0) {
@@ -108,15 +131,16 @@ void Toy_usageCommandLine(int argc, const char* argv[]) {
 void Toy_helpCommandLine(int argc, const char* argv[]) {
 	Toy_usageCommandLine(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");
-	printf("-t\t| --initial filename\tStart the repl as normal, after first running the given file.\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("  -d, --debug\t\t\tBe verbose when operating.\n");
+	printf("  -f, --file filename\t\tParse, compile and execute the source file.\n");
+	printf("  -i, --input source\t\tParse, compile and execute this given string of source code.\n");
+	printf("  -c, --compile filename\tParse and compile the specified source file into an output file.\n");
+	printf("  -o, --output outfile\t\tName of the output file built with --compile (default: out.tb).\n");
+	printf("  -t, --initial filename\tStart the repl as normal, after first running the given file.\n");
+	printf("  -p\t\t\t\tParse the given bytecode's header, then exit (requires file.tb).\n");
+	printf("  -n\t\t\t\tDisable the newline character at the end of the print statement.\n");
 }
 
 void Toy_copyrightCommandLine(int argc, const char* argv[]) {

source/toy_common.h

@@ -4,10 +4,10 @@
 #include <stddef.h>
 #include <stdint.h>
 
-#define TOY_VERSION_MAJOR 0
-#define TOY_VERSION_MINOR 8
-#define TOY_VERSION_PATCH 3
-#define TOY_VERSION_BUILD __DATE__ " " __TIME__
+#define TOY_VERSION_MAJOR 1
+#define TOY_VERSION_MINOR 1
+#define TOY_VERSION_PATCH 5
+#define TOY_VERSION_BUILD Toy_private_version_build()
 
 //platform/compiler-specific instructions
 #if defined(__linux__) || defined(__MINGW32__) || defined(__GNUC__)
@@ -28,7 +28,9 @@
 
 #endif
 
-//for processing the command line arguments
+TOY_API const char* Toy_private_version_build();
+
+//for processing the command line arguments in the repl
 typedef struct {
 	bool error;
 	bool help;
@@ -39,9 +41,12 @@ typedef struct {
 	char* outfile; //defaults to out.tb
 	char* source;
 	char* initialfile;
+	bool enablePrintNewline;
+	bool parseBytecodeHeader;
 	bool verbose;
 } Toy_CommandLine;
 
+//these are intended for the repl only, despite using the api prefix
 TOY_API Toy_CommandLine Toy_commandLine;
 
 TOY_API void Toy_initCommandLine(int argc, const char* argv[]);

source/toy_compiler.c

@@ -9,6 +9,7 @@
 #include "toy_console_colors.h"
 
 #include <stdio.h>
+#include <string.h>
 
 void Toy_initCompiler(Toy_Compiler* compiler) {
 	Toy_initLiteralArray(&compiler->literalCache);
@@ -129,7 +130,7 @@ static int writeNodeCompoundToCache(Toy_Compiler* compiler, Toy_ASTNode* node) {
 		}
 
 		//push the store to the cache, with instructions about how pack it
-		Toy_Literal literal = TOY_TO_DICTIONARY_LITERAL(store);
+		Toy_Literal literal = TOY_TO_DICTIONARY_LITERAL((Toy_LiteralDictionary*)store); //cast from array to dict, because it's intermediate
 		literal.type = TOY_LITERAL_DICTIONARY_INTERMEDIATE; //god damn it - nested in a dictionary
 		index = Toy_pushLiteralArray(&compiler->literalCache, literal);
 		Toy_freeLiteral(literal);
@@ -258,6 +259,81 @@ static int writeLiteralToCompiler(Toy_Compiler* compiler, Toy_Literal literal) {
 	return index;
 }
 
+//BUGFIX: check to see if this node lies within this tree
+bool checkNodeInTree(Toy_ASTNode* tree, Toy_ASTNode* node) {
+	if (tree == node) {
+		return true;
+	}
+
+	if (tree == NULL) {
+		return false;
+	}
+
+	switch(tree->type) {
+		case TOY_AST_NODE_UNARY:
+			return checkNodeInTree(tree->unary.child, node);
+
+		case TOY_AST_NODE_BINARY:
+			return checkNodeInTree(tree->binary.left, node) || checkNodeInTree(tree->binary.right, node);
+
+		case TOY_AST_NODE_TERNARY:
+			return checkNodeInTree(tree->ternary.condition, node) || checkNodeInTree(tree->ternary.thenPath, node) || checkNodeInTree(tree->ternary.elsePath, node);
+
+		case TOY_AST_NODE_GROUPING:
+			return checkNodeInTree(tree->grouping.child, node);
+
+		case TOY_AST_NODE_BLOCK:
+			return checkNodeInTree(tree->block.nodes, node);
+
+		case TOY_AST_NODE_COMPOUND:
+			return checkNodeInTree(tree->compound.nodes, node);
+
+		case TOY_AST_NODE_PAIR:
+			return checkNodeInTree(tree->pair.left, node) || checkNodeInTree(tree->pair.right, node);
+
+		case TOY_AST_NODE_INDEX:
+			return checkNodeInTree(tree->index.first, node) || checkNodeInTree(tree->index.second, node) || checkNodeInTree(tree->index.third, node);
+
+		case TOY_AST_NODE_VAR_DECL:
+			return checkNodeInTree(tree->varDecl.expression, node);
+
+		case TOY_AST_NODE_FN_COLLECTION:
+			return checkNodeInTree(tree->fnCollection.nodes, node);
+
+		case TOY_AST_NODE_FN_DECL:
+			return checkNodeInTree(tree->fnDecl.arguments, node) || checkNodeInTree(tree->fnDecl.returns, node) || checkNodeInTree(tree->fnDecl.block, node);
+
+		case TOY_AST_NODE_FN_CALL:
+			return checkNodeInTree(tree->fnCall.arguments, node);
+
+		case TOY_AST_NODE_FN_RETURN:
+			return checkNodeInTree(tree->returns.returns, node);
+
+		case TOY_AST_NODE_IF:
+			return checkNodeInTree(tree->pathIf.condition, node) || checkNodeInTree(tree->pathIf.thenPath, node) || checkNodeInTree(tree->pathIf.elsePath, node);
+
+		case TOY_AST_NODE_WHILE:
+			return checkNodeInTree(tree->pathWhile.condition, node) || checkNodeInTree(tree->pathWhile.thenPath, node);
+
+		case TOY_AST_NODE_FOR:
+			return checkNodeInTree(tree->pathFor.preClause, node) || checkNodeInTree(tree->pathFor.condition, node) || checkNodeInTree(tree->pathFor.postClause, node) || checkNodeInTree(tree->pathFor.thenPath, node);
+
+		case TOY_AST_NODE_ERROR:
+		case TOY_AST_NODE_LITERAL:
+		case TOY_AST_NODE_BREAK:
+		case TOY_AST_NODE_CONTINUE:
+		case TOY_AST_NODE_PREFIX_INCREMENT:
+		case TOY_AST_NODE_PREFIX_DECREMENT:
+		case TOY_AST_NODE_POSTFIX_INCREMENT:
+		case TOY_AST_NODE_POSTFIX_DECREMENT:
+		case TOY_AST_NODE_IMPORT:
+		case TOY_AST_NODE_PASS:
+			return false;
+	}
+
+	return false;
+}
+
 //NOTE: jumpOfsets are included, because function arg and return indexes are embedded in the code body i.e. need to include their sizes in the jump
 //NOTE: rootNode should NOT include groupings and blocks
 static Toy_Opcode Toy_writeCompilerWithJumps(Toy_Compiler* compiler, Toy_ASTNode* node, void* breakAddressesPtr, void* continueAddressesPtr, int jumpOffsets, Toy_ASTNode* rootNode) {
@@ -321,7 +397,8 @@ static Toy_Opcode Toy_writeCompilerWithJumps(Toy_Compiler* compiler, Toy_ASTNode
 			//return this if...
 			Toy_Opcode ret = Toy_writeCompilerWithJumps(compiler, node->binary.right, breakAddressesPtr, continueAddressesPtr, jumpOffsets, rootNode);
 
-			if (node->binary.opcode == TOY_OP_INDEX && rootNode->type == TOY_AST_NODE_BINARY && (rootNode->binary.opcode >= TOY_OP_VAR_ASSIGN && rootNode->binary.opcode <= TOY_OP_VAR_MODULO_ASSIGN) && rootNode->binary.right != node) { //range-based check for assignment type; make sure the index is on the left of the assignment symbol
+			//range-based check for assignment type; make sure the index is on the left of the assignment symbol
+			if (node->binary.opcode == TOY_OP_INDEX && rootNode->type == TOY_AST_NODE_BINARY && (rootNode->binary.opcode >= TOY_OP_VAR_ASSIGN && rootNode->binary.opcode <= TOY_OP_VAR_MODULO_ASSIGN) && !checkNodeInTree(rootNode->binary.right, node)) {
 				return TOY_OP_INDEX_ASSIGN_INTERMEDIATE;
 			}
 
@@ -330,9 +407,37 @@ static Toy_Opcode Toy_writeCompilerWithJumps(Toy_Compiler* compiler, Toy_ASTNode
 				return node->binary.opcode;
 			}
 
-			if (ret != TOY_OP_EOF && (node->binary.opcode == TOY_OP_VAR_ASSIGN || node->binary.opcode == TOY_OP_AND || node->binary.opcode == TOY_OP_OR || (node->binary.opcode >= TOY_OP_COMPARE_EQUAL && node->binary.opcode <= TOY_OP_INVERT))) {
-				compiler->bytecode[compiler->count++] = (unsigned char)ret; //1 byte
-				ret = TOY_OP_EOF; //untangle in this case
+			//untangle in these cases - (WTF, are you serious?)
+			if (ret != TOY_OP_EOF) {
+				switch(node->binary.opcode) {
+					case TOY_OP_NEGATE:
+					case TOY_OP_ADDITION:
+					case TOY_OP_SUBTRACTION:
+					case TOY_OP_MULTIPLICATION:
+					case TOY_OP_DIVISION:
+					case TOY_OP_MODULO:
+					case TOY_OP_VAR_ASSIGN:
+					case TOY_OP_VAR_ADDITION_ASSIGN:
+					case TOY_OP_VAR_SUBTRACTION_ASSIGN:
+					case TOY_OP_VAR_MULTIPLICATION_ASSIGN:
+					case TOY_OP_VAR_DIVISION_ASSIGN:
+					case TOY_OP_VAR_MODULO_ASSIGN:
+					case TOY_OP_COMPARE_EQUAL:
+					case TOY_OP_COMPARE_NOT_EQUAL:
+					case TOY_OP_COMPARE_LESS:
+					case TOY_OP_COMPARE_LESS_EQUAL:
+					case TOY_OP_COMPARE_GREATER:
+					case TOY_OP_COMPARE_GREATER_EQUAL:
+					case TOY_OP_INVERT:
+					case TOY_OP_AND:
+					case TOY_OP_OR:
+						//place the rhs result before the outer instruction
+						compiler->bytecode[compiler->count++] = (unsigned char)ret; //1 byte
+						ret = TOY_OP_EOF;
+
+					default:
+						break;
+				}
 			}
 
 			compiler->bytecode[compiler->count++] = (unsigned char)node->binary.opcode; //1 byte
@@ -489,8 +594,7 @@ static Toy_Opcode Toy_writeCompilerWithJumps(Toy_Compiler* compiler, Toy_ASTNode
 			}
 
 			//create the function in the literal cache (by storing the compiler object)
-			Toy_Literal fnLiteral = TOY_TO_FUNCTION_LITERAL(fnCompiler, 0);
-			fnLiteral.type = TOY_LITERAL_FUNCTION_INTERMEDIATE; //NOTE: changing type
+			Toy_Literal fnLiteral = ((Toy_Literal){ .as = { .generic = fnCompiler }, .type = TOY_LITERAL_FUNCTION_INTERMEDIATE});
 
 			//push the name
 			int identifierIndex = Toy_findLiteralIndex(&compiler->literalCache, node->fnDecl.identifier);
@@ -965,6 +1069,11 @@ static Toy_Opcode Toy_writeCompilerWithJumps(Toy_Compiler* compiler, Toy_ASTNode
 			return TOY_OP_INDEX_ASSIGN; //override binary's instruction IF it is assign
 		}
 		break;
+
+		case TOY_AST_NODE_PASS: {
+			return TOY_OP_PASS;
+		}
+		break;
 	}
 
 	return TOY_OP_EOF;
@@ -976,6 +1085,8 @@ void Toy_writeCompiler(Toy_Compiler* compiler, Toy_ASTNode* node) {
 	if (op != TOY_OP_EOF) {//compensate for indexing & dot notation being screwy
 		compiler->bytecode[compiler->count++] = (unsigned char)op; //1 byte
 	}
+
+	//TODO: could free up AST Nodes
 }
 
 void Toy_freeCompiler(Toy_Compiler* compiler) {
@@ -984,6 +1095,7 @@ void Toy_freeCompiler(Toy_Compiler* compiler) {
 	compiler->bytecode = NULL;
 	compiler->capacity = 0;
 	compiler->count = 0;
+	compiler->panic = false;
 }
 
 static void emitByte(unsigned char** collationPtr, int* capacityPtr, int* countPtr, unsigned char byte) {
@@ -1031,7 +1143,7 @@ static void emitFloat(unsigned char** collationPtr, int* capacityPtr, int* count
 }
 
 //return the result
-static unsigned char* collateCompilerHeaderOpt(Toy_Compiler* compiler, int* size, bool embedHeader) {
+static unsigned char* collateCompilerHeaderOpt(Toy_Compiler* compiler, size_t* size, bool embedHeader) {
 	if (compiler->panic) {
 		fprintf(stderr, TOY_CC_ERROR "[internal] Can't collate a panicked compiler\n" TOY_CC_RESET);
 		return NULL;
@@ -1173,17 +1285,17 @@ static unsigned char* collateCompilerHeaderOpt(Toy_Compiler* compiler, int* size
 			case TOY_LITERAL_FUNCTION_INTERMEDIATE: {
 				//extract the compiler
 				Toy_Literal fn = compiler->literalCache.literals[i];
-				void* fnCompiler = TOY_AS_FUNCTION(fn).inner.bytecode; //store the compiler here for now
+				void* fnCompiler = fn.as.generic; //store the compiler here for now
 
 				//collate the function into bytecode (without header)
-				int size = 0;
+				size_t size = 0;
 				unsigned char* bytes = collateCompilerHeaderOpt((Toy_Compiler*)fnCompiler, &size, false);
 
 				//emit how long this section is, +1 for ending mark
 				Toy_emitShort(&fnCollation, &fnCapacity, &fnCount, (unsigned short)size + 1);
 
 				//write the fn to the fn collation
-				for (int i = 0; i < size; i++) {
+				for (size_t i = 0; i < size; i++) {
 					emitByte(&fnCollation, &fnCapacity, &fnCount, bytes[i]);
 				}
 
@@ -1291,6 +1403,6 @@ static unsigned char* collateCompilerHeaderOpt(Toy_Compiler* compiler, int* size
 }
 
 //the whole point of the compiler is to alter bytecode, so leave it as non-const
-unsigned char* Toy_collateCompiler(Toy_Compiler* compiler, int* size) {
+unsigned char* Toy_collateCompiler(Toy_Compiler* compiler, size_t* size) {
 	return collateCompilerHeaderOpt(compiler, size, true);
 }

source/toy_compiler.h

@@ -19,4 +19,4 @@ TOY_API void Toy_writeCompiler(Toy_Compiler* compiler, Toy_ASTNode* node);
 TOY_API void Toy_freeCompiler(Toy_Compiler* compiler);
 
 //embed the header, data section, code section, function section, etc.
-TOY_API unsigned char* Toy_collateCompiler(Toy_Compiler* compiler, int* size);
+TOY_API unsigned char* Toy_collateCompiler(Toy_Compiler* compiler, size_t* size);

source/toy_console_colors.h

@@ -1,6 +1,16 @@
 #pragma once
 
-//NOTE: you need both font AND background for these to work
+/* toy_console_colors.h - console utility
+
+This file provides a number of macros that can set the color of text in a console
+window. These are used for convenience only. They are supposed to be dropped into
+a printf()'s first argument, like so:
+
+    printf(TOY_CC_NOTICE "Hello world" TOY_CC_RESET);
+
+NOTE: you need both font AND background for these to work
+
+*/
 
 //platform/compiler-specific instructions
 #if defined(__linux__) || defined(__MINGW32__) || defined(__GNUC__)

source/toy_drive_system.c

@@ -0,0 +1,99 @@
+#include "toy_drive_system.h"
+
+#include "toy_memory.h"
+#include "toy_literal_dictionary.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+//file system API
+static Toy_LiteralDictionary driveDictionary;
+
+void Toy_initDriveSystem() {
+	Toy_initLiteralDictionary(&driveDictionary);
+}
+
+void Toy_freeDriveSystem() {
+	Toy_freeLiteralDictionary(&driveDictionary);
+}
+
+TOY_API void Toy_setDrivePath(char* drive, char* path) {
+	Toy_Literal driveLiteral = TOY_TO_STRING_LITERAL(Toy_createRefString(drive));
+	Toy_Literal pathLiteral = TOY_TO_STRING_LITERAL(Toy_createRefString(path));
+
+	Toy_setLiteralDictionary(&driveDictionary, driveLiteral, pathLiteral);
+
+	Toy_freeLiteral(driveLiteral);
+	Toy_freeLiteral(pathLiteral);
+}
+
+Toy_Literal Toy_getDrivePathLiteral(Toy_Interpreter* interpreter, Toy_Literal* drivePathLiteral) {
+	//check argument types
+	if (!TOY_IS_STRING(*drivePathLiteral)) {
+		interpreter->errorOutput("Incorrect argument type passed to Toy_getDrivePathLiteral\n");
+		return TOY_TO_NULL_LITERAL;
+	}
+
+	Toy_RefString* drivePath = Toy_copyRefString(TOY_AS_STRING(*drivePathLiteral));
+
+	//get the drive and path as a string (can't trust that pesky strtok - custom split) TODO: move this to refstring library
+	size_t driveLength = 0;
+	while (Toy_toCString(drivePath)[driveLength] != ':') {
+		if (driveLength >= Toy_lengthRefString(drivePath)) {
+			interpreter->errorOutput("Incorrect drive path format given to Toy_getDrivePathLiteral\n");
+
+			return TOY_TO_NULL_LITERAL;
+		}
+
+		driveLength++;
+	}
+
+	Toy_RefString* drive = Toy_createRefStringLength(Toy_toCString(drivePath), driveLength);
+	Toy_RefString* filePath = Toy_createRefStringLength( &Toy_toCString(drivePath)[driveLength + 1], Toy_lengthRefString(drivePath) - driveLength );
+
+	//get the real drive file path
+	Toy_Literal driveLiteral = TOY_TO_STRING_LITERAL(drive); //NOTE: driveLiteral takes ownership of the refString
+	Toy_Literal pathLiteral = Toy_getLiteralDictionary(&driveDictionary, driveLiteral);
+
+	if (!TOY_IS_STRING(pathLiteral)) {
+		interpreter->errorOutput("Incorrect literal type found for drive: ");
+		Toy_printLiteralCustom(pathLiteral, interpreter->errorOutput);
+		interpreter->errorOutput("\n");
+		Toy_freeLiteral(driveLiteral);
+		Toy_freeLiteral(pathLiteral);
+		Toy_deleteRefString(filePath);
+		Toy_deleteRefString(drivePath);
+
+		return TOY_TO_NULL_LITERAL;
+	}
+
+	//get the final real file path (concat) TODO: move this concat to refstring library
+	Toy_RefString* path = Toy_copyRefString(TOY_AS_STRING(pathLiteral));
+	size_t fileLength = Toy_lengthRefString(path) + Toy_lengthRefString(filePath);
+
+	char* file = TOY_ALLOCATE(char, fileLength + 1); //+1 for null
+	snprintf(file, fileLength, "%s%s", Toy_toCString(path), Toy_toCString(filePath));
+
+	//clean up the drive/path stuff
+    Toy_deleteRefString(drivePath);
+    Toy_deleteRefString(filePath);
+    Toy_deleteRefString(path);
+    Toy_freeLiteral(driveLiteral);
+	Toy_freeLiteral(pathLiteral);
+
+	//check for break-out attempts
+	for (size_t i = 0; i < fileLength - 1; i++) {
+		if (file[i] == '.' && file[i + 1] == '.') {
+			interpreter->errorOutput("Parent directory access not allowed\n");
+			TOY_FREE_ARRAY(char, file, fileLength + 1);
+			return TOY_TO_NULL_LITERAL;
+		}
+	}
+
+	Toy_Literal result = TOY_TO_STRING_LITERAL(Toy_createRefStringLength(file, fileLength));
+
+	TOY_FREE_ARRAY(char, file, fileLength + 1);
+
+	return result;
+}

source/toy_drive_system.h

@@ -0,0 +1,12 @@
+#include "toy_common.h"
+
+#include "toy_literal.h"
+#include "toy_interpreter.h"
+
+//file system API - these need to be set by the host
+TOY_API void Toy_initDriveSystem();
+TOY_API void Toy_freeDriveSystem();
+
+//file system API - for use with libs
+TOY_API void Toy_setDrivePath(char* drive, char* path);
+TOY_API Toy_Literal Toy_getDrivePathLiteral(Toy_Interpreter* interpreter, Toy_Literal* drivePathLiteral);

source/toy_interpreter.c

@@ -12,14 +12,21 @@
 #include <string.h>
 
 static void printWrapper(const char* output) {
-	printf("%s", output);
-	// printf("\n"); //default new line
+	//allow for disabling of newlines in the repl
+#ifndef TOY_EXPORT
+	if (Toy_commandLine.enablePrintNewline) {
+		printf("%s\n", output);
+	}
+	else {
+		printf("%s", output);
+	}
+#else
+	printf("%s\n", output);
+#endif
 }
 
 static void assertWrapper(const char* output) {
-	fprintf(stderr, TOY_CC_ERROR "Assertion failure: ");
-	fprintf(stderr, "%s", output);
-	fprintf(stderr, "\n" TOY_CC_RESET); //default new line
+	fprintf(stderr, TOY_CC_ERROR "Assertion failure: %s\n" TOY_CC_RESET, output);
 }
 
 static void errorWrapper(const char* output) {
@@ -33,8 +40,7 @@ bool Toy_injectNativeFn(Toy_Interpreter* interpreter, const char* name, Toy_Nati
 		return false;
 	}
 
-	int identifierLength = strlen(name);
-	Toy_Literal identifier = TOY_TO_IDENTIFIER_LITERAL(Toy_createRefStringLength(name, identifierLength));
+	Toy_Literal identifier = TOY_TO_IDENTIFIER_LITERAL(Toy_createRefString(name));
 
 	//make sure the name isn't taken
 	if (Toy_existsLiteralDictionary(&interpreter->scope->variables, identifier)) {
@@ -230,6 +236,12 @@ static bool execAssert(Toy_Interpreter* interpreter) {
 		Toy_freeLiteral(lhsIdn);
 	}
 
+	if (TOY_IS_IDENTIFIER(lhs)) {
+		Toy_freeLiteral(lhs);
+		Toy_freeLiteral(rhs);
+		return false;
+	}
+
 	if (!TOY_IS_STRING(rhs)) {
 		interpreter->errorOutput("The assert keyword needs a string as the second argument, received: ");
 		Toy_printLiteralCustom(rhs, interpreter->errorOutput);
@@ -264,6 +276,11 @@ static bool execPrint(Toy_Interpreter* interpreter) {
 		Toy_freeLiteral(idn);
 	}
 
+	if (TOY_IS_IDENTIFIER(lit)) {
+		Toy_freeLiteral(lit);
+		return false;
+	}
+
 	Toy_printLiteralCustom(lit, interpreter->printOutput);
 
 	Toy_freeLiteral(lit);
@@ -296,6 +313,11 @@ static bool rawLiteral(Toy_Interpreter* interpreter) {
 		Toy_freeLiteral(idn);
 	}
 
+	if (TOY_IS_IDENTIFIER(lit)) {
+		Toy_freeLiteral(lit);
+		return false;
+	}
+
 	Toy_pushLiteralArray(&interpreter->stack, lit);
 	Toy_freeLiteral(lit);
 
@@ -311,6 +333,11 @@ static bool execNegate(Toy_Interpreter* interpreter) {
 		Toy_freeLiteral(idn);
 	}
 
+	if (TOY_IS_IDENTIFIER(lit)) {
+		Toy_freeLiteral(lit);
+		return false;
+	}
+
 	if (TOY_IS_INTEGER(lit)) {
 		lit = TOY_TO_INTEGER_LITERAL(-TOY_AS_INTEGER(lit));
 	}
@@ -342,6 +369,11 @@ static bool execInvert(Toy_Interpreter* interpreter) {
 		Toy_freeLiteral(idn);
 	}
 
+	if (TOY_IS_IDENTIFIER(lit)) {
+		Toy_freeLiteral(lit);
+		return false;
+	}
+
 	if (TOY_IS_BOOLEAN(lit)) {
 		lit = TOY_TO_BOOLEAN_LITERAL(!TOY_AS_BOOLEAN(lit));
 	}
@@ -375,6 +407,12 @@ static bool execArithmetic(Toy_Interpreter* interpreter, Toy_Opcode opcode) {
 		Toy_freeLiteral(lhsIdn);
 	}
 
+	if (TOY_IS_IDENTIFIER(lhs) || TOY_IS_IDENTIFIER(rhs)) {
+		Toy_freeLiteral(lhs);
+		Toy_freeLiteral(rhs);
+		return false;
+	}
+
 	//special case for string concatenation ONLY
 	if (TOY_IS_STRING(lhs) && TOY_IS_STRING(rhs) && (opcode == TOY_OP_ADDITION || opcode == TOY_OP_VAR_ADDITION_ASSIGN)) {
 		//check for overflow
@@ -507,6 +545,10 @@ static Toy_Literal parseTypeToValue(Toy_Interpreter* interpreter, Toy_Literal ty
 		Toy_freeLiteral(typeIdn);
 	}
 
+	if (TOY_IS_IDENTIFIER(type)) {
+		return TOY_TO_NULL_LITERAL;
+	}
+
 	//if this is an array or dictionary, continue to the subtypes
 	if (TOY_IS_TYPE(type) && (TOY_AS_TYPE(type).typeOf == TOY_LITERAL_ARRAY || TOY_AS_TYPE(type).typeOf == TOY_LITERAL_DICTIONARY)) {
 		for (int i = 0; i < TOY_AS_TYPE(type).count; i++) {
@@ -547,6 +589,12 @@ static bool execVarDecl(Toy_Interpreter* interpreter, bool lng) {
 		Toy_freeLiteral(typeIdn);
 	}
 
+	if (TOY_IS_IDENTIFIER(type)) {
+		Toy_freeLiteral(identifier);
+		Toy_freeLiteral(type);
+		return false;
+	}
+
 	//BUGFIX: because identifiers are getting embedded in type definitions
 	type = parseTypeToValue(interpreter, type);
 
@@ -564,6 +612,13 @@ static bool execVarDecl(Toy_Interpreter* interpreter, bool lng) {
 		Toy_freeLiteral(valIdn);
 	}
 
+	if (TOY_IS_IDENTIFIER(val)) {
+		Toy_freeLiteral(identifier);
+		Toy_freeLiteral(type);
+		Toy_freeLiteral(val);
+		return false;
+	}
+
 	if (TOY_IS_ARRAY(val) || TOY_IS_DICTIONARY(val)) {
 		Toy_parseCompoundToPureValues(interpreter, &val);
 	}
@@ -644,6 +699,12 @@ static bool execVarAssign(Toy_Interpreter* interpreter) {
 		Toy_freeLiteral(rhsIdn);
 	}
 
+	if (TOY_IS_IDENTIFIER(rhs)) {
+		Toy_freeLiteral(lhs);
+		Toy_freeLiteral(rhs);
+		return false;
+	}
+
 	if (TOY_IS_ARRAY(rhs) || TOY_IS_DICTIONARY(rhs)) {
 		Toy_parseCompoundToPureValues(interpreter, &rhs);
 	}
@@ -713,6 +774,12 @@ static bool execValCast(Toy_Interpreter* interpreter) {
 		Toy_freeLiteral(valueIdn);
 	}
 
+	if (TOY_IS_IDENTIFIER(value)) {
+		Toy_freeLiteral(type);
+		Toy_freeLiteral(value);
+		return false;
+	}
+
 	Toy_Literal result = TOY_TO_NULL_LITERAL;
 
 	if (TOY_IS_NULL(value)) {
@@ -847,6 +914,12 @@ static bool execCompareEqual(Toy_Interpreter* interpreter, bool invert) {
 		Toy_freeLiteral(lhsIdn);
 	}
 
+	if (TOY_IS_IDENTIFIER(lhs) || TOY_IS_IDENTIFIER(rhs)) {
+		Toy_freeLiteral(lhs);
+		Toy_freeLiteral(rhs);
+		return false;
+	}
+
 	bool result = Toy_literalsAreEqual(lhs, rhs);
 
 	if (invert) {
@@ -875,6 +948,12 @@ static bool execCompareLess(Toy_Interpreter* interpreter, bool invert) {
 		Toy_freeLiteral(lhsIdn);
 	}
 
+	if (TOY_IS_IDENTIFIER(lhs) || TOY_IS_IDENTIFIER(rhs)) {
+		Toy_freeLiteral(lhs);
+		Toy_freeLiteral(rhs);
+		return false;
+	}
+
 	//not a number, return falure
 	if (!(TOY_IS_INTEGER(lhs) || TOY_IS_FLOAT(lhs))) {
 		interpreter->errorOutput("Incorrect type in comparison, value \"");
@@ -935,6 +1014,12 @@ static bool execCompareLessEqual(Toy_Interpreter* interpreter, bool invert) {
 		Toy_freeLiteral(lhsIdn);
 	}
 
+	if (TOY_IS_IDENTIFIER(lhs) || TOY_IS_IDENTIFIER(rhs)) {
+		Toy_freeLiteral(lhs);
+		Toy_freeLiteral(rhs);
+		return false;
+	}
+
 	//not a number, return falure
 	if (!(TOY_IS_INTEGER(lhs) || TOY_IS_FLOAT(lhs))) {
 		interpreter->errorOutput("Incorrect type in comparison, value \"");
@@ -996,11 +1081,18 @@ static bool execAnd(Toy_Interpreter* interpreter) {
 		Toy_freeLiteral(lhsIdn);
 	}
 
-	if (TOY_IS_TRUTHY(lhs) && TOY_IS_TRUTHY(rhs)) {
-		Toy_pushLiteralArray(&interpreter->stack, TOY_TO_BOOLEAN_LITERAL(true));
+	if (TOY_IS_IDENTIFIER(lhs) || TOY_IS_IDENTIFIER(rhs)) {
+		Toy_freeLiteral(lhs);
+		Toy_freeLiteral(rhs);
+		return false;
+	}
+
+	//short-circuit support
+	if (!TOY_IS_TRUTHY(lhs)) {
+		Toy_pushLiteralArray(&interpreter->stack, lhs);
 	}
 	else {
-		Toy_pushLiteralArray(&interpreter->stack, TOY_TO_BOOLEAN_LITERAL(false));
+		Toy_pushLiteralArray(&interpreter->stack, rhs);
 	}
 
 	Toy_freeLiteral(lhs);
@@ -1023,11 +1115,18 @@ static bool execOr(Toy_Interpreter* interpreter) {
 		Toy_freeLiteral(lhsIdn);
 	}
 
-	if (TOY_IS_TRUTHY(lhs) || TOY_IS_TRUTHY(rhs)) {
-		Toy_pushLiteralArray(&interpreter->stack, TOY_TO_BOOLEAN_LITERAL(true));
+	if (TOY_IS_IDENTIFIER(lhs) || TOY_IS_IDENTIFIER(rhs)) {
+		Toy_freeLiteral(lhs);
+		Toy_freeLiteral(rhs);
+		return false;
+	}
+
+	//short-circuit support
+	if (TOY_IS_TRUTHY(lhs)) {
+		Toy_pushLiteralArray(&interpreter->stack, lhs);
 	}
 	else {
-		Toy_pushLiteralArray(&interpreter->stack, TOY_TO_BOOLEAN_LITERAL(false));
+		Toy_pushLiteralArray(&interpreter->stack, rhs);
 	}
 
 	Toy_freeLiteral(lhs);
@@ -1066,6 +1165,11 @@ static bool execFalseJump(Toy_Interpreter* interpreter) {
 		Toy_freeLiteral(litIdn);
 	}
 
+	if (TOY_IS_IDENTIFIER(lit)) {
+		Toy_freeLiteral(lit);
+		return false;
+	}
+
 	if (TOY_IS_NULL(lit)) {
 		interpreter->errorOutput("Null detected in comparison\n");
 		Toy_freeLiteral(lit);
@@ -1085,9 +1189,11 @@ static bool execFalseJump(Toy_Interpreter* interpreter) {
 static void execInterpreter(Toy_Interpreter*);
 static void readInterpreterSections(Toy_Interpreter* interpreter);
 
+//expect stack: identifier, arg1, arg2, arg3..., stackSize
+//also supports identifier & arg1 to be other way around (looseFirstArgument)
 static bool execFnCall(Toy_Interpreter* interpreter, bool looseFirstArgument) {
 	//BUGFIX: depth check - don't drown!
-	if (interpreter->depth >= 200) {
+	if (interpreter->depth >= 1000) {
 		interpreter->errorOutput("Infinite recursion detected - panicking\n");
 		interpreter->panic = true;
 		return false;
@@ -1121,57 +1227,13 @@ static bool execFnCall(Toy_Interpreter* interpreter, bool looseFirstArgument) {
 		Toy_freeLiteral(lit);
 	}
 
-	//let's screw with the fn name, too
-	if (looseFirstArgument) {
-		if (!TOY_IS_IDENTIFIER(identifier)) {
-			interpreter->errorOutput("Bad literal passed as a function identifier\n");
-			Toy_freeLiteral(identifier);
-			Toy_freeLiteral(stackSize);
-			Toy_freeLiteralArray(&arguments);
-			return false;
-		}
-
-		int length = TOY_AS_IDENTIFIER(identifier)->length + 1;
-		char buffer[TOY_MAX_STRING_LENGTH];
-		snprintf(buffer, TOY_MAX_STRING_LENGTH, "_%s", Toy_toCString(TOY_AS_IDENTIFIER(identifier))); //prepend an underscore
-
-		Toy_freeLiteral(identifier);
-		identifier = TOY_TO_IDENTIFIER_LITERAL(Toy_createRefStringLength(buffer, length));
-	}
-
+	//get the function literal
 	Toy_Literal func = identifier;
-
-	if (!Toy_parseIdentifierToValue(interpreter, &func)) {
-		Toy_freeLiteralArray(&arguments);
-		Toy_freeLiteral(stackSize);
+	if (!TOY_IS_FUNCTION(func) && Toy_parseIdentifierToValue(interpreter, &func)) {
 		Toy_freeLiteral(identifier);
-		return false;
 	}
 
-	//check for side-loaded native functions
-	if (TOY_IS_FUNCTION_NATIVE(func)) {
-		//reverse the order to the correct order
-		Toy_LiteralArray correct;
-		Toy_initLiteralArray(&correct);
-
-		while(arguments.count) {
-			Toy_Literal lit =  Toy_popLiteralArray(&arguments);
-			Toy_pushLiteralArray(&correct, lit);
-			Toy_freeLiteral(lit);
-		}
-
-		Toy_freeLiteralArray(&arguments);
-
-		//call the native function
-		TOY_AS_FUNCTION_NATIVE(func)(interpreter, &correct);
-
-		Toy_freeLiteralArray(&correct);
-		Toy_freeLiteral(stackSize);
-		Toy_freeLiteral(identifier);
-		return true;
-	}
-
-	if (!TOY_IS_FUNCTION(func)) {
+	if (!TOY_IS_FUNCTION(func) && !TOY_IS_FUNCTION_NATIVE(func)) {
 		interpreter->errorOutput("Function not found: ");
 		Toy_printLiteralCustom(identifier, interpreter->errorOutput);
 		interpreter->errorOutput("\n");
@@ -1182,7 +1244,18 @@ static bool execFnCall(Toy_Interpreter* interpreter, bool looseFirstArgument) {
 		return false;
 	}
 
-	bool ret = Toy_callLiteralFn(interpreter, func, &arguments, &interpreter->stack);
+	//BUGFIX: correct the argument order
+	Toy_LiteralArray correct;
+	Toy_initLiteralArray(&correct);
+
+	while (arguments.count > 0) {
+		Toy_Literal lit = Toy_popLiteralArray(&arguments);
+		Toy_pushLiteralArray(&correct, lit);
+		Toy_freeLiteral(lit);
+	}
+
+	//call the function literal
+	bool ret = Toy_callLiteralFn(interpreter, func, &correct, &interpreter->stack);
 
 	if (!ret) {
 		interpreter->errorOutput("Error encountered in function \"");
@@ -1190,33 +1263,25 @@ static bool execFnCall(Toy_Interpreter* interpreter, bool looseFirstArgument) {
 		interpreter->errorOutput("\"\n");
 	}
 
+	Toy_freeLiteralArray(&correct);
 	Toy_freeLiteralArray(&arguments);
 	Toy_freeLiteral(func);
 	Toy_freeLiteral(stackSize);
-	Toy_freeLiteral(identifier);
 
 	return ret;
 }
 
+//expects arguments in correct order
 bool Toy_callLiteralFn(Toy_Interpreter* interpreter, Toy_Literal func, Toy_LiteralArray* arguments, Toy_LiteralArray* returns) {
 	//check for side-loaded native functions
 	if (TOY_IS_FUNCTION_NATIVE(func)) {
-		//reverse the order to the correct order
-		Toy_LiteralArray correct;
-		Toy_initLiteralArray(&correct);
-
-		while(arguments->count) {
-			Toy_Literal lit =  Toy_popLiteralArray(arguments);
-			Toy_pushLiteralArray(&correct, lit);
-			Toy_freeLiteral(lit);
-		}
+		//TODO: parse out identifier values, see issue #64
 
 		//call the native function
-		int returnsCount = TOY_AS_FUNCTION_NATIVE(func)(interpreter, &correct);
+		int returnsCount = TOY_AS_FUNCTION_NATIVE(func)(interpreter, arguments);
 
 		if (returnsCount < 0) {
-			interpreter->errorOutput("Unknown error from native function\n");
-			Toy_freeLiteralArray(&correct);
+			// interpreter->errorOutput("Unknown error from native function\n");
 			return false;
 		}
 
@@ -1238,13 +1303,12 @@ bool Toy_callLiteralFn(Toy_Interpreter* interpreter, Toy_Literal func, Toy_Liter
 		}
 
 		Toy_freeLiteralArray(&returnsFromInner);
-		Toy_freeLiteralArray(&correct);
 		return true;
 	}
 
 	//normal Toy function
 	if (!TOY_IS_FUNCTION(func)) {
-		interpreter->errorOutput("Function required in Toy_callLiteralFn()\n");
+		interpreter->errorOutput("Function literal required in Toy_callLiteralFn()\n");
 		return false;
 	}
 
@@ -1254,8 +1318,8 @@ bool Toy_callLiteralFn(Toy_Interpreter* interpreter, Toy_Literal func, Toy_Liter
 	//init the inner interpreter manually
 	Toy_initLiteralArray(&inner.literalCache);
 	inner.scope = Toy_pushScope(func.as.function.scope);
-	inner.bytecode = TOY_AS_FUNCTION(func).inner.bytecode;
-	inner.length = TOY_AS_FUNCTION_BYTECODE_LENGTH(func);
+	inner.bytecode = ((Toy_RefFunction*)(TOY_AS_FUNCTION(func).inner.ptr))->data;
+	inner.length = ((Toy_RefFunction*)(TOY_AS_FUNCTION(func).inner.ptr))->length;
 	inner.count = 0;
 	inner.codeStart = -1;
 	inner.depth = interpreter->depth + 1;
@@ -1292,6 +1356,9 @@ bool Toy_callLiteralFn(Toy_Interpreter* interpreter, Toy_Literal func, Toy_Liter
 		return false;
 	}
 
+	//BUGFIX: access the arguments from the beginning
+	int argumentIndex = 0;
+
 	//contents is the indexes of identifier & type
 	for (int i = 0; i < paramArray->count - (TOY_IS_NULL(restParam) ? 0 : 2); i += 2) { //don't count the rest parameter, if present
 		//declare and define each entry in the scope
@@ -1307,13 +1374,28 @@ bool Toy_callLiteralFn(Toy_Interpreter* interpreter, Toy_Literal func, Toy_Liter
 			return false;
 		}
 
-		Toy_Literal arg = Toy_popLiteralArray(arguments);
+		//access the arguments in order
+		Toy_Literal arg = TOY_TO_NULL_LITERAL;
+		if (argumentIndex < arguments->count) {
+			arg = Toy_copyLiteral(arguments->literals[argumentIndex++]);
+		}
 
 		Toy_Literal argIdn = arg;
 		if (TOY_IS_IDENTIFIER(arg) && Toy_parseIdentifierToValue(interpreter, &arg)) {
 			Toy_freeLiteral(argIdn);
 		}
 
+		if (TOY_IS_IDENTIFIER(arg)) {
+			//free, and skip out
+			Toy_freeLiteral(arg);
+			Toy_popScope(inner.scope);
+
+			Toy_freeLiteralArray(&inner.stack);
+			Toy_freeLiteralArray(&inner.literalCache);
+
+			return false;
+		}
+
 		if (!Toy_setScopeVariable(inner.scope, paramArray->literals[i], arg, false)) {
 			interpreter->errorOutput("[internal] Could not define parameter (bad type?)\n");
 
@@ -1334,8 +1416,9 @@ bool Toy_callLiteralFn(Toy_Interpreter* interpreter, Toy_Literal func, Toy_Liter
 		Toy_LiteralArray rest;
 		Toy_initLiteralArray(&rest);
 
-		while (arguments->count > 0) {
-			Toy_Literal lit = Toy_popLiteralArray(arguments);
+		//access the arguments in order
+		while (argumentIndex < arguments->count) {
+			Toy_Literal lit = Toy_copyLiteral(arguments->literals[argumentIndex++]);
 			Toy_pushLiteralArray(&rest, lit);
 			Toy_freeLiteral(lit);
 		}
@@ -1442,6 +1525,9 @@ bool Toy_callLiteralFn(Toy_Interpreter* interpreter, Toy_Literal func, Toy_Liter
 	Toy_freeLiteralArray(&inner.stack);
 	Toy_freeLiteralArray(&inner.literalCache);
 
+	//BUGFIX: this function needs to eat the arguments
+	Toy_freeLiteralArray(arguments);
+
 	//actual bytecode persists until next call
 	return true;
 }
@@ -1478,6 +1564,12 @@ static bool execFnReturn(Toy_Interpreter* interpreter) {
 			Toy_freeLiteral(litIdn);
 		}
 
+		if (TOY_IS_IDENTIFIER(lit)) {
+			Toy_freeLiteralArray(&returns);
+			Toy_freeLiteral(lit);
+			return false;
+		}
+
 		if (TOY_IS_ARRAY(lit) || TOY_IS_DICTIONARY(lit)) {
 			Toy_parseCompoundToPureValues(interpreter, &lit);
 		}
@@ -1549,8 +1641,19 @@ static bool execIndex(Toy_Interpreter* interpreter, bool assignIntermediate) {
 		freeIdn = true;
 	}
 
+	if (TOY_IS_IDENTIFIER(compound)) {
+		Toy_freeLiteral(third);
+		Toy_freeLiteral(second);
+		Toy_freeLiteral(first);
+		Toy_freeLiteral(compound);
+		if (freeIdn) {
+			Toy_freeLiteral(compoundIdn);
+		}
+		return true;
+	}
+
 	if (!TOY_IS_ARRAY(compound) && !TOY_IS_DICTIONARY(compound) && !TOY_IS_STRING(compound)) {
-		interpreter->errorOutput("Unknown compound found in indexing notation: ");
+		interpreter->errorOutput("Unknown compound found in index notation: ");
 		Toy_printLiteralCustom(compound, interpreter->errorOutput);
 		interpreter->errorOutput("\n");
 
@@ -1588,7 +1691,7 @@ static bool execIndex(Toy_Interpreter* interpreter, bool assignIntermediate) {
 		Toy_pushLiteralArray(&interpreter->stack, third);
 	}
 
-	//call the _index function
+	//call the index function
 	if (Toy_private_index(interpreter, &arguments) < 0) {
 		interpreter->errorOutput("Something went wrong while indexing (simple index): ");
 		Toy_printLiteralCustom(compoundIdn, interpreter->errorOutput);
@@ -1619,64 +1722,101 @@ static bool execIndex(Toy_Interpreter* interpreter, bool assignIntermediate) {
 	return true;
 }
 
-static bool execIndexAssign(Toy_Interpreter* interpreter) {
+static bool execIndexAssign(Toy_Interpreter* interpreter, int assignDepth) {
 	//assume -> compound, first, second, third, assign are all on the stack
 
-	Toy_Literal assign = Toy_popLiteralArray(&interpreter->stack);
-	Toy_Literal third = Toy_popLiteralArray(&interpreter->stack);
-	Toy_Literal second = Toy_popLiteralArray(&interpreter->stack);
-	Toy_Literal first = Toy_popLiteralArray(&interpreter->stack);
-	Toy_Literal compound = Toy_popLiteralArray(&interpreter->stack);
-
-	Toy_Literal assignIdn = assign;
-	if (TOY_IS_IDENTIFIER(assign) && Toy_parseIdentifierToValue(interpreter, &assign)) {
-		Toy_freeLiteral(assignIdn);
-	}
-
-	Toy_Literal compoundIdn = compound;
+	Toy_Literal assign = TOY_TO_NULL_LITERAL, third = TOY_TO_NULL_LITERAL, second = TOY_TO_NULL_LITERAL, first = TOY_TO_NULL_LITERAL, compound = TOY_TO_NULL_LITERAL, result = TOY_TO_NULL_LITERAL;
+	Toy_Literal compoundIdn = TOY_TO_NULL_LITERAL;
 	bool freeIdn = false;
-	if (TOY_IS_IDENTIFIER(compound) && Toy_parseIdentifierToValue(interpreter, &compound)) {
-		freeIdn = true;
+
+	//build the opcode
+	unsigned char opcode = readByte(interpreter->bytecode, &interpreter->count);
+	char* opStr = "";
+	switch (opcode) {
+	case TOY_OP_VAR_ASSIGN:
+		opStr = "=";
+		break;
+	case TOY_OP_VAR_ADDITION_ASSIGN:
+		opStr = "+=";
+		break;
+	case TOY_OP_VAR_SUBTRACTION_ASSIGN:
+		opStr = "-=";
+		break;
+	case TOY_OP_VAR_MULTIPLICATION_ASSIGN:
+		opStr = "*=";
+		break;
+	case TOY_OP_VAR_DIVISION_ASSIGN:
+		opStr = "/=";
+		break;
+	case TOY_OP_VAR_MODULO_ASSIGN:
+		opStr = "%=";
+		break;
+
+	default:
+		interpreter->errorOutput("bad opcode in index assigning notation\n");
+		return false;
 	}
 
-	if (!TOY_IS_ARRAY(compound) && !TOY_IS_DICTIONARY(compound) && !TOY_IS_STRING(compound)) {
-		interpreter->errorOutput("Unknown compound found in index assigning notation\n");
+	//iterate...
+	while(assignDepth-- >= 0) {
 		Toy_freeLiteral(assign);
 		Toy_freeLiteral(third);
 		Toy_freeLiteral(second);
 		Toy_freeLiteral(first);
 		Toy_freeLiteral(compound);
-		if (freeIdn) {
-			Toy_freeLiteral(compoundIdn);
+
+		if (TOY_IS_NULL(result)) {
+			assign = Toy_popLiteralArray(&interpreter->stack);
+		}
+		else {
+			assign = result;
 		}
-		return false;
-	}
 
-	//build the opcode
-	unsigned char opcode = readByte(interpreter->bytecode, &interpreter->count);
-	char* opStr = "";
-	switch(opcode) {
-		case TOY_OP_VAR_ASSIGN:
-			opStr = "=";
-		break;
-		case TOY_OP_VAR_ADDITION_ASSIGN:
-			opStr = "+=";
-		break;
-		case TOY_OP_VAR_SUBTRACTION_ASSIGN:
-			opStr = "-=";
-		break;
-		case TOY_OP_VAR_MULTIPLICATION_ASSIGN:
-			opStr = "*=";
-		break;
-		case TOY_OP_VAR_DIVISION_ASSIGN:
-			opStr = "/=";
-		break;
-		case TOY_OP_VAR_MODULO_ASSIGN:
-			opStr = "%=";
-		break;
+		third = Toy_popLiteralArray(&interpreter->stack);
+		second = Toy_popLiteralArray(&interpreter->stack);
+		first = Toy_popLiteralArray(&interpreter->stack);
+		compound = Toy_popLiteralArray(&interpreter->stack);
 
-		default:
-			interpreter->errorOutput("bad opcode in index assigning notation\n");
+		if (TOY_IS_IDENTIFIER(compound)) {
+			if (freeIdn) {
+				Toy_freeLiteral(compoundIdn);
+			}
+
+			compoundIdn = compound;
+			Toy_parseIdentifierToValue(interpreter, &compound);
+			freeIdn = true;
+		}
+
+		if (TOY_IS_IDENTIFIER(compound)) {
+			Toy_freeLiteral(compound);
+			Toy_freeLiteral(first);
+			Toy_freeLiteral(second);
+			Toy_freeLiteral(third);
+			Toy_freeLiteral(assign);
+			if (freeIdn) {
+				Toy_freeLiteral(compoundIdn);
+			}
+			return false;
+		}
+
+		Toy_Literal assignIdn = assign;
+		if (TOY_IS_IDENTIFIER(assign) && Toy_parseIdentifierToValue(interpreter, &assign)) {
+			Toy_freeLiteral(assignIdn);
+		}
+
+		if (TOY_IS_IDENTIFIER(assign)) {
+			Toy_freeLiteral(compound);
+			Toy_freeLiteral(first);
+			Toy_freeLiteral(second);
+			Toy_freeLiteral(third);
+			Toy_freeLiteral(assign);
+			return false;
+		}
+
+		if (!TOY_IS_ARRAY(compound) && !TOY_IS_DICTIONARY(compound) && !TOY_IS_STRING(compound)) {
+			interpreter->errorOutput("Unknown compound found in index assigning notation: ");
+			Toy_printLiteralCustom(compound, interpreter->errorOutput);
+			interpreter->errorOutput("\n");
 			Toy_freeLiteral(assign);
 			Toy_freeLiteral(third);
 			Toy_freeLiteral(second);
@@ -1686,103 +1826,60 @@ static bool execIndexAssign(Toy_Interpreter* interpreter) {
 				Toy_freeLiteral(compoundIdn);
 			}
 			return false;
-	}
-
-	int opLength = strlen(opStr);
-	Toy_Literal op = TOY_TO_STRING_LITERAL(Toy_createRefStringLength(opStr, opLength)); //TODO: static reference optimisation?
-
-	//build the argument list
-	Toy_LiteralArray arguments;
-	Toy_initLiteralArray(&arguments);
-
-	Toy_pushLiteralArray(&arguments, compound);
-	Toy_pushLiteralArray(&arguments, first);
-	Toy_pushLiteralArray(&arguments, second);
-	Toy_pushLiteralArray(&arguments, third);
-	Toy_pushLiteralArray(&arguments, assign); //it expects an assignment command
-	Toy_pushLiteralArray(&arguments, op); //it expects an assignment "opcode"
-
-	//call the _index function
-	if (Toy_private_index(interpreter, &arguments) < 0) {
-		//clean up
-		Toy_freeLiteral(assign);
-		Toy_freeLiteral(third);
-		Toy_freeLiteral(second);
-		Toy_freeLiteral(first);
-		Toy_freeLiteral(compound);
-		if (freeIdn) {
-			Toy_freeLiteral(compoundIdn);
 		}
-		Toy_freeLiteral(op);
-		Toy_freeLiteralArray(&arguments);
 
-		return false;
-	}
+		int opLength = strlen(opStr);
+		Toy_Literal op = TOY_TO_STRING_LITERAL(Toy_createRefStringLength(opStr, opLength)); //TODO: static reference optimisation?
 
-	//save the result (assume top of the interpreter stack is the new compound value)
-	Toy_Literal result = Toy_popLiteralArray(&interpreter->stack);
+		//build the argument list
+		Toy_LiteralArray arguments;
+		Toy_initLiteralArray(&arguments);
 
-	//deep
-	if (!freeIdn) {
-		while (interpreter->stack.count > 1) {
-			//read the new values
-			Toy_freeLiteral(compound);
+		Toy_pushLiteralArray(&arguments, compound);
+		Toy_pushLiteralArray(&arguments, first);
+		Toy_pushLiteralArray(&arguments, second);
+		Toy_pushLiteralArray(&arguments, third);
+		Toy_pushLiteralArray(&arguments, assign); //it expects an assignment command
+		Toy_pushLiteralArray(&arguments, op); //it expects an assignment "opcode"
+
+		//call the index function
+		if (Toy_private_index(interpreter, &arguments) < 0) {
+			//clean up
+			Toy_freeLiteral(assign);
 			Toy_freeLiteral(third);
 			Toy_freeLiteral(second);
 			Toy_freeLiteral(first);
-			Toy_freeLiteralArray(&arguments);
-			Toy_initLiteralArray(&arguments);
-			Toy_freeLiteral(op);
-
-			//reuse these like an idiot
-			third = Toy_popLiteralArray(&interpreter->stack);
-			second = Toy_popLiteralArray(&interpreter->stack);
-			first = Toy_popLiteralArray(&interpreter->stack);
-			compound = Toy_popLiteralArray(&interpreter->stack);
-
-			char* opStr = "="; //shadow, but force assignment
-			int opLength = strlen(opStr);
-			op = TOY_TO_STRING_LITERAL(Toy_createRefStringLength(opStr, opLength)); //TODO: static reference optimisation?
-
-			//assign to the idn / compound - with _index
-			Toy_pushLiteralArray(&arguments, compound); //
-			Toy_pushLiteralArray(&arguments, first);
-			Toy_pushLiteralArray(&arguments, second);
-			Toy_pushLiteralArray(&arguments, third);
-			Toy_pushLiteralArray(&arguments, result);
-			Toy_pushLiteralArray(&arguments, op);
-
-			if (Toy_private_index(interpreter, &arguments) < 0) {
-				interpreter->errorOutput("Something went wrong while indexing (index assign): ");
-				Toy_printLiteralCustom(compound, interpreter->errorOutput);
-				interpreter->errorOutput("\n");
-
-				//clean up
-				Toy_freeLiteral(assign);
-				Toy_freeLiteral(third);
-				Toy_freeLiteral(second);
-				Toy_freeLiteral(first);
-				if (freeIdn) {
-					Toy_freeLiteral(compoundIdn);
-				}
-				Toy_freeLiteral(op);
-				Toy_freeLiteralArray(&arguments);
-				return false;
+			Toy_freeLiteral(compound);
+			if (freeIdn) {
+				Toy_freeLiteral(compoundIdn);
 			}
+			Toy_freeLiteral(op);
+			Toy_freeLiteralArray(&arguments);
 
-			Toy_freeLiteral(result);
-			result = Toy_popLiteralArray(&interpreter->stack);
+			return false;
 		}
 
-		Toy_freeLiteral(compound);
-		compound = Toy_popLiteralArray(&interpreter->stack);
-		compoundIdn = compound;
-		freeIdn = false;
+		//save the result (assume top of the interpreter stack is the new compound value)
+		result = Toy_popLiteralArray(&interpreter->stack);
+
+		Toy_freeLiteral(op);
+		Toy_freeLiteralArray(&arguments);
+
+		//if we loop, then we need to be assigning
+		opStr = "=";
+	}
+
+	//BUGFIX: make sure the compound name can be assigned
+	if (TOY_IS_NULL(compoundIdn)) {
+		compoundIdn = Toy_popLiteralArray(&interpreter->stack);
+		freeIdn = true;
 	}
 
 	if (TOY_IS_IDENTIFIER(compoundIdn) && !Toy_setScopeVariable(interpreter->scope, compoundIdn, result, true)) {
 		interpreter->errorOutput("Incorrect type assigned to compound member ");
 		Toy_printLiteralCustom(compoundIdn, interpreter->errorOutput);
+		interpreter->errorOutput(", value: ");
+		Toy_printLiteralCustom(result, interpreter->errorOutput);
 		interpreter->errorOutput("\n");
 
 		//clean up
@@ -1794,8 +1891,6 @@ static bool execIndexAssign(Toy_Interpreter* interpreter) {
 		if (freeIdn) {
 			Toy_freeLiteral(compoundIdn);
 		}
-		Toy_freeLiteral(op);
-		Toy_freeLiteralArray(&arguments);
 		Toy_freeLiteral(result);
 		return false;
 	}
@@ -1809,8 +1904,6 @@ static bool execIndexAssign(Toy_Interpreter* interpreter) {
 	if (freeIdn) {
 		Toy_freeLiteral(compoundIdn);
 	}
-	Toy_freeLiteral(op);
-	Toy_freeLiteralArray(&arguments);
 	Toy_freeLiteral(result);
 
 	return true;
@@ -1823,10 +1916,17 @@ static void execInterpreter(Toy_Interpreter* interpreter) {
 		interpreter->codeStart = interpreter->count;
 	}
 
+	//BUGFIX
+	int intermediateAssignDepth = 0;
+
 	unsigned char opcode = readByte(interpreter->bytecode, &interpreter->count);
 
 	while(opcode != TOY_OP_EOF && opcode != TOY_OP_SECTION_END && !interpreter->panic) {
 		switch(opcode) {
+			case TOY_OP_PASS:
+				//DO NOTHING
+			break;
+
 			case TOY_OP_ASSERT:
 				if (!execAssert(interpreter)) {
 					return;
@@ -2033,12 +2133,14 @@ static void execInterpreter(Toy_Interpreter* interpreter) {
 				if (!execIndex(interpreter, true)) {
 					return;
 				}
+				intermediateAssignDepth++;
 			break;
 
 			case TOY_OP_INDEX_ASSIGN:
-				if (!execIndexAssign(interpreter)) {
+				if (!execIndexAssign(interpreter, intermediateAssignDepth)) {
 					return;
 				}
+				intermediateAssignDepth = 0;
 			break;
 
 			case TOY_OP_POP_STACK:
@@ -2321,21 +2423,16 @@ static void readInterpreterSections(Toy_Interpreter* interpreter) {
 			//get the size of the function
 			size_t size = (size_t)readShort(interpreter->bytecode, &interpreter->count);
 
-			//read the function code (literal cache and all)
-			unsigned char* bytes = TOY_ALLOCATE(unsigned char, size);
-			memcpy(bytes, interpreter->bytecode + interpreter->count, size); //TODO: -1 for the ending mark
-			interpreter->count += size;
-
 			//assert that the last memory slot is function end
-			if (bytes[size - 1] != TOY_OP_FN_END) {
+			if (interpreter->bytecode[interpreter->count + size - 1] != TOY_OP_FN_END) {
 				interpreter->errorOutput("[internal] Failed to find function end");
-				TOY_FREE_ARRAY(unsigned char, bytes, size);
 				return;
 			}
 
-			//change the type to normal
-			interpreter->literalCache.literals[i] = TOY_TO_FUNCTION_LITERAL(bytes, size);
-			TOY_AS_FUNCTION(interpreter->literalCache.literals[i]).scope = NULL;
+			//copies internally, since functions can exist independant of literalCache
+			interpreter->literalCache.literals[i] = TOY_TO_FUNCTION_LITERAL(Toy_createRefFunction(interpreter->bytecode + interpreter->count, size));
+
+			interpreter->count += size;
 		}
 	}
 
@@ -2445,12 +2542,12 @@ void Toy_resetInterpreter(Toy_Interpreter* interpreter) {
 	interpreter->scope = Toy_pushScope(NULL);
 
 	//globally available functions
-	Toy_injectNativeFn(interpreter, "_set", Toy_private_set);
-	Toy_injectNativeFn(interpreter, "_get", Toy_private_get);
-	Toy_injectNativeFn(interpreter, "_push", Toy_private_push);
-	Toy_injectNativeFn(interpreter, "_pop", Toy_private_pop);
-	Toy_injectNativeFn(interpreter, "_length", Toy_private_length);
-	Toy_injectNativeFn(interpreter, "_clear", Toy_private_clear);
+	Toy_injectNativeFn(interpreter, "set", Toy_private_set);
+	Toy_injectNativeFn(interpreter, "get", Toy_private_get);
+	Toy_injectNativeFn(interpreter, "push", Toy_private_push);
+	Toy_injectNativeFn(interpreter, "pop", Toy_private_pop);
+	Toy_injectNativeFn(interpreter, "length", Toy_private_length);
+	Toy_injectNativeFn(interpreter, "clear", Toy_private_clear);
 }
 
 void Toy_freeInterpreter(Toy_Interpreter* interpreter) {

source/toy_interpreter.h

@@ -6,8 +6,6 @@
 #include "toy_literal_dictionary.h"
 #include "toy_scope.h"
 
-typedef void (*Toy_PrintFn)(const char*);
-
 //the interpreter acts depending on the bytecode instructions
 typedef struct Toy_Interpreter {
 	//input

source/toy_lexer.c

@@ -117,7 +117,7 @@ static Toy_Token makeErrorToken(Toy_Lexer* lexer, char* msg) {
 #ifndef TOY_EXPORT
 	if (Toy_commandLine.verbose) {
 		printf("err:");
-		Toy_printToken(&token);
+		Toy_private_printToken(&token);
 	}
 #endif
 
@@ -136,7 +136,7 @@ static Toy_Token makeToken(Toy_Lexer* lexer, Toy_TokenType type) {
 	//BUG #10: this shows TOKEN_EOF twice due to the overarching structure of the program - can't be fixed
 	if (Toy_commandLine.verbose) {
 		printf("tok:");
-		Toy_printToken(&token);
+		Toy_private_printToken(&token);
 	}
 #endif
 
@@ -168,7 +168,7 @@ static Toy_Token makeIntegerOrFloat(Toy_Lexer* lexer) {
 		} else {
 			printf("flt:");
 		}
-		Toy_printToken(&token);
+		Toy_private_printToken(&token);
 	}
 #endif
 
@@ -221,7 +221,7 @@ static Toy_Token makeString(Toy_Lexer* lexer, char terminator) {
 #ifndef TOY_EXPORT
 	if (Toy_commandLine.verbose) {
 		printf("str:");
-		Toy_printToken(&token);
+		Toy_private_printToken(&token);
 	}
 #endif
 
@@ -248,7 +248,7 @@ static Toy_Token makeKeywordOrIdentifier(Toy_Lexer* lexer) {
 #ifndef TOY_EXPORT
 			if (Toy_commandLine.verbose) {
 				printf("kwd:");
-				Toy_printToken(&token);
+				Toy_private_printToken(&token);
 			}
 #endif
 
@@ -267,7 +267,7 @@ static Toy_Token makeKeywordOrIdentifier(Toy_Lexer* lexer) {
 #ifndef TOY_EXPORT
 	if (Toy_commandLine.verbose) {
 		printf("idf:");
-		Toy_printToken(&token);
+		Toy_private_printToken(&token);
 	}
 #endif
 
@@ -281,7 +281,7 @@ void Toy_initLexer(Toy_Lexer* lexer, const char* source) {
 	lexer->source = source;
 }
 
-Toy_Token Toy_scanLexer(Toy_Lexer* lexer) {
+Toy_Token Toy_private_scanLexer(Toy_Lexer* lexer) {
 	eatWhitespace(lexer);
 
 	lexer->start = lexer->current;
@@ -352,7 +352,7 @@ static void trim(char** s, int* l) { //all this to remove a newline?
 }
 
 //for debugging
-void Toy_printToken(Toy_Token* token) {
+void Toy_private_printToken(Toy_Token* token) {
 	if (token->type == TOY_TOKEN_ERROR) {
 		printf(TOY_CC_ERROR "Error\t%d\t%.*s\n" TOY_CC_RESET, token->line, token->length, token->lexeme);
 		return;

source/toy_lexer.h

@@ -21,9 +21,9 @@ typedef struct {
 } Toy_Token;
 
 TOY_API void Toy_initLexer(Toy_Lexer* lexer, const char* source);
-TOY_API Toy_Token Toy_scanLexer(Toy_Lexer* lexer);
+TOY_API Toy_Token Toy_private_scanLexer(Toy_Lexer* lexer);
 
 //for debugging
-TOY_API void Toy_printToken(Toy_Token* token);
+TOY_API void Toy_private_printToken(Toy_Token* token);
 
 TOY_API void Toy_private_setComments(Toy_Lexer* lexer, bool enabled);

source/toy_literal.c

@@ -8,6 +8,7 @@
 #include "toy_console_colors.h"
 
 #include <stdio.h>
+#include <string.h>
 
 //hash util functions
 static unsigned int hashString(const char* string, int length) {
@@ -58,10 +59,10 @@ void Toy_freeLiteral(Toy_Literal literal) {
 	if (TOY_IS_FUNCTION(literal)) {
 		Toy_popScope(TOY_AS_FUNCTION(literal).scope);
 		TOY_AS_FUNCTION(literal).scope = NULL;
-		TOY_FREE_ARRAY(unsigned char, TOY_AS_FUNCTION(literal).inner.bytecode, TOY_AS_FUNCTION_BYTECODE_LENGTH(literal));
+		Toy_deleteRefFunction((Toy_RefFunction*)(TOY_AS_FUNCTION(literal).inner.ptr));
 	}
 
-	if (TOY_IS_TYPE(literal)) {
+	if (TOY_IS_TYPE(literal) && TOY_AS_TYPE(literal).capacity > 0) {
 		for (int i = 0; i < TOY_AS_TYPE(literal).count; i++) {
 			Toy_freeLiteral(((Toy_Literal*)(TOY_AS_TYPE(literal).subtypes))[i]);
 		}
@@ -83,12 +84,8 @@ bool Toy_private_isTruthy(Toy_Literal x) {
 	return true;
 }
 
-Toy_Literal Toy_private_toStringLiteral(Toy_RefString* ptr) {
-	return ((Toy_Literal){{ .string.ptr = ptr },TOY_LITERAL_STRING, 0});
-}
-
 Toy_Literal Toy_private_toIdentifierLiteral(Toy_RefString* ptr) {
-	return ((Toy_Literal){{ .identifier.ptr = ptr, .identifier.hash = hashString(Toy_toCString(ptr), Toy_lengthRefString(ptr)) },TOY_LITERAL_IDENTIFIER, 0});
+	return ((Toy_Literal){{ .identifier = { .ptr = ptr, .hash = hashString(Toy_toCString(ptr), Toy_lengthRefString(ptr)) }},TOY_LITERAL_IDENTIFIER});
 }
 
 Toy_Literal* Toy_private_typePushSubtype(Toy_Literal* lit, Toy_Literal subtype) {
@@ -122,6 +119,10 @@ Toy_Literal Toy_copyLiteral(Toy_Literal original) {
 			Toy_LiteralArray* array = TOY_ALLOCATE(Toy_LiteralArray, 1);
 			Toy_initLiteralArray(array);
 
+			//preallocate enough space
+			array->capacity = TOY_AS_ARRAY(original)->capacity;
+			array->literals = TOY_GROW_ARRAY(Toy_Literal, array->literals, 0, array->capacity);
+
 			//copy each element
 			for (int i = 0; i < TOY_AS_ARRAY(original)->count; i++) {
 				Toy_pushLiteralArray(array, TOY_AS_ARRAY(original)->literals[i]);
@@ -134,6 +135,15 @@ Toy_Literal Toy_copyLiteral(Toy_Literal original) {
 			Toy_LiteralDictionary* dictionary = TOY_ALLOCATE(Toy_LiteralDictionary, 1);
 			Toy_initLiteralDictionary(dictionary);
 
+			//preallocate enough space
+			dictionary->capacity = TOY_AS_DICTIONARY(original)->capacity;
+			dictionary->entries = TOY_ALLOCATE(Toy_private_dictionary_entry, dictionary->capacity);
+
+			for (int i = 0; i < dictionary->capacity; i++) {
+				dictionary->entries[i].key = TOY_TO_NULL_LITERAL;
+				dictionary->entries[i].value = TOY_TO_NULL_LITERAL;
+			}
+
 			//copy each entry
 			for (int i = 0; i < TOY_AS_DICTIONARY(original)->capacity; i++) {
 				if ( !TOY_IS_NULL(TOY_AS_DICTIONARY(original)->entries[i].key) ) {
@@ -145,17 +155,16 @@ Toy_Literal Toy_copyLiteral(Toy_Literal original) {
 		}
 
 		case TOY_LITERAL_FUNCTION: {
-			unsigned char* buffer = TOY_ALLOCATE(unsigned char, TOY_AS_FUNCTION_BYTECODE_LENGTH(original));
-			memcpy(buffer, TOY_AS_FUNCTION(original).inner.bytecode, TOY_AS_FUNCTION_BYTECODE_LENGTH(original));
+			Toy_Literal literal = TOY_TO_FUNCTION_LITERAL(Toy_copyRefFunction( TOY_AS_FUNCTION(original).inner.ptr ));
 
-			Toy_Literal literal = TOY_TO_FUNCTION_LITERAL(buffer, TOY_AS_FUNCTION_BYTECODE_LENGTH(original));
 			TOY_AS_FUNCTION(literal).scope = Toy_copyScope(TOY_AS_FUNCTION(original).scope);
 
 			return literal;
 		}
 
 		case TOY_LITERAL_IDENTIFIER: {
-			 return TOY_TO_IDENTIFIER_LITERAL(Toy_copyRefString(TOY_AS_IDENTIFIER(original)));
+			//NOTE: could optimise this by copying the hash manually, but it's a very small increase in performance
+			return TOY_TO_IDENTIFIER_LITERAL(Toy_copyRefString(TOY_AS_IDENTIFIER(original)));
 		}
 
 		case TOY_LITERAL_TYPE: {
@@ -172,7 +181,7 @@ Toy_Literal Toy_copyLiteral(Toy_Literal original) {
 			return original; //literally a shallow copy
 		}
 
-		case TOY_LITERAL_ARRAY_INTERMEDIATE: {
+		case TOY_LITERAL_ARRAY_INTERMEDIATE: { //TODO: efficient preallocation?
 			Toy_LiteralArray* array = TOY_ALLOCATE(Toy_LiteralArray, 1);
 			Toy_initLiteralArray(array);
 
@@ -188,7 +197,7 @@ Toy_Literal Toy_copyLiteral(Toy_Literal original) {
 			return ret;
 		}
 
-		case TOY_LITERAL_DICTIONARY_INTERMEDIATE: {
+		case TOY_LITERAL_DICTIONARY_INTERMEDIATE: { //TODO: efficient preallocation?
 			Toy_LiteralArray* array = TOY_ALLOCATE(Toy_LiteralArray, 1);
 			Toy_initLiteralArray(array);
 
@@ -204,7 +213,7 @@ Toy_Literal Toy_copyLiteral(Toy_Literal original) {
 			return ret;
 		}
 
-		case TOY_LITERAL_TYPE_INTERMEDIATE: {
+		case TOY_LITERAL_TYPE_INTERMEDIATE: { //TODO: efficient preallocation?
 			Toy_LiteralArray* array = TOY_ALLOCATE(Toy_LiteralArray, 1);
 			Toy_initLiteralArray(array);
 
@@ -239,10 +248,10 @@ bool Toy_literalsAreEqual(Toy_Literal lhs, Toy_Literal rhs) {
 		// ints and floats are compatible
 		if ((TOY_IS_INTEGER(lhs) || TOY_IS_FLOAT(lhs)) && (TOY_IS_INTEGER(rhs) || TOY_IS_FLOAT(rhs))) {
 			if (TOY_IS_INTEGER(lhs)) {
-				return TOY_AS_INTEGER(lhs) + TOY_AS_FLOAT(rhs);
+				return TOY_AS_INTEGER(lhs) == TOY_AS_FLOAT(rhs);
 			}
 			else {
-				return TOY_AS_FLOAT(lhs) + TOY_AS_INTEGER(rhs);
+				return TOY_AS_FLOAT(lhs) == TOY_AS_INTEGER(rhs);
 			}
 		}
 
@@ -376,8 +385,10 @@ int Toy_hashLiteral(Toy_Literal lit) {
 		case TOY_LITERAL_INTEGER:
 			return hashUInt((unsigned int)TOY_AS_INTEGER(lit));
 
-		case TOY_LITERAL_FLOAT:
-			return hashUInt(*(unsigned int*)(&TOY_AS_FLOAT(lit)));
+		case TOY_LITERAL_FLOAT: {
+			unsigned int* ptr = (unsigned int*)(&TOY_AS_FLOAT(lit));
+			return hashUInt(*ptr);
+		}
 
 		case TOY_LITERAL_STRING:
 			return hashString(Toy_toCString(TOY_AS_STRING(lit)), Toy_lengthRefString(TOY_AS_STRING(lit)));
@@ -404,20 +415,20 @@ int Toy_hashLiteral(Toy_Literal lit) {
 		case TOY_LITERAL_FUNCTION:
 		case TOY_LITERAL_FUNCTION_NATIVE:
 		case TOY_LITERAL_FUNCTION_HOOK:
-			return 0; //can't hash these
+			return -1; //can't hash these
 
 		case TOY_LITERAL_IDENTIFIER:
 			return TOY_HASH_I(lit); //pre-computed
 
 		case TOY_LITERAL_TYPE:
-			return TOY_AS_TYPE(lit).typeOf; //nothing else I can do
+			return -1; //not much i can really do
 
 		case TOY_LITERAL_OPAQUE:
 		case TOY_LITERAL_ANY:
 			return -1;
 
 		default:
-			//should never bee seen
+			//should never be seen
 			fprintf(stderr, TOY_CC_ERROR "[internal] Unrecognized literal type in hash: %d\n" TOY_CC_RESET, lit.type);
 			return 0;
 	}
@@ -444,7 +455,7 @@ static void printToBuffer(const char* str) {
 		globalPrintBuffer = TOY_GROW_ARRAY(char, globalPrintBuffer, oldCapacity, globalPrintCapacity);
 	}
 
-	snprintf(globalPrintBuffer + globalPrintCount, strlen(str) + 1, "%s", str);
+	snprintf(globalPrintBuffer + globalPrintCount, strlen(str) + 1, "%s", str ? str : "\0");
 	globalPrintCount += strlen(str);
 }
 
@@ -453,7 +464,7 @@ void Toy_printLiteral(Toy_Literal literal) {
 	Toy_printLiteralCustom(literal, stdoutWrapper);
 }
 
-void Toy_printLiteralCustom(Toy_Literal literal, void (printFn)(const char*)) {
+void Toy_printLiteralCustom(Toy_Literal literal, Toy_PrintFn printFn) {
 	switch(literal.type) {
 		case TOY_LITERAL_NULL:
 			printFn("null");

source/toy_literal.h

@@ -3,15 +3,17 @@
 #include "toy_common.h"
 
 #include "toy_refstring.h"
+#include "toy_reffunction.h"
 
 //forward delcare stuff
 struct Toy_Literal;
 struct Toy_Interpreter;
 struct Toy_LiteralArray;
+struct Toy_LiteralDictionary;
+struct Toy_Scope;
 typedef int (*Toy_NativeFn)(struct Toy_Interpreter* interpreter, struct Toy_LiteralArray* arguments);
 typedef int (*Toy_HookFn)(struct Toy_Interpreter* interpreter, struct Toy_Literal identifier, struct Toy_Literal alias);
-
-#include <string.h>
+typedef void (*Toy_PrintFn)(const char*);
 
 typedef enum {
 	TOY_LITERAL_NULL,
@@ -49,25 +51,25 @@ typedef struct Toy_Literal {
 			//string hash?
 		} string; //8
 
-		void* array; //8
-		void* dictionary; //8
+		struct Toy_LiteralArray* array; //8
+		struct Toy_LiteralDictionary* dictionary; //8
 
 		struct {
 			union {
-				void* bytecode;  //8
+				Toy_RefFunction* ptr;  //8
 				Toy_NativeFn native; //8
 				Toy_HookFn hook; //8
 			} inner;  //8
-			void* scope; //8
+			struct Toy_Scope* scope; //8
 		} function; //16
 
 		struct { //for variable names
-            Toy_RefString* ptr;  //8
+			Toy_RefString* ptr;  //8
 			int hash; //4
-        } identifier; //16
+		} identifier; //16
 
 		struct {
-			void* subtypes; //8
+			struct Toy_Literal* subtypes; //8
 			Toy_LiteralType typeOf;  //4
 			unsigned char capacity; //1
 			unsigned char count; //1
@@ -78,10 +80,13 @@ typedef struct Toy_Literal {
 			void* ptr; //8
 			int tag; //4
 		} opaque; //16
+
+		void* generic; //8
 	} as; //16
 
 	Toy_LiteralType type; //4
-	int bytecodeLength; //4 - shenanigans with byte alignment reduces the size of Toy_Literal
+	//4 - unused
+	//shenanigans with byte alignment reduces the size of Toy_Literal
 } Toy_Literal;
 
 #define TOY_IS_NULL(value)						((value).type == TOY_LITERAL_NULL)
@@ -111,29 +116,29 @@ typedef struct Toy_Literal {
 #define TOY_AS_TYPE(value)						((value).as.type)
 #define TOY_AS_OPAQUE(value)					((value).as.opaque.ptr)
 
-#define TOY_TO_NULL_LITERAL						((Toy_Literal){{ .integer = 0 }, TOY_LITERAL_NULL, 0})
-#define TOY_TO_BOOLEAN_LITERAL(value)			((Toy_Literal){{ .boolean = value }, TOY_LITERAL_BOOLEAN, 0})
-#define TOY_TO_INTEGER_LITERAL(value)			((Toy_Literal){{ .integer = value }, TOY_LITERAL_INTEGER, 0})
-#define TOY_TO_FLOAT_LITERAL(value)				((Toy_Literal){{ .number = value }, TOY_LITERAL_FLOAT, 0})
-#define TOY_TO_STRING_LITERAL(value)			Toy_private_toStringLiteral(value)
-#define TOY_TO_ARRAY_LITERAL(value)				((Toy_Literal){{ .array = value }, TOY_LITERAL_ARRAY, 0})
-#define TOY_TO_DICTIONARY_LITERAL(value)		((Toy_Literal){{ .dictionary = value }, TOY_LITERAL_DICTIONARY, 0})
-#define TOY_TO_FUNCTION_LITERAL(value, l)		((Toy_Literal){{ .function.inner.bytecode = value, .function.scope = NULL }, TOY_LITERAL_FUNCTION, l})
-#define TOY_TO_FUNCTION_NATIVE_LITERAL(value)	((Toy_Literal){{ .function.inner.native = value, .function.scope = NULL }, TOY_LITERAL_FUNCTION_NATIVE, 0})
-#define TOY_TO_FUNCTION_HOOK_LITERAL(value)		((Toy_Literal){{ .function.inner.hook = value, .function.scope = NULL }, TOY_LITERAL_FUNCTION_HOOK, 0})
+#define TOY_TO_NULL_LITERAL						((Toy_Literal){{ .integer = 0 }, TOY_LITERAL_NULL})
+#define TOY_TO_BOOLEAN_LITERAL(value)			((Toy_Literal){{ .boolean = value }, TOY_LITERAL_BOOLEAN})
+#define TOY_TO_INTEGER_LITERAL(value)			((Toy_Literal){{ .integer = value }, TOY_LITERAL_INTEGER})
+#define TOY_TO_FLOAT_LITERAL(value)				((Toy_Literal){{ .number = value }, TOY_LITERAL_FLOAT})
+#define TOY_TO_STRING_LITERAL(value)			((Toy_Literal){{ .string = { .ptr = value }},TOY_LITERAL_STRING})
+#define TOY_TO_ARRAY_LITERAL(value)				((Toy_Literal){{ .array = value }, TOY_LITERAL_ARRAY})
+#define TOY_TO_DICTIONARY_LITERAL(value)		((Toy_Literal){{ .dictionary = value }, TOY_LITERAL_DICTIONARY})
+#define TOY_TO_FUNCTION_LITERAL(value)			((Toy_Literal){{ .function = { .inner = { .ptr = value }, .scope = NULL }}, TOY_LITERAL_FUNCTION})
+#define TOY_TO_FUNCTION_NATIVE_LITERAL(value)	((Toy_Literal){{ .function = { .inner = { .native = value }, .scope = NULL }}, TOY_LITERAL_FUNCTION_NATIVE})
+#define TOY_TO_FUNCTION_HOOK_LITERAL(value)		((Toy_Literal){{ .function = { .inner = { .hook = value }, .scope = NULL }}, TOY_LITERAL_FUNCTION_HOOK})
 #define TOY_TO_IDENTIFIER_LITERAL(value)		Toy_private_toIdentifierLiteral(value)
-#define TOY_TO_TYPE_LITERAL(value, c)			((Toy_Literal){{ .type.typeOf = value, .type.constant = c, .type.subtypes = NULL, .type.capacity = 0, .type.count = 0 }, TOY_LITERAL_TYPE, 0})
-#define TOY_TO_OPAQUE_LITERAL(value, t)			((Toy_Literal){{ .opaque.ptr = value, .opaque.tag = t }, TOY_LITERAL_OPAQUE, 0})
+#define TOY_TO_TYPE_LITERAL(value, c)			((Toy_Literal){{ .type = { .typeOf = value, .constant = c, .subtypes = NULL, .capacity = 0, .count = 0 }}, TOY_LITERAL_TYPE})
+#define TOY_TO_OPAQUE_LITERAL(value, t)			((Toy_Literal){{ .opaque = { .ptr = value, .tag = t }}, TOY_LITERAL_OPAQUE})
 
 //BUGFIX: For blank indexing
 #define TOY_IS_INDEX_BLANK(value)				((value).type == TOY_LITERAL_INDEX_BLANK)
-#define TOY_TO_INDEX_BLANK_LITERAL				((Toy_Literal){{ .integer = 0 }, TOY_LITERAL_INDEX_BLANK, 0})
+#define TOY_TO_INDEX_BLANK_LITERAL				((Toy_Literal){{ .integer = 0 }, TOY_LITERAL_INDEX_BLANK})
 
 TOY_API void Toy_freeLiteral(Toy_Literal literal);
 
 #define TOY_IS_TRUTHY(x) Toy_private_isTruthy(x)
 
-#define TOY_AS_FUNCTION_BYTECODE_LENGTH(lit)	((lit).bytecodeLength)
+#define TOY_AS_FUNCTION_BYTECODE_LENGTH(lit)	(Toy_lengthRefFunction((lit).inner.ptr))
 
 #define TOY_MAX_STRING_LENGTH					4096
 #define TOY_HASH_I(lit)							((lit).as.identifier.hash)
@@ -142,7 +147,6 @@ TOY_API void Toy_freeLiteral(Toy_Literal literal);
 
 //BUGFIX: macros are not functions
 TOY_API bool Toy_private_isTruthy(Toy_Literal x);
-TOY_API Toy_Literal Toy_private_toStringLiteral(Toy_RefString* ptr);
 TOY_API Toy_Literal Toy_private_toIdentifierLiteral(Toy_RefString* ptr);
 TOY_API Toy_Literal* Toy_private_typePushSubtype(Toy_Literal* lit, Toy_Literal subtype);
 
@@ -151,5 +155,6 @@ TOY_API Toy_Literal Toy_copyLiteral(Toy_Literal original);
 TOY_API bool Toy_literalsAreEqual(Toy_Literal lhs, Toy_Literal rhs);
 TOY_API int Toy_hashLiteral(Toy_Literal lit);
 
+//not thread-safe
 TOY_API void Toy_printLiteral(Toy_Literal literal);
-TOY_API void Toy_printLiteralCustom(Toy_Literal literal, void (printFn)(const char*));
+TOY_API void Toy_printLiteralCustom(Toy_Literal literal, Toy_PrintFn);

source/toy_literal_array.c

@@ -18,8 +18,10 @@ void Toy_freeLiteralArray(Toy_LiteralArray* array) {
 		Toy_freeLiteral(array->literals[i]);
 	}
 
-	TOY_FREE_ARRAY(Toy_Literal, array->literals, array->capacity);
-	Toy_initLiteralArray(array);
+	if (array->capacity > 0) {
+		TOY_FREE_ARRAY(Toy_Literal, array->literals, array->capacity);
+		Toy_initLiteralArray(array);
+	}
 }
 
 int Toy_pushLiteralArray(Toy_LiteralArray* array, Toy_Literal literal) {

source/toy_literal_array.h

@@ -18,3 +18,5 @@ TOY_API bool Toy_setLiteralArray(Toy_LiteralArray* array, Toy_Literal index, Toy
 TOY_API Toy_Literal Toy_getLiteralArray(Toy_LiteralArray* array, Toy_Literal index);
 
 int Toy_findLiteralIndex(Toy_LiteralArray* array, Toy_Literal literal);
+
+//TODO: add a function to get the capacity & count

source/toy_literal_dictionary.c

@@ -7,7 +7,7 @@
 #include <stdio.h>
 
 //util functions
-static void setEntryValues(Toy_private_entry* entry, Toy_Literal key, Toy_Literal value) {
+static void setEntryValues(Toy_private_dictionary_entry* entry, Toy_Literal key, Toy_Literal value) {
 	//much simpler now
 	Toy_freeLiteral(entry->key);
 	entry->key = Toy_copyLiteral(key);
@@ -16,17 +16,23 @@ static void setEntryValues(Toy_private_entry* entry, Toy_Literal key, Toy_Litera
 	entry->value = Toy_copyLiteral(value);
 }
 
-static Toy_private_entry* getEntryArray(Toy_private_entry* array, int capacity, Toy_Literal key, unsigned int hash, bool mustExist) {
+static Toy_private_dictionary_entry* getEntryArray(Toy_private_dictionary_entry* array, int capacity, Toy_Literal key, unsigned int hash, bool mustExist) {
+	if (!capacity) {
+		return NULL;
+	}
+
 	//find "key", starting at index
-	unsigned int index = hash % capacity;
-	unsigned int start = index;
+	int index = hash % capacity;
+	int start = index;
 
 	//increment once, so it can't equal start
-	index = (index + 1) % capacity;
+	if (++index >= capacity) {
+		index = 0;
+	}
 
 	//literal probing and collision checking
 	while (index != start) { //WARNING: this is the only function allowed to retrieve an entry from the array
-		Toy_private_entry* entry = &array[index];
+		Toy_private_dictionary_entry* entry = &array[index];
 
 		if (TOY_IS_NULL(entry->key)) { //if key is empty, it's either empty or tombstone
 			if (TOY_IS_NULL(entry->value) && !mustExist) {
@@ -40,15 +46,18 @@ static Toy_private_entry* getEntryArray(Toy_private_entry* array, int capacity,
 			}
 		}
 
-		index = (index + 1) % capacity;
+		if (++index >= capacity) {
+			index = 0;
+		}
+		//index = (index + 1) % capacity;
 	}
 
 	return NULL;
 }
 
-static void adjustEntryCapacity(Toy_private_entry** dictionaryHandle, int oldCapacity, int capacity) {
+static void adjustEntryCapacity(Toy_private_dictionary_entry** dictionaryHandle, int oldCapacity, int capacity) {
 	//new entry space
-	Toy_private_entry* newEntries = TOY_ALLOCATE(Toy_private_entry, capacity);
+	Toy_private_dictionary_entry* newEntries = TOY_ALLOCATE(Toy_private_dictionary_entry, capacity);
 
 	for (int i = 0; i < capacity; i++) {
 		newEntries[i].key = TOY_TO_NULL_LITERAL;
@@ -62,19 +71,21 @@ static void adjustEntryCapacity(Toy_private_entry** dictionaryHandle, int oldCap
 		}
 
 		//place the key and value in the new array (reusing string memory)
-		Toy_private_entry* entry = getEntryArray(newEntries, capacity, TOY_TO_NULL_LITERAL, Toy_hashLiteral((*dictionaryHandle)[i].key), false);
+		Toy_private_dictionary_entry* entry = getEntryArray(newEntries, capacity, TOY_TO_NULL_LITERAL, Toy_hashLiteral((*dictionaryHandle)[i].key), false);
 
 		entry->key = (*dictionaryHandle)[i].key;
 		entry->value = (*dictionaryHandle)[i].value;
 	}
 
 	//clear the old array
-	TOY_FREE_ARRAY(Toy_private_entry, *dictionaryHandle, oldCapacity);
+	if (oldCapacity > 0) {
+		TOY_FREE_ARRAY(Toy_private_dictionary_entry, *dictionaryHandle, oldCapacity);
+	}
 
 	*dictionaryHandle = newEntries;
 }
 
-static bool setEntryArray(Toy_private_entry** dictionaryHandle, int* capacityPtr, int contains, Toy_Literal key, Toy_Literal value, int hash) {
+static bool setEntryArray(Toy_private_dictionary_entry** dictionaryHandle, int* capacityPtr, int contains, Toy_Literal key, Toy_Literal value, int hash) {
 	//expand array if needed
 	if (contains + 1 > *capacityPtr * TOY_DICTIONARY_MAX_LOAD) {
 		int oldCapacity = *capacityPtr;
@@ -82,7 +93,7 @@ static bool setEntryArray(Toy_private_entry** dictionaryHandle, int* capacityPtr
 		adjustEntryCapacity(dictionaryHandle, oldCapacity, *capacityPtr); //custom rather than automatic reallocation
 	}
 
-	Toy_private_entry* entry = getEntryArray(*dictionaryHandle, *capacityPtr, key, hash, false);
+	Toy_private_dictionary_entry* entry = getEntryArray(*dictionaryHandle, *capacityPtr, key, hash, false);
 
 	//true = contains increase
 	if (TOY_IS_NULL(entry->key)) {
@@ -97,14 +108,14 @@ static bool setEntryArray(Toy_private_entry** dictionaryHandle, int* capacityPtr
 	return false;
 }
 
-static void freeEntry(Toy_private_entry* entry) {
+static void freeEntry(Toy_private_dictionary_entry* entry) {
 	Toy_freeLiteral(entry->key);
 	Toy_freeLiteral(entry->value);
 	entry->key = TOY_TO_NULL_LITERAL;
 	entry->value = TOY_TO_NULL_LITERAL;
 }
 
-static void freeEntryArray(Toy_private_entry* array, int capacity) {
+static void freeEntryArray(Toy_private_dictionary_entry* array, int capacity) {
 	if (array == NULL) {
 		return;
 	}
@@ -115,23 +126,25 @@ static void freeEntryArray(Toy_private_entry* array, int capacity) {
 		}
 	}
 
-	TOY_FREE_ARRAY(Toy_private_entry, array, capacity);
+	TOY_FREE_ARRAY(Toy_private_dictionary_entry, array, capacity);
 }
 
 //exposed functions
 void Toy_initLiteralDictionary(Toy_LiteralDictionary* dictionary) {
 	//HACK: because modulo by 0 is undefined, set the capacity to a non-zero value (and allocate the arrays)
 	dictionary->entries = NULL;
-	dictionary->capacity = TOY_GROW_CAPACITY(0);
+	dictionary->capacity = 0;
 	dictionary->contains = 0;
 	dictionary->count = 0;
-	adjustEntryCapacity(&dictionary->entries, 0, dictionary->capacity);
+	dictionary->capacity = 0;
 }
 
 void Toy_freeLiteralDictionary(Toy_LiteralDictionary* dictionary) {
-	freeEntryArray(dictionary->entries, dictionary->capacity);
-	dictionary->capacity = 0;
-	dictionary->contains = 0;
+	if (dictionary->capacity > 0) {
+		freeEntryArray(dictionary->entries, dictionary->capacity);
+		dictionary->capacity = 0;
+		dictionary->contains = 0;
+	}
 }
 
 void Toy_setLiteralDictionary(Toy_LiteralDictionary* dictionary, Toy_Literal key, Toy_Literal value) {
@@ -141,7 +154,7 @@ void Toy_setLiteralDictionary(Toy_LiteralDictionary* dictionary, Toy_Literal key
 	}
 
 	//BUGFIX: Can't hash a function
-	if (TOY_IS_FUNCTION(key) || TOY_IS_FUNCTION_NATIVE(key)) {
+	if (TOY_IS_FUNCTION(key) || TOY_IS_FUNCTION_NATIVE(key) || TOY_IS_FUNCTION_HOOK(key)) {
 		fprintf(stderr, TOY_CC_ERROR "Dictionaries can't have function keys (set)\n" TOY_CC_RESET);
 		return;
 	}
@@ -166,7 +179,7 @@ Toy_Literal Toy_getLiteralDictionary(Toy_LiteralDictionary* dictionary, Toy_Lite
 	}
 
 	//BUGFIX: Can't hash a function
-	if (TOY_IS_FUNCTION(key) || TOY_IS_FUNCTION_NATIVE(key)) {
+	if (TOY_IS_FUNCTION(key) || TOY_IS_FUNCTION_NATIVE(key) || TOY_IS_FUNCTION_HOOK(key)) {
 		fprintf(stderr, TOY_CC_ERROR "Dictionaries can't have function keys (get)\n" TOY_CC_RESET);
 		return TOY_TO_NULL_LITERAL;
 	}
@@ -176,7 +189,7 @@ Toy_Literal Toy_getLiteralDictionary(Toy_LiteralDictionary* dictionary, Toy_Lite
 		return TOY_TO_NULL_LITERAL;
 	}
 
-	Toy_private_entry* entry = getEntryArray(dictionary->entries, dictionary->capacity, key, Toy_hashLiteral(key), true);
+	Toy_private_dictionary_entry* entry = getEntryArray(dictionary->entries, dictionary->capacity, key, Toy_hashLiteral(key), true);
 
 	if (entry != NULL) {
 		return Toy_copyLiteral(entry->value);
@@ -193,7 +206,7 @@ void Toy_removeLiteralDictionary(Toy_LiteralDictionary* dictionary, Toy_Literal
 	}
 
 	//BUGFIX: Can't hash a function
-	if (TOY_IS_FUNCTION(key) || TOY_IS_FUNCTION_NATIVE(key)) {
+	if (TOY_IS_FUNCTION(key) || TOY_IS_FUNCTION_NATIVE(key) || TOY_IS_FUNCTION_HOOK(key)) {
 		fprintf(stderr, TOY_CC_ERROR "Dictionaries can't have function keys (remove)\n" TOY_CC_RESET);
 		return;
 	}
@@ -203,7 +216,7 @@ void Toy_removeLiteralDictionary(Toy_LiteralDictionary* dictionary, Toy_Literal
 		return;
 	}
 
-	Toy_private_entry* entry = getEntryArray(dictionary->entries, dictionary->capacity, key, Toy_hashLiteral(key), true);
+	Toy_private_dictionary_entry* entry = getEntryArray(dictionary->entries, dictionary->capacity, key, Toy_hashLiteral(key), true);
 
 	if (entry != NULL) {
 		freeEntry(entry);
@@ -214,6 +227,6 @@ void Toy_removeLiteralDictionary(Toy_LiteralDictionary* dictionary, Toy_Literal
 
 bool Toy_existsLiteralDictionary(Toy_LiteralDictionary* dictionary, Toy_Literal key) {
 	//null & not tombstoned
-	Toy_private_entry* entry = getEntryArray(dictionary->entries, dictionary->capacity, key, Toy_hashLiteral(key), false);
-	return !(TOY_IS_NULL(entry->key) && TOY_IS_NULL(entry->value));
+	Toy_private_dictionary_entry* entry = getEntryArray(dictionary->entries, dictionary->capacity, key, Toy_hashLiteral(key), false);
+	return entry != NULL && !(TOY_IS_NULL(entry->key) && TOY_IS_NULL(entry->value));
 }

source/toy_literal_dictionary.h

@@ -7,13 +7,13 @@
 //TODO: benchmark this
 #define TOY_DICTIONARY_MAX_LOAD 0.75
 
-typedef struct Toy_private_entry {
+typedef struct Toy_private_dictionary_entry {
 	Toy_Literal key;
 	Toy_Literal value;
-} Toy_private_entry;
+} Toy_private_dictionary_entry;
 
 typedef struct Toy_LiteralDictionary {
-	Toy_private_entry* entries;
+	Toy_private_dictionary_entry* entries;
 	int capacity;
 	int count;
 	int contains; //count + tombstones, for internal use

source/toy_memory.c

@@ -1,5 +1,6 @@
 #include "toy_memory.h"
 #include "toy_refstring.h"
+#include "toy_reffunction.h"
 
 #include "toy_console_colors.h"
 
@@ -8,22 +9,21 @@
 
 //default allocator
 void* Toy_private_defaultMemoryAllocator(void* pointer, size_t oldSize, size_t newSize) {
-	if (newSize == 0 && oldSize == 0) {
-		//causes issues, so just skip out with a NO-OP
-		return NULL;
-	}
+	//causes issues, so just skip out with a NO-OP (DISABLED for performance reasons)
+	// if (newSize == 0 && oldSize == 0) {
+	// 	return NULL;
+	// }
 
 	if (newSize == 0) {
 		free(pointer);
-
 		return NULL;
 	}
 
 	void* mem = realloc(pointer, newSize);
 
 	if (mem == NULL) {
-		fprintf(stderr, TOY_CC_ERROR "[internal] Memory allocation error (requested %d, replacing %d)\n" TOY_CC_RESET, (int)newSize, (int)oldSize);
-		exit(-1);
+		fprintf(stderr, TOY_CC_ERROR "[internal] Memory allocation error (requested %zu, replacing %zu)\n" TOY_CC_RESET, newSize, oldSize);
+		return NULL;
 	}
 
 	return mem;
@@ -50,4 +50,5 @@ void Toy_setMemoryAllocator(Toy_MemoryAllocatorFn fn) {
 
 	allocator = fn;
 	Toy_setRefStringAllocatorFn(fn);
+	Toy_setRefFunctionAllocatorFn(fn);
 }

source/toy_memory.h

@@ -2,13 +2,16 @@
 
 #include "toy_common.h"
 
-#define TOY_ALLOCATE(type, count) ((type*)Toy_reallocate(NULL, 0, sizeof(type) * (count)))
-#define TOY_FREE(type, pointer) Toy_reallocate(pointer, sizeof(type), 0)
-#define TOY_GROW_CAPACITY(capacity) ((capacity) < 8 ? 8 : (capacity) * 2)
-#define TOY_GROW_CAPACITY_FAST(capacity) ((capacity) < 32 ? 32 : (capacity) * 2)
-#define TOY_GROW_ARRAY(type, pointer, oldCount, count) (type*)Toy_reallocate((type*)pointer, sizeof(type) * (oldCount), sizeof(type) * (count))
-#define TOY_SHRINK_ARRAY(type, pointer, oldCount, count) (type*)Toy_reallocate((type*)pointer, sizeof(type) * (oldCount), sizeof(type) * (count))
-#define TOY_FREE_ARRAY(type, pointer, oldCount) Toy_reallocate((type*)pointer, sizeof(type) * (oldCount), 0)
+#define TOY_GROW_CAPACITY(capacity) 						((capacity) < 8 ? 8 : (capacity) * 2)
+#define TOY_GROW_CAPACITY_FAST(capacity)					((capacity) < 32 ? 32 : (capacity) * 2)
+
+#define TOY_ALLOCATE(type, count)							((type*)Toy_reallocate(NULL, 0, sizeof(type) * (count)))
+
+#define TOY_FREE(type, pointer)								Toy_reallocate(pointer, sizeof(type), 0)
+#define TOY_FREE_ARRAY(type, pointer, oldCount)				Toy_reallocate((type*)pointer, sizeof(type) * (oldCount), 0)
+
+#define TOY_GROW_ARRAY(type, pointer, oldCount, count)		(type*)Toy_reallocate((type*)pointer, sizeof(type) * (oldCount), sizeof(type) * (count))
+#define TOY_SHRINK_ARRAY(type, pointer, oldCount, count)	(type*)Toy_reallocate((type*)pointer, sizeof(type) * (oldCount), sizeof(type) * (count))
 
 //implementation details
 TOY_API void* Toy_reallocate(void* pointer, size_t oldSize, size_t newSize);

source/toy_opcodes.h

@@ -3,6 +3,9 @@
 typedef enum Toy_Opcode {
 	TOY_OP_EOF,
 
+	//do nothing
+	TOY_OP_PASS,
+
 	//basic statements
 	TOY_OP_ASSERT,
 	TOY_OP_PRINT,

source/toy_parser.c

@@ -32,7 +32,7 @@ static void error(Toy_Parser* parser, Toy_Token token, const char* message) {
 
 static void advance(Toy_Parser* parser) {
 	parser->previous = parser->current;
-	parser->current = Toy_scanLexer(parser->lexer);
+	parser->current = Toy_private_scanLexer(parser->lexer);
 
 	if (parser->current.type == TOY_TOKEN_ERROR) {
 		error(parser, parser->current, "Toy_Lexer error");
@@ -119,6 +119,7 @@ ParseRule parseRules[];
 static void declaration(Toy_Parser* parser, Toy_ASTNode** nodeHandle);
 static void parsePrecedence(Toy_Parser* parser, Toy_ASTNode** nodeHandle, PrecedenceRule rule);
 static Toy_Literal readTypeToLiteral(Toy_Parser* parser);
+static void varDecl(Toy_Parser* parser, Toy_ASTNode** nodeHandle);
 
 //TODO: resolve the messy order of these
 //the expression rules
@@ -140,7 +141,7 @@ static Toy_Opcode asType(Toy_Parser* parser, Toy_ASTNode** nodeHandle) {
 
 static Toy_Opcode typeOf(Toy_Parser* parser, Toy_ASTNode** nodeHandle) {
 	Toy_ASTNode* rhs = NULL;
-	parsePrecedence(parser, &rhs, PREC_TERNARY);
+	parsePrecedence(parser, &rhs, PREC_CALL);
 	Toy_emitASTNodeUnary(nodeHandle, TOY_OP_TYPE_OF, rhs);
 	return TOY_OP_EOF;
 }
@@ -341,99 +342,99 @@ static Toy_Opcode binary(Toy_Parser* parser, Toy_ASTNode** nodeHandle) {
 	switch(parser->previous.type) {
 		//arithmetic
 		case TOY_TOKEN_PLUS: {
-			parsePrecedence(parser, nodeHandle, PREC_TERM);
+			parsePrecedence(parser, nodeHandle, PREC_TERM + 1);
 			return TOY_OP_ADDITION;
 		}
 
 		case TOY_TOKEN_MINUS: {
-			parsePrecedence(parser, nodeHandle, PREC_TERM);
+			parsePrecedence(parser, nodeHandle, PREC_TERM + 1);
 			return TOY_OP_SUBTRACTION;
 		}
 
 		case TOY_TOKEN_MULTIPLY: {
-			parsePrecedence(parser, nodeHandle, PREC_FACTOR);
+			parsePrecedence(parser, nodeHandle, PREC_FACTOR + 1);
 			return TOY_OP_MULTIPLICATION;
 		}
 
 		case TOY_TOKEN_DIVIDE: {
-			parsePrecedence(parser, nodeHandle, PREC_FACTOR);
+			parsePrecedence(parser, nodeHandle, PREC_FACTOR + 1);
 			return TOY_OP_DIVISION;
 		}
 
 		case TOY_TOKEN_MODULO: {
-			parsePrecedence(parser, nodeHandle, PREC_FACTOR);
+			parsePrecedence(parser, nodeHandle, PREC_FACTOR + 1);
 			return TOY_OP_MODULO;
 		}
 
 		//assignment
 		case TOY_TOKEN_ASSIGN: {
-			parsePrecedence(parser, nodeHandle, PREC_ASSIGNMENT);
+			parsePrecedence(parser, nodeHandle, PREC_ASSIGNMENT + 1);
 			return TOY_OP_VAR_ASSIGN;
 		}
 
 		case TOY_TOKEN_PLUS_ASSIGN: {
-			parsePrecedence(parser, nodeHandle, PREC_ASSIGNMENT);
+			parsePrecedence(parser, nodeHandle, PREC_ASSIGNMENT + 1);
 			return TOY_OP_VAR_ADDITION_ASSIGN;
 		}
 
 		case TOY_TOKEN_MINUS_ASSIGN: {
-			parsePrecedence(parser, nodeHandle, PREC_ASSIGNMENT);
+			parsePrecedence(parser, nodeHandle, PREC_ASSIGNMENT + 1);
 			return TOY_OP_VAR_SUBTRACTION_ASSIGN;
 		}
 
 		case TOY_TOKEN_MULTIPLY_ASSIGN: {
-			parsePrecedence(parser, nodeHandle, PREC_ASSIGNMENT);
+			parsePrecedence(parser, nodeHandle, PREC_ASSIGNMENT + 1);
 			return TOY_OP_VAR_MULTIPLICATION_ASSIGN;
 		}
 
 		case TOY_TOKEN_DIVIDE_ASSIGN: {
-			parsePrecedence(parser, nodeHandle, PREC_ASSIGNMENT);
+			parsePrecedence(parser, nodeHandle, PREC_ASSIGNMENT + 1);
 			return TOY_OP_VAR_DIVISION_ASSIGN;
 		}
 
 		case TOY_TOKEN_MODULO_ASSIGN: {
-			parsePrecedence(parser, nodeHandle, PREC_ASSIGNMENT);
+			parsePrecedence(parser, nodeHandle, PREC_ASSIGNMENT + 1);
 			return TOY_OP_VAR_MODULO_ASSIGN;
 		}
 
 		//comparison
 		case TOY_TOKEN_EQUAL: {
-			parsePrecedence(parser, nodeHandle, PREC_COMPARISON);
+			parsePrecedence(parser, nodeHandle, PREC_COMPARISON + 1);
 			return TOY_OP_COMPARE_EQUAL;
 		}
 
 		case TOY_TOKEN_NOT_EQUAL: {
-			parsePrecedence(parser, nodeHandle, PREC_COMPARISON);
+			parsePrecedence(parser, nodeHandle, PREC_COMPARISON + 1);
 			return TOY_OP_COMPARE_NOT_EQUAL;
 		}
 
 		case TOY_TOKEN_LESS: {
-			parsePrecedence(parser, nodeHandle, PREC_COMPARISON);
+			parsePrecedence(parser, nodeHandle, PREC_COMPARISON + 1);
 			return TOY_OP_COMPARE_LESS;
 		}
 
 		case TOY_TOKEN_LESS_EQUAL: {
-			parsePrecedence(parser, nodeHandle, PREC_COMPARISON);
+			parsePrecedence(parser, nodeHandle, PREC_COMPARISON + 1);
 			return TOY_OP_COMPARE_LESS_EQUAL;
 		}
 
 		case TOY_TOKEN_GREATER: {
-			parsePrecedence(parser, nodeHandle, PREC_COMPARISON);
+			parsePrecedence(parser, nodeHandle, PREC_COMPARISON + 1);
 			return TOY_OP_COMPARE_GREATER;
 		}
 
 		case TOY_TOKEN_GREATER_EQUAL: {
-			parsePrecedence(parser, nodeHandle, PREC_COMPARISON);
+			parsePrecedence(parser, nodeHandle, PREC_COMPARISON + 1);
 			return TOY_OP_COMPARE_GREATER_EQUAL;
 		}
 
 		case TOY_TOKEN_AND: {
-			parsePrecedence(parser, nodeHandle, PREC_AND);
+			parsePrecedence(parser, nodeHandle, PREC_AND + 1);
 			return TOY_OP_AND;
 		}
 
 		case TOY_TOKEN_OR: {
-			parsePrecedence(parser, nodeHandle, PREC_OR);
+			parsePrecedence(parser, nodeHandle, PREC_OR + 1);
 			return TOY_OP_OR;
 		}
 
@@ -627,6 +628,14 @@ static Toy_Opcode castingPrefix(Toy_Parser* parser, Toy_ASTNode** nodeHandle) {
 		}
 		break;
 
+		//BUGFIX: handle this here, and not in castingPrefix, so "any" can be recognized as a type properly
+		case TOY_TOKEN_ANY: {
+			Toy_Literal literal = TOY_TO_TYPE_LITERAL(TOY_LITERAL_ANY, false);
+			Toy_emitASTNodeLiteral(nodeHandle, literal);
+			Toy_freeLiteral(literal);
+		}
+		break;
+
 		default:
 			error(parser, parser->previous, "Unexpected token passed to casting precedence rule");
 			return TOY_OP_EOF;
@@ -658,7 +667,7 @@ static Toy_Opcode castingInfix(Toy_Parser* parser, Toy_ASTNode** nodeHandle) {
 		break;
 
 		case TOY_TOKEN_LITERAL_STRING:
-			atomic(parser, nodeHandle);
+			string(parser, nodeHandle);
 		break;
 
 		default:
@@ -739,6 +748,27 @@ static Toy_Opcode decrementInfix(Toy_Parser* parser, Toy_ASTNode** nodeHandle) {
 }
 
 static Toy_Opcode fnCall(Toy_Parser* parser, Toy_ASTNode** nodeHandle) {
+	//wait - is the previous token a type? this should be casting instead
+	if (parser->previous.type >= TOY_TOKEN_NULL && parser->previous.type <= TOY_TOKEN_ANY) {
+		//casting type
+		Toy_ASTNode* lhsNode = NULL;
+		castingPrefix(parser, &lhsNode);
+		advance(parser);
+
+		//casting value
+		Toy_ASTNode* rhsNode = NULL;
+		grouping(parser, &rhsNode);
+
+		//emit the cast node
+
+		Toy_emitASTNodeBinary(&lhsNode, rhsNode, TOY_OP_TYPE_CAST);
+
+		//pass it off to the caller
+		*nodeHandle = lhsNode;
+
+		return TOY_OP_GROUPING_BEGIN; //dummy value
+	}
+
 	advance(parser); //skip the left paren
 
 	//binary() is an infix rule - so only get the RHS of the operator
@@ -810,13 +840,20 @@ static Toy_Opcode indexAccess(Toy_Parser* parser, Toy_ASTNode** nodeHandle) { //
 	//eat the first
 	if (!match(parser, TOY_TOKEN_COLON)) {
 		Toy_freeASTNode(first);
+		first = NULL;
 		parsePrecedence(parser, &first, PREC_TERNARY);
 		match(parser, TOY_TOKEN_COLON);
 		readFirst = true;
 	}
 
-	if (match(parser, TOY_TOKEN_BRACKET_RIGHT)) {
+	if (!first) {
+		Toy_freeASTNode(first);
+		Toy_freeASTNode(second);
+		Toy_freeASTNode(third);
+		return TOY_OP_EOF;
+	}
 
+	if (match(parser, TOY_TOKEN_BRACKET_RIGHT)) {
 		if (readFirst) {
 			Toy_freeASTNode(second);
 			second = NULL;
@@ -832,10 +869,18 @@ static Toy_Opcode indexAccess(Toy_Parser* parser, Toy_ASTNode** nodeHandle) { //
 	//eat the second
 	if (!match(parser, TOY_TOKEN_COLON)) {
 		Toy_freeASTNode(second);
+		second = NULL;
 		parsePrecedence(parser, &second, PREC_TERNARY);
 		match(parser, TOY_TOKEN_COLON);
 	}
 
+	if (!second) {
+		Toy_freeASTNode(first);
+		Toy_freeASTNode(second);
+		Toy_freeASTNode(third);
+		return TOY_OP_EOF;
+	}
+
 	if (match(parser, TOY_TOKEN_BRACKET_RIGHT)) {
 		Toy_freeASTNode(third);
 		third = NULL;
@@ -845,7 +890,16 @@ static Toy_Opcode indexAccess(Toy_Parser* parser, Toy_ASTNode** nodeHandle) { //
 
 	//eat the third
 	Toy_freeASTNode(third);
+	third = NULL;
 	parsePrecedence(parser, &third, PREC_TERNARY);
+
+	if (!third) {
+		Toy_freeASTNode(first);
+		Toy_freeASTNode(second);
+		Toy_freeASTNode(third);
+		return TOY_OP_EOF;
+	}
+
 	Toy_emitASTNodeIndex(nodeHandle, first, second, third);
 
 	consume(parser, TOY_TOKEN_BRACKET_RIGHT, "Expected ']' in index notation");
@@ -894,7 +948,7 @@ ParseRule parseRules[] = { //must match the token types
 	{NULL, NULL, PREC_NONE},// TOKEN_DICTIONARY,
 	{NULL, NULL, PREC_NONE},// TOKEN_FUNCTION,
 	{NULL, NULL, PREC_NONE},// TOKEN_OPAQUE,
-	{NULL, NULL, PREC_NONE},// TOKEN_ANY,
+	{castingPrefix, NULL, PREC_CALL},// TOKEN_ANY,
 
 	//keywords and reserved words
 	{NULL, NULL, PREC_NONE},// TOKEN_AS,
@@ -1350,13 +1404,42 @@ static void forStmt(Toy_Parser* parser, Toy_ASTNode** nodeHandle) {
 	//read the clauses
 	consume(parser, TOY_TOKEN_PAREN_LEFT, "Expected '(' at beginning of for clause");
 
-	declaration(parser, &preClause); //allow defining variables in the pre-clause
+	//check the pre-clause
+	if (parser->current.type != TOY_TOKEN_SEMICOLON) {
+		//allow defining variables in the pre-clause
+		if (match(parser, TOY_TOKEN_VAR)) {
+			varDecl(parser, &preClause);
+		}
+		else {
+			parsePrecedence(parser, &preClause, PREC_ASSIGNMENT);
+		}
+	}
+	else {
+		consume(parser, TOY_TOKEN_SEMICOLON, "Expected ';' after empty declaration of for clause");
+		Toy_emitASTNodePass(&preClause);
+	}
 
-	parsePrecedence(parser, &condition, PREC_TERNARY);
-	consume(parser, TOY_TOKEN_SEMICOLON, "Expected ';' after condition of for clause");
+	//check the condition clause
+	if (parser->current.type != TOY_TOKEN_SEMICOLON) {
+		parsePrecedence(parser, &condition, PREC_TERNARY);
+		consume(parser, TOY_TOKEN_SEMICOLON, "Expected ';' after condition of for clause");
+	}
+	else {
+		consume(parser, TOY_TOKEN_SEMICOLON, "Expected ';' after empty condition of for clause");
+		//empty clause defaults to forever
+		Toy_Literal f = TOY_TO_BOOLEAN_LITERAL(true);
+		Toy_emitASTNodeLiteral(&condition, f);
+	}
 
-	parsePrecedence(parser, &postClause, PREC_ASSIGNMENT);
-	consume(parser, TOY_TOKEN_PAREN_RIGHT, "Expected ')' at end of for clause");
+	//check the postfix clause
+	if (parser->current.type != TOY_TOKEN_PAREN_RIGHT) {
+		parsePrecedence(parser, &postClause, PREC_ASSIGNMENT);
+		consume(parser, TOY_TOKEN_PAREN_RIGHT, "Expected ')' at end of for clause");
+	}
+	else {
+		consume(parser, TOY_TOKEN_PAREN_RIGHT, "Expected ')' after empty increment of for clause");
+		Toy_emitASTNodePass(&postClause);
+	}
 
 	//read the path
 	declaration(parser, &thenPath);

source/toy_reffunction.c

@@ -0,0 +1,55 @@
+#include "toy_reffunction.h"
+
+#include <string.h>
+
+//memory allocation
+extern void* Toy_private_defaultMemoryAllocator(void* pointer, size_t oldSize, size_t newSize);
+static Toy_RefFunctionAllocatorFn allocate = Toy_private_defaultMemoryAllocator;
+
+void Toy_setRefFunctionAllocatorFn(Toy_RefFunctionAllocatorFn allocator) {
+	allocate = allocator;
+}
+
+//API
+Toy_RefFunction* Toy_createRefFunction(const void* data, size_t length) {
+	//allocate the memory area (including metadata space)
+	Toy_RefFunction* refFunction = allocate(NULL, 0, sizeof(size_t) + sizeof(int) + sizeof(char) * length);
+
+	if (refFunction == NULL) {
+		return NULL;
+	}
+
+	//set the data
+	refFunction->refCount = 1;
+	refFunction->length = length;
+	memcpy(refFunction->data, data, refFunction->length);
+
+	return refFunction;
+}
+
+void Toy_deleteRefFunction(Toy_RefFunction* refFunction) {
+	//decrement, then check
+	refFunction->refCount--;
+	if (refFunction->refCount <= 0) {
+		allocate(refFunction, sizeof(size_t) + sizeof(int) + sizeof(char) * (refFunction->length + 1), 0);
+	}
+}
+
+int Toy_countRefFunction(Toy_RefFunction* refFunction) {
+	return refFunction->refCount;
+}
+
+size_t Toy_lengthRefFunction(Toy_RefFunction* refFunction) {
+	return refFunction->length;
+}
+
+Toy_RefFunction* Toy_copyRefFunction(Toy_RefFunction* refFunction) {
+	//Cheaty McCheater Face
+	refFunction->refCount++;
+	return refFunction;
+}
+
+Toy_RefFunction* Toy_deepCopyRefFunction(Toy_RefFunction* refFunction) {
+	//create a new function, with a new refCount
+	return Toy_createRefFunction(refFunction->data, refFunction->length);
+}

source/toy_reffunction.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#include "toy_common.h"
+
+//memory allocation hook
+typedef void* (*Toy_RefFunctionAllocatorFn)(void* pointer, size_t oldSize, size_t newSize);
+TOY_API void Toy_setRefFunctionAllocatorFn(Toy_RefFunctionAllocatorFn);
+
+//the RefFunction structure
+typedef struct Toy_RefFunction {
+	size_t length;
+	int refCount;
+	unsigned char data[];
+} Toy_RefFunction;
+
+//API
+TOY_API Toy_RefFunction* Toy_createRefFunction(const void* data, size_t length);
+TOY_API void Toy_deleteRefFunction(Toy_RefFunction* refFunction);
+TOY_API int Toy_countRefFunction(Toy_RefFunction* refFunction);
+TOY_API size_t Toy_lengthRefFunction(Toy_RefFunction* refFunction);
+TOY_API Toy_RefFunction* Toy_copyRefFunction(Toy_RefFunction* refFunction);
+TOY_API Toy_RefFunction* Toy_deepCopyRefFunction(Toy_RefFunction* refFunction);
+

source/toy_refstring.c

@@ -1,7 +1,5 @@
 #include "toy_refstring.h"
 
-#include <string.h>
-
 //memory allocation
 extern void* Toy_private_defaultMemoryAllocator(void* pointer, size_t oldSize, size_t newSize);
 static Toy_RefStringAllocatorFn allocate = Toy_private_defaultMemoryAllocator;

source/toy_refstring.h

@@ -1,13 +1,12 @@
 #pragma once
 
-#include <stdbool.h>
-#include <stddef.h>
-
 #include "toy_common.h"
 
+#include <string.h>
+
 //memory allocation hook
 typedef void* (*Toy_RefStringAllocatorFn)(void* pointer, size_t oldSize, size_t newSize);
-void Toy_setRefStringAllocatorFn(Toy_RefStringAllocatorFn);
+TOY_API void Toy_setRefStringAllocatorFn(Toy_RefStringAllocatorFn);
 
 //the RefString structure
 typedef struct Toy_RefString {
@@ -27,3 +26,6 @@ TOY_API Toy_RefString* Toy_deepCopyRefString(Toy_RefString* refString);
 TOY_API const char* Toy_toCString(Toy_RefString* refString);
 TOY_API bool Toy_equalsRefString(Toy_RefString* lhs, Toy_RefString* rhs);
 TOY_API bool Toy_equalsRefStringCString(Toy_RefString* lhs, char* cstring);
+
+//TODO: merge refstring memory
+

source/toy_scope.c

@@ -4,21 +4,19 @@
 
 //run up the ancestor chain, freeing anything with 0 references left
 static void freeAncestorChain(Toy_Scope* scope) {
-	scope->references--;
+	while (scope != NULL) {
+		Toy_Scope* next = scope->ancestor;
 
-	//free scope chain
-	if (scope->ancestor != NULL) {
-		freeAncestorChain(scope->ancestor);
+		scope->references--;
+
+		if (scope->references <= 0) {
+			Toy_freeLiteralDictionary(&scope->variables);
+			Toy_freeLiteralDictionary(&scope->types);
+			TOY_FREE(Toy_Scope, scope);
+		}
+
+		scope = next;
 	}
-
-	if (scope->references > 0) {
-		return;
-	}
-
-	Toy_freeLiteralDictionary(&scope->variables);
-	Toy_freeLiteralDictionary(&scope->types);
-
-	TOY_FREE(Toy_Scope, scope);
 }
 
 //return false if invalid type
@@ -126,7 +124,7 @@ static bool checkType(Toy_Literal typeLiteral, Toy_Literal original, Toy_Literal
 			}
 
 			//find the internal child of original that matches this child of value
-			Toy_private_entry* ptr = NULL;
+			Toy_private_dictionary_entry* ptr = NULL;
 
 			for (int j = 0; j < TOY_AS_DICTIONARY(original)->capacity; j++) {
 				if (Toy_literalsAreEqual(TOY_AS_DICTIONARY(original)->entries[j].key, TOY_AS_DICTIONARY(value)->entries[i].key)) {
@@ -159,6 +157,10 @@ static bool checkType(Toy_Literal typeLiteral, Toy_Literal original, Toy_Literal
 		return false;
 	}
 
+	if (TOY_AS_TYPE(typeLiteral).typeOf == TOY_LITERAL_OPAQUE && !TOY_IS_OPAQUE(value)) {
+		return false;
+	}
+
 	return true;
 }
 
@@ -185,7 +187,7 @@ Toy_Scope* Toy_popScope(Toy_Scope* scope) {
 
 	Toy_Scope* ret = scope->ancestor;
 
-	//BUGFIX: when freeing a scope, free the function's scopes manually
+	//BUGFIX: when freeing a scope, free the functions' scopes manually - I *think* this is related to the closure hack-in
 	for (int i = 0; i < scope->variables.capacity; i++) {
 		//handle keys, just in case
 		if (TOY_IS_FUNCTION(scope->variables.entries[i].key)) {
@@ -205,6 +207,10 @@ Toy_Scope* Toy_popScope(Toy_Scope* scope) {
 }
 
 Toy_Scope* Toy_copyScope(Toy_Scope* original) {
+	if (original == NULL) {
+		return NULL;
+	}
+
 	Toy_Scope* scope = TOY_ALLOCATE(Toy_Scope, 1);
 	scope->ancestor = original->ancestor;
 	Toy_initLiteralDictionary(&scope->variables);
@@ -251,74 +257,70 @@ bool Toy_declareScopeVariable(Toy_Scope* scope, Toy_Literal key, Toy_Literal typ
 }
 
 bool Toy_isDelcaredScopeVariable(Toy_Scope* scope, Toy_Literal key) {
-	if (scope == NULL) {
-		return false;
+	while (scope != NULL) {
+		if (Toy_existsLiteralDictionary(&scope->variables, key)) {
+			return true;
+		}
+
+		scope = scope->ancestor;
 	}
 
-	//if it's not in this scope, keep searching up the chain
-	if (!Toy_existsLiteralDictionary(&scope->variables, key)) {
-		return Toy_isDelcaredScopeVariable(scope->ancestor, key);
-	}
-
-	return true;
+	return false;
 }
 
 //return false if undefined, or can't be assigned
 bool Toy_setScopeVariable(Toy_Scope* scope, Toy_Literal key, Toy_Literal value, bool constCheck) {
-	//dead end
-	if (scope == NULL) {
-		return false;
-	}
+	while (scope != NULL) {
+		//if it's not in this scope, keep searching up the chain
+		if (!Toy_existsLiteralDictionary(&scope->variables, key)) {
+			scope = scope->ancestor;
+			continue;
+		}
 
-	//if it's not in this scope, keep searching up the chain
-	if (!Toy_existsLiteralDictionary(&scope->variables, key)) {
-		return Toy_setScopeVariable(scope->ancestor, key, value, constCheck);
-	}
+		//type checking
+		Toy_Literal typeLiteral = Toy_getLiteralDictionary(&scope->types, key);
+		Toy_Literal original = Toy_getLiteralDictionary(&scope->variables, key);
 
-	//type checking
-	Toy_Literal typeLiteral = Toy_getLiteralDictionary(&scope->types, key);
-	Toy_Literal original = Toy_getLiteralDictionary(&scope->variables, key);
+		if (!checkType(typeLiteral, original, value, constCheck)) {
+			Toy_freeLiteral(typeLiteral);
+			Toy_freeLiteral(original);
+			return false;
+		}
+
+		//actually assign
+		Toy_setLiteralDictionary(&scope->variables, key, value); //key & value are copied here
 
-	if (!checkType(typeLiteral, original, value, constCheck)) {
 		Toy_freeLiteral(typeLiteral);
 		Toy_freeLiteral(original);
-		return false;
+
+		return true;
 	}
 
-	//actually assign
-	Toy_setLiteralDictionary(&scope->variables, key, value);
-
-	Toy_freeLiteral(typeLiteral);
-	Toy_freeLiteral(original);
-
-	return true;
+	return false;
 }
 
 bool Toy_getScopeVariable(Toy_Scope* scope, Toy_Literal key, Toy_Literal* valueHandle) {
-	//dead end
-	if (scope == NULL) {
-		return false;
+	//optimized to reduce call stack
+	while (scope != NULL) {
+		if (Toy_existsLiteralDictionary(&scope->variables, key)) {
+			*valueHandle = Toy_getLiteralDictionary(&scope->variables, key);
+			return true;
+		}
+
+		scope = scope->ancestor;
 	}
 
-	//if it's not in this scope, keep searching up the chain
-	if (!Toy_existsLiteralDictionary(&scope->variables, key)) {
-		return Toy_getScopeVariable(scope->ancestor, key, valueHandle);
-	}
-
-	*valueHandle = Toy_getLiteralDictionary(&scope->variables, key);
-	return true;
+	return false;
 }
 
 Toy_Literal Toy_getScopeType(Toy_Scope* scope, Toy_Literal key) {
-	//dead end
-	if (scope == NULL) {
-		return TOY_TO_NULL_LITERAL;
+	while (scope != NULL) {
+		if (Toy_existsLiteralDictionary(&scope->types, key)) {
+			return Toy_getLiteralDictionary(&scope->types, key);
+		}
+
+		scope = scope->ancestor;
 	}
 
-	//if it's not in this scope, keep searching up the chain
-	if (!Toy_existsLiteralDictionary(&scope->types, key)) {
-		return Toy_getScopeType(scope->ancestor, key);
-	}
-
-	return Toy_getLiteralDictionary(&scope->types, key);
+	return TOY_TO_NULL_LITERAL;
 }

source/toy_scope.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include "toy_literal.h"
 #include "toy_literal_array.h"
 #include "toy_literal_dictionary.h"
 

test/scripts/arithmetic.toy

@@ -38,5 +38,12 @@ s += "bar";
 
 assert s == "foobar", "string addition failed (wasn't sticky enough)";
 
+//check order of operations
+assert 30 / 3 * 2 == 20, "Order of operations failed (raw numbers)";
+var x = 30;
+var y = 3;
+var z = 2;
+assert x / y * z == 20, "Order of operations failed (variables)";
+
 
 print "All good";

test/scripts/casting-parentheses-bugfix.toy

@@ -0,0 +1,7 @@
+var s = "42";
+var t = "69";
+
+assert int (s + t) - 1 == 4268, "casting parentheses failed";
+
+
+print "All good";

test/scripts/comparisons.toy

@@ -23,5 +23,8 @@ assert !false, "!false";
 var c = false;
 assert !c, "!c";
 
+//test multiple comparisons
+assert 1 == 2 == false, "Left-accociative equality failed";
+
 
 print "All good";

test/scripts/dot-and-matrix.toy

@@ -2,11 +2,11 @@
 var a = [1, 2, 3];
 var b = [4, 5, 6];
 
-assert _length(a) == _length(b), "a and b lengths are wrong";
+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);
+for (var i = 0; i < length(a); i++) {
+	acc += get(a, i) * get(b, i);
 }
 
 assert acc == 32, "dot product failed";
@@ -15,38 +15,38 @@ 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 l1 = length(first); //rows
+	var l2 = length(get(first, 0)); //cols
 
-	var l3 = _length(second); //rows
-	var l4 = _length(_get(second, 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);
+		push(row, 0);
 	}
 
 	var result = [];
 	for (var i = 0; i < l1; i++) {
-		_push(result, row);
+		push(result, row);
 	}
 
 	//assign the values
-	for (var i = 0; i < _length(first); i++) {
+	for (var i = 0; i < length(first); i++) {
 		//select each element of "first"
-		var firstElement = _get(first, i);
+		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++) {
+		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);
+				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);
+				var tmpRow = get(result, i);
+				set(tmpRow, j2, val);
+				set(result, i, tmpRow);
 
 				//result[ i ][ j2 ] += first[i][i2] * second[i2][j2]
 			}

test/scripts/dot-assignments-bugfix.toy

@@ -9,7 +9,7 @@ It appears to be a compiler issue, see issue #38 for more info.
 
 */
 
-fn _getValue(self) {
+fn getValue(self) {
 	return self;
 }
 

test/scripts/dot-chaining.toy

@@ -1,10 +1,10 @@
 //test function chaining with the dot operator
 
-fn _identity(self) {
+fn identity(self) {
 	return self;
 }
 
-fn _check(self) {
+fn check(self) {
 	assert self == 42, "dot chaining failed";
 	return self;
 }
@@ -20,7 +20,7 @@ val
 
 
 //test the value is actually altered
-fn _increment(self) {
+fn increment(self) {
 	return self + 1;
 }
 

test/scripts/dot-modulo-bugfix.toy

@@ -0,0 +1,23 @@
+var days = [
+    "sunday",
+    "monday",
+    "tuesday",
+    "wednesday",
+    "thursday",
+    "friday",
+    "saturday"
+];
+
+var rng = 10; //for chosen at random
+
+
+var index = rng % days.length();
+
+assert index == 3, "dot modulo bugfix failed";
+
+rng %= days.length();
+
+assert rng == 3, "dot modulo assign bugfix failed";
+
+
+print "All good";

test/scripts/dottify-bugfix.toy

@@ -1,5 +1,5 @@
 
-fn _add(self, inc) {
+fn add(self, inc) {
 	return self + inc;
 }
 

test/scripts/function-within-function-bugfix.toy

@@ -0,0 +1,30 @@
+{
+	fn a() {
+		fn b() {
+			return 42;
+		}
+
+		return b;
+	}
+
+	assert a()() == 42, "function within function failed";
+}
+
+{
+	fn a() {
+		fn b() {
+			fn c() {
+				return 42;
+			}
+
+			return c;
+		}
+
+		return b;
+	}
+
+	assert a()()() == 42, "function within function within function failed";
+}
+
+
+print "All good";

test/scripts/functions.toy

@@ -63,7 +63,7 @@ extra("one", "two", "three", "four", "five", "six", "seven");
 
 
 //test underscore functions
-fn _example(self, a, b, c) {
+fn example(self, a, b, c) {
 	assert a == "a", "underscore failed (a)";
 	assert b == "b", "underscore failed (b)";
 	assert c == "c", "underscore failed (c)";

test/scripts/index-assignment-intermediate-bugfix.toy

@@ -0,0 +1,10 @@
+
+var result; //result must exist to ensure assingment, rather than declaration is invoked by the comparison below
+
+var lhs = [0];
+var rhs = [0];
+
+result = lhs[0] < rhs[0]; //make sure this doesn't invoke TOY_OP_INDEX_ASSIGN_INTERMEDIATE
+
+
+print "All good";

test/scripts/lib/random.toy

@@ -0,0 +1,17 @@
+import standard;
+import random;
+
+var generator: opaque = createRandomGenerator(clock().hash()); //create a new generator object, from a non-determinant source
+
+var a: int = generator.generateRandomNumber();
+var b: int = generator.generateRandomNumber();
+var c: int = generator.generateRandomNumber();
+
+generator.freeRandomGenerator();
+
+assert a != b, "random a != random b failed";
+assert a != c, "random a != random c failed";
+assert b != c, "random b != random c failed";
+
+
+print "All good";

test/scripts/lib/standard.toy

@@ -7,6 +7,100 @@ import standard;
 }
 
 
+//test hash
+{
+	assert typeof "Hello world".hash() == int, "typeof \"Hello world\".hash() failed";
+	assert "Hello world".hash() == 994097935, "\"Hello world\".hash() failed"; //NOTE: specific value based on algorithm
+}
+
+
+//test abs
+{
+	assert abs(-5) == 5, "abs(-integer) failed";
+	assert abs(-5.5) == 5.5, "abs(-float) failed";
+	assert abs(5) == 5, "abs(+integer) failed";
+	assert abs(5.5) == 5.5, "abs(+float) failed";
+
+	var x = -5;
+
+	assert x.abs() == 5, "var.abs() failed";
+}
+
+
+//test ceil
+{
+	assert ceil(4) == 4, "ceil(int) failed";
+	assert ceil(4.0) == 4, "ceil(float) failed";
+	assert ceil(4.1) == 5, "ceil() failed";
+
+	var x = 4.1;
+
+	assert x.ceil() == 5, "var.ceil() failed";
+}
+
+
+//test floor
+{
+	assert floor(4) == 4, "floor(int) failed";
+	assert floor(4.0) == 4, "floor(float) failed";
+	assert floor(4.1) == 4, "floor() failed";
+
+	var x = 4.1;
+
+	assert x.floor() == 4, "var.floor() failed";
+}
+
+
+//test max
+{
+	assert max(1, 2, 3) == 3, "max() failed";
+
+	var a = 1;
+	var b = 2;
+	var c = 3;
+
+	assert max(a, b, c) == 3, "var.max() failed";
+
+	assert max(1, 2, 3, 4, 5, 6, 7, 8, 9, 0) == 9, "max() with many args failed";
+
+	assert typeof max(1, 2, 3) == int, "typeof max() == int failed";
+	assert typeof max(1, 2, 3.4) == float, "typeof max() == float failed";
+}
+
+
+//test min
+{
+	assert min(1, 2, 3) == 1, "min() failed";
+
+	var a = 1;
+	var b = 2;
+	var c = 3;
+
+	assert min(a, b, c) == 1, "var.min() failed";
+
+	assert min(1, 2, 3, 4, 5, 6, 7, 8, 9, 0) == 0, "min() with many args failed";
+
+	assert typeof min(1, 2, 3) == int, "typeof min() == int failed";
+	assert typeof min(1, 2, 3.4) == float, "typeof min() == float failed";
+}
+
+
+//test round
+{
+	assert round(4) == 4, "round(int) failed";
+	assert round(4.0) == 4, "round(float) failed";
+	assert round(4.1) == 4, "round(less than half) failed";
+	assert round(4.9) == 5, "round(greater than half) failed";
+	assert round(4.5) == 5, "round(exactly half) failed";
+
+	var x = 4.1;
+
+	assert x.round() == 4, "var.round() failed";
+
+	assert typeof round(1.0) == int, "typeof round() == int failed";
+}
+
+
 //test concat
 {
 	//test array concat

test/scripts/mustfail/index-access-bugfix.toy

@@ -0,0 +1 @@
+"a"[--];

test/scripts/native-functions.toy

@@ -3,41 +3,41 @@
 	//test arrays without types
 	var array = [];
 
-	assert _length(array) == 0, "_length failed with array";
+	assert length(array) == 0, "length failed with array";
 
-	_push(array, 1);
-	_push(array, 2);
-	_push(array, 3);
-	_push(array, 4);
-	_push(array, "foo");
+	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";
+	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";
+	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);
+	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";
+	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 length
+	assert length(array) == 4 && length(dict) == 2, "length failed with array or dictionaries";
 
 
 	//test clear
-	_clear(array);
-	_clear(dict);
+	clear(array);
+	clear(dict);
 
-	assert _length(array) == 0 && _length(dict) == 0, "_clear failed with array or dictionaries";
+	assert length(array) == 0 && length(dict) == 0, "clear failed with array or dictionaries";
 }
 
 
@@ -45,46 +45,46 @@
 	//test arrays with types
 	var array: [int] = [];
 
-	assert _length(array) == 0, "_length failed with array (+ types)";
+	assert length(array) == 0, "length failed with array (+ types)";
 
-	_push(array, 1);
-	_push(array, 2);
-	_push(array, 3);
-	_push(array, 4);
-	_push(array, 10);
+	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)";
+	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)";
+	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");
+	set(dict, "key", "value");
 
-	assert dict == ["key":"value"], "_set failed with dictionaries (+ types)";
-	assert _get(dict, "key") == "value", "_get failed with dictionaries (+ types)";
+	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)";
+	assert length(array) == 4 && length(dict) == 1, "length failed with array or dictionaries (+ types)";
 
 
 	//test clear with types
-	_clear(array);
-	_clear(dict);
+	clear(array);
+	clear(dict);
 
-	assert _length(array) == 0 && _length(dict) == 0, "_clear failed with array or dictionaries (+ types)";
+	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";
+	assert length(str) == 11, "length failed with string";
 }
 
 

test/scripts/polyfill-insert.toy

@@ -1,5 +1,5 @@
-//polyfill the _insert function
-fn _insert(self, k, v) {
+//polyfill the insert function
+fn insert(self, k, v) {
 	var tmp1 = v;
 	var tmp2;
 	for (var i = k; i < self.length(); i++) {

test/scripts/polyfill-remove.toy

@@ -1,5 +1,5 @@
 //polyfill the remove function
-fn _remove(self, k) {
+fn remove(self, k) {
 	var result = [];
 
 	for (var i = 0; i <= k - 1; i++) {

test/scripts/runner_sample_code.toy

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

test/scripts/short-circuiting-support.toy

@@ -0,0 +1,9 @@
+//explicitly support && and || short circuits
+
+assert 1 && 2 == 2, "&& short-circuit failed";
+
+assert 1 || 2 == 1, "|| short-circuit failed";
+
+
+print "All good";
+

test/scripts/types.toy

@@ -22,4 +22,9 @@ var dict: complex = [
 	"third array": [7, 8, 9]
 ];
 
+
+//check the any type is recognized as a type within an array
+var a: [type] = [int, bool, any];
+
+
 print "All good";

test/test_call_from_host.c

@@ -20,14 +20,14 @@ static void noPrintFn(const char* output) {
 }
 
 void error(char* msg) {
-	printf("%s", msg);
+	printf("%s\n", msg);
 	exit(-1);
 }
 
 int main() {
 	{
 		size_t size = 0;
-		const char* source = Toy_readFile("scripts/call-from-host.toy", &size);
+		const char* source = (const char*)Toy_readFile("scripts/call-from-host.toy", &size);
 		const unsigned char* tb = Toy_compileString(source, &size);
 		free((void*)source);
 
@@ -41,7 +41,7 @@ int main() {
 
 		//test answer
 		{
-			interpreter.printOutput("Testing answer\n");
+			interpreter.printOutput("Testing answer");
 
 			Toy_LiteralArray arguments;
 			Toy_initLiteralArray(&arguments);
@@ -52,15 +52,15 @@ int main() {
 
 			//check the results
 			if (arguments.count != 0) {
-				error("Arguments has the wrong number of members\n");
+				error("Arguments has the wrong number of members");
 			}
 
 			if (returns.count != 1) {
-				error("Returns has the wrong number of members\n");
+				error("Returns has the wrong number of members");
 			}
 
 			if (!TOY_IS_INTEGER(returns.literals[0]) || TOY_AS_INTEGER(returns.literals[0]) != 42) {
-				error("Returned value is incorrect\n");
+				error("Returned value is incorrect");
 			}
 
 			Toy_freeLiteralArray(&arguments);
@@ -69,7 +69,7 @@ int main() {
 
 		//test identity
 		{
-			interpreter.printOutput("Testing identity\n");
+			interpreter.printOutput("Testing identity");
 
 			Toy_LiteralArray arguments;
 			Toy_initLiteralArray(&arguments);
@@ -85,17 +85,17 @@ int main() {
 
 			//check the results
 			if (arguments.count != 0) {
-				error("Arguments has the wrong number of members\n");
+				error("Arguments has the wrong number of members");
 			}
 
 			if (returns.count != 1) {
-				error("Returns has the wrong number of members\n");
+				error("Returns has the wrong number of members");
 			}
 
 			float epsilon = 0.1; //because floats are evil
 
 			if (!TOY_IS_FLOAT(returns.literals[0]) || fabs(TOY_AS_FLOAT(returns.literals[0]) - pi) > epsilon) {
-				error("Returned value is incorrect\n");
+				error("Returned value is incorrect");
 			}
 
 			Toy_freeLiteralArray(&arguments);
@@ -104,7 +104,7 @@ int main() {
 
 		//test makeCounter (closures)
 		{
-			interpreter.printOutput("Testing makeCounter (closures)\n");
+			interpreter.printOutput("Testing makeCounter (closures)");
 
 			Toy_LiteralArray arguments;
 			Toy_initLiteralArray(&arguments);
@@ -115,11 +115,11 @@ int main() {
 
 			//check the results
 			if (arguments.count != 0) {
-				error("Arguments has the wrong number of members\n");
+				error("Arguments has the wrong number of members");
 			}
 
 			if (returns.count != 1) {
-				error("Returns has the wrong number of members\n");
+				error("Returns has the wrong number of members");
 			}
 
 			//grab the resulting literal
@@ -139,15 +139,15 @@ int main() {
 
 				//check the results
 				if (arguments.count != 0) {
-					error("Arguments (1) has the wrong number of members\n");
+					error("Arguments (1) has the wrong number of members");
 				}
 
 				if (returns.count != 1) {
-					error("Returns (1) has the wrong number of members\n");
+					error("Returns (1) has the wrong number of members");
 				}
 
 				if (!TOY_IS_INTEGER(returns.literals[0]) || TOY_AS_INTEGER(returns.literals[0]) != 1) {
-					error("Returned value (1) is incorrect\n");
+					error("Returned value (1) is incorrect");
 				}
 
 				Toy_freeLiteralArray(&arguments);
@@ -164,15 +164,15 @@ int main() {
 
 				//check the results
 				if (arguments.count != 0) {
-					error("Arguments (2) has the wrong number of members\n");
+					error("Arguments (2) has the wrong number of members");
 				}
 
 				if (returns.count != 1) {
-					error("Returns (2) has the wrong number of members\n");
+					error("Returns (2) has the wrong number of members");
 				}
 
 				if (!TOY_IS_INTEGER(returns.literals[0]) || TOY_AS_INTEGER(returns.literals[0]) != 2) {
-					error("Returned value (2) is incorrect\n");
+					error("Returned value (2) is incorrect");
 				}
 
 				Toy_freeLiteralArray(&arguments);
@@ -189,15 +189,15 @@ int main() {
 
 				//check the results
 				if (arguments.count != 0) {
-					error("Arguments (3) has the wrong number of members\n");
+					error("Arguments (3) has the wrong number of members");
 				}
 
 				if (returns.count != 1) {
-					error("Returns (3) has the wrong number of members\n");
+					error("Returns (3) has the wrong number of members");
 				}
 
 				if (!TOY_IS_INTEGER(returns.literals[0]) || TOY_AS_INTEGER(returns.literals[0]) != 3) {
-					error("Returned value (3) is incorrect\n");
+					error("Returned value (3) is incorrect");
 				}
 
 				Toy_freeLiteralArray(&arguments);
@@ -209,7 +209,7 @@ int main() {
 
 		//test assertion failure
 		{
-			interpreter.printOutput("Testing assertion failure\n");
+			interpreter.printOutput("Testing assertion failure");
 
 			Toy_setInterpreterAssert(&interpreter, noPrintFn);
 
@@ -222,15 +222,15 @@ int main() {
 
 			//check the results
 			if (arguments.count != 0) {
-				error("Arguments has the wrong number of members\n");
+				error("Arguments has the wrong number of members");
 			}
 
 			if (returns.count != 1 || !TOY_IS_NULL(returns.literals[0])) {
-				error("Returns has the wrong number of members\n");
+				error("Returns has the wrong number of members");
 			}
 
 			if (!ret) {
-				error("Assertion gives the wrong return value\n");
+				error("Assertion gives the wrong return value");
 			}
 
 			Toy_freeLiteralArray(&arguments);

test/test_compiler.c

@@ -39,7 +39,7 @@ int main() {
 		Toy_writeCompiler(&compiler, node);
 
 		//collate
-		int size = 0;
+		size_t size = 0;
 		unsigned char* bytecode = Toy_collateCompiler(&compiler, &size);
 
 		//cleanup
@@ -52,7 +52,7 @@ int main() {
 	{
 		//source
 		size_t sourceLength = 0;
-		const char* source = Toy_readFile("scripts/compiler_sample_code.toy", &sourceLength);
+		const char* source = (const char*)Toy_readFile("scripts/compiler_sample_code.toy", &sourceLength);
 
 		//test basic compilation & collation
 		Toy_Lexer lexer;
@@ -78,7 +78,7 @@ int main() {
 		}
 
 		//collate
-		int size = 0;
+		size_t size = 0;
 		unsigned char* bytecode = Toy_collateCompiler(&compiler, &size);
 
 		//cleanup

test/test_interpreter.c

@@ -53,7 +53,7 @@ void runSourceCustom(const char* source) {
 
 void runSourceFileCustom(const char* fname) {
 	size_t size = 0; //not used
-	const char* source = Toy_readFile(fname, &size);
+	const char* source = (const char*)Toy_readFile(fname, &size);
 	runSourceCustom(source);
 	free((void*)source);
 }
@@ -87,7 +87,7 @@ int main() {
 		Toy_writeCompiler(&compiler, node);
 
 		//collate
-		int size = 0;
+		size_t size = 0;
 		const unsigned char* bytecode = Toy_collateCompiler(&compiler, &size);
 
 		//NOTE: suppress print output for testing
@@ -108,16 +108,20 @@ int main() {
 		//run each file in tests/scripts/
 		const char* filenames[] = {
 			"arithmetic.toy",
+			"casting-parentheses-bugfix.toy",
 			"casting.toy",
 			"coercions.toy",
 			"comparisons.toy",
 			"dot-and-matrix.toy",
 			"dot-assignments-bugfix.toy",
 			"dot-chaining.toy",
+			"dot-modulo-bugfix.toy",
 			"dottify-bugfix.toy",
+			"function-within-function-bugfix.toy",
 			"functions.toy",
 			"index-arrays.toy",
 			"index-assignment-both-bugfix.toy",
+			"index-assignment-intermediate-bugfix.toy",
 			"index-assignment-left-bugfix.toy",
 			"index-dictionaries.toy",
 			"index-strings.toy",
@@ -132,6 +136,7 @@ int main() {
 			"panic-within-functions.toy",
 			"polyfill-insert.toy",
 			"polyfill-remove.toy",
+			"short-circuiting-support.toy",
 			"ternary-expressions.toy",
 			"types.toy",
 			NULL

test/test_lexer.c

@@ -15,10 +15,10 @@ int main() {
 		Toy_initLexer(&lexer, source);
 
 		//get each token
-		Toy_Token print = Toy_scanLexer(&lexer);
-		Toy_Token null = Toy_scanLexer(&lexer);
-		Toy_Token semi = Toy_scanLexer(&lexer);
-		Toy_Token eof = Toy_scanLexer(&lexer);
+		Toy_Token print = Toy_private_scanLexer(&lexer);
+		Toy_Token null = Toy_private_scanLexer(&lexer);
+		Toy_Token semi = Toy_private_scanLexer(&lexer);
+		Toy_Token eof = Toy_private_scanLexer(&lexer);
 
 		//test each token is correct
 		if (strncmp(print.lexeme, "print", print.length)) {

test/test_libraries.c

@@ -6,6 +6,7 @@
 #include "toy_console_colors.h"
 
 #include "toy_memory.h"
+#include "toy_drive_system.h"
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -14,6 +15,7 @@
 #include "../repl/repl_tools.h"
 
 #include "../repl/lib_about.h"
+#include "../repl/lib_random.h"
 #include "../repl/lib_runner.h"
 #include "../repl/lib_standard.h"
 
@@ -45,30 +47,15 @@ void runBinaryWithLibrary(const unsigned char* tb, size_t size, const char* libr
 	Toy_setInterpreterError(&interpreter, errorWrapper);
 
 	//inject the standard libraries into this interpreter
+	if (hook != Toy_hookStandard) {
+		Toy_injectNativeHook(&interpreter, "standard", Toy_hookStandard);
+	}
 	Toy_injectNativeHook(&interpreter, library, hook);
 
 	Toy_runInterpreter(&interpreter, tb, size);
 	Toy_freeInterpreter(&interpreter);
 }
 
-void runBinaryQuietly(const unsigned char* tb, size_t size) {
-	Toy_Interpreter interpreter;
-	Toy_initInterpreter(&interpreter);
-
-	//NOTE: supress print output for testing
-	Toy_setInterpreterPrint(&interpreter, noPrintFn);
-	Toy_setInterpreterAssert(&interpreter, assertWrapper);
-	Toy_setInterpreterError(&interpreter, errorWrapper);
-
-	//inject the libs
-	Toy_injectNativeHook(&interpreter, "about", Toy_hookAbout);
-	Toy_injectNativeHook(&interpreter, "standard", Toy_hookStandard);
-	Toy_injectNativeHook(&interpreter, "runner", Toy_hookRunner);
-
-	Toy_runInterpreter(&interpreter, tb, size);
-	Toy_freeInterpreter(&interpreter);
-}
-
 typedef struct Payload {
 	char* fname;
 	char* libname;
@@ -77,15 +64,9 @@ typedef struct Payload {
 
 int main() {
 	//setup the runner filesystem (hacky)
-	Toy_initDriveDictionary();
+	Toy_initDriveSystem();
 
-	Toy_Literal driveLiteral = TOY_TO_STRING_LITERAL(Toy_createRefString("scripts"));
-	Toy_Literal pathLiteral = TOY_TO_STRING_LITERAL(Toy_createRefString("scripts"));
-
-	Toy_setLiteralDictionary(Toy_getDriveDictionary(), driveLiteral, pathLiteral);
-
-	Toy_freeLiteral(driveLiteral);
-	Toy_freeLiteral(pathLiteral);
+	Toy_setDrivePath("scripts", "scripts");
 
 	{
 		//run each file in test/scripts
@@ -94,6 +75,7 @@ int main() {
 			{"about.toy", "about", Toy_hookAbout},
 			{"standard.toy", "standard", Toy_hookStandard},
 			{"runner.toy", "runner", Toy_hookRunner},
+			{"random.toy", "random", Toy_hookRandom},
 			{NULL, NULL, NULL}
 		};
 
@@ -105,7 +87,7 @@ int main() {
 
 			//compile the source
 			size_t size = 0;
-			const char* source = Toy_readFile(fname, &size);
+			const char* source = (const char*)Toy_readFile(fname, &size);
 			if (!source) {
 				printf(TOY_CC_ERROR "Failed to load file: %s\n" TOY_CC_RESET, fname);
 				failedAsserts++;
@@ -125,43 +107,8 @@ int main() {
 		}
 	}
 
-	{
-		//run whatever, testing stuff together to check for memory leaks
-		char* whatever[] = {
-			"random-stuff.toy",
-			NULL
-		};
-
-		for (int i = 0; whatever[i]; i++) {
-			printf("Running %s\n", whatever[i]);
-
-			char fname[128];
-			snprintf(fname, 128, "scripts/lib/%s", whatever[i]);
-
-			//compile the source
-			size_t size = 0;
-			const char* source = Toy_readFile(fname, &size);
-			if (!source) {
-				printf(TOY_CC_ERROR "Failed to load file: %s\n" TOY_CC_RESET, fname);
-				failedAsserts++;
-				continue;
-			}
-
-			const unsigned char* tb = Toy_compileString(source, &size);
-			free((void*)source);
-
-			if (!tb) {
-				printf(TOY_CC_ERROR "Failed to compile file: %s\n" TOY_CC_RESET, fname);
-				failedAsserts++;
-				continue;
-			}
-
-			runBinaryQuietly(tb, size);
-		}
-	}
-
 	//lib cleanup
-	Toy_freeDriveDictionary();
+	Toy_freeDriveSystem();
 
 	if (!failedAsserts) {
 		printf(TOY_CC_NOTICE "All good\n" TOY_CC_RESET);

test/test_mustfail.c

@@ -50,7 +50,7 @@ const unsigned char* compileStringCustom(const char* source, size_t* size) {
 	}
 
 	//get the bytecode dump
-	const unsigned char* tb = Toy_collateCompiler(&compiler, (int*)(size));
+	const unsigned char* tb = Toy_collateCompiler(&compiler, size);
 
 	//cleanup
 	Toy_freeCompiler(&compiler);
@@ -84,7 +84,7 @@ void runSourceCustom(const char* source) {
 
 void runSourceFileCustom(const char* fname) {
 	size_t size = 0; //not used
-	const char* source = Toy_readFile(fname, &size);
+	const char* source = (const char*)Toy_readFile(fname, &size);
 	runSourceCustom(source);
 	free((void*)source);
 }
@@ -101,6 +101,7 @@ int main() {
 			"declare-types-array.toy",
 			"declare-types-dictionary-key.toy",
 			"declare-types-dictionary-value.toy",
+			"index-access-bugfix.toy",
 			"index-arrays-non-integer.toy",
 			"string-concat.toy",
 			"unary-inverted-nothing.toy",

test/test_opaque_data_type.c

@@ -68,7 +68,7 @@ static int consume(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments) {
 int main() {
 	{
 		size_t size = 0;
-		const char* source = Toy_readFile("scripts/opaque-data-type.toy", &size);
+		const char* source = (const char*)Toy_readFile("scripts/opaque-data-type.toy", &size);
 		const unsigned char* tb = Toy_compileString(source, &size);
 		free((void*)source);
 

test/test_parser.c

@@ -58,7 +58,7 @@ int main() {
 	{
 		//get the source file
 		size_t size = 0;
-		const char* source = Toy_readFile("scripts/parser_sample_code.toy", &size);
+		const char* source = (const char*)Toy_readFile("scripts/parser_sample_code.toy", &size);
 
 		//test parsing a chunk of junk (valgrind will find leaks)
 		Toy_Lexer lexer;

tools/memusage/main.c

@@ -10,25 +10,32 @@
 int currentMemoryUsed = 0;
 int maxMemoryUsed = 0;
 int memoryAllocCalls = 0;
+int memoryAllocFree = 0;
+int memoryAllocRealloc = 0;
 
 static void* trackerAllocator(void* pointer, size_t oldSize, size_t newSize) {
+	//the number of raw calls
+	memoryAllocCalls++;
+
+	//causes issues, so just skip out with a NO-OP
 	if (newSize == 0 && oldSize == 0) {
-		//causes issues, so just skip out with a NO-OP
 		return NULL;
 	}
 
-	memoryAllocCalls++;
-
 	//track the changes
 	currentMemoryUsed = currentMemoryUsed - oldSize + newSize;
 	maxMemoryUsed = currentMemoryUsed > maxMemoryUsed ? currentMemoryUsed : maxMemoryUsed;
 
 	if (newSize == 0) {
+		//the number of frees
+		memoryAllocFree++;
 		free(pointer);
 
 		return NULL;
 	}
 
+	//the number of reallocations
+	memoryAllocRealloc++;
 	void* mem = realloc(pointer, newSize);
 
 	if (mem == NULL) {
@@ -39,11 +46,14 @@ static void* trackerAllocator(void* pointer, size_t oldSize, size_t newSize) {
 	return mem;
 }
 
-int main(int argc, char* argv[]) {
+int main(int argc, const char* argv[]) {
 	if (argc <= 1) {
 		return -1;
 	}
 
+	//not used, except for print
+	Toy_initCommandLine(argc, argv);
+
 	//setup for runner
 	Toy_initDriveDictionary();
 
@@ -66,7 +76,7 @@ int main(int argc, char* argv[]) {
 	Toy_freeDriveDictionary();
 
 	//report output
-	printf("Memory report: %d max bytes, %d calls\n", maxMemoryUsed, memoryAllocCalls);
+	printf("Heap Memory Report:\n\t%d max bytes\n\t%d calls to the allocator\n\t%d calls to realloc()\n\t%d calls to free()\n\t%d discrepancies\n", maxMemoryUsed, memoryAllocCalls, memoryAllocRealloc, memoryAllocFree, memoryAllocCalls - memoryAllocRealloc - memoryAllocFree);
 
 	return 0;
 }