Renemed all variables to fit into a namespace

Basically, all Toy varaibles, functions, etc. are prepended with "Toy_",
and macros are prepended with "TOY_". This is to reduce namespace
pollution, which was an issue pointed out to be - blame @GyroVorbis.

I've also bumped the minor version number - theoretically I should bump
the major number, but I'm not quite ready for 1.0 yet.

source/toy_ast_node.c

@@ -1,173 +1,173 @@
-#include "ast_node.h"
+#include "toy_ast_node.h"
 
-#include "memory.h"
+#include "toy_memory.h"
 
 #include <stdio.h>
 #include <stdlib.h>
 
-void freeASTNodeCustom(ASTNode* node, bool freeSelf) {
+static void freeASTNodeCustom(Toy_ASTNode* node, bool freeSelf) {
 	//don't free a NULL node
 	if (node == NULL) {
 		return;
 	}
 
 	switch(node->type) {
-		case AST_NODE_ERROR:
+		case TOY_AST_NODE_ERROR:
 			//NO-OP
 		break;
 
-		case AST_NODE_LITERAL:
-			freeLiteral(node->atomic.literal);
+		case TOY_AST_NODE_LITERAL:
+			Toy_freeLiteral(node->atomic.literal);
 		break;
 
-		case AST_NODE_UNARY:
-			freeASTNode(node->unary.child);
+		case TOY_AST_NODE_UNARY:
+			Toy_freeASTNode(node->unary.child);
 		break;
 
-		case AST_NODE_BINARY:
-			freeASTNode(node->binary.left);
-			freeASTNode(node->binary.right);
+		case TOY_AST_NODE_BINARY:
+			Toy_freeASTNode(node->binary.left);
+			Toy_freeASTNode(node->binary.right);
 		break;
 
-		case AST_NODE_TERNARY:
-			freeASTNode(node->ternary.condition);
-			freeASTNode(node->ternary.thenPath);
-			freeASTNode(node->ternary.elsePath);
+		case TOY_AST_NODE_TERNARY:
+			Toy_freeASTNode(node->ternary.condition);
+			Toy_freeASTNode(node->ternary.thenPath);
+			Toy_freeASTNode(node->ternary.elsePath);
 		break;
 
-		case AST_NODE_GROUPING:
-			freeASTNode(node->grouping.child);
+		case TOY_AST_NODE_GROUPING:
+			Toy_freeASTNode(node->grouping.child);
 		break;
 
-		case AST_NODE_BLOCK:
+		case TOY_AST_NODE_BLOCK:
 			for (int i = 0; i < node->block.count; i++) {
 				freeASTNodeCustom(node->block.nodes + i, false);
 			}
-			FREE_ARRAY(ASTNode, node->block.nodes, node->block.capacity);
+			TOY_FREE_ARRAY(Toy_ASTNode, node->block.nodes, node->block.capacity);
 		break;
 
-		case AST_NODE_COMPOUND:
+		case TOY_AST_NODE_COMPOUND:
 			for (int i = 0; i < node->compound.count; i++) {
 				freeASTNodeCustom(node->compound.nodes + i, false);
 			}
-			FREE_ARRAY(ASTNode, node->compound.nodes, node->compound.capacity);
+			TOY_FREE_ARRAY(Toy_ASTNode, node->compound.nodes, node->compound.capacity);
 		break;
 
-		case AST_NODE_PAIR:
-			freeASTNode(node->pair.left);
-			freeASTNode(node->pair.right);
+		case TOY_AST_NODE_PAIR:
+			Toy_freeASTNode(node->pair.left);
+			Toy_freeASTNode(node->pair.right);
 		break;
 
-		case AST_NODE_INDEX:
-			freeASTNode(node->index.first);
-			freeASTNode(node->index.second);
-			freeASTNode(node->index.third);
+		case TOY_AST_NODE_INDEX:
+			Toy_freeASTNode(node->index.first);
+			Toy_freeASTNode(node->index.second);
+			Toy_freeASTNode(node->index.third);
 		break;
 
-		case AST_NODE_VAR_DECL:
-			freeLiteral(node->varDecl.identifier);
-			freeLiteral(node->varDecl.typeLiteral);
-			freeASTNode(node->varDecl.expression);
+		case TOY_AST_NODE_VAR_DECL:
+			Toy_freeLiteral(node->varDecl.identifier);
+			Toy_freeLiteral(node->varDecl.typeLiteral);
+			Toy_freeASTNode(node->varDecl.expression);
 		break;
 
-		case AST_NODE_FN_COLLECTION:
+		case TOY_AST_NODE_FN_COLLECTION:
 			for (int i = 0; i < node->fnCollection.count; i++) {
 				freeASTNodeCustom(node->fnCollection.nodes + i, false);
 			}
-			FREE_ARRAY(ASTNode, node->fnCollection.nodes, node->fnCollection.capacity);
+			TOY_FREE_ARRAY(Toy_ASTNode, node->fnCollection.nodes, node->fnCollection.capacity);
 		break;
 
-		case AST_NODE_FN_DECL:
-			freeLiteral(node->fnDecl.identifier);
-			freeASTNode(node->fnDecl.arguments);
-			freeASTNode(node->fnDecl.returns);
-			freeASTNode(node->fnDecl.block);
+		case TOY_AST_NODE_FN_DECL:
+			Toy_freeLiteral(node->fnDecl.identifier);
+			Toy_freeASTNode(node->fnDecl.arguments);
+			Toy_freeASTNode(node->fnDecl.returns);
+			Toy_freeASTNode(node->fnDecl.block);
 		break;
 
-		case AST_NODE_FN_CALL:
-			freeASTNode(node->fnCall.arguments);
+		case TOY_AST_NODE_FN_CALL:
+			Toy_freeASTNode(node->fnCall.arguments);
 		break;
 
-		case AST_NODE_FN_RETURN:
-			freeASTNode(node->returns.returns);
+		case TOY_AST_NODE_FN_RETURN:
+			Toy_freeASTNode(node->returns.returns);
 		break;
 
-		case AST_NODE_IF:
-			freeASTNode(node->pathIf.condition);
-			freeASTNode(node->pathIf.thenPath);
-			freeASTNode(node->pathIf.elsePath);
+		case TOY_AST_NODE_IF:
+			Toy_freeASTNode(node->pathIf.condition);
+			Toy_freeASTNode(node->pathIf.thenPath);
+			Toy_freeASTNode(node->pathIf.elsePath);
 		break;
 
-		case AST_NODE_WHILE:
-			freeASTNode(node->pathWhile.condition);
-			freeASTNode(node->pathWhile.thenPath);
+		case TOY_AST_NODE_WHILE:
+			Toy_freeASTNode(node->pathWhile.condition);
+			Toy_freeASTNode(node->pathWhile.thenPath);
 		break;
 
-		case AST_NODE_FOR:
-			freeASTNode(node->pathFor.preClause);
-			freeASTNode(node->pathFor.postClause);
-			freeASTNode(node->pathFor.condition);
-			freeASTNode(node->pathFor.thenPath);
+		case TOY_AST_NODE_FOR:
+			Toy_freeASTNode(node->pathFor.preClause);
+			Toy_freeASTNode(node->pathFor.postClause);
+			Toy_freeASTNode(node->pathFor.condition);
+			Toy_freeASTNode(node->pathFor.thenPath);
 		break;
 
-		case AST_NODE_BREAK:
+		case TOY_AST_NODE_BREAK:
 			//NO-OP
 		break;
 
-		case AST_NODE_CONTINUE:
+		case TOY_AST_NODE_CONTINUE:
 			//NO-OP
 		break;
 
-		case AST_NODE_PREFIX_INCREMENT:
-			freeLiteral(node->prefixIncrement.identifier);
+		case TOY_AST_NODE_PREFIX_INCREMENT:
+			Toy_freeLiteral(node->prefixIncrement.identifier);
 		break;
-		case AST_NODE_PREFIX_DECREMENT:
-			freeLiteral(node->prefixDecrement.identifier);
+		case TOY_AST_NODE_PREFIX_DECREMENT:
+			Toy_freeLiteral(node->prefixDecrement.identifier);
 		break;
-		case AST_NODE_POSTFIX_INCREMENT:
-			freeLiteral(node->postfixIncrement.identifier);
+		case TOY_AST_NODE_POSTFIX_INCREMENT:
+			Toy_freeLiteral(node->postfixIncrement.identifier);
 		break;
-		case AST_NODE_POSTFIX_DECREMENT:
-			freeLiteral(node->postfixDecrement.identifier);
+		case TOY_AST_NODE_POSTFIX_DECREMENT:
+			Toy_freeLiteral(node->postfixDecrement.identifier);
 		break;
 
-		case AST_NODE_IMPORT:
-			freeLiteral(node->import.identifier);
-			freeLiteral(node->import.alias);
+		case TOY_AST_NODE_IMPORT:
+			Toy_freeLiteral(node->import.identifier);
+			Toy_freeLiteral(node->import.alias);
 		break;
 	}
 
 	if (freeSelf) {
-		FREE(ASTNode, node);
+		TOY_FREE(Toy_ASTNode, node);
 	}
 }
 
-void freeASTNode(ASTNode* node) {
+void Toy_freeASTNode(Toy_ASTNode* node) {
 	freeASTNodeCustom(node, true);
 }
 
 //various emitters
-void emitASTNodeLiteral(ASTNode** nodeHandle, Literal literal) {
+void Toy_emitASTNodeLiteral(Toy_ASTNode** nodeHandle, Toy_Literal literal) {
 	//allocate a new node
-	*nodeHandle = ALLOCATE(ASTNode, 1);
+	*nodeHandle = TOY_ALLOCATE(Toy_ASTNode, 1);
 
-	(*nodeHandle)->type = AST_NODE_LITERAL;
-	(*nodeHandle)->atomic.literal = copyLiteral(literal);
+	(*nodeHandle)->type = TOY_AST_NODE_LITERAL;
+	(*nodeHandle)->atomic.literal = Toy_copyLiteral(literal);
 }
 
-void emitASTNodeUnary(ASTNode** nodeHandle, Opcode opcode, ASTNode* child) {
+void Toy_emitASTNodeUnary(Toy_ASTNode** nodeHandle, Toy_Opcode opcode, Toy_ASTNode* child) {
 	//allocate a new node
-	*nodeHandle = ALLOCATE(ASTNode, 1);
+	*nodeHandle = TOY_ALLOCATE(Toy_ASTNode, 1);
 
-	(*nodeHandle)->type = AST_NODE_UNARY;
+	(*nodeHandle)->type = TOY_AST_NODE_UNARY;
 	(*nodeHandle)->unary.opcode = opcode;
 	(*nodeHandle)->unary.child = child;
 }
 
-void emitASTNodeBinary(ASTNode** nodeHandle, ASTNode* rhs, Opcode opcode) {
-	ASTNode* tmp = ALLOCATE(ASTNode, 1);
+void Toy_emitASTNodeBinary(Toy_ASTNode** nodeHandle, Toy_ASTNode* rhs, Toy_Opcode opcode) {
+	Toy_ASTNode* tmp = TOY_ALLOCATE(Toy_ASTNode, 1);
 
-	tmp->type = AST_NODE_BINARY;
+	tmp->type = TOY_AST_NODE_BINARY;
 	tmp->binary.opcode = opcode;
 	tmp->binary.left = *nodeHandle;
 	tmp->binary.right = rhs;
@@ -175,10 +175,10 @@ void emitASTNodeBinary(ASTNode** nodeHandle, ASTNode* rhs, Opcode opcode) {
 	*nodeHandle = tmp;
 }
 
-void emitASTNodeTernary(ASTNode** nodeHandle, ASTNode* condition, ASTNode* thenPath, ASTNode* elsePath) {
-	ASTNode* tmp = ALLOCATE(ASTNode, 1);
+void Toy_emitASTNodeTernary(Toy_ASTNode** nodeHandle, Toy_ASTNode* condition, Toy_ASTNode* thenPath, Toy_ASTNode* elsePath) {
+	Toy_ASTNode* tmp = TOY_ALLOCATE(Toy_ASTNode, 1);
 
-	tmp->type = AST_NODE_TERNARY;
+	tmp->type = TOY_AST_NODE_TERNARY;
 	tmp->ternary.condition = condition;
 	tmp->ternary.thenPath = thenPath;
 	tmp->ternary.elsePath = elsePath;
@@ -186,19 +186,19 @@ void emitASTNodeTernary(ASTNode** nodeHandle, ASTNode* condition, ASTNode* thenP
 	*nodeHandle = tmp;
 }
 
-void emitASTNodeGrouping(ASTNode** nodeHandle) {
-	ASTNode* tmp = ALLOCATE(ASTNode, 1);
+void Toy_emitASTNodeGrouping(Toy_ASTNode** nodeHandle) {
+	Toy_ASTNode* tmp = TOY_ALLOCATE(Toy_ASTNode, 1);
 
-	tmp->type = AST_NODE_GROUPING;
+	tmp->type = TOY_AST_NODE_GROUPING;
 	tmp->grouping.child = *nodeHandle;
 
 	*nodeHandle = tmp;
 }
 
-void emitASTNodeBlock(ASTNode** nodeHandle) {
-	ASTNode* tmp = ALLOCATE(ASTNode, 1);
+void Toy_emitASTNodeBlock(Toy_ASTNode** nodeHandle) {
+	Toy_ASTNode* tmp = TOY_ALLOCATE(Toy_ASTNode, 1);
 
-	tmp->type = AST_NODE_BLOCK;
+	tmp->type = TOY_AST_NODE_BLOCK;
 	tmp->block.nodes = NULL; //NOTE: appended by the parser
 	tmp->block.capacity = 0;
 	tmp->block.count = 0;
@@ -206,10 +206,10 @@ void emitASTNodeBlock(ASTNode** nodeHandle) {
 	*nodeHandle = tmp;
 }
 
-void emitASTNodeCompound(ASTNode** nodeHandle, LiteralType literalType) {
-	ASTNode* tmp = ALLOCATE(ASTNode, 1);
+void Toy_emitASTNodeCompound(Toy_ASTNode** nodeHandle, Toy_LiteralType literalType) {
+	Toy_ASTNode* tmp = TOY_ALLOCATE(Toy_ASTNode, 1);
 
-	tmp->type = AST_NODE_COMPOUND;
+	tmp->type = TOY_AST_NODE_COMPOUND;
 	tmp->compound.literalType = literalType;
 	tmp->compound.nodes = NULL;
 	tmp->compound.capacity = 0;
@@ -218,17 +218,17 @@ void emitASTNodeCompound(ASTNode** nodeHandle, LiteralType literalType) {
 	*nodeHandle = tmp;
 }
 
-void setASTNodePair(ASTNode* node, ASTNode* left, ASTNode* right) {
+void Toy_setASTNodePair(Toy_ASTNode* node, Toy_ASTNode* left, Toy_ASTNode* right) {
 	//set - assume the node has already been allocated
-	node->type = AST_NODE_PAIR;
+	node->type = TOY_AST_NODE_PAIR;
 	node->pair.left = left;
 	node->pair.right = right;
 }
 
-void emitASTNodeIndex(ASTNode** nodeHandle, ASTNode* first, ASTNode* second, ASTNode* third) {
-	ASTNode* tmp = ALLOCATE(ASTNode, 1);
+void Toy_emitASTNodeIndex(Toy_ASTNode** nodeHandle, Toy_ASTNode* first, Toy_ASTNode* second, Toy_ASTNode* third) {
+	Toy_ASTNode* tmp = TOY_ALLOCATE(Toy_ASTNode, 1);
 
-	tmp->type = AST_NODE_INDEX;
+	tmp->type = TOY_AST_NODE_INDEX;
 	tmp->index.first = first;
 	tmp->index.second = second;
 	tmp->index.third = third;
@@ -236,10 +236,10 @@ void emitASTNodeIndex(ASTNode** nodeHandle, ASTNode* first, ASTNode* second, AST
 	*nodeHandle = tmp;
 }
 
-void emitASTNodeVarDecl(ASTNode** nodeHandle, Literal identifier, Literal typeLiteral, ASTNode* expression) {
-	ASTNode* tmp = ALLOCATE(ASTNode, 1);
+void Toy_emitASTNodeVarDecl(Toy_ASTNode** nodeHandle, Toy_Literal identifier, Toy_Literal typeLiteral, Toy_ASTNode* expression) {
+	Toy_ASTNode* tmp = TOY_ALLOCATE(Toy_ASTNode, 1);
 
-	tmp->type = AST_NODE_VAR_DECL;
+	tmp->type = TOY_AST_NODE_VAR_DECL;
 	tmp->varDecl.identifier = identifier;
 	tmp->varDecl.typeLiteral = typeLiteral;
 	tmp->varDecl.expression = expression;
@@ -247,10 +247,10 @@ void emitASTNodeVarDecl(ASTNode** nodeHandle, Literal identifier, Literal typeLi
 	*nodeHandle = tmp;
 }
 
-void emitASTNodeFnCollection(ASTNode** nodeHandle) { //a collection of nodes, intended for use with functions
-	ASTNode* tmp = ALLOCATE(ASTNode, 1);
+void Toy_emitASTNodeFnCollection(Toy_ASTNode** nodeHandle) { //a collection of nodes, intended for use with functions
+	Toy_ASTNode* tmp = TOY_ALLOCATE(Toy_ASTNode, 1);
 
-	tmp->type = AST_NODE_FN_COLLECTION;
+	tmp->type = TOY_AST_NODE_FN_COLLECTION;
 	tmp->fnCollection.nodes = NULL;
 	tmp->fnCollection.capacity = 0;
 	tmp->fnCollection.count = 0;
@@ -258,10 +258,10 @@ void emitASTNodeFnCollection(ASTNode** nodeHandle) { //a collection of nodes, in
 	*nodeHandle = tmp;
 }
 
-void emitASTNodeFnDecl(ASTNode** nodeHandle, Literal identifier, ASTNode* arguments, ASTNode* returns, ASTNode* block) {
-	ASTNode* tmp = ALLOCATE(ASTNode, 1);
+void Toy_emitASTNodeFnDecl(Toy_ASTNode** nodeHandle, Toy_Literal identifier, Toy_ASTNode* arguments, Toy_ASTNode* returns, Toy_ASTNode* block) {
+	Toy_ASTNode* tmp = TOY_ALLOCATE(Toy_ASTNode, 1);
 
-	tmp->type = AST_NODE_FN_DECL;
+	tmp->type = TOY_AST_NODE_FN_DECL;
 	tmp->fnDecl.identifier = identifier;
 	tmp->fnDecl.arguments = arguments;
 	tmp->fnDecl.returns = returns;
@@ -270,29 +270,29 @@ void emitASTNodeFnDecl(ASTNode** nodeHandle, Literal identifier, ASTNode* argume
 	*nodeHandle = tmp;
 }
 
-void emitASTNodeFnCall(ASTNode** nodeHandle, ASTNode* arguments) {
-	ASTNode* tmp = ALLOCATE(ASTNode, 1);
+void Toy_emitASTNodeFnCall(Toy_ASTNode** nodeHandle, Toy_ASTNode* arguments) {
+	Toy_ASTNode* tmp = TOY_ALLOCATE(Toy_ASTNode, 1);
 
-	tmp->type = AST_NODE_FN_CALL;
+	tmp->type = TOY_AST_NODE_FN_CALL;
 	tmp->fnCall.arguments = arguments;
 	tmp->fnCall.argumentCount = arguments->fnCollection.count;
 
 	*nodeHandle = tmp;
 }
 
-void emitASTNodeFnReturn(ASTNode** nodeHandle, ASTNode* returns) {
-	ASTNode* tmp = ALLOCATE(ASTNode, 1);
+void Toy_emitASTNodeFnReturn(Toy_ASTNode** nodeHandle, Toy_ASTNode* returns) {
+	Toy_ASTNode* tmp = TOY_ALLOCATE(Toy_ASTNode, 1);
 
-	tmp->type = AST_NODE_FN_RETURN;
+	tmp->type = TOY_AST_NODE_FN_RETURN;
 	tmp->returns.returns = returns;
 
 	*nodeHandle = tmp;
 }
 
-void emitASTNodeIf(ASTNode** nodeHandle, ASTNode* condition, ASTNode* thenPath, ASTNode* elsePath) {
-	ASTNode* tmp = ALLOCATE(ASTNode, 1);
+void Toy_emitASTNodeIf(Toy_ASTNode** nodeHandle, Toy_ASTNode* condition, Toy_ASTNode* thenPath, Toy_ASTNode* elsePath) {
+	Toy_ASTNode* tmp = TOY_ALLOCATE(Toy_ASTNode, 1);
 
-	tmp->type = AST_NODE_IF;
+	tmp->type = TOY_AST_NODE_IF;
 	tmp->pathIf.condition = condition;
 	tmp->pathIf.thenPath = thenPath;
 	tmp->pathIf.elsePath = elsePath;
@@ -300,20 +300,20 @@ void emitASTNodeIf(ASTNode** nodeHandle, ASTNode* condition, ASTNode* thenPath,
 	*nodeHandle = tmp;
 }
 
-void emitASTNodeWhile(ASTNode** nodeHandle, ASTNode* condition, ASTNode* thenPath) {
-	ASTNode* tmp = ALLOCATE(ASTNode, 1);
+void Toy_emitASTNodeWhile(Toy_ASTNode** nodeHandle, Toy_ASTNode* condition, Toy_ASTNode* thenPath) {
+	Toy_ASTNode* tmp = TOY_ALLOCATE(Toy_ASTNode, 1);
 
-	tmp->type = AST_NODE_WHILE;
+	tmp->type = TOY_AST_NODE_WHILE;
 	tmp->pathWhile.condition = condition;
 	tmp->pathWhile.thenPath = thenPath;
 
 	*nodeHandle = tmp;
 }
 
-void emitASTNodeFor(ASTNode** nodeHandle, ASTNode* preClause, ASTNode* condition, ASTNode* postClause, ASTNode* thenPath) {
-	ASTNode* tmp = ALLOCATE(ASTNode, 1);
+void Toy_emitASTNodeFor(Toy_ASTNode** nodeHandle, Toy_ASTNode* preClause, Toy_ASTNode* condition, Toy_ASTNode* postClause, Toy_ASTNode* thenPath) {
+	Toy_ASTNode* tmp = TOY_ALLOCATE(Toy_ASTNode, 1);
 
-	tmp->type = AST_NODE_FOR;
+	tmp->type = TOY_AST_NODE_FOR;
 	tmp->pathFor.preClause = preClause;
 	tmp->pathFor.condition = condition;
 	tmp->pathFor.postClause = postClause;
@@ -322,64 +322,64 @@ void emitASTNodeFor(ASTNode** nodeHandle, ASTNode* preClause, ASTNode* condition
 	*nodeHandle = tmp;
 }
 
-void emitASTNodeBreak(ASTNode** nodeHandle) {
-	ASTNode* tmp = ALLOCATE(ASTNode, 1);
+void Toy_emitASTNodeBreak(Toy_ASTNode** nodeHandle) {
+	Toy_ASTNode* tmp = TOY_ALLOCATE(Toy_ASTNode, 1);
 
-	tmp->type = AST_NODE_BREAK;
+	tmp->type = TOY_AST_NODE_BREAK;
 
 	*nodeHandle = tmp;
 }
 
-void emitASTNodeContinue(ASTNode** nodeHandle) {
-	ASTNode* tmp = ALLOCATE(ASTNode, 1);
+void Toy_emitASTNodeContinue(Toy_ASTNode** nodeHandle) {
+	Toy_ASTNode* tmp = TOY_ALLOCATE(Toy_ASTNode, 1);
 
-	tmp->type = AST_NODE_CONTINUE;
+	tmp->type = TOY_AST_NODE_CONTINUE;
 
 	*nodeHandle = tmp;
 }
 
-void emitASTNodePrefixIncrement(ASTNode** nodeHandle, Literal identifier) {
-	ASTNode* tmp = ALLOCATE(ASTNode, 1);
+void Toy_emitASTNodePrefixIncrement(Toy_ASTNode** nodeHandle, Toy_Literal identifier) {
+	Toy_ASTNode* tmp = TOY_ALLOCATE(Toy_ASTNode, 1);
 
-	tmp->type = AST_NODE_PREFIX_INCREMENT;
-	tmp->prefixIncrement.identifier = copyLiteral(identifier);
+	tmp->type = TOY_AST_NODE_PREFIX_INCREMENT;
+	tmp->prefixIncrement.identifier = Toy_copyLiteral(identifier);
 
 	*nodeHandle = tmp;
 }
 
-void emitASTNodePrefixDecrement(ASTNode** nodeHandle, Literal identifier) {
-	ASTNode* tmp = ALLOCATE(ASTNode, 1);
+void Toy_emitASTNodePrefixDecrement(Toy_ASTNode** nodeHandle, Toy_Literal identifier) {
+	Toy_ASTNode* tmp = TOY_ALLOCATE(Toy_ASTNode, 1);
 
-	tmp->type = AST_NODE_PREFIX_DECREMENT;
-	tmp->prefixDecrement.identifier = copyLiteral(identifier);
+	tmp->type = TOY_AST_NODE_PREFIX_DECREMENT;
+	tmp->prefixDecrement.identifier = Toy_copyLiteral(identifier);
 
 	*nodeHandle = tmp;
 }
 
-void emitASTNodePostfixIncrement(ASTNode** nodeHandle, Literal identifier) {
-	ASTNode* tmp = ALLOCATE(ASTNode, 1);
+void Toy_emitASTNodePostfixIncrement(Toy_ASTNode** nodeHandle, Toy_Literal identifier) {
+	Toy_ASTNode* tmp = TOY_ALLOCATE(Toy_ASTNode, 1);
 
-	tmp->type = AST_NODE_POSTFIX_INCREMENT;
-	tmp->postfixIncrement.identifier = copyLiteral(identifier);
+	tmp->type = TOY_AST_NODE_POSTFIX_INCREMENT;
+	tmp->postfixIncrement.identifier = Toy_copyLiteral(identifier);
 
 	*nodeHandle = tmp;
 }
 
-void emitASTNodePostfixDecrement(ASTNode** nodeHandle, Literal identifier) {
-	ASTNode* tmp = ALLOCATE(ASTNode, 1);
+void Toy_emitASTNodePostfixDecrement(Toy_ASTNode** nodeHandle, Toy_Literal identifier) {
+	Toy_ASTNode* tmp = TOY_ALLOCATE(Toy_ASTNode, 1);
 
-	tmp->type = AST_NODE_POSTFIX_DECREMENT;
-	tmp->postfixDecrement.identifier = copyLiteral(identifier);
+	tmp->type = TOY_AST_NODE_POSTFIX_DECREMENT;
+	tmp->postfixDecrement.identifier = Toy_copyLiteral(identifier);
 
 	*nodeHandle = tmp;
 }
 
-void emitASTNodeImport(ASTNode** nodeHandle, Literal identifier, Literal alias) {
-	ASTNode* tmp = ALLOCATE(ASTNode, 1);
+void Toy_emitASTNodeImport(Toy_ASTNode** nodeHandle, Toy_Literal identifier, Toy_Literal alias) {
+	Toy_ASTNode* tmp = TOY_ALLOCATE(Toy_ASTNode, 1);
 
-	tmp->type = AST_NODE_IMPORT;
-	tmp->import.identifier = copyLiteral(identifier);
-	tmp->import.alias = copyLiteral(alias);
+	tmp->type = TOY_AST_NODE_IMPORT;
+	tmp->import.identifier = Toy_copyLiteral(identifier);
+	tmp->import.alias = Toy_copyLiteral(alias);
 
 	*nodeHandle = tmp;
 }

source/toy_ast_node.h

@@ -1,269 +1,269 @@
 #pragma once
 
 #include "toy_common.h"
-#include "literal.h"
-#include "opcodes.h"
-#include "token_types.h"
+#include "toy_literal.h"
+#include "toy_opcodes.h"
+#include "toy_token_types.h"
 
 //nodes are the intermediaries between parsers and compilers
-typedef union _node ASTNode;
+typedef union Toy_private_node Toy_ASTNode;
 
-typedef enum ASTNodeType {
-	AST_NODE_ERROR,
-	AST_NODE_LITERAL, //a simple value
-	AST_NODE_UNARY, //one child + opcode
-	AST_NODE_BINARY, //two children, left and right + opcode
-	AST_NODE_TERNARY, //three children, condition, then path & else path
-	AST_NODE_GROUPING, //one child
-	AST_NODE_BLOCK, //contains a sub-node array
-	AST_NODE_COMPOUND, //contains a sub-node array
-	AST_NODE_PAIR, //contains a left and right
-	AST_NODE_INDEX, //index a variable
-	AST_NODE_VAR_DECL, //contains identifier literal, typenode, expression definition
-	AST_NODE_FN_DECL, //containd identifier literal, arguments node, returns node, block node
-	AST_NODE_FN_COLLECTION, //parts of a function
-	AST_NODE_FN_CALL, //call a function
-	AST_NODE_FN_RETURN, //for control flow
-	AST_NODE_IF, //for control flow
-	AST_NODE_WHILE, //for control flow
-	AST_NODE_FOR, //for control flow
-	AST_NODE_BREAK, //for control flow
-	AST_NODE_CONTINUE, //for control flow
-	AST_NODE_PREFIX_INCREMENT, //increment a variable
-	AST_NODE_POSTFIX_INCREMENT, //increment a variable
-	AST_NODE_PREFIX_DECREMENT, //decrement a variable
-	AST_NODE_POSTFIX_DECREMENT, //decrement a variable
-	AST_NODE_IMPORT, //import a library
-} ASTNodeType;
+typedef enum Toy_ASTNodeType {
+	TOY_AST_NODE_ERROR,
+	TOY_AST_NODE_LITERAL, //a simple value
+	TOY_AST_NODE_UNARY, //one child + opcode
+	TOY_AST_NODE_BINARY, //two children, left and right + opcode
+	TOY_AST_NODE_TERNARY, //three children, condition, then path & else path
+	TOY_AST_NODE_GROUPING, //one child
+	TOY_AST_NODE_BLOCK, //contains a sub-node array
+	TOY_AST_NODE_COMPOUND, //contains a sub-node array
+	TOY_AST_NODE_PAIR, //contains a left and right
+	TOY_AST_NODE_INDEX, //index a variable
+	TOY_AST_NODE_VAR_DECL, //contains identifier literal, typenode, expression definition
+	TOY_AST_NODE_FN_DECL, //containd identifier literal, arguments node, returns node, block node
+	TOY_AST_NODE_FN_COLLECTION, //parts of a function
+	TOY_AST_NODE_FN_CALL, //call a function
+	TOY_AST_NODE_FN_RETURN, //for control flow
+	TOY_AST_NODE_IF, //for control flow
+	TOY_AST_NODE_WHILE, //for control flow
+	TOY_AST_NODE_FOR, //for control flow
+	TOY_AST_NODE_BREAK, //for control flow
+	TOY_AST_NODE_CONTINUE, //for control flow
+	TOY_AST_NODE_PREFIX_INCREMENT, //increment a variable
+	TOY_AST_NODE_POSTFIX_INCREMENT, //increment a variable
+	TOY_AST_NODE_PREFIX_DECREMENT, //decrement a variable
+	TOY_AST_NODE_POSTFIX_DECREMENT, //decrement a variable
+	TOY_AST_NODE_IMPORT, //import a library
+} Toy_ASTNodeType;
 
 //literals
-void emitASTNodeLiteral(ASTNode** nodeHandle, Literal literal);
+void Toy_emitASTNodeLiteral(Toy_ASTNode** nodeHandle, Toy_Literal literal);
 
-typedef struct NodeLiteral {
-	ASTNodeType type;
-	Literal literal;
-} NodeLiteral;
+typedef struct Toy_NodeLiteral {
+	Toy_ASTNodeType type;
+	Toy_Literal literal;
+} Toy_NodeLiteral;
 
 //unary operator
-void emitASTNodeUnary(ASTNode** nodeHandle, Opcode opcode, ASTNode* child);
+void Toy_emitASTNodeUnary(Toy_ASTNode** nodeHandle, Toy_Opcode opcode, Toy_ASTNode* child);
 
-typedef struct NodeUnary {
-	ASTNodeType type;
-	Opcode opcode;
-	ASTNode* child;
-} NodeUnary;
+typedef struct Toy_NodeUnary {
+	Toy_ASTNodeType type;
+	Toy_Opcode opcode;
+	Toy_ASTNode* child;
+} Toy_NodeUnary;
 
 //binary operator
-void emitASTNodeBinary(ASTNode** nodeHandle, ASTNode* rhs, Opcode opcode); //handled node becomes lhs
+void Toy_emitASTNodeBinary(Toy_ASTNode** nodeHandle, Toy_ASTNode* rhs, Toy_Opcode opcode); //handled node becomes lhs
 
-typedef struct NodeBinary {
-	ASTNodeType type;
-	Opcode opcode;
-	ASTNode* left;
-	ASTNode* right;
-} NodeBinary;
+typedef struct Toy_NodeBinary {
+	Toy_ASTNodeType type;
+	Toy_Opcode opcode;
+	Toy_ASTNode* left;
+	Toy_ASTNode* right;
+} Toy_NodeBinary;
 
 //ternary operator
-void emitASTNodeTernary(ASTNode** nodeHandle, ASTNode* condition, ASTNode* thenPath, ASTNode* elsePath);
+void Toy_emitASTNodeTernary(Toy_ASTNode** nodeHandle, Toy_ASTNode* condition, Toy_ASTNode* thenPath, Toy_ASTNode* elsePath);
 
-typedef struct NodeTernary {
-	ASTNodeType type;
-	ASTNode* condition;
-	ASTNode* thenPath;
-	ASTNode* elsePath;
-} NodeTernary;
+typedef struct Toy_NodeTernary {
+	Toy_ASTNodeType type;
+	Toy_ASTNode* condition;
+	Toy_ASTNode* thenPath;
+	Toy_ASTNode* elsePath;
+} Toy_NodeTernary;
 
 //grouping of other AST nodes
-void emitASTNodeGrouping(ASTNode** nodeHandle);
+void Toy_emitASTNodeGrouping(Toy_ASTNode** nodeHandle);
 
-typedef struct NodeGrouping {
-	ASTNodeType type;
-	ASTNode* child;
-} NodeGrouping;
+typedef struct Toy_NodeGrouping {
+	Toy_ASTNodeType type;
+	Toy_ASTNode* child;
+} Toy_NodeGrouping;
 
 //block of statement nodes
-void emitASTNodeBlock(ASTNode** nodeHandle);
+void Toy_emitASTNodeBlock(Toy_ASTNode** nodeHandle);
 
-typedef struct NodeBlock {
-	ASTNodeType type;
-	ASTNode* nodes;
+typedef struct Toy_NodeBlock {
+	Toy_ASTNodeType type;
+	Toy_ASTNode* nodes;
 	int capacity;
 	int count;
-} NodeBlock;
+} Toy_NodeBlock;
 
 //compound literals (array, dictionary)
-void emitASTNodeCompound(ASTNode** nodeHandle, LiteralType literalType);
+void Toy_emitASTNodeCompound(Toy_ASTNode** nodeHandle, Toy_LiteralType literalType);
 
-typedef struct NodeCompound {
-	ASTNodeType type;
-	LiteralType literalType;
-	ASTNode* nodes;
+typedef struct Toy_NodeCompound {
+	Toy_ASTNodeType type;
+	Toy_LiteralType literalType;
+	Toy_ASTNode* nodes;
 	int capacity;
 	int count;
-} NodeCompound;
+} Toy_NodeCompound;
 
-void setASTNodePair(ASTNode* node, ASTNode* left, ASTNode* right); //NOTE: this is a set function, not an emit function
+void Toy_setASTNodePair(Toy_ASTNode* node, Toy_ASTNode* left, Toy_ASTNode* right); //NOTE: this is a set function, not an emit function
 
-typedef struct NodePair {
-	ASTNodeType type;
-	ASTNode* left;
-	ASTNode* right;
-} NodePair;
+typedef struct Toy_NodePair {
+	Toy_ASTNodeType type;
+	Toy_ASTNode* left;
+	Toy_ASTNode* right;
+} Toy_NodePair;
 
-void emitASTNodeIndex(ASTNode** nodeHandle, ASTNode* first, ASTNode* second, ASTNode* third);
+void Toy_emitASTNodeIndex(Toy_ASTNode** nodeHandle, Toy_ASTNode* first, Toy_ASTNode* second, Toy_ASTNode* third);
 
-typedef struct NodeIndex {
-	ASTNodeType type;
-	ASTNode* first;
-	ASTNode* second;
-	ASTNode* third;
-} NodeIndex;
+typedef struct Toy_NodeIndex {
+	Toy_ASTNodeType type;
+	Toy_ASTNode* first;
+	Toy_ASTNode* second;
+	Toy_ASTNode* third;
+} Toy_NodeIndex;
 
 //variable declaration
-void emitASTNodeVarDecl(ASTNode** nodeHandle, Literal identifier, Literal type, ASTNode* expression);
+void Toy_emitASTNodeVarDecl(Toy_ASTNode** nodeHandle, Toy_Literal identifier, Toy_Literal type, Toy_ASTNode* expression);
 
-typedef struct NodeVarDecl {
-	ASTNodeType type;
-	Literal identifier;
-	Literal typeLiteral;
-	ASTNode* expression;
-} NodeVarDecl;
+typedef struct Toy_NodeVarDecl {
+	Toy_ASTNodeType type;
+	Toy_Literal identifier;
+	Toy_Literal typeLiteral;
+	Toy_ASTNode* expression;
+} Toy_NodeVarDecl;
 
 //NOTE: fnCollection is used by fnDecl, fnCall and fnReturn
-void emitASTNodeFnCollection(ASTNode** nodeHandle);
+void Toy_emitASTNodeFnCollection(Toy_ASTNode** nodeHandle);
 
-typedef struct NodeFnCollection {
-	ASTNodeType type;
-	ASTNode* nodes;
+typedef struct Toy_NodeFnCollection {
+	Toy_ASTNodeType type;
+	Toy_ASTNode* nodes;
 	int capacity;
 	int count;
-} NodeFnCollection;
+} Toy_NodeFnCollection;
 
 //function declaration
-void emitASTNodeFnDecl(ASTNode** nodeHandle, Literal identifier, ASTNode* arguments, ASTNode* returns, ASTNode* block);
+void Toy_emitASTNodeFnDecl(Toy_ASTNode** nodeHandle, Toy_Literal identifier, Toy_ASTNode* arguments, Toy_ASTNode* returns, Toy_ASTNode* block);
 
-typedef struct NodeFnDecl {
-	ASTNodeType type;
-	Literal identifier;
-	ASTNode* arguments;
-	ASTNode* returns;
-	ASTNode* block;
-} NodeFnDecl;
+typedef struct Toy_NodeFnDecl {
+	Toy_ASTNodeType type;
+	Toy_Literal identifier;
+	Toy_ASTNode* arguments;
+	Toy_ASTNode* returns;
+	Toy_ASTNode* block;
+} Toy_NodeFnDecl;
 
 //function call
-void emitASTNodeFnCall(ASTNode** nodeHandle, ASTNode* arguments);
+void Toy_emitASTNodeFnCall(Toy_ASTNode** nodeHandle, Toy_ASTNode* arguments);
 
-typedef struct NodeFnCall {
-	ASTNodeType type;
-	ASTNode* arguments;
+typedef struct Toy_NodeFnCall {
+	Toy_ASTNodeType type;
+	Toy_ASTNode* arguments;
 	int argumentCount; //NOTE: leave this, so it can be hacked by dottify()
-} NodeFnCall;
+} Toy_NodeFnCall;
 
 //function return
-void emitASTNodeFnReturn(ASTNode** nodeHandle, ASTNode* returns);
+void Toy_emitASTNodeFnReturn(Toy_ASTNode** nodeHandle, Toy_ASTNode* returns);
 
-typedef struct NodeFnReturn {
-	ASTNodeType type;
-	ASTNode* returns;
-} NodeFnReturn;
+typedef struct Toy_NodeFnReturn {
+	Toy_ASTNodeType type;
+	Toy_ASTNode* returns;
+} Toy_NodeFnReturn;
 
 //control flow path - if-else, while, for, break, continue, return
-void emitASTNodeIf(ASTNode** nodeHandle, ASTNode* condition, ASTNode* thenPath, ASTNode* elsePath);
-void emitASTNodeWhile(ASTNode** nodeHandle, ASTNode* condition, ASTNode* thenPath);
-void emitASTNodeFor(ASTNode** nodeHandle, ASTNode* preClause, ASTNode* condition, ASTNode* postClause, ASTNode* thenPath);
-void emitASTNodeBreak(ASTNode** nodeHandle);
-void emitASTNodeContinue(ASTNode** nodeHandle);
+void Toy_emitASTNodeIf(Toy_ASTNode** nodeHandle, Toy_ASTNode* condition, Toy_ASTNode* thenPath, Toy_ASTNode* elsePath);
+void Toy_emitASTNodeWhile(Toy_ASTNode** nodeHandle, Toy_ASTNode* condition, Toy_ASTNode* thenPath);
+void Toy_emitASTNodeFor(Toy_ASTNode** nodeHandle, Toy_ASTNode* preClause, Toy_ASTNode* condition, Toy_ASTNode* postClause, Toy_ASTNode* thenPath);
+void Toy_emitASTNodeBreak(Toy_ASTNode** nodeHandle);
+void Toy_emitASTNodeContinue(Toy_ASTNode** nodeHandle);
 
-typedef struct NodeIf {
-	ASTNodeType type;
-	ASTNode* condition;
-	ASTNode* thenPath;
-	ASTNode* elsePath;
-} NodeIf;
+typedef struct Toy_NodeIf {
+	Toy_ASTNodeType type;
+	Toy_ASTNode* condition;
+	Toy_ASTNode* thenPath;
+	Toy_ASTNode* elsePath;
+} Toy_NodeIf;
 
-typedef struct NodeWhile {
-	ASTNodeType type;
-	ASTNode* condition;
-	ASTNode* thenPath;
-} NodeWhile;
+typedef struct Toy_NodeWhile {
+	Toy_ASTNodeType type;
+	Toy_ASTNode* condition;
+	Toy_ASTNode* thenPath;
+} Toy_NodeWhile;
 
-typedef struct NodeFor {
-	ASTNodeType type;
-	ASTNode* preClause;
-	ASTNode* condition;
-	ASTNode* postClause;
-	ASTNode* thenPath;
-} NodeFor;
+typedef struct Toy_NodeFor {
+	Toy_ASTNodeType type;
+	Toy_ASTNode* preClause;
+	Toy_ASTNode* condition;
+	Toy_ASTNode* postClause;
+	Toy_ASTNode* thenPath;
+} Toy_NodeFor;
 
-typedef struct NodeBreak {
-	ASTNodeType type;
-} NodeBreak;
+typedef struct Toy_NodeBreak {
+	Toy_ASTNodeType type;
+} Toy_NodeBreak;
 
-typedef struct NodeContinue {
-	ASTNodeType type;
-} NodeContinue;
+typedef struct Toy_NodeContinue {
+	Toy_ASTNodeType type;
+} Toy_NodeContinue;
 
 //pre-post increment/decrement
-void emitASTNodePrefixIncrement(ASTNode** nodeHandle, Literal identifier);
-void emitASTNodePrefixDecrement(ASTNode** nodeHandle, Literal identifier);
-void emitASTNodePostfixIncrement(ASTNode** nodeHandle, Literal identifier);
-void emitASTNodePostfixDecrement(ASTNode** nodeHandle, Literal identifier);
+void Toy_emitASTNodePrefixIncrement(Toy_ASTNode** nodeHandle, Toy_Literal identifier);
+void Toy_emitASTNodePrefixDecrement(Toy_ASTNode** nodeHandle, Toy_Literal identifier);
+void Toy_emitASTNodePostfixIncrement(Toy_ASTNode** nodeHandle, Toy_Literal identifier);
+void Toy_emitASTNodePostfixDecrement(Toy_ASTNode** nodeHandle, Toy_Literal identifier);
 
-typedef struct NodePrefixIncrement {
-	ASTNodeType type;
-	Literal identifier;
-} NodePrefixIncrement;
+typedef struct Toy_NodePrefixIncrement {
+	Toy_ASTNodeType type;
+	Toy_Literal identifier;
+} Toy_NodePrefixIncrement;
 
-typedef struct NodePrefixDecrement {
-	ASTNodeType type;
-	Literal identifier;
-} NodePrefixDecrement;
+typedef struct Toy_NodePrefixDecrement {
+	Toy_ASTNodeType type;
+	Toy_Literal identifier;
+} Toy_NodePrefixDecrement;
 
-typedef struct NodePostfixIncrement {
-	ASTNodeType type;
-	Literal identifier;
-} NodePostfixIncrement;
+typedef struct Toy_NodePostfixIncrement {
+	Toy_ASTNodeType type;
+	Toy_Literal identifier;
+} Toy_NodePostfixIncrement;
 
-typedef struct NodePostfixDecrement {
-	ASTNodeType type;
-	Literal identifier;
-} NodePostfixDecrement;
+typedef struct Toy_NodePostfixDecrement {
+	Toy_ASTNodeType type;
+	Toy_Literal identifier;
+} Toy_NodePostfixDecrement;
 
 //import a library
-void emitASTNodeImport(ASTNode** nodeHandle, Literal identifier, Literal alias);
+void Toy_emitASTNodeImport(Toy_ASTNode** nodeHandle, Toy_Literal identifier, Toy_Literal alias);
 
-typedef struct NodeImport {
-	ASTNodeType type;
-	Literal identifier;
-	Literal alias;
-} NodeImport;
+typedef struct Toy_NodeImport {
+	Toy_ASTNodeType type;
+	Toy_Literal identifier;
+	Toy_Literal alias;
+} Toy_NodeImport;
 
-union _node {
-	ASTNodeType type;
-	NodeLiteral atomic;
-	NodeUnary unary;
-	NodeBinary binary;
-	NodeTernary ternary;
-	NodeGrouping grouping;
-	NodeBlock block;
-	NodeCompound compound;
-	NodePair pair;
-	NodeIndex index;
-	NodeVarDecl varDecl;
-	NodeFnCollection fnCollection;
-	NodeFnDecl fnDecl;
-	NodeFnCall fnCall;
-	NodeFnReturn returns;
-	NodeIf pathIf;
-	NodeWhile pathWhile;
-	NodeFor pathFor;
-	NodeBreak pathBreak;
-	NodeContinue pathContinue;
-	NodePrefixIncrement prefixIncrement;
-	NodePrefixDecrement prefixDecrement;
-	NodePostfixIncrement postfixIncrement;
-	NodePostfixDecrement postfixDecrement;
-	NodeImport import;
+union Toy_private_node {
+	Toy_ASTNodeType type;
+	Toy_NodeLiteral atomic;
+	Toy_NodeUnary unary;
+	Toy_NodeBinary binary;
+	Toy_NodeTernary ternary;
+	Toy_NodeGrouping grouping;
+	Toy_NodeBlock block;
+	Toy_NodeCompound compound;
+	Toy_NodePair pair;
+	Toy_NodeIndex index;
+	Toy_NodeVarDecl varDecl;
+	Toy_NodeFnCollection fnCollection;
+	Toy_NodeFnDecl fnDecl;
+	Toy_NodeFnCall fnCall;
+	Toy_NodeFnReturn returns;
+	Toy_NodeIf pathIf;
+	Toy_NodeWhile pathWhile;
+	Toy_NodeFor pathFor;
+	Toy_NodeBreak pathBreak;
+	Toy_NodeContinue pathContinue;
+	Toy_NodePrefixIncrement prefixIncrement;
+	Toy_NodePrefixDecrement prefixDecrement;
+	Toy_NodePostfixIncrement postfixIncrement;
+	Toy_NodePostfixDecrement postfixDecrement;
+	Toy_NodeImport import;
 };
 
-TOY_API void freeASTNode(ASTNode* node);
+TOY_API void Toy_freeASTNode(Toy_ASTNode* node);

source/toy_builtin.h

@@ -1,14 +1,14 @@
 #pragma once
 
-#include "interpreter.h"
+#include "toy_interpreter.h"
 
 //the _index function is a historical oddity - it's used whenever a compound is indexed
-int _index(Interpreter* interpreter, LiteralArray* arguments);
+int _index(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments);
 
 //globally available native functions
-int _set(Interpreter* interpreter, LiteralArray* arguments);
-int _get(Interpreter* interpreter, LiteralArray* arguments);
-int _push(Interpreter* interpreter, LiteralArray* arguments);
-int _pop(Interpreter* interpreter, LiteralArray* arguments);
-int _length(Interpreter* interpreter, LiteralArray* arguments);
-int _clear(Interpreter* interpreter, LiteralArray* arguments);
+int _set(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments);
+int _get(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments);
+int _push(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments);
+int _pop(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments);
+int _length(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments);
+int _clear(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments);

source/toy_common.c

@@ -20,7 +20,7 @@ STATIC_ASSERT(sizeof(unsigned int) == 4);
 //declare the singleton
 Command command;
 
-void initCommand(int argc, const char* argv[]) {
+void Toy_initCommand(int argc, const char* argv[]) {
 	//default values
 	command.error = false;
 	command.help = false;
@@ -95,12 +95,12 @@ void initCommand(int argc, const char* argv[]) {
 	}
 }
 
-void usageCommand(int argc, const char* argv[]) {
+void Toy_usageCommand(int argc, const char* argv[]) {
 	printf("Usage: %s [<file.tb> | -h | -v | [-d][-f file | -i source | -c file [-o outfile]]]\n\n", argv[0]);
 }
 
-void helpCommand(int argc, const char* argv[]) {
-	usageCommand(argc, argv);
+void Toy_helpCommand(int argc, const char* argv[]) {
+	Toy_usageCommand(argc, argv);
 
 	printf("<file.tb>\t\t\tBinary input file in tb format, must be version %d.%d.%d.\n\n", TOY_VERSION_MAJOR, TOY_VERSION_MINOR, TOY_VERSION_PATCH);
 	printf("-h\t| --help\t\tShow this help then exit.\n\n");
@@ -112,7 +112,7 @@ void helpCommand(int argc, const char* argv[]) {
 	printf("-o\t| --output outfile\tName of the output file built with --compile (default: out.tb).\n\n");
 }
 
-void copyrightCommand(int argc, const char* argv[]) {
+void Toy_copyrightCommand(int argc, const char* argv[]) {
 	printf("Toy Programming Language Interpreter Version %d.%d.%d (built on %s)\n\n", TOY_VERSION_MAJOR, TOY_VERSION_MINOR, TOY_VERSION_PATCH, TOY_VERSION_BUILD);
 	printf("Copyright (c) 2020-2022 Kayne Ruse, KR Game Studios\n\n");
 	printf("This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software.\n\n");

source/toy_common.h

@@ -5,8 +5,8 @@
 #include <stdint.h>
 
 #define TOY_VERSION_MAJOR 0
-#define TOY_VERSION_MINOR 7
-#define TOY_VERSION_PATCH 1
+#define TOY_VERSION_MINOR 8
+#define TOY_VERSION_PATCH 0
 #define TOY_VERSION_BUILD __DATE__ " " __TIME__
 
 //platform-specific specifications
@@ -37,9 +37,9 @@ typedef struct {
 
 extern Command command;
 
-void initCommand(int argc, const char* argv[]);
+void Toy_initCommand(int argc, const char* argv[]);
 
-void usageCommand(int argc, const char* argv[]);
-void helpCommand(int argc, const char* argv[]);
-void copyrightCommand(int argc, const char* argv[]);
+void Toy_usageCommand(int argc, const char* argv[]);
+void Toy_helpCommand(int argc, const char* argv[]);
+void Toy_copyrightCommand(int argc, const char* argv[]);
 #endif

source/toy_compiler.h

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

source/toy_console_colors.h

@@ -3,28 +3,28 @@
 //NOTE: you need both font AND background for these to work
 
 //fonts color
-#define FONT_BLACK      "\033[30;"
-#define FONT_RED        "\033[31;"
-#define FONT_GREEN      "\033[32;"
-#define FONT_YELLOW     "\033[33;"
-#define FONT_BLUE       "\033[34;"
-#define FONT_PURPLE     "\033[35;"
-#define FONT_DGREEN     "\033[6;"
-#define FONT_WHITE      "\033[7;"
-#define FONT_CYAN       "\x1b[36m"
+#define TOY_CC_FONT_BLACK      "\033[30;"
+#define TOY_CC_FONT_RED        "\033[31;"
+#define TOY_CC_FONT_GREEN      "\033[32;"
+#define TOY_CC_FONT_YELLOW     "\033[33;"
+#define TOY_CC_FONT_BLUE       "\033[34;"
+#define TOY_CC_FONT_PURPLE     "\033[35;"
+#define TOY_CC_FONT_DGREEN     "\033[6;"
+#define TOY_CC_FONT_WHITE      "\033[7;"
+#define TOY_CC_FONT_CYAN       "\x1b[36m"
 
 //background color
-#define BACK_BLACK      "40m"
-#define BACK_RED        "41m"
-#define BACK_GREEN      "42m"
-#define BACK_YELLOW     "43m"
-#define BACK_BLUE       "44m"
-#define BACK_PURPLE     "45m"
-#define BACK_DGREEN     "46m"
-#define BACK_WHITE      "47m"
+#define TOY_CC_BACK_BLACK      "40m"
+#define TOY_CC_BACK_RED        "41m"
+#define TOY_CC_BACK_GREEN      "42m"
+#define TOY_CC_BACK_YELLOW     "43m"
+#define TOY_CC_BACK_BLUE       "44m"
+#define TOY_CC_BACK_PURPLE     "45m"
+#define TOY_CC_BACK_DGREEN     "46m"
+#define TOY_CC_BACK_WHITE      "47m"
 
 //useful
-#define NOTICE FONT_GREEN BACK_BLACK
-#define WARN FONT_YELLOW BACK_BLACK   
-#define ERROR FONT_RED BACK_BLACK   
-#define RESET "\033[0m"
+#define TOY_CC_NOTICE TOY_CC_FONT_GREEN TOY_CC_BACK_BLACK
+#define TOY_CC_WARN TOY_CC_FONT_YELLOW TOY_CC_BACK_BLACK   
+#define TOY_CC_ERROR TOY_CC_FONT_RED TOY_CC_BACK_BLACK   
+#define TOY_CC_RESET "\033[0m"

source/toy_interpreter.h

@@ -1,56 +1,56 @@
 #pragma once
 
 #include "toy_common.h"
-#include "literal.h"
-#include "literal_array.h"
-#include "literal_dictionary.h"
-#include "scope.h"
+#include "toy_literal.h"
+#include "toy_literal_array.h"
+#include "toy_literal_dictionary.h"
+#include "toy_scope.h"
 
-typedef void (*PrintFn)(const char*);
+typedef void (*Toy_PrintFn)(const char*);
 
 //the interpreter acts depending on the bytecode instructions
-typedef struct Interpreter {
+typedef struct Toy_Interpreter {
 	//input
 	unsigned char* bytecode;
 	int length;
 	int count;
 	int codeStart; //BUGFIX: for jumps, must be initialized to -1
-	LiteralArray literalCache; //read-only - built from the bytecode, refreshed each time new bytecode is provided
+	Toy_LiteralArray literalCache; //read-only - built from the bytecode, refreshed each time new bytecode is provided
 
 	//operation
-	Scope* scope;
-	LiteralArray stack;
+	Toy_Scope* scope;
+	Toy_LiteralArray stack;
 
 	//Library APIs
-	LiteralDictionary* hooks;
+	Toy_LiteralDictionary* hooks;
 
 	//debug outputs
-	PrintFn printOutput;
-	PrintFn assertOutput;
-	PrintFn errorOutput;
+	Toy_PrintFn printOutput;
+	Toy_PrintFn assertOutput;
+	Toy_PrintFn errorOutput;
 
 	int depth; //don't overflow
 	bool panic;
-} Interpreter;
+} Toy_Interpreter;
 
 //native API
-typedef int (*NativeFn)(Interpreter* interpreter, LiteralArray* arguments);
-TOY_API bool injectNativeFn(Interpreter* interpreter, char* name, NativeFn func);
+typedef int (*Toy_NativeFn)(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments);
+TOY_API bool Toy_injectNativeFn(Toy_Interpreter* interpreter, char* name, Toy_NativeFn func);
 
-typedef int (*HookFn)(Interpreter* interpreter, Literal identifier, Literal alias);
-TOY_API bool injectNativeHook(Interpreter* interpreter, char* name, HookFn hook);
+typedef int (*Toy_HookFn)(Toy_Interpreter* interpreter, Toy_Literal identifier, Toy_Literal alias);
+TOY_API bool Toy_injectNativeHook(Toy_Interpreter* interpreter, char* name, Toy_HookFn hook);
 
-TOY_API bool callLiteralFn(Interpreter* interpreter, Literal func, LiteralArray* arguments, LiteralArray* returns);
-TOY_API bool callFn(Interpreter* interpreter, char* name, LiteralArray* arguments, LiteralArray* returns);
+TOY_API bool Toy_callLiteralFn(Toy_Interpreter* interpreter, Toy_Literal func, Toy_LiteralArray* arguments, Toy_LiteralArray* returns);
+TOY_API bool Toy_callFn(Toy_Interpreter* interpreter, char* name, Toy_LiteralArray* arguments, Toy_LiteralArray* returns);
 
 //utilities for the host program
-TOY_API bool parseIdentifierToValue(Interpreter* interpreter, Literal* literalPtr);
-TOY_API void setInterpreterPrint(Interpreter* interpreter, PrintFn printOutput);
-TOY_API void setInterpreterAssert(Interpreter* interpreter, PrintFn assertOutput);
-TOY_API void setInterpreterError(Interpreter* interpreter, PrintFn errorOutput);
+TOY_API bool Toy_parseIdentifierToValue(Toy_Interpreter* interpreter, Toy_Literal* literalPtr);
+TOY_API void Toy_setInterpreterPrint(Toy_Interpreter* interpreter, Toy_PrintFn printOutput);
+TOY_API void Toy_setInterpreterAssert(Toy_Interpreter* interpreter, Toy_PrintFn assertOutput);
+TOY_API void Toy_setInterpreterError(Toy_Interpreter* interpreter, Toy_PrintFn errorOutput);
 
 //main access
-TOY_API void initInterpreter(Interpreter* interpreter); //start of program
-TOY_API void runInterpreter(Interpreter* interpreter, unsigned char* bytecode, int length); //run the code
-TOY_API void resetInterpreter(Interpreter* interpreter); //use this to reset the interpreter's environment between runs
-TOY_API void freeInterpreter(Interpreter* interpreter); //end of program
+TOY_API void Toy_initInterpreter(Toy_Interpreter* interpreter); //start of program
+TOY_API void Toy_runInterpreter(Toy_Interpreter* interpreter, unsigned char* bytecode, int length); //run the code
+TOY_API void Toy_resetInterpreter(Toy_Interpreter* interpreter); //use this to reset the interpreter's environment between runs
+TOY_API void Toy_freeInterpreter(Toy_Interpreter* interpreter); //end of program

source/toy_keyword_types.c

@@ -1,77 +1,77 @@
-#include "keyword_types.h"
+#include "toy_keyword_types.h"
 
 #include "toy_common.h"
 
 #include <string.h>
 
-KeywordType keywordTypes[] = {
+Toy_KeywordType Toy_keywordTypes[] = {
 	//type keywords
-	{TOKEN_NULL,       "null"},
-	{TOKEN_BOOLEAN,    "bool"},
-	{TOKEN_INTEGER,    "int"},
-	{TOKEN_FLOAT,      "float"},
-	{TOKEN_STRING,     "string"},
-	{TOKEN_FUNCTION,   "fn"},
-	{TOKEN_OPAQUE,     "opaque"},
-	{TOKEN_ANY,        "any"},
+	{TOY_TOKEN_NULL,       "null"},
+	{TOY_TOKEN_BOOLEAN,    "bool"},
+	{TOY_TOKEN_INTEGER,    "int"},
+	{TOY_TOKEN_FLOAT,      "float"},
+	{TOY_TOKEN_STRING,     "string"},
+	{TOY_TOKEN_FUNCTION,   "fn"},
+	{TOY_TOKEN_OPAQUE,     "opaque"},
+	{TOY_TOKEN_ANY,        "any"},
 
 	//other keywords
-	{TOKEN_AS,         "as"},
-	{TOKEN_ASSERT,     "assert"},
-	{TOKEN_BREAK,      "break"},
-	{TOKEN_CLASS,      "class"},
-	{TOKEN_CONST,      "const"},
-	{TOKEN_CONTINUE,   "continue"},
-	{TOKEN_DO,         "do"},
-	{TOKEN_ELSE,       "else"},
-	{TOKEN_EXPORT,     "export"},
-	{TOKEN_FOR,        "for"},
-	{TOKEN_FOREACH,    "foreach"},
-	{TOKEN_IF,         "if"},
-	{TOKEN_IMPORT,     "import"},
-	{TOKEN_IN,         "in"},
-	{TOKEN_OF,         "of"},
-	{TOKEN_PRINT,      "print"},
-	{TOKEN_RETURN,     "return"},
-	{TOKEN_TYPE,       "type"},
-	{TOKEN_ASTYPE,     "astype"},
-	{TOKEN_TYPEOF,     "typeof"},
-	{TOKEN_VAR,        "var"},
-	{TOKEN_WHILE,      "while"},
+	{TOY_TOKEN_AS,         "as"},
+	{TOY_TOKEN_ASSERT,     "assert"},
+	{TOY_TOKEN_BREAK,      "break"},
+	{TOY_TOKEN_CLASS,      "class"},
+	{TOY_TOKEN_CONST,      "const"},
+	{TOY_TOKEN_CONTINUE,   "continue"},
+	{TOY_TOKEN_DO,         "do"},
+	{TOY_TOKEN_ELSE,       "else"},
+	{TOY_TOKEN_EXPORT,     "export"},
+	{TOY_TOKEN_FOR,        "for"},
+	{TOY_TOKEN_FOREACH,    "foreach"},
+	{TOY_TOKEN_IF,         "if"},
+	{TOY_TOKEN_IMPORT,     "import"},
+	{TOY_TOKEN_IN,         "in"},
+	{TOY_TOKEN_OF,         "of"},
+	{TOY_TOKEN_PRINT,      "print"},
+	{TOY_TOKEN_RETURN,     "return"},
+	{TOY_TOKEN_TYPE,       "type"},
+	{TOY_TOKEN_ASTYPE,     "astype"},
+	{TOY_TOKEN_TYPEOF,     "typeof"},
+	{TOY_TOKEN_VAR,        "var"},
+	{TOY_TOKEN_WHILE,      "while"},
 
 	//literal values
-	{TOKEN_LITERAL_TRUE,   "true"},
-	{TOKEN_LITERAL_FALSE,  "false"},
+	{TOY_TOKEN_LITERAL_TRUE,   "true"},
+	{TOY_TOKEN_LITERAL_FALSE,  "false"},
 
 	//meta tokens
-	{TOKEN_PASS,       NULL},
-	{TOKEN_ERROR,      NULL},
+	{TOY_TOKEN_PASS,       NULL},
+	{TOY_TOKEN_ERROR,      NULL},
 
-	{TOKEN_EOF, NULL},
+	{TOY_TOKEN_EOF, NULL},
 };
 
-char* findKeywordByType(TokenType type) {
-	if (type == TOKEN_EOF) {
+char* Toy_findKeywordByType(Toy_TokenType type) {
+	if (type == TOY_TOKEN_EOF) {
 		return "EOF";
 	}
 
-	for(int i = 0; keywordTypes[i].keyword; i++) {
-		if (keywordTypes[i].type == type) {
-			return keywordTypes[i].keyword;
+	for(int i = 0; Toy_keywordTypes[i].keyword; i++) {
+		if (Toy_keywordTypes[i].type == type) {
+			return Toy_keywordTypes[i].keyword;
 		}
 	}
 
 	return NULL;
 }
 
-TokenType findTypeByKeyword(const char* keyword) {
+Toy_TokenType Toy_findTypeByKeyword(const char* keyword) {
 	const int length = strlen(keyword);
 
-	for (int i = 0; keywordTypes[i].keyword; i++) {
-		if (!strncmp(keyword, keywordTypes[i].keyword, length)) {
-			return keywordTypes[i].type;
+	for (int i = 0; Toy_keywordTypes[i].keyword; i++) {
+		if (!strncmp(keyword, Toy_keywordTypes[i].keyword, length)) {
+			return Toy_keywordTypes[i].type;
 		}
 	}
 
-	return TOKEN_EOF;
+	return TOY_TOKEN_EOF;
 }

source/toy_keyword_types.h

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

source/toy_lexer.c

@@ -1,33 +1,33 @@
-#include "lexer.h"
-#include "console_colors.h"
-#include "keyword_types.h"
+#include "toy_lexer.h"
+#include "toy_console_colors.h"
+#include "toy_keyword_types.h"
 
 #include <stdio.h>
 #include <string.h>
 #include <ctype.h>
 
 //static generic utility functions
-static void cleanLexer(Lexer* lexer) {
+static void cleanLexer(Toy_Lexer* lexer) {
 	lexer->source = NULL;
 	lexer->start = 0;
 	lexer->current = 0;
 	lexer->line = 1;
 }
 
-static bool isAtEnd(Lexer* lexer) {
+static bool isAtEnd(Toy_Lexer* lexer) {
 	return lexer->source[lexer->current] == '\0';
 }
 
-static char peek(Lexer* lexer) {
+static char peek(Toy_Lexer* lexer) {
 	return lexer->source[lexer->current];
 }
 
-static char peekNext(Lexer* lexer) {
+static char peekNext(Toy_Lexer* lexer) {
 	if (isAtEnd(lexer)) return '\0';
 	return lexer->source[lexer->current + 1];
 }
 
-static char advance(Lexer* lexer) {
+static char advance(Toy_Lexer* lexer) {
 	if (isAtEnd(lexer)) {
 		return '\0';
 	}
@@ -41,7 +41,7 @@ static char advance(Lexer* lexer) {
 	return lexer->source[lexer->current - 1];
 }
 
-static void eatWhitespace(Lexer* lexer) {
+static void eatWhitespace(Toy_Lexer* lexer) {
 	const char c = peek(lexer);
 
 	switch(c) {
@@ -79,11 +79,11 @@ static void eatWhitespace(Lexer* lexer) {
 	eatWhitespace(lexer);
 }
 
-static bool isDigit(Lexer* lexer) {
+static bool isDigit(Toy_Lexer* lexer) {
 	return peek(lexer) >= '0' && peek(lexer) <= '9';
 }
 
-static bool isAlpha(Lexer* lexer) {
+static bool isAlpha(Toy_Lexer* lexer) {
 	return
 		(peek(lexer) >= 'A' && peek(lexer) <= 'Z') ||
 		(peek(lexer) >= 'a' && peek(lexer) <= 'z') ||
@@ -91,7 +91,7 @@ static bool isAlpha(Lexer* lexer) {
 	;
 }
 
-static bool match(Lexer* lexer, char c) {
+static bool match(Toy_Lexer* lexer, char c) {
 	if (peek(lexer) == c) {
 		advance(lexer);
 		return true;
@@ -101,10 +101,10 @@ static bool match(Lexer* lexer, char c) {
 }
 
 //token generators
-static Token makeErrorToken(Lexer* lexer, char* msg) {
-	Token token;
+static Toy_Token makeErrorToken(Toy_Lexer* lexer, char* msg) {
+	Toy_Token token;
 
-	token.type = TOKEN_ERROR;
+	token.type = TOY_TOKEN_ERROR;
 	token.lexeme = msg;
 	token.length = strlen(msg);
 	token.line = lexer->line;
@@ -112,15 +112,15 @@ static Token makeErrorToken(Lexer* lexer, char* msg) {
 #ifndef TOY_EXPORT
 	if (command.verbose) {
 		printf("err:");
-		printToken(&token);
+		Toy_printToken(&token);
 	}
 #endif
 
 	return token;
 }
 
-static Token makeToken(Lexer* lexer, TokenType type) {
-	Token token;
+static Toy_Token makeToken(Toy_Lexer* lexer, Toy_TokenType type) {
+	Toy_Token token;
 
 	token.type = type;
 	token.length = lexer->current - lexer->start;
@@ -131,25 +131,25 @@ static Token makeToken(Lexer* lexer, TokenType type) {
 	//BUG #10: this shows TOKEN_EOF twice due to the overarching structure of the program - can't be fixed
 	if (command.verbose) {
 		printf("tok:");
-		printToken(&token);
+		Toy_printToken(&token);
 	}
 #endif
 
 	return token;
 }
 
-static Token makeIntegerOrFloat(Lexer* lexer) {
-	TokenType type = TOKEN_LITERAL_INTEGER; //what am I making?
+static Toy_Token makeIntegerOrFloat(Toy_Lexer* lexer) {
+	Toy_TokenType type = TOY_TOKEN_LITERAL_INTEGER; //what am I making?
 
 	while(isDigit(lexer)) advance(lexer);
 
 	if (peek(lexer) == '.' && (peekNext(lexer) >= '0' && peekNext(lexer) <= '9')) { //BUGFIX: peekNext == digit
-		type = TOKEN_LITERAL_FLOAT;
+		type = TOY_TOKEN_LITERAL_FLOAT;
 		advance(lexer);
 		while(isDigit(lexer)) advance(lexer);
 	}
 
-	Token token;
+	Toy_Token token;
 
 	token.type = type;
 	token.lexeme = &lexer->source[lexer->start];
@@ -158,19 +158,19 @@ static Token makeIntegerOrFloat(Lexer* lexer) {
 
 #ifndef TOY_EXPORT
 	if (command.verbose) {
-		if (type == TOKEN_LITERAL_INTEGER) {
+		if (type == TOY_TOKEN_LITERAL_INTEGER) {
 			printf("int:");
 		} else {
 			printf("flt:");
 		}
-		printToken(&token);
+		Toy_printToken(&token);
 	}
 #endif
 
 	return token;
 }
 
-static Token makeString(Lexer* lexer, char terminator) {
+static Toy_Token makeString(Toy_Lexer* lexer, char terminator) {
 	while (!isAtEnd(lexer) && peek(lexer) != terminator) {
 		advance(lexer);
 	}
@@ -181,9 +181,9 @@ static Token makeString(Lexer* lexer, char terminator) {
 		return makeErrorToken(lexer, "Unterminated string");
 	}
 
-	Token token;
+	Toy_Token token;
 
-	token.type = TOKEN_LITERAL_STRING;
+	token.type = TOY_TOKEN_LITERAL_STRING;
 	token.lexeme = &lexer->source[lexer->start + 1];
 	token.length = lexer->current - lexer->start - 2;
 	token.line = lexer->line;
@@ -191,14 +191,14 @@ static Token makeString(Lexer* lexer, char terminator) {
 #ifndef TOY_EXPORT
 	if (command.verbose) {
 		printf("str:");
-		printToken(&token);
+		Toy_printToken(&token);
 	}
 #endif
 
 	return token;
 }
 
-static Token makeKeywordOrIdentifier(Lexer* lexer) {
+static Toy_Token makeKeywordOrIdentifier(Toy_Lexer* lexer) {
 	advance(lexer); //first letter can only be alpha
 
 	while(isDigit(lexer) || isAlpha(lexer)) {
@@ -206,11 +206,11 @@ static Token makeKeywordOrIdentifier(Lexer* lexer) {
 	}
 
 	//scan for a keyword
-	for (int i = 0; keywordTypes[i].keyword; i++) {
-		if (strlen(keywordTypes[i].keyword) == (long unsigned int)(lexer->current - lexer->start) && !strncmp(keywordTypes[i].keyword, &lexer->source[lexer->start], lexer->current - lexer->start)) {
-			Token token;
+	for (int i = 0; Toy_keywordTypes[i].keyword; i++) {
+		if (strlen(Toy_keywordTypes[i].keyword) == (long unsigned int)(lexer->current - lexer->start) && !strncmp(Toy_keywordTypes[i].keyword, &lexer->source[lexer->start], lexer->current - lexer->start)) {
+			Toy_Token token;
 
-			token.type = keywordTypes[i].type;
+			token.type = Toy_keywordTypes[i].type;
 			token.lexeme = &lexer->source[lexer->start];
 			token.length = lexer->current - lexer->start;
 			token.line = lexer->line;
@@ -218,7 +218,7 @@ static Token makeKeywordOrIdentifier(Lexer* lexer) {
 #ifndef TOY_EXPORT
 			if (command.verbose) {
 				printf("kwd:");
-				printToken(&token);
+				Toy_printToken(&token);
 			}
 #endif
 
@@ -227,9 +227,9 @@ static Token makeKeywordOrIdentifier(Lexer* lexer) {
 	}
 
 	//return an identifier
-	Token token;
+	Toy_Token token;
 
-	token.type = TOKEN_IDENTIFIER;
+	token.type = TOY_TOKEN_IDENTIFIER;
 	token.lexeme = &lexer->source[lexer->start];
 	token.length = lexer->current - lexer->start;
 	token.line = lexer->line;
@@ -237,7 +237,7 @@ static Token makeKeywordOrIdentifier(Lexer* lexer) {
 #ifndef TOY_EXPORT
 	if (command.verbose) {
 		printf("idf:");
-		printToken(&token);
+		Toy_printToken(&token);
 	}
 #endif
 
@@ -245,18 +245,18 @@ static Token makeKeywordOrIdentifier(Lexer* lexer) {
 }
 
 //exposed functions
-void initLexer(Lexer* lexer, char* source) {
+void Toy_initLexer(Toy_Lexer* lexer, char* source) {
 	cleanLexer(lexer);
 
 	lexer->source = source;
 }
 
-Token scanLexer(Lexer* lexer) {
+Toy_Token Toy_scanLexer(Toy_Lexer* lexer) {
 	eatWhitespace(lexer);
 
 	lexer->start = lexer->current;
 
-	if (isAtEnd(lexer)) return makeToken(lexer, TOKEN_EOF);
+	if (isAtEnd(lexer)) return makeToken(lexer, TOY_TOKEN_EOF);
 
 	if (isDigit(lexer)) return makeIntegerOrFloat(lexer);
 	if (isAlpha(lexer)) return makeKeywordOrIdentifier(lexer);
@@ -264,45 +264,45 @@ Token scanLexer(Lexer* lexer) {
 	char c = advance(lexer);
 
 	switch(c) {
-		case '(': return makeToken(lexer, TOKEN_PAREN_LEFT);
-		case ')': return makeToken(lexer, TOKEN_PAREN_RIGHT);
-		case '{': return makeToken(lexer, TOKEN_BRACE_LEFT);
-		case '}': return makeToken(lexer, TOKEN_BRACE_RIGHT);
-		case '[': return makeToken(lexer, TOKEN_BRACKET_LEFT);
-		case ']': return makeToken(lexer, TOKEN_BRACKET_RIGHT);
+		case '(': return makeToken(lexer, TOY_TOKEN_PAREN_LEFT);
+		case ')': return makeToken(lexer, TOY_TOKEN_PAREN_RIGHT);
+		case '{': return makeToken(lexer, TOY_TOKEN_BRACE_LEFT);
+		case '}': return makeToken(lexer, TOY_TOKEN_BRACE_RIGHT);
+		case '[': return makeToken(lexer, TOY_TOKEN_BRACKET_LEFT);
+		case ']': return makeToken(lexer, TOY_TOKEN_BRACKET_RIGHT);
 
-		case '+': return makeToken(lexer, match(lexer, '=') ? TOKEN_PLUS_ASSIGN : match(lexer, '+') ? TOKEN_PLUS_PLUS: TOKEN_PLUS);
-		case '-': return makeToken(lexer, match(lexer, '=') ? TOKEN_MINUS_ASSIGN : match(lexer, '-') ? TOKEN_MINUS_MINUS: TOKEN_MINUS);
-		case '*': return makeToken(lexer, match(lexer, '=') ? TOKEN_MULTIPLY_ASSIGN : TOKEN_MULTIPLY);
-		case '/': return makeToken(lexer, match(lexer, '=') ? TOKEN_DIVIDE_ASSIGN : TOKEN_DIVIDE);
-		case '%': return makeToken(lexer, match(lexer, '=') ? TOKEN_MODULO_ASSIGN : TOKEN_MODULO);
+		case '+': return makeToken(lexer, match(lexer, '=') ? TOY_TOKEN_PLUS_ASSIGN : match(lexer, '+') ? TOY_TOKEN_PLUS_PLUS: TOY_TOKEN_PLUS);
+		case '-': return makeToken(lexer, match(lexer, '=') ? TOY_TOKEN_MINUS_ASSIGN : match(lexer, '-') ? TOY_TOKEN_MINUS_MINUS: TOY_TOKEN_MINUS);
+		case '*': return makeToken(lexer, match(lexer, '=') ? TOY_TOKEN_MULTIPLY_ASSIGN : TOY_TOKEN_MULTIPLY);
+		case '/': return makeToken(lexer, match(lexer, '=') ? TOY_TOKEN_DIVIDE_ASSIGN : TOY_TOKEN_DIVIDE);
+		case '%': return makeToken(lexer, match(lexer, '=') ? TOY_TOKEN_MODULO_ASSIGN : TOY_TOKEN_MODULO);
 
-		case '!': return makeToken(lexer, match(lexer, '=') ? TOKEN_NOT_EQUAL : TOKEN_NOT);
-		case '=': return makeToken(lexer, match(lexer, '=') ? TOKEN_EQUAL : TOKEN_ASSIGN);
+		case '!': return makeToken(lexer, match(lexer, '=') ? TOY_TOKEN_NOT_EQUAL : TOY_TOKEN_NOT);
+		case '=': return makeToken(lexer, match(lexer, '=') ? TOY_TOKEN_EQUAL : TOY_TOKEN_ASSIGN);
 
-		case '<': return makeToken(lexer, match(lexer, '=') ? TOKEN_LESS_EQUAL : TOKEN_LESS);
-		case '>': return makeToken(lexer, match(lexer, '=') ? TOKEN_GREATER_EQUAL : TOKEN_GREATER);
+		case '<': return makeToken(lexer, match(lexer, '=') ? TOY_TOKEN_LESS_EQUAL : TOY_TOKEN_LESS);
+		case '>': return makeToken(lexer, match(lexer, '=') ? TOY_TOKEN_GREATER_EQUAL : TOY_TOKEN_GREATER);
 
 		case '&': //TOKEN_AND not used
 			if (advance(lexer) != '&') {
 				return makeErrorToken(lexer, "Unexpected '&'");
 			} else {
-				return makeToken(lexer, TOKEN_AND);
+				return makeToken(lexer, TOY_TOKEN_AND);
 			}
 
-		case '|':  return makeToken(lexer, match(lexer, '|') ? TOKEN_OR : TOKEN_PIPE);
+		case '|':  return makeToken(lexer, match(lexer, '|') ? TOY_TOKEN_OR : TOY_TOKEN_PIPE);
 
-		case '?': return makeToken(lexer, TOKEN_QUESTION);
-		case ':': return makeToken(lexer, TOKEN_COLON);
-		case ';': return makeToken(lexer, TOKEN_SEMICOLON);
-		case ',': return makeToken(lexer, TOKEN_COMMA);
+		case '?': return makeToken(lexer, TOY_TOKEN_QUESTION);
+		case ':': return makeToken(lexer, TOY_TOKEN_COLON);
+		case ';': return makeToken(lexer, TOY_TOKEN_SEMICOLON);
+		case ',': return makeToken(lexer, TOY_TOKEN_COMMA);
 		case '.':
 			if (peek(lexer) == '.' && peekNext(lexer) == '.') {
 				advance(lexer);
 				advance(lexer);
-				return makeToken(lexer, TOKEN_REST);
+				return makeToken(lexer, TOY_TOKEN_REST);
 			}
-			return makeToken(lexer, TOKEN_DOT);
+			return makeToken(lexer, TOY_TOKEN_DOT);
 
 		case '"':
 			return makeString(lexer, c);
@@ -322,18 +322,18 @@ static void trim(char** s, int* l) { //all this to remove a newline?
 }
 
 //for debugging
-void printToken(Token* token) {
-	if (token->type == TOKEN_ERROR) {
-		printf(ERROR "Error\t%d\t%.*s\n" RESET, token->line, token->length, token->lexeme);
+void Toy_printToken(Toy_Token* token) {
+	if (token->type == TOY_TOKEN_ERROR) {
+		printf(TOY_CC_ERROR "Error\t%d\t%.*s\n" TOY_CC_RESET, token->line, token->length, token->lexeme);
 		return;
 	}
 
 	printf("\t%d\t%d\t", token->type, token->line);
 
-	if (token->type == TOKEN_IDENTIFIER || token->type == TOKEN_LITERAL_INTEGER || token->type == TOKEN_LITERAL_FLOAT || token->type == TOKEN_LITERAL_STRING) {
+	if (token->type == TOY_TOKEN_IDENTIFIER || token->type == TOY_TOKEN_LITERAL_INTEGER || token->type == TOY_TOKEN_LITERAL_FLOAT || token->type == TOY_TOKEN_LITERAL_STRING) {
 		printf("%.*s\t", token->length, token->lexeme);
 	} else {
-		char* keyword = findKeywordByType(token->type);
+		char* keyword = Toy_findKeywordByType(token->type);
 
 		if (keyword != NULL) {
 			printf("%s", keyword);

source/toy_lexer.h

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

source/toy_literal.c

@@ -1,11 +1,11 @@
-#include "literal.h"
-#include "memory.h"
+#include "toy_literal.h"
+#include "toy_memory.h"
 
-#include "literal_array.h"
-#include "literal_dictionary.h"
-#include "scope.h"
+#include "toy_literal_array.h"
+#include "toy_literal_dictionary.h"
+#include "toy_scope.h"
 
-#include "console_colors.h"
+#include "toy_console_colors.h"
 
 #include <stdio.h>
 
@@ -29,203 +29,203 @@ static unsigned int hashUInt(unsigned int x) {
 }
 
 //exposed functions
-void freeLiteral(Literal literal) {
+void Toy_freeLiteral(Toy_Literal literal) {
 	//refstrings
-	if (IS_STRING(literal)) {
-		deleteRefString(AS_STRING(literal));
+	if (TOY_IS_STRING(literal)) {
+		Toy_deleteRefString(TOY_AS_STRING(literal));
 		return;
 	}
 
-	if (IS_IDENTIFIER(literal)) {
-		deleteRefString(AS_IDENTIFIER(literal));
+	if (TOY_IS_IDENTIFIER(literal)) {
+		Toy_deleteRefString(TOY_AS_IDENTIFIER(literal));
 		return;
 	}
 
 	//compounds
-	if (IS_ARRAY(literal) || literal.type == LITERAL_DICTIONARY_INTERMEDIATE || literal.type == LITERAL_TYPE_INTERMEDIATE) {
-		freeLiteralArray(AS_ARRAY(literal));
-		FREE(LiteralArray, AS_ARRAY(literal));
+	if (TOY_IS_ARRAY(literal) || literal.type == TOY_LITERAL_DICTIONARY_INTERMEDIATE || literal.type == TOY_LITERAL_TYPE_INTERMEDIATE) {
+		Toy_freeLiteralArray(TOY_AS_ARRAY(literal));
+		TOY_FREE(Toy_LiteralArray, TOY_AS_ARRAY(literal));
 		return;
 	}
 
-	if (IS_DICTIONARY(literal)) {
-		freeLiteralDictionary(AS_DICTIONARY(literal));
-		FREE(LiteralDictionary, AS_DICTIONARY(literal));
+	if (TOY_IS_DICTIONARY(literal)) {
+		Toy_freeLiteralDictionary(TOY_AS_DICTIONARY(literal));
+		TOY_FREE(Toy_LiteralDictionary, TOY_AS_DICTIONARY(literal));
 		return;
 	}
 
 	//complex literals
-	if (IS_FUNCTION(literal)) {
-		popScope(AS_FUNCTION(literal).scope);
-		AS_FUNCTION(literal).scope = NULL;
-		FREE_ARRAY(unsigned char, AS_FUNCTION(literal).bytecode, AS_FUNCTION(literal).length);
+	if (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).bytecode, TOY_AS_FUNCTION(literal).length);
 	}
 
-	if (IS_TYPE(literal)) {
-		for (int i = 0; i < AS_TYPE(literal).count; i++) {
-			freeLiteral(((Literal*)(AS_TYPE(literal).subtypes))[i]);
+	if (TOY_IS_TYPE(literal)) {
+		for (int i = 0; i < TOY_AS_TYPE(literal).count; i++) {
+			Toy_freeLiteral(((Toy_Literal*)(TOY_AS_TYPE(literal).subtypes))[i]);
 		}
-		FREE_ARRAY(Literal, AS_TYPE(literal).subtypes, AS_TYPE(literal).capacity);
+		TOY_FREE_ARRAY(Toy_Literal, TOY_AS_TYPE(literal).subtypes, TOY_AS_TYPE(literal).capacity);
 		return;
 	}
 }
 
-bool _isTruthy(Literal x) {
-	if (IS_NULL(x)) {
-		fprintf(stderr, ERROR "ERROR: Null is neither true nor false\n" RESET);
+bool Toy_private_isTruthy(Toy_Literal x) {
+	if (TOY_IS_NULL(x)) {
+		fprintf(stderr, TOY_CC_ERROR "TOY_CC_ERROR: Null is neither true nor false\n" TOY_CC_RESET);
 		return false;
 	}
 
-	if (IS_BOOLEAN(x)) {
-		return AS_BOOLEAN(x);
+	if (TOY_IS_BOOLEAN(x)) {
+		return TOY_AS_BOOLEAN(x);
 	}
 
 	return true;
 }
 
-Literal _toStringLiteral(RefString* ptr) {
-	return ((Literal){LITERAL_STRING, { .string.ptr = ptr }});
+Toy_Literal Toy_private_toStringLiteral(Toy_RefString* ptr) {
+	return ((Toy_Literal){TOY_LITERAL_STRING, { .string.ptr = ptr }});
 }
 
-Literal _toIdentifierLiteral(RefString* ptr) {
-	return ((Literal){LITERAL_IDENTIFIER,{ .identifier.ptr = ptr, .identifier.hash = hashString(toCString(ptr), lengthRefString(ptr)) }});
+Toy_Literal Toy_private_toIdentifierLiteral(Toy_RefString* ptr) {
+	return ((Toy_Literal){TOY_LITERAL_IDENTIFIER,{ .identifier.ptr = ptr, .identifier.hash = hashString(Toy_toCString(ptr), Toy_lengthRefString(ptr)) }});
 }
 
-Literal* _typePushSubtype(Literal* lit, Literal subtype) {
+Toy_Literal* Toy_private_typePushSubtype(Toy_Literal* lit, Toy_Literal subtype) {
 	//grow the subtype array
-	if (AS_TYPE(*lit).count + 1 > AS_TYPE(*lit).capacity) {
-		int oldCapacity = AS_TYPE(*lit).capacity;
+	if (TOY_AS_TYPE(*lit).count + 1 > TOY_AS_TYPE(*lit).capacity) {
+		int oldCapacity = TOY_AS_TYPE(*lit).capacity;
 
-		AS_TYPE(*lit).capacity = GROW_CAPACITY(oldCapacity);
-		AS_TYPE(*lit).subtypes = GROW_ARRAY(Literal, AS_TYPE(*lit).subtypes, oldCapacity, AS_TYPE(*lit).capacity);
+		TOY_AS_TYPE(*lit).capacity = TOY_GROW_CAPACITY(oldCapacity);
+		TOY_AS_TYPE(*lit).subtypes = TOY_GROW_ARRAY(Toy_Literal, TOY_AS_TYPE(*lit).subtypes, oldCapacity, TOY_AS_TYPE(*lit).capacity);
 	}
 
 	//actually push
-	((Literal*)(AS_TYPE(*lit).subtypes))[ AS_TYPE(*lit).count++ ] = subtype;
-	return &((Literal*)(AS_TYPE(*lit).subtypes))[ AS_TYPE(*lit).count - 1 ];
+	((Toy_Literal*)(TOY_AS_TYPE(*lit).subtypes))[ TOY_AS_TYPE(*lit).count++ ] = subtype;
+	return &((Toy_Literal*)(TOY_AS_TYPE(*lit).subtypes))[ TOY_AS_TYPE(*lit).count - 1 ];
 }
 
-Literal copyLiteral(Literal original) {
+Toy_Literal Toy_copyLiteral(Toy_Literal original) {
 	switch(original.type) {
-		case LITERAL_NULL:
-		case LITERAL_BOOLEAN:
-		case LITERAL_INTEGER:
-		case LITERAL_FLOAT:
+		case TOY_LITERAL_NULL:
+		case TOY_LITERAL_BOOLEAN:
+		case TOY_LITERAL_INTEGER:
+		case TOY_LITERAL_FLOAT:
 			//no copying needed
 			return original;
 
-		case LITERAL_STRING: {
-			return TO_STRING_LITERAL(copyRefString(AS_STRING(original)));
+		case TOY_LITERAL_STRING: {
+			return TOY_TO_STRING_LITERAL(Toy_copyRefString(TOY_AS_STRING(original)));
 		}
 
-		case LITERAL_ARRAY: {
-			LiteralArray* array = ALLOCATE(LiteralArray, 1);
-			initLiteralArray(array);
+		case TOY_LITERAL_ARRAY: {
+			Toy_LiteralArray* array = TOY_ALLOCATE(Toy_LiteralArray, 1);
+			Toy_initLiteralArray(array);
 
 			//copy each element
-			for (int i = 0; i < AS_ARRAY(original)->count; i++) {
-				pushLiteralArray(array, AS_ARRAY(original)->literals[i]);
+			for (int i = 0; i < TOY_AS_ARRAY(original)->count; i++) {
+				Toy_pushLiteralArray(array, TOY_AS_ARRAY(original)->literals[i]);
 			}
 
-			return TO_ARRAY_LITERAL(array);
+			return TOY_TO_ARRAY_LITERAL(array);
 		}
 
-		case LITERAL_DICTIONARY: {
-			LiteralDictionary* dictionary = ALLOCATE(LiteralDictionary, 1);
-			initLiteralDictionary(dictionary);
+		case TOY_LITERAL_DICTIONARY: {
+			Toy_LiteralDictionary* dictionary = TOY_ALLOCATE(Toy_LiteralDictionary, 1);
+			Toy_initLiteralDictionary(dictionary);
 
 			//copy each entry
-			for (int i = 0; i < AS_DICTIONARY(original)->capacity; i++) {
-				if ( !IS_NULL(AS_DICTIONARY(original)->entries[i].key) ) {
-					setLiteralDictionary(dictionary, AS_DICTIONARY(original)->entries[i].key, AS_DICTIONARY(original)->entries[i].value);
+			for (int i = 0; i < TOY_AS_DICTIONARY(original)->capacity; i++) {
+				if ( !TOY_IS_NULL(TOY_AS_DICTIONARY(original)->entries[i].key) ) {
+					Toy_setLiteralDictionary(dictionary, TOY_AS_DICTIONARY(original)->entries[i].key, TOY_AS_DICTIONARY(original)->entries[i].value);
 				}
 			}
 
-			return TO_DICTIONARY_LITERAL(dictionary);
+			return TOY_TO_DICTIONARY_LITERAL(dictionary);
 		}
 
-		case LITERAL_FUNCTION: {
-			unsigned char* buffer = ALLOCATE(unsigned char, AS_FUNCTION(original).length);
-			memcpy(buffer, AS_FUNCTION(original).bytecode, AS_FUNCTION(original).length);
+		case TOY_LITERAL_FUNCTION: {
+			unsigned char* buffer = TOY_ALLOCATE(unsigned char, TOY_AS_FUNCTION(original).length);
+			memcpy(buffer, TOY_AS_FUNCTION(original).bytecode, TOY_AS_FUNCTION(original).length);
 
-			Literal literal = TO_FUNCTION_LITERAL(buffer, AS_FUNCTION(original).length);
-			AS_FUNCTION(literal).scope = copyScope(AS_FUNCTION(original).scope);
+			Toy_Literal literal = TOY_TO_FUNCTION_LITERAL(buffer, TOY_AS_FUNCTION(original).length);
+			TOY_AS_FUNCTION(literal).scope = Toy_copyScope(TOY_AS_FUNCTION(original).scope);
 
 			return literal;
 		}
 
-		case LITERAL_IDENTIFIER: {
-			 return TO_IDENTIFIER_LITERAL(copyRefString(AS_IDENTIFIER(original)));
+		case TOY_LITERAL_IDENTIFIER: {
+			 return TOY_TO_IDENTIFIER_LITERAL(Toy_copyRefString(TOY_AS_IDENTIFIER(original)));
 		}
 
-		case LITERAL_TYPE: {
-			Literal lit = TO_TYPE_LITERAL(AS_TYPE(original).typeOf, AS_TYPE(original).constant);
+		case TOY_LITERAL_TYPE: {
+			Toy_Literal lit = TOY_TO_TYPE_LITERAL(TOY_AS_TYPE(original).typeOf, TOY_AS_TYPE(original).constant);
 
-			for (int i = 0; i < AS_TYPE(original).count; i++) {
-				TYPE_PUSH_SUBTYPE(&lit, copyLiteral( ((Literal*)(AS_TYPE(original).subtypes))[i] ));
+			for (int i = 0; i < TOY_AS_TYPE(original).count; i++) {
+				TOY_TYPE_PUSH_SUBTYPE(&lit, Toy_copyLiteral( ((Toy_Literal*)(TOY_AS_TYPE(original).subtypes))[i] ));
 			}
 
 			return lit;
 		}
 
-		case LITERAL_OPAQUE: {
+		case TOY_LITERAL_OPAQUE: {
 			return original; //literally a shallow copy
 		}
 
-		case LITERAL_DICTIONARY_INTERMEDIATE: {
-			LiteralArray* array = ALLOCATE(LiteralArray, 1);
-			initLiteralArray(array);
+		case TOY_LITERAL_DICTIONARY_INTERMEDIATE: {
+			Toy_LiteralArray* array = TOY_ALLOCATE(Toy_LiteralArray, 1);
+			Toy_initLiteralArray(array);
 
 			//copy each element
-			for (int i = 0; i < AS_ARRAY(original)->count; i++) {
-				Literal literal = copyLiteral(AS_ARRAY(original)->literals[i]);
-				pushLiteralArray(array, literal);
-				freeLiteral(literal);
+			for (int i = 0; i < TOY_AS_ARRAY(original)->count; i++) {
+				Toy_Literal literal = Toy_copyLiteral(TOY_AS_ARRAY(original)->literals[i]);
+				Toy_pushLiteralArray(array, literal);
+				Toy_freeLiteral(literal);
 			}
 
-			Literal ret = TO_ARRAY_LITERAL(array);
-			ret.type = LITERAL_DICTIONARY_INTERMEDIATE;
+			Toy_Literal ret = TOY_TO_ARRAY_LITERAL(array);
+			ret.type = TOY_LITERAL_DICTIONARY_INTERMEDIATE;
 			return ret;
 		}
 
-		case LITERAL_TYPE_INTERMEDIATE: {
-			LiteralArray* array = ALLOCATE(LiteralArray, 1);
-			initLiteralArray(array);
+		case TOY_LITERAL_TYPE_INTERMEDIATE: {
+			Toy_LiteralArray* array = TOY_ALLOCATE(Toy_LiteralArray, 1);
+			Toy_initLiteralArray(array);
 
 			//copy each element
-			for (int i = 0; i < AS_ARRAY(original)->count; i++) {
-				Literal literal =  copyLiteral(AS_ARRAY(original)->literals[i]);
-				pushLiteralArray(array, literal);
-				freeLiteral(literal);
+			for (int i = 0; i < TOY_AS_ARRAY(original)->count; i++) {
+				Toy_Literal literal =  Toy_copyLiteral(TOY_AS_ARRAY(original)->literals[i]);
+				Toy_pushLiteralArray(array, literal);
+				Toy_freeLiteral(literal);
 			}
 
-			Literal ret = TO_ARRAY_LITERAL(array);
-			ret.type = LITERAL_TYPE_INTERMEDIATE;
+			Toy_Literal ret = TOY_TO_ARRAY_LITERAL(array);
+			ret.type = TOY_LITERAL_TYPE_INTERMEDIATE;
 			return ret;
 		}
 
-		case LITERAL_FUNCTION_INTERMEDIATE: //caries a compiler
-		case LITERAL_FUNCTION_NATIVE:
-		case LITERAL_INDEX_BLANK:
+		case TOY_LITERAL_FUNCTION_INTERMEDIATE: //caries a compiler
+		case TOY_LITERAL_FUNCTION_NATIVE:
+		case TOY_LITERAL_INDEX_BLANK:
 			//no copying possible
 			return original;
 
 		default:
-			fprintf(stderr, ERROR "ERROR: Can't copy that literal type: %d\n" RESET, original.type);
-			return TO_NULL_LITERAL;
+			fprintf(stderr, TOY_CC_ERROR "TOY_CC_ERROR: Can't copy that literal type: %d\n" TOY_CC_RESET, original.type);
+			return TOY_TO_NULL_LITERAL;
 	}
 }
 
-bool literalsAreEqual(Literal lhs, Literal rhs) {
+bool Toy_literalsAreEqual(Toy_Literal lhs, Toy_Literal rhs) {
 	//utility for other things
 	if (lhs.type != rhs.type) {
 		// ints and floats are compatible
-		if ((IS_INTEGER(lhs) || IS_FLOAT(lhs)) && (IS_INTEGER(rhs) || IS_FLOAT(rhs))) {
-			if (IS_INTEGER(lhs)) {
-				return AS_INTEGER(lhs) + AS_FLOAT(rhs);
+		if ((TOY_IS_INTEGER(lhs) || TOY_IS_FLOAT(lhs)) && (TOY_IS_INTEGER(rhs) || TOY_IS_FLOAT(rhs))) {
+			if (TOY_IS_INTEGER(lhs)) {
+				return TOY_AS_INTEGER(lhs) + TOY_AS_FLOAT(rhs);
 			}
 			else {
-				return AS_FLOAT(lhs) + AS_INTEGER(rhs);
+				return TOY_AS_FLOAT(lhs) + TOY_AS_INTEGER(rhs);
 			}
 		}
 
@@ -233,172 +233,172 @@ bool literalsAreEqual(Literal lhs, Literal rhs) {
 	}
 
 	switch(lhs.type) {
-		case LITERAL_NULL:
+		case TOY_LITERAL_NULL:
 			return true; //can only be true because of the check above
 
-		case LITERAL_BOOLEAN:
-			return AS_BOOLEAN(lhs) == AS_BOOLEAN(rhs);
+		case TOY_LITERAL_BOOLEAN:
+			return TOY_AS_BOOLEAN(lhs) == TOY_AS_BOOLEAN(rhs);
 
-		case LITERAL_INTEGER:
-			return AS_INTEGER(lhs) == AS_INTEGER(rhs);
+		case TOY_LITERAL_INTEGER:
+			return TOY_AS_INTEGER(lhs) == TOY_AS_INTEGER(rhs);
 
-		case LITERAL_FLOAT:
-			return AS_FLOAT(lhs) == AS_FLOAT(rhs);
+		case TOY_LITERAL_FLOAT:
+			return TOY_AS_FLOAT(lhs) == TOY_AS_FLOAT(rhs);
 
-		case LITERAL_STRING:
-			return equalsRefString(AS_STRING(lhs), AS_STRING(rhs));
+		case TOY_LITERAL_STRING:
+			return Toy_equalsRefString(TOY_AS_STRING(lhs), TOY_AS_STRING(rhs));
 
-		case LITERAL_ARRAY:
-		case LITERAL_DICTIONARY_INTERMEDIATE: //BUGFIX
-		case LITERAL_TYPE_INTERMEDIATE: //BUGFIX: used for storing types as an array
+		case TOY_LITERAL_ARRAY:
+		case TOY_LITERAL_DICTIONARY_INTERMEDIATE: //BUGFIX
+		case TOY_LITERAL_TYPE_INTERMEDIATE: //BUGFIX: used for storing types as an array
 			//mismatched sizes
-			if (AS_ARRAY(lhs)->count != AS_ARRAY(rhs)->count) {
+			if (TOY_AS_ARRAY(lhs)->count != TOY_AS_ARRAY(rhs)->count) {
 				return false;
 			}
 
 			//mismatched elements (in order)
-			for (int i = 0; i < AS_ARRAY(lhs)->count; i++) {
-				if (!literalsAreEqual( AS_ARRAY(lhs)->literals[i], AS_ARRAY(rhs)->literals[i] )) {
+			for (int i = 0; i < TOY_AS_ARRAY(lhs)->count; i++) {
+				if (!Toy_literalsAreEqual( TOY_AS_ARRAY(lhs)->literals[i], TOY_AS_ARRAY(rhs)->literals[i] )) {
 					return false;
 				}
 			}
 			return true;
 
-		case LITERAL_DICTIONARY:
+		case TOY_LITERAL_DICTIONARY:
 			//relatively slow, especially when nested
-			for (int i = 0; i < AS_DICTIONARY(lhs)->capacity; i++) {
-				if (!IS_NULL(AS_DICTIONARY(lhs)->entries[i].key)) { //only compare non-null keys
+			for (int i = 0; i < TOY_AS_DICTIONARY(lhs)->capacity; i++) {
+				if (!TOY_IS_NULL(TOY_AS_DICTIONARY(lhs)->entries[i].key)) { //only compare non-null keys
 					//check it exists in rhs
-					if (!existsLiteralDictionary(AS_DICTIONARY(rhs), AS_DICTIONARY(lhs)->entries[i].key)) {
+					if (!Toy_existsLiteralDictionary(TOY_AS_DICTIONARY(rhs), TOY_AS_DICTIONARY(lhs)->entries[i].key)) {
 						return false;
 					}
 
 					//compare the values
-					Literal val = getLiteralDictionary(AS_DICTIONARY(rhs), AS_DICTIONARY(lhs)->entries[i].key); //TODO: could be more efficient
-					if (!literalsAreEqual(AS_DICTIONARY(lhs)->entries[i].value, val)) {
-						freeLiteral(val);
+					Toy_Literal val = Toy_getLiteralDictionary(TOY_AS_DICTIONARY(rhs), TOY_AS_DICTIONARY(lhs)->entries[i].key); //TODO: could be more efficient
+					if (!Toy_literalsAreEqual(TOY_AS_DICTIONARY(lhs)->entries[i].value, val)) {
+						Toy_freeLiteral(val);
 						return false;
 					}
-					freeLiteral(val);
+					Toy_freeLiteral(val);
 				}
 			}
 
 			return true;
 
-		case LITERAL_FUNCTION:
-		case LITERAL_FUNCTION_NATIVE:
+		case TOY_LITERAL_FUNCTION:
+		case TOY_LITERAL_FUNCTION_NATIVE:
 			return false; //functions are never equal
 		break;
 
-		case LITERAL_IDENTIFIER:
+		case TOY_LITERAL_IDENTIFIER:
 			//check shortcuts
-			if (HASH_I(lhs) != HASH_I(rhs)) {
+			if (TOY_HASH_I(lhs) != TOY_HASH_I(rhs)) {
 				return false;
 			}
 
-			return equalsRefString(AS_IDENTIFIER(lhs), AS_IDENTIFIER(rhs));
+			return Toy_equalsRefString(TOY_AS_IDENTIFIER(lhs), TOY_AS_IDENTIFIER(rhs));
 
-		case LITERAL_TYPE:
+		case TOY_LITERAL_TYPE:
 			//check types
-			if (AS_TYPE(lhs).typeOf != AS_TYPE(rhs).typeOf) {
+			if (TOY_AS_TYPE(lhs).typeOf != TOY_AS_TYPE(rhs).typeOf) {
 				return false;
 			}
 
 			//const don't match
-			if (AS_TYPE(lhs).constant != AS_TYPE(rhs).constant) {
+			if (TOY_AS_TYPE(lhs).constant != TOY_AS_TYPE(rhs).constant) {
 				return false;
 			}
 
 			//check subtypes
-			if (AS_TYPE(lhs).count != AS_TYPE(rhs).count) {
+			if (TOY_AS_TYPE(lhs).count != TOY_AS_TYPE(rhs).count) {
 				return false;
 			}
 
 			//check array|dictionary signatures are the same (in order)
-			if (AS_TYPE(lhs).typeOf == LITERAL_ARRAY || AS_TYPE(lhs).typeOf == LITERAL_DICTIONARY) {
-				for (int i = 0; i < AS_TYPE(lhs).count; i++) {
-					if (!literalsAreEqual(((Literal*)(AS_TYPE(lhs).subtypes))[i], ((Literal*)(AS_TYPE(rhs).subtypes))[i])) {
+			if (TOY_AS_TYPE(lhs).typeOf == TOY_LITERAL_ARRAY || TOY_AS_TYPE(lhs).typeOf == TOY_LITERAL_DICTIONARY) {
+				for (int i = 0; i < TOY_AS_TYPE(lhs).count; i++) {
+					if (!Toy_literalsAreEqual(((Toy_Literal*)(TOY_AS_TYPE(lhs).subtypes))[i], ((Toy_Literal*)(TOY_AS_TYPE(rhs).subtypes))[i])) {
 						return false;
 					}
 				}
 			}
 			return true;
 
-		case LITERAL_OPAQUE:
+		case TOY_LITERAL_OPAQUE:
 			return false; //IDK what this is!
 
-		case LITERAL_ANY:
+		case TOY_LITERAL_ANY:
 			return true;
 
-		case LITERAL_FUNCTION_INTERMEDIATE:
-			fprintf(stderr, ERROR "[internal] Can't compare intermediate functions\n" RESET);
+		case TOY_LITERAL_FUNCTION_INTERMEDIATE:
+			fprintf(stderr, TOY_CC_ERROR "[internal] Can't compare intermediate functions\n" TOY_CC_RESET);
 			return false;
 
-		case LITERAL_INDEX_BLANK:
+		case TOY_LITERAL_INDEX_BLANK:
 			return false;
 
 		default:
 			//should never be seen
-			fprintf(stderr, ERROR "[internal] Unrecognized literal type in equality: %d\n" RESET, lhs.type);
+			fprintf(stderr, TOY_CC_ERROR "[internal] Unrecognized literal type in equality: %d\n" TOY_CC_RESET, lhs.type);
 			return false;
 	}
 
 	return false;
 }
 
-int hashLiteral(Literal lit) {
+int Toy_hashLiteral(Toy_Literal lit) {
 	switch(lit.type) {
-		case LITERAL_NULL:
+		case TOY_LITERAL_NULL:
 			return 0;
 
-		case LITERAL_BOOLEAN:
-			return AS_BOOLEAN(lit) ? 1 : 0;
+		case TOY_LITERAL_BOOLEAN:
+			return TOY_AS_BOOLEAN(lit) ? 1 : 0;
 
-		case LITERAL_INTEGER:
-			return hashUInt((unsigned int)AS_INTEGER(lit));
+		case TOY_LITERAL_INTEGER:
+			return hashUInt((unsigned int)TOY_AS_INTEGER(lit));
 
-		case LITERAL_FLOAT:
-			return hashUInt(*(unsigned int*)(&AS_FLOAT(lit)));
+		case TOY_LITERAL_FLOAT:
+			return hashUInt(*(unsigned int*)(&TOY_AS_FLOAT(lit)));
 
-		case LITERAL_STRING:
-			return hashString(toCString(AS_STRING(lit)), lengthRefString(AS_STRING(lit)));
+		case TOY_LITERAL_STRING:
+			return hashString(Toy_toCString(TOY_AS_STRING(lit)), Toy_lengthRefString(TOY_AS_STRING(lit)));
 
-		case LITERAL_ARRAY: {
+		case TOY_LITERAL_ARRAY: {
 			unsigned int res = 0;
-			for (int i = 0; i < AS_ARRAY(lit)->count; i++) {
-				res += hashLiteral(AS_ARRAY(lit)->literals[i]);
+			for (int i = 0; i < TOY_AS_ARRAY(lit)->count; i++) {
+				res += Toy_hashLiteral(TOY_AS_ARRAY(lit)->literals[i]);
 			}
 			return hashUInt(res);
 		}
 
-		case LITERAL_DICTIONARY: {
+		case TOY_LITERAL_DICTIONARY: {
 			unsigned int res = 0;
-			for (int i = 0; i < AS_DICTIONARY(lit)->capacity; i++) {
-				if (!IS_NULL(AS_DICTIONARY(lit)->entries[i].key)) { //only hash non-null keys
-					res += hashLiteral(AS_DICTIONARY(lit)->entries[i].key);
-					res += hashLiteral(AS_DICTIONARY(lit)->entries[i].value);
+			for (int i = 0; i < TOY_AS_DICTIONARY(lit)->capacity; i++) {
+				if (!TOY_IS_NULL(TOY_AS_DICTIONARY(lit)->entries[i].key)) { //only hash non-null keys
+					res += Toy_hashLiteral(TOY_AS_DICTIONARY(lit)->entries[i].key);
+					res += Toy_hashLiteral(TOY_AS_DICTIONARY(lit)->entries[i].value);
 				}
 			}
 			return hashUInt(res);
 		}
 
-		case LITERAL_FUNCTION:
-		case LITERAL_FUNCTION_NATIVE:
+		case TOY_LITERAL_FUNCTION:
+		case TOY_LITERAL_FUNCTION_NATIVE:
 			return 0; //can't hash these
 
-		case LITERAL_IDENTIFIER:
-			return HASH_I(lit); //pre-computed
+		case TOY_LITERAL_IDENTIFIER:
+			return TOY_HASH_I(lit); //pre-computed
 
-		case LITERAL_TYPE:
-			return AS_TYPE(lit).typeOf; //nothing else I can do
+		case TOY_LITERAL_TYPE:
+			return TOY_AS_TYPE(lit).typeOf; //nothing else I can do
 
-		case LITERAL_OPAQUE:
-		case LITERAL_ANY:
+		case TOY_LITERAL_OPAQUE:
+		case TOY_LITERAL_ANY:
 			return -1;
 
 		default:
 			//should never bee seen
-			fprintf(stderr, ERROR "[internal] Unrecognized literal type in hash: %d\n" RESET, lit.type);
+			fprintf(stderr, TOY_CC_ERROR "[internal] Unrecognized literal type in hash: %d\n" TOY_CC_RESET, lit.type);
 			return 0;
 	}
 }
@@ -420,8 +420,8 @@ static void printToBuffer(const char* str) {
 	while (strlen(str) + globalPrintCount + 1 > globalPrintCapacity) {
 		int oldCapacity = globalPrintCapacity;
 
-		globalPrintCapacity = GROW_CAPACITY(globalPrintCapacity);
-		globalPrintBuffer = GROW_ARRAY(char, globalPrintBuffer, oldCapacity, globalPrintCapacity);
+		globalPrintCapacity = TOY_GROW_CAPACITY(globalPrintCapacity);
+		globalPrintBuffer = TOY_GROW_ARRAY(char, globalPrintBuffer, oldCapacity, globalPrintCapacity);
 	}
 
 	snprintf(globalPrintBuffer + globalPrintCount, strlen(str) + 1, "%s", str);
@@ -429,55 +429,55 @@ static void printToBuffer(const char* str) {
 }
 
 //exposed functions
-void printLiteral(Literal literal) {
-	printLiteralCustom(literal, stdoutWrapper);
+void Toy_printLiteral(Toy_Literal literal) {
+	Toy_printLiteralCustom(literal, stdoutWrapper);
 }
 
-void printLiteralCustom(Literal literal, void (printFn)(const char*)) {
+void Toy_printLiteralCustom(Toy_Literal literal, void (printFn)(const char*)) {
 	switch(literal.type) {
-		case LITERAL_NULL:
+		case TOY_LITERAL_NULL:
 			printFn("null");
 		break;
 
-		case LITERAL_BOOLEAN:
-			printFn(AS_BOOLEAN(literal) ? "true" : "false");
+		case TOY_LITERAL_BOOLEAN:
+			printFn(TOY_AS_BOOLEAN(literal) ? "true" : "false");
 		break;
 
-		case LITERAL_INTEGER: {
+		case TOY_LITERAL_INTEGER: {
 			char buffer[256];
-			snprintf(buffer, 256, "%d", AS_INTEGER(literal));
+			snprintf(buffer, 256, "%d", TOY_AS_INTEGER(literal));
 			printFn(buffer);
 		}
 		break;
 
-		case LITERAL_FLOAT: {
+		case TOY_LITERAL_FLOAT: {
 			char buffer[256];
 
-			if (AS_FLOAT(literal) - (int)AS_FLOAT(literal)) {
-				snprintf(buffer, 256, "%g", AS_FLOAT(literal));
+			if (TOY_AS_FLOAT(literal) - (int)TOY_AS_FLOAT(literal)) {
+				snprintf(buffer, 256, "%g", TOY_AS_FLOAT(literal));
 			}
 			else {
-				snprintf(buffer, 256, "%.1f", AS_FLOAT(literal));
+				snprintf(buffer, 256, "%.1f", TOY_AS_FLOAT(literal));
 			}
 
 			printFn(buffer);
 		}
 		break;
 
-		case LITERAL_STRING: {
-			char buffer[MAX_STRING_LENGTH];
+		case TOY_LITERAL_STRING: {
+			char buffer[TOY_MAX_STRING_LENGTH];
 			if (!quotes) {
-				snprintf(buffer, MAX_STRING_LENGTH, "%.*s", lengthRefString(AS_STRING(literal)), toCString(AS_STRING(literal)));
+				snprintf(buffer, TOY_MAX_STRING_LENGTH, "%.*s", Toy_lengthRefString(TOY_AS_STRING(literal)), Toy_toCString(TOY_AS_STRING(literal)));
 			}
 			else {
-				snprintf(buffer, MAX_STRING_LENGTH, "%c%.*s%c", quotes, lengthRefString(AS_STRING(literal)), toCString(AS_STRING(literal)), quotes);
+				snprintf(buffer, TOY_MAX_STRING_LENGTH, "%c%.*s%c", quotes, Toy_lengthRefString(TOY_AS_STRING(literal)), Toy_toCString(TOY_AS_STRING(literal)), quotes);
 			}
 			printFn(buffer);
 		}
 		break;
 
-		case LITERAL_ARRAY: {
-			LiteralArray* ptr = AS_ARRAY(literal);
+		case TOY_LITERAL_ARRAY: {
+			Toy_LiteralArray* ptr = TOY_AS_ARRAY(literal);
 
 			//hold potential parent-call buffers on the C stack
 			char* cacheBuffer = globalPrintBuffer;
@@ -491,7 +491,7 @@ void printLiteralCustom(Literal literal, void (printFn)(const char*)) {
 			printToBuffer("[");
 			for (int i = 0; i < ptr->count; i++) {
 				quotes = '"';
-				printLiteralCustom(ptr->literals[i], printToBuffer);
+				Toy_printLiteralCustom(ptr->literals[i], printToBuffer);
 
 				if (i + 1 < ptr->count) {
 					printToBuffer(",");
@@ -510,13 +510,13 @@ void printLiteralCustom(Literal literal, void (printFn)(const char*)) {
 
 			//finally, output and cleanup
 			printFn(printBuffer);
-			FREE_ARRAY(char, printBuffer, printCapacity);
+			TOY_FREE_ARRAY(char, printBuffer, printCapacity);
 			quotes = 0;
 		}
 		break;
 
-		case LITERAL_DICTIONARY: {
-			LiteralDictionary* ptr = AS_DICTIONARY(literal);
+		case TOY_LITERAL_DICTIONARY: {
+			Toy_LiteralDictionary* ptr = TOY_AS_DICTIONARY(literal);
 
 			//hold potential parent-call buffers on the C stack
 			char* cacheBuffer = globalPrintBuffer;
@@ -530,7 +530,7 @@ void printLiteralCustom(Literal literal, void (printFn)(const char*)) {
 			int delimCount = 0;
 			printToBuffer("[");
 			for (int i = 0; i < ptr->capacity; i++) {
-				if (IS_NULL(ptr->entries[i].key)) {
+				if (TOY_IS_NULL(ptr->entries[i].key)) {
 					continue;
 				}
 
@@ -539,10 +539,10 @@ void printLiteralCustom(Literal literal, void (printFn)(const char*)) {
 				}
 
 				quotes = '"';
-				printLiteralCustom(ptr->entries[i].key, printToBuffer);
+				Toy_printLiteralCustom(ptr->entries[i].key, printToBuffer);
 				printToBuffer(":");
 				quotes = '"';
-				printLiteralCustom(ptr->entries[i].value, printToBuffer);
+				Toy_printLiteralCustom(ptr->entries[i].value, printToBuffer);
 			}
 
 			//empty dicts MUST have a ":" printed
@@ -563,24 +563,24 @@ void printLiteralCustom(Literal literal, void (printFn)(const char*)) {
 
 			//finally, output and cleanup
 			printFn(printBuffer);
-			FREE_ARRAY(char, printBuffer, printCapacity);
+			TOY_FREE_ARRAY(char, printBuffer, printCapacity);
 			quotes = 0;
 		}
 		break;
 
-		case LITERAL_FUNCTION:
-		case LITERAL_FUNCTION_NATIVE:
+		case TOY_LITERAL_FUNCTION:
+		case TOY_LITERAL_FUNCTION_NATIVE:
 			printFn("(function)");
 		break;
 
-		case LITERAL_IDENTIFIER: {
+		case TOY_LITERAL_IDENTIFIER: {
 			char buffer[256];
-			snprintf(buffer, 256, "%.*s", lengthRefString(AS_IDENTIFIER(literal)), toCString(AS_IDENTIFIER(literal)));
+			snprintf(buffer, 256, "%.*s", Toy_lengthRefString(TOY_AS_IDENTIFIER(literal)), Toy_toCString(TOY_AS_IDENTIFIER(literal)));
 			printFn(buffer);
 		}
 		break;
 
-		case LITERAL_TYPE: {
+		case TOY_LITERAL_TYPE: {
 			//hold potential parent-call buffers on the C stack
 			char* cacheBuffer = globalPrintBuffer;
 			globalPrintBuffer = NULL;
@@ -592,78 +592,78 @@ void printLiteralCustom(Literal literal, void (printFn)(const char*)) {
 			//print the type correctly
 			printToBuffer("<");
 
-			switch(AS_TYPE(literal).typeOf) {
-				case LITERAL_NULL:
+			switch(TOY_AS_TYPE(literal).typeOf) {
+				case TOY_LITERAL_NULL:
 					printToBuffer("null");
 				break;
 
-				case LITERAL_BOOLEAN:
+				case TOY_LITERAL_BOOLEAN:
 					printToBuffer("bool");
 				break;
 
-				case LITERAL_INTEGER:
+				case TOY_LITERAL_INTEGER:
 					printToBuffer("int");
 				break;
 
-				case LITERAL_FLOAT:
+				case TOY_LITERAL_FLOAT:
 					printToBuffer("float");
 				break;
 
-				case LITERAL_STRING:
+				case TOY_LITERAL_STRING:
 					printToBuffer("string");
 				break;
 
-				case LITERAL_ARRAY:
+				case TOY_LITERAL_ARRAY:
 					//print all in the array
 					printToBuffer("[");
-					for (int i = 0; i < AS_TYPE(literal).count; i++) {
-						printLiteralCustom(((Literal*)(AS_TYPE(literal).subtypes))[i], printToBuffer);
+					for (int i = 0; i < TOY_AS_TYPE(literal).count; i++) {
+						Toy_printLiteralCustom(((Toy_Literal*)(TOY_AS_TYPE(literal).subtypes))[i], printToBuffer);
 					}
 					printToBuffer("]");
 				break;
 
-				case LITERAL_DICTIONARY:
+				case TOY_LITERAL_DICTIONARY:
 					printToBuffer("[");
 
-					for (int i = 0; i < AS_TYPE(literal).count; i += 2) {
-						printLiteralCustom(((Literal*)(AS_TYPE(literal).subtypes))[i], printToBuffer);
+					for (int i = 0; i < TOY_AS_TYPE(literal).count; i += 2) {
+						Toy_printLiteralCustom(((Toy_Literal*)(TOY_AS_TYPE(literal).subtypes))[i], printToBuffer);
 						printToBuffer(":");
-						printLiteralCustom(((Literal*)(AS_TYPE(literal).subtypes))[i + 1], printToBuffer);
+						Toy_printLiteralCustom(((Toy_Literal*)(TOY_AS_TYPE(literal).subtypes))[i + 1], printToBuffer);
 					}
 					printToBuffer("]");
 				break;
 
-				case LITERAL_FUNCTION:
+				case TOY_LITERAL_FUNCTION:
 					printToBuffer("function");
 				break;
 
-				case LITERAL_FUNCTION_NATIVE:
+				case TOY_LITERAL_FUNCTION_NATIVE:
 					printToBuffer("native");
 				break;
 
-				case LITERAL_IDENTIFIER:
+				case TOY_LITERAL_IDENTIFIER:
 					printToBuffer("identifier");
 				break;
 
-				case LITERAL_TYPE:
+				case TOY_LITERAL_TYPE:
 					printToBuffer("type");
 				break;
 
-				case LITERAL_OPAQUE:
+				case TOY_LITERAL_OPAQUE:
 					printToBuffer("opaque");
 				break;
 
-				case LITERAL_ANY:
+				case TOY_LITERAL_ANY:
 					printToBuffer("any");
 				break;
 
 				default:
 					//should never be seen
-					fprintf(stderr, ERROR "[internal] Unrecognized literal type in print type: %d\n" RESET, AS_TYPE(literal).typeOf);
+					fprintf(stderr, TOY_CC_ERROR "[internal] Unrecognized literal type in print type: %d\n" TOY_CC_RESET, TOY_AS_TYPE(literal).typeOf);
 			}
 
 			//const (printed last)
-			if (AS_TYPE(literal).constant) {
+			if (TOY_AS_TYPE(literal).constant) {
 				printToBuffer(" const");
 			}
 
@@ -680,26 +680,26 @@ void printLiteralCustom(Literal literal, void (printFn)(const char*)) {
 
 			//finally, output and cleanup
 			printFn(printBuffer);
-			FREE_ARRAY(char, printBuffer, printCapacity);
+			TOY_FREE_ARRAY(char, printBuffer, printCapacity);
 			quotes = 0;
 		}
 		break;
 
-		case LITERAL_TYPE_INTERMEDIATE:
-		case LITERAL_FUNCTION_INTERMEDIATE:
+		case TOY_LITERAL_TYPE_INTERMEDIATE:
+		case TOY_LITERAL_FUNCTION_INTERMEDIATE:
 			printFn("Unprintable literal found");
 		break;
 
-		case LITERAL_OPAQUE:
+		case TOY_LITERAL_OPAQUE:
 			printFn("(opaque)");
 		break;
 
-		case LITERAL_ANY:
+		case TOY_LITERAL_ANY:
 			printFn("(any)");
 		break;
 
 		default:
 			//should never be seen
-			fprintf(stderr, ERROR "[internal] Unrecognized literal type in print: %d\n" RESET, literal.type);
+			fprintf(stderr, TOY_CC_ERROR "[internal] Unrecognized literal type in print: %d\n" TOY_CC_RESET, literal.type);
 	}
 }

source/toy_literal.h

@@ -2,41 +2,41 @@
 
 #include "toy_common.h"
 
-#include "refstring.h"
+#include "toy_refstring.h"
 
 #include <string.h>
 
 typedef enum {
-	LITERAL_NULL,
-	LITERAL_BOOLEAN,
-	LITERAL_INTEGER,
-	LITERAL_FLOAT,
-	LITERAL_STRING,
-	LITERAL_ARRAY,
-	LITERAL_DICTIONARY,
-	LITERAL_FUNCTION,
-	LITERAL_IDENTIFIER,
-	LITERAL_TYPE,
-	LITERAL_OPAQUE,
-	LITERAL_ANY,
+	TOY_LITERAL_NULL,
+	TOY_LITERAL_BOOLEAN,
+	TOY_LITERAL_INTEGER,
+	TOY_LITERAL_FLOAT,
+	TOY_LITERAL_STRING,
+	TOY_LITERAL_ARRAY,
+	TOY_LITERAL_DICTIONARY,
+	TOY_LITERAL_FUNCTION,
+	TOY_LITERAL_IDENTIFIER,
+	TOY_LITERAL_TYPE,
+	TOY_LITERAL_OPAQUE,
+	TOY_LITERAL_ANY,
 
 	//these are meta-level types - not for general use
-	LITERAL_TYPE_INTERMEDIATE, //used to process types in the compiler only
-	LITERAL_DICTIONARY_INTERMEDIATE, //used to process dictionaries in the compiler only
-	LITERAL_FUNCTION_INTERMEDIATE, //used to process functions in the compiler only
-	LITERAL_FUNCTION_ARG_REST, //used to process function rest parameters only
-	LITERAL_FUNCTION_NATIVE, //for handling native functions only
-	LITERAL_INDEX_BLANK, //for blank indexing i.e. arr[:]
-} LiteralType;
+	TOY_LITERAL_TYPE_INTERMEDIATE, //used to process types in the compiler only
+	TOY_LITERAL_DICTIONARY_INTERMEDIATE, //used to process dictionaries in the compiler only
+	TOY_LITERAL_FUNCTION_INTERMEDIATE, //used to process functions in the compiler only
+	TOY_LITERAL_FUNCTION_ARG_REST, //used to process function rest parameters only
+	TOY_LITERAL_FUNCTION_NATIVE, //for handling native functions only
+	TOY_LITERAL_INDEX_BLANK, //for blank indexing i.e. arr[:]
+} Toy_LiteralType;
 
 typedef struct {
-	LiteralType type;
+	Toy_LiteralType type;
 	union {
 		bool boolean;
 		int integer;
 		float number;
 		struct {
-			RefString* ptr;
+			Toy_RefString* ptr;
 			//string hash?
 		} string;
 
@@ -50,12 +50,12 @@ typedef struct {
 		} function;
 
 		struct { //for variable names
-            RefString* ptr;
+            Toy_RefString* ptr;
 			int hash;
         } identifier;
 
 		struct {
-			LiteralType typeOf; //no longer a mask
+			Toy_LiteralType typeOf; //no longer a mask
 			bool constant;
 			void* subtypes; //for nested types caused by compounds
 			int capacity;
@@ -67,67 +67,67 @@ typedef struct {
 			int tag; //TODO: remove tags?
 		} opaque;
 	} as;
-} Literal;
+} Toy_Literal;
 
-#define IS_NULL(value)						((value).type == LITERAL_NULL)
-#define IS_BOOLEAN(value)					((value).type == LITERAL_BOOLEAN)
-#define IS_INTEGER(value)					((value).type == LITERAL_INTEGER)
-#define IS_FLOAT(value)						((value).type == LITERAL_FLOAT)
-#define IS_STRING(value)					((value).type == LITERAL_STRING)
-#define IS_ARRAY(value)						((value).type == LITERAL_ARRAY)
-#define IS_DICTIONARY(value)				((value).type == LITERAL_DICTIONARY)
-#define IS_FUNCTION(value)					((value).type == LITERAL_FUNCTION)
-#define IS_FUNCTION_NATIVE(value)			((value).type == LITERAL_FUNCTION_NATIVE)
-#define IS_IDENTIFIER(value)				((value).type == LITERAL_IDENTIFIER)
-#define IS_TYPE(value)						((value).type == LITERAL_TYPE)
-#define IS_OPAQUE(value)					((value).type == LITERAL_OPAQUE)
+#define TOY_IS_NULL(value)						((value).type == TOY_LITERAL_NULL)
+#define TOY_IS_BOOLEAN(value)					((value).type == TOY_LITERAL_BOOLEAN)
+#define TOY_IS_INTEGER(value)					((value).type == TOY_LITERAL_INTEGER)
+#define TOY_IS_FLOAT(value)						((value).type == TOY_LITERAL_FLOAT)
+#define TOY_IS_STRING(value)					((value).type == TOY_LITERAL_STRING)
+#define TOY_IS_ARRAY(value)						((value).type == TOY_LITERAL_ARRAY)
+#define TOY_IS_DICTIONARY(value)				((value).type == TOY_LITERAL_DICTIONARY)
+#define TOY_IS_FUNCTION(value)					((value).type == TOY_LITERAL_FUNCTION)
+#define TOY_IS_FUNCTION_NATIVE(value)			((value).type == TOY_LITERAL_FUNCTION_NATIVE)
+#define TOY_IS_IDENTIFIER(value)				((value).type == TOY_LITERAL_IDENTIFIER)
+#define TOY_IS_TYPE(value)						((value).type == TOY_LITERAL_TYPE)
+#define TOY_IS_OPAQUE(value)					((value).type == TOY_LITERAL_OPAQUE)
 
-#define AS_BOOLEAN(value)					((value).as.boolean)
-#define AS_INTEGER(value)					((value).as.integer)
-#define AS_FLOAT(value)						((value).as.number)
-#define AS_STRING(value)					((value).as.string.ptr)
-#define AS_ARRAY(value)						((LiteralArray*)((value).as.array))
-#define AS_DICTIONARY(value)				((LiteralDictionary*)((value).as.dictionary))
-#define AS_FUNCTION(value)					((value).as.function)
-#define AS_IDENTIFIER(value)				((value).as.identifier.ptr)
-#define AS_TYPE(value)						((value).as.type)
-#define AS_OPAQUE(value)					((value).as.opaque.ptr)
+#define TOY_AS_BOOLEAN(value)					((value).as.boolean)
+#define TOY_AS_INTEGER(value)					((value).as.integer)
+#define TOY_AS_FLOAT(value)						((value).as.number)
+#define TOY_AS_STRING(value)					((value).as.string.ptr)
+#define TOY_AS_ARRAY(value)						((Toy_LiteralArray*)((value).as.array))
+#define TOY_AS_DICTIONARY(value)				((Toy_LiteralDictionary*)((value).as.dictionary))
+#define TOY_AS_FUNCTION(value)					((value).as.function)
+#define TOY_AS_IDENTIFIER(value)				((value).as.identifier.ptr)
+#define TOY_AS_TYPE(value)						((value).as.type)
+#define TOY_AS_OPAQUE(value)					((value).as.opaque.ptr)
 
-#define TO_NULL_LITERAL						((Literal){LITERAL_NULL,		{ .integer = 0 }})
-#define TO_BOOLEAN_LITERAL(value)			((Literal){LITERAL_BOOLEAN,		{ .boolean = value }})
-#define TO_INTEGER_LITERAL(value)			((Literal){LITERAL_INTEGER,		{ .integer = value }})
-#define TO_FLOAT_LITERAL(value)				((Literal){LITERAL_FLOAT,		{ .number = value }})
-#define TO_STRING_LITERAL(value)			_toStringLiteral(value)
-#define TO_ARRAY_LITERAL(value)				((Literal){LITERAL_ARRAY,		{ .array = value }})
-#define TO_DICTIONARY_LITERAL(value)		((Literal){LITERAL_DICTIONARY,	{ .dictionary = value }})
-#define TO_FUNCTION_LITERAL(value, l)		((Literal){LITERAL_FUNCTION,	{ .function.bytecode = value, .function.scope = NULL, .function.length = l }})
-#define TO_IDENTIFIER_LITERAL(value)		_toIdentifierLiteral(value)
-#define TO_TYPE_LITERAL(value, c)			((Literal){ LITERAL_TYPE,		{ .type.typeOf = value, .type.constant = c, .type.subtypes = NULL, .type.capacity = 0, .type.count = 0 }})
-#define TO_OPAQUE_LITERAL(value, t)			((Literal){ LITERAL_OPAQUE,		{ .opaque.ptr = value, .opaque.tag = t }})
+#define TOY_TO_NULL_LITERAL						((Toy_Literal){TOY_LITERAL_NULL,		{ .integer = 0 }})
+#define TOY_TO_BOOLEAN_LITERAL(value)			((Toy_Literal){TOY_LITERAL_BOOLEAN,		{ .boolean = value }})
+#define TOY_TO_INTEGER_LITERAL(value)			((Toy_Literal){TOY_LITERAL_INTEGER,		{ .integer = value }})
+#define TOY_TO_FLOAT_LITERAL(value)				((Toy_Literal){TOY_LITERAL_FLOAT,		{ .number = value }})
+#define TOY_TO_STRING_LITERAL(value)			Toy_private_toStringLiteral(value)
+#define TOY_TO_ARRAY_LITERAL(value)				((Toy_Literal){TOY_LITERAL_ARRAY,		{ .array = value }})
+#define TOY_TO_DICTIONARY_LITERAL(value)		((Toy_Literal){TOY_LITERAL_DICTIONARY,	{ .dictionary = value }})
+#define TOY_TO_FUNCTION_LITERAL(value, l)		((Toy_Literal){TOY_LITERAL_FUNCTION,	{ .function.bytecode = value, .function.scope = NULL, .function.length = l }})
+#define TOY_TO_IDENTIFIER_LITERAL(value)		Toy_private_toIdentifierLiteral(value)
+#define TOY_TO_TYPE_LITERAL(value, c)			((Toy_Literal){ TOY_LITERAL_TYPE,		{ .type.typeOf = value, .type.constant = c, .type.subtypes = NULL, .type.capacity = 0, .type.count = 0 }})
+#define TOY_TO_OPAQUE_LITERAL(value, t)			((Toy_Literal){ TOY_LITERAL_OPAQUE,		{ .opaque.ptr = value, .opaque.tag = t }})
 
 //BUGFIX: For blank indexing
-#define IS_INDEX_BLANK(value)				((value).type == LITERAL_INDEX_BLANK)
-#define TO_INDEX_BLANK_LITERAL				((Literal){LITERAL_INDEX_BLANK,	{ .integer = 0 }})
+#define TOY_IS_INDEX_BLANK(value)				((value).type == TOY_LITERAL_INDEX_BLANK)
+#define TOY_TO_INDEX_BLANK_LITERAL				((Toy_Literal){TOY_LITERAL_INDEX_BLANK,	{ .integer = 0 }})
 
-TOY_API void freeLiteral(Literal literal);
+TOY_API void Toy_freeLiteral(Toy_Literal literal);
 
-#define IS_TRUTHY(x) _isTruthy(x)
+#define TOY_IS_TRUTHY(x) Toy_private_isTruthy(x)
 
-#define MAX_STRING_LENGTH					4096
-#define HASH_I(lit)							((lit).as.identifier.hash)
-#define TYPE_PUSH_SUBTYPE(lit, subtype)		_typePushSubtype(lit, subtype)
-#define OPAQUE_TAG(o)						o.as.opaque.tag
+#define TOY_MAX_STRING_LENGTH					4096
+#define TOY_HASH_I(lit)							((lit).as.identifier.hash)
+#define TOY_TYPE_PUSH_SUBTYPE(lit, subtype)		Toy_private_typePushSubtype(lit, subtype)
+#define TOY_GET_OPAQUE_TAG(o)						o.as.opaque.tag
 
 //BUGFIX: macros are not functions
-TOY_API bool _isTruthy(Literal x);
-TOY_API Literal _toStringLiteral(RefString* ptr);
-TOY_API Literal _toIdentifierLiteral(RefString* ptr);
-TOY_API Literal* _typePushSubtype(Literal* lit, Literal subtype);
+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);
 
 //utils
-TOY_API Literal copyLiteral(Literal original);
-TOY_API bool literalsAreEqual(Literal lhs, Literal rhs);
-TOY_API int hashLiteral(Literal lit);
+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);
 
-TOY_API void printLiteral(Literal literal);
-TOY_API void printLiteralCustom(Literal literal, void (printFn)(const char*));
+TOY_API void Toy_printLiteral(Toy_Literal literal);
+TOY_API void Toy_printLiteralCustom(Toy_Literal literal, void (printFn)(const char*));

source/toy_literal_array.c

@@ -1,56 +1,56 @@
-#include "literal_array.h"
+#include "toy_literal_array.h"
 
-#include "memory.h"
+#include "toy_memory.h"
 
 #include <stdio.h>
 #include <string.h>
 
 //exposed functions
-void initLiteralArray(LiteralArray* array) {
+void Toy_initLiteralArray(Toy_LiteralArray* array) {
 	array->capacity = 0;
 	array->count = 0;
 	array->literals = NULL;
 }
 
-void freeLiteralArray(LiteralArray* array) {
+void Toy_freeLiteralArray(Toy_LiteralArray* array) {
 	//clean up memory
 	for(int i = 0; i < array->count; i++) {
-		freeLiteral(array->literals[i]);
+		Toy_freeLiteral(array->literals[i]);
 	}
 
-	FREE_ARRAY(Literal, array->literals, array->capacity);
-	initLiteralArray(array);
+	TOY_FREE_ARRAY(Toy_Literal, array->literals, array->capacity);
+	Toy_initLiteralArray(array);
 }
 
-int pushLiteralArray(LiteralArray* array, Literal literal) {
+int Toy_pushLiteralArray(Toy_LiteralArray* array, Toy_Literal literal) {
 	if (array->capacity < array->count + 1) {
 		int oldCapacity = array->capacity;
 
-		array->capacity = GROW_CAPACITY(oldCapacity);
-		array->literals = GROW_ARRAY(Literal, array->literals, oldCapacity, array->capacity);
+		array->capacity = TOY_GROW_CAPACITY(oldCapacity);
+		array->literals = TOY_GROW_ARRAY(Toy_Literal, array->literals, oldCapacity, array->capacity);
 	}
 
-	array->literals[array->count] = copyLiteral(literal);
+	array->literals[array->count] = Toy_copyLiteral(literal);
 	return array->count++;
 }
 
-Literal popLiteralArray(LiteralArray* array) {
+Toy_Literal Toy_popLiteralArray(Toy_LiteralArray* array) {
 	if (array->count <= 0) {
-		return TO_NULL_LITERAL;
+		return TOY_TO_NULL_LITERAL;
 	}
 
 	//get the return
-	Literal ret = array->literals[array->count-1];
+	Toy_Literal ret = array->literals[array->count-1];
 
 	//null the existing data
-	array->literals[array->count-1] = TO_NULL_LITERAL;
+	array->literals[array->count-1] = TOY_TO_NULL_LITERAL;
 
 	array->count--;
 	return ret;
 }
 
 //find a literal in the array that matches the "literal" argument
-int findLiteralIndex(LiteralArray* array, Literal literal) {
+int Toy_findLiteralIndex(Toy_LiteralArray* array, Toy_Literal literal) {
 	for (int i = 0; i < array->count; i++) {
 		//not the same type
 		if (array->literals[i].type != literal.type) {
@@ -58,7 +58,7 @@ int findLiteralIndex(LiteralArray* array, Literal literal) {
 		}
 
 		//types match?
-		if (literalsAreEqual(array->literals[i], literal)) {
+		if (Toy_literalsAreEqual(array->literals[i], literal)) {
 			return i;
 		}
 	}
@@ -66,33 +66,33 @@ int findLiteralIndex(LiteralArray* array, Literal literal) {
 	return -1;
 }
 
-bool setLiteralArray(LiteralArray* array, Literal index, Literal value) {
-	if (!IS_INTEGER(index)) {
+bool Toy_setLiteralArray(Toy_LiteralArray* array, Toy_Literal index, Toy_Literal value) {
+	if (!TOY_IS_INTEGER(index)) {
 		return false;
 	}
 
-	int idx = AS_INTEGER(index);
+	int idx = TOY_AS_INTEGER(index);
 
 	if (idx < 0 || idx >= array->count) {
 		return false;
 	}
 
-	freeLiteral(array->literals[idx]);
-	array->literals[idx] = copyLiteral(value);
+	Toy_freeLiteral(array->literals[idx]);
+	array->literals[idx] = Toy_copyLiteral(value);
 
 	return true;
 }
 
-Literal getLiteralArray(LiteralArray* array, Literal index) {
-	if (!IS_INTEGER(index)) {
-		return TO_NULL_LITERAL;
+Toy_Literal Toy_getLiteralArray(Toy_LiteralArray* array, Toy_Literal index) {
+	if (!TOY_IS_INTEGER(index)) {
+		return TOY_TO_NULL_LITERAL;
 	}
 
-	int idx = AS_INTEGER(index);
+	int idx = TOY_AS_INTEGER(index);
 
 	if (idx < 0 || idx >= array->count) {
-		return TO_NULL_LITERAL;
+		return TOY_TO_NULL_LITERAL;
 	}
 
-	return copyLiteral(array->literals[idx]);
+	return Toy_copyLiteral(array->literals[idx]);
 }

source/toy_literal_array.h

@@ -2,19 +2,19 @@
 
 #include "toy_common.h"
 
-#include "literal.h"
+#include "toy_literal.h"
 
-typedef struct LiteralArray {
-	Literal* literals;
+typedef struct Toy_LiteralArray {
+	Toy_Literal* literals;
 	int capacity;
 	int count;
-} LiteralArray;
+} Toy_LiteralArray;
 
-TOY_API void initLiteralArray(LiteralArray* array);
-TOY_API void freeLiteralArray(LiteralArray* array);
-TOY_API int pushLiteralArray(LiteralArray* array, Literal literal);
-TOY_API Literal popLiteralArray(LiteralArray* array);
-TOY_API bool setLiteralArray(LiteralArray* array, Literal index, Literal value);
-TOY_API Literal getLiteralArray(LiteralArray* array, Literal index);
+TOY_API void Toy_initLiteralArray(Toy_LiteralArray* array);
+TOY_API void Toy_freeLiteralArray(Toy_LiteralArray* array);
+TOY_API int Toy_pushLiteralArray(Toy_LiteralArray* array, Toy_Literal literal);
+TOY_API Toy_Literal Toy_popLiteralArray(Toy_LiteralArray* array);
+TOY_API bool Toy_setLiteralArray(Toy_LiteralArray* array, Toy_Literal index, Toy_Literal value);
+TOY_API Toy_Literal Toy_getLiteralArray(Toy_LiteralArray* array, Toy_Literal index);
 
-int findLiteralIndex(LiteralArray* array, Literal literal);
+int Toy_findLiteralIndex(Toy_LiteralArray* array, Toy_Literal literal);

source/toy_literal_dictionary.c

@@ -1,22 +1,22 @@
-#include "literal_dictionary.h"
+#include "toy_literal_dictionary.h"
 
-#include "memory.h"
+#include "toy_memory.h"
 
-#include "console_colors.h"
+#include "toy_console_colors.h"
 
 #include <stdio.h>
 
 //util functions
-static void setEntryValues(_entry* entry, Literal key, Literal value) {
+static void setEntryValues(Toy_private_entry* entry, Toy_Literal key, Toy_Literal value) {
 	//much simpler now
-	freeLiteral(entry->key);
-	entry->key = copyLiteral(key);
+	Toy_freeLiteral(entry->key);
+	entry->key = Toy_copyLiteral(key);
 
-	freeLiteral(entry->value);
-	entry->value = copyLiteral(value);
+	Toy_freeLiteral(entry->value);
+	entry->value = Toy_copyLiteral(value);
 }
 
-static _entry* getEntryArray(_entry* array, int capacity, Literal key, unsigned int hash, bool mustExist) {
+static Toy_private_entry* getEntryArray(Toy_private_entry* array, int capacity, Toy_Literal key, unsigned int hash, bool mustExist) {
 	//find "key", starting at index
 	unsigned int index = hash % capacity;
 	unsigned int start = index;
@@ -26,16 +26,16 @@ static _entry* getEntryArray(_entry* array, int capacity, Literal key, unsigned
 
 	//literal probing and collision checking
 	while (index != start) { //WARNING: this is the only function allowed to retrieve an entry from the array
-		_entry* entry = &array[index];
+		Toy_private_entry* entry = &array[index];
 
-		if (IS_NULL(entry->key)) { //if key is empty, it's either empty or tombstone
-			if (IS_NULL(entry->value) && !mustExist) {
+		if (TOY_IS_NULL(entry->key)) { //if key is empty, it's either empty or tombstone
+			if (TOY_IS_NULL(entry->value) && !mustExist) {
 				//found a truly empty bucket
 				return entry;
 			}
 			//else it's a tombstone - ignore
 		} else {
-			if (literalsAreEqual(key, entry->key)) {
+			if (Toy_literalsAreEqual(key, entry->key)) {
 				return entry;
 			}
 		}
@@ -46,46 +46,46 @@ static _entry* getEntryArray(_entry* array, int capacity, Literal key, unsigned
 	return NULL;
 }
 
-static void adjustEntryCapacity(_entry** dictionaryHandle, int oldCapacity, int capacity) {
+static void adjustEntryCapacity(Toy_private_entry** dictionaryHandle, int oldCapacity, int capacity) {
 	//new entry space
-	_entry* newEntries = ALLOCATE(_entry, capacity);
+	Toy_private_entry* newEntries = TOY_ALLOCATE(Toy_private_entry, capacity);
 
 	for (int i = 0; i < capacity; i++) {
-		newEntries[i].key = TO_NULL_LITERAL;
-		newEntries[i].value = TO_NULL_LITERAL;
+		newEntries[i].key = TOY_TO_NULL_LITERAL;
+		newEntries[i].value = TOY_TO_NULL_LITERAL;
 	}
 
 	//move the old array into the new one
 	for (int i = 0; i < oldCapacity; i++) {
-		if (IS_NULL((*dictionaryHandle)[i].key)) {
+		if (TOY_IS_NULL((*dictionaryHandle)[i].key)) {
 			continue;
 		}
 
 		//place the key and value in the new array (reusing string memory)
-		_entry* entry = getEntryArray(newEntries, capacity, TO_NULL_LITERAL, hashLiteral((*dictionaryHandle)[i].key), false);
+		Toy_private_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
-	FREE_ARRAY(_entry, *dictionaryHandle, oldCapacity);
+	TOY_FREE_ARRAY(Toy_private_entry, *dictionaryHandle, oldCapacity);
 
 	*dictionaryHandle = newEntries;
 }
 
-static bool setEntryArray(_entry** dictionaryHandle, int* capacityPtr, int contains, Literal key, Literal value, int hash) {
+static bool setEntryArray(Toy_private_entry** dictionaryHandle, int* capacityPtr, int contains, Toy_Literal key, Toy_Literal value, int hash) {
 	//expand array if needed
-	if (contains + 1 > *capacityPtr * DICTIONARY_MAX_LOAD) {
+	if (contains + 1 > *capacityPtr * TOY_DICTIONARY_MAX_LOAD) {
 		int oldCapacity = *capacityPtr;
-		*capacityPtr = GROW_CAPACITY(*capacityPtr);
+		*capacityPtr = TOY_GROW_CAPACITY(*capacityPtr);
 		adjustEntryCapacity(dictionaryHandle, oldCapacity, *capacityPtr); //custom rather than automatic reallocation
 	}
 
-	_entry* entry = getEntryArray(*dictionaryHandle, *capacityPtr, key, hash, false);
+	Toy_private_entry* entry = getEntryArray(*dictionaryHandle, *capacityPtr, key, hash, false);
 
 	//true = contains increase
-	if (IS_NULL(entry->key)) {
+	if (TOY_IS_NULL(entry->key)) {
 		setEntryValues(entry, key, value);
 		return true;
 	}
@@ -97,61 +97,61 @@ static bool setEntryArray(_entry** dictionaryHandle, int* capacityPtr, int conta
 	return false;
 }
 
-static void freeEntry(_entry* entry) {
-	freeLiteral(entry->key);
-	freeLiteral(entry->value);
-	entry->key = TO_NULL_LITERAL;
-	entry->value = TO_NULL_LITERAL;
+static void freeEntry(Toy_private_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(_entry* array, int capacity) {
+static void freeEntryArray(Toy_private_entry* array, int capacity) {
 	if (array == NULL) {
 		return;
 	}
 
 	for (int i = 0; i < capacity; i++) {
-		if (!IS_NULL(array[i].key)) {
+		if (!TOY_IS_NULL(array[i].key)) {
 			freeEntry(&array[i]);
 		}
 	}
 
-	FREE_ARRAY(_entry, array, capacity);
+	TOY_FREE_ARRAY(Toy_private_entry, array, capacity);
 }
 
 //exposed functions
-void initLiteralDictionary(LiteralDictionary* dictionary) {
+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 = GROW_CAPACITY(0);
+	dictionary->capacity = TOY_GROW_CAPACITY(0);
 	dictionary->contains = 0;
 	dictionary->count = 0;
 	adjustEntryCapacity(&dictionary->entries, 0, dictionary->capacity);
 }
 
-void freeLiteralDictionary(LiteralDictionary* dictionary) {
+void Toy_freeLiteralDictionary(Toy_LiteralDictionary* dictionary) {
 	freeEntryArray(dictionary->entries, dictionary->capacity);
 	dictionary->capacity = 0;
 	dictionary->contains = 0;
 }
 
-void setLiteralDictionary(LiteralDictionary* dictionary, Literal key, Literal value) {
-	if (IS_NULL(key)) {
-		fprintf(stderr, ERROR "Dictionaries can't have null keys (set)\n" RESET);
+void Toy_setLiteralDictionary(Toy_LiteralDictionary* dictionary, Toy_Literal key, Toy_Literal value) {
+	if (TOY_IS_NULL(key)) {
+		fprintf(stderr, TOY_CC_ERROR "Dictionaries can't have null keys (set)\n" TOY_CC_RESET);
 		return;
 	}
 
 	//BUGFIX: Can't hash a function
-	if (IS_FUNCTION(key) || IS_FUNCTION_NATIVE(key)) {
-		fprintf(stderr, ERROR "Dictionaries can't have function keys (set)\n" RESET);
+	if (TOY_IS_FUNCTION(key) || TOY_IS_FUNCTION_NATIVE(key)) {
+		fprintf(stderr, TOY_CC_ERROR "Dictionaries can't have function keys (set)\n" TOY_CC_RESET);
 		return;
 	}
 
-	if (IS_OPAQUE(key)) {
-		fprintf(stderr, ERROR "Dictionaries can't have opaque keys (set)\n" RESET);
+	if (TOY_IS_OPAQUE(key)) {
+		fprintf(stderr, TOY_CC_ERROR "Dictionaries can't have opaque keys (set)\n" TOY_CC_RESET);
 		return;
 	}
 
-	const int increment = setEntryArray(&dictionary->entries, &dictionary->capacity, dictionary->contains, key, value, hashLiteral(key));
+	const int increment = setEntryArray(&dictionary->entries, &dictionary->capacity, dictionary->contains, key, value, Toy_hashLiteral(key));
 
 	if (increment) {
 		dictionary->contains++;
@@ -159,61 +159,61 @@ void setLiteralDictionary(LiteralDictionary* dictionary, Literal key, Literal va
 	}
 }
 
-Literal getLiteralDictionary(LiteralDictionary* dictionary, Literal key) {
-	if (IS_NULL(key)) {
-		fprintf(stderr, ERROR "Dictionaries can't have null keys (get)\n" RESET);
-		return TO_NULL_LITERAL;
+Toy_Literal Toy_getLiteralDictionary(Toy_LiteralDictionary* dictionary, Toy_Literal key) {
+	if (TOY_IS_NULL(key)) {
+		fprintf(stderr, TOY_CC_ERROR "Dictionaries can't have null keys (get)\n" TOY_CC_RESET);
+		return TOY_TO_NULL_LITERAL;
 	}
 
 	//BUGFIX: Can't hash a function
-	if (IS_FUNCTION(key) || IS_FUNCTION_NATIVE(key)) {
-		fprintf(stderr, ERROR "Dictionaries can't have function keys (get)\n" RESET);
-		return TO_NULL_LITERAL;
+	if (TOY_IS_FUNCTION(key) || TOY_IS_FUNCTION_NATIVE(key)) {
+		fprintf(stderr, TOY_CC_ERROR "Dictionaries can't have function keys (get)\n" TOY_CC_RESET);
+		return TOY_TO_NULL_LITERAL;
 	}
 
-	if (IS_OPAQUE(key)) {
-		fprintf(stderr, ERROR "Dictionaries can't have opaque keys (get)\n" RESET);
-		return TO_NULL_LITERAL;
+	if (TOY_IS_OPAQUE(key)) {
+		fprintf(stderr, TOY_CC_ERROR "Dictionaries can't have opaque keys (get)\n" TOY_CC_RESET);
+		return TOY_TO_NULL_LITERAL;
 	}
 
-	_entry* entry = getEntryArray(dictionary->entries, dictionary->capacity, key, hashLiteral(key), true);
+	Toy_private_entry* entry = getEntryArray(dictionary->entries, dictionary->capacity, key, Toy_hashLiteral(key), true);
 
 	if (entry != NULL) {
-		return copyLiteral(entry->value);
+		return Toy_copyLiteral(entry->value);
 	}
 	else {
-		return TO_NULL_LITERAL;
+		return TOY_TO_NULL_LITERAL;
 	}
 }
 
-void removeLiteralDictionary(LiteralDictionary* dictionary, Literal key) {
-	if (IS_NULL(key)) {
-		fprintf(stderr, ERROR "Dictionaries can't have null keys (remove)\n" RESET);
+void Toy_removeLiteralDictionary(Toy_LiteralDictionary* dictionary, Toy_Literal key) {
+	if (TOY_IS_NULL(key)) {
+		fprintf(stderr, TOY_CC_ERROR "Dictionaries can't have null keys (remove)\n" TOY_CC_RESET);
 		return;
 	}
 
 	//BUGFIX: Can't hash a function
-	if (IS_FUNCTION(key) || IS_FUNCTION_NATIVE(key)) {
-		fprintf(stderr, ERROR "Dictionaries can't have function keys (remove)\n" RESET);
+	if (TOY_IS_FUNCTION(key) || TOY_IS_FUNCTION_NATIVE(key)) {
+		fprintf(stderr, TOY_CC_ERROR "Dictionaries can't have function keys (remove)\n" TOY_CC_RESET);
 		return;
 	}
 
-	if (IS_OPAQUE(key)) {
-		fprintf(stderr, ERROR "Dictionaries can't have opaque keys (remove)\n" RESET);
+	if (TOY_IS_OPAQUE(key)) {
+		fprintf(stderr, TOY_CC_ERROR "Dictionaries can't have opaque keys (remove)\n" TOY_CC_RESET);
 		return;
 	}
 
-	_entry* entry = getEntryArray(dictionary->entries, dictionary->capacity, key, hashLiteral(key), true);
+	Toy_private_entry* entry = getEntryArray(dictionary->entries, dictionary->capacity, key, Toy_hashLiteral(key), true);
 
 	if (entry != NULL) {
 		freeEntry(entry);
-		entry->value = TO_BOOLEAN_LITERAL(true); //tombstone
+		entry->value = TOY_TO_BOOLEAN_LITERAL(true); //tombstone
 		dictionary->count--;
 	}
 }
 
-bool existsLiteralDictionary(LiteralDictionary* dictionary, Literal key) {
+bool Toy_existsLiteralDictionary(Toy_LiteralDictionary* dictionary, Toy_Literal key) {
 	//null & not tombstoned
-	_entry* entry = getEntryArray(dictionary->entries, dictionary->capacity, key, hashLiteral(key), false);
-	return !(IS_NULL(entry->key) && IS_NULL(entry->value));
+	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));
 }

source/toy_literal_dictionary.h

@@ -2,28 +2,28 @@
 
 #include "toy_common.h"
 
-#include "literal.h"
+#include "toy_literal.h"
 
 //TODO: benchmark this
-#define DICTIONARY_MAX_LOAD 0.75
+#define TOY_DICTIONARY_MAX_LOAD 0.75
 
-typedef struct _entry {
-	Literal key;
-	Literal value;
-} _entry;
+typedef struct Toy_private_entry {
+	Toy_Literal key;
+	Toy_Literal value;
+} Toy_private_entry;
 
-typedef struct LiteralDictionary {
-	_entry* entries;
+typedef struct Toy_LiteralDictionary {
+	Toy_private_entry* entries;
 	int capacity;
 	int count;
 	int contains; //count + tombstones, for internal use
-} LiteralDictionary;
+} Toy_LiteralDictionary;
 
-TOY_API void initLiteralDictionary(LiteralDictionary* dictionary);
-TOY_API void freeLiteralDictionary(LiteralDictionary* dictionary);
+TOY_API void Toy_initLiteralDictionary(Toy_LiteralDictionary* dictionary);
+TOY_API void Toy_freeLiteralDictionary(Toy_LiteralDictionary* dictionary);
 
-TOY_API void setLiteralDictionary(LiteralDictionary* dictionary, Literal key, Literal value);
-TOY_API Literal getLiteralDictionary(LiteralDictionary* dictionary, Literal key);
-TOY_API void removeLiteralDictionary(LiteralDictionary* dictionary, Literal key);
+TOY_API void Toy_setLiteralDictionary(Toy_LiteralDictionary* dictionary, Toy_Literal key, Toy_Literal value);
+TOY_API Toy_Literal Toy_getLiteralDictionary(Toy_LiteralDictionary* dictionary, Toy_Literal key);
+TOY_API void Toy_removeLiteralDictionary(Toy_LiteralDictionary* dictionary, Toy_Literal key);
 
-TOY_API bool existsLiteralDictionary(LiteralDictionary* dictionary, Literal key);
+TOY_API bool Toy_existsLiteralDictionary(Toy_LiteralDictionary* dictionary, Toy_Literal key);

source/toy_memory.c

@@ -1,13 +1,13 @@
-#include "memory.h"
-#include "refstring.h"
+#include "toy_memory.h"
+#include "toy_refstring.h"
 
-#include "console_colors.h"
+#include "toy_console_colors.h"
 
 #include <stdio.h>
 #include <stdlib.h>
 
 //default allocator
-void* defaultMemoryAllocator(void* pointer, size_t oldSize, size_t newSize) {
+static void* 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;
@@ -22,7 +22,7 @@ void* defaultMemoryAllocator(void* pointer, size_t oldSize, size_t newSize) {
 	void* mem = realloc(pointer, newSize);
 
 	if (mem == NULL) {
-		fprintf(stderr, ERROR "[internal] Memory allocation error (requested %d for %ld, replacing %d)\n" RESET, (int)newSize, (long int)pointer, (int)oldSize);
+		fprintf(stderr, TOY_CC_ERROR "[internal] Memory allocation error (requested %d for %ld, replacing %d)\n" TOY_CC_RESET, (int)newSize, (long int)pointer, (int)oldSize);
 		exit(-1);
 	}
 
@@ -30,29 +30,29 @@ void* defaultMemoryAllocator(void* pointer, size_t oldSize, size_t newSize) {
 }
 
 //static variables
-static MemoryAllocatorFn allocator;
+static Toy_MemoryAllocatorFn allocator;
 
 //preload
 static void __attribute__((constructor)) preloadMemoryAllocator() {
-	setMemoryAllocator(defaultMemoryAllocator);
+	Toy_setMemoryAllocator(defaultMemoryAllocator);
 }
 
 //exposed API
-void* reallocate(void* pointer, size_t oldSize, size_t newSize) {
+void* Toy_reallocate(void* pointer, size_t oldSize, size_t newSize) {
 	return allocator(pointer, oldSize, newSize);
 }
 
-void setMemoryAllocator(MemoryAllocatorFn fn) {
+void Toy_setMemoryAllocator(Toy_MemoryAllocatorFn fn) {
 	if (fn == NULL) {
-		fprintf(stderr, ERROR "[internal] Memory allocator error (can't be null)\n" RESET);
+		fprintf(stderr, TOY_CC_ERROR "[internal] Memory allocator error (can't be null)\n" TOY_CC_RESET);
 		exit(-1);
 	}
 
-	if (fn == reallocate) {
-		fprintf(stderr, ERROR "[internal] Memory allocator error (can't loop the reallocate function)\n" RESET);
+	if (fn == Toy_reallocate) {
+		fprintf(stderr, TOY_CC_ERROR "[internal] Memory allocator error (can't loop the Toy_reallocate function)\n" TOY_CC_RESET);
 		exit(-1);
 	}
 
 	allocator = fn;
-	setRefStringAllocatorFn(fn);
+	Toy_setRefStringAllocatorFn(fn);
 }

source/toy_memory.h

@@ -2,17 +2,17 @@
 
 #include "toy_common.h"
 
-#define ALLOCATE(type, count) ((type*)reallocate(NULL, 0, sizeof(type) * (count)))
-#define FREE(type, pointer) reallocate(pointer, sizeof(type), 0)
-#define GROW_CAPACITY(capacity) ((capacity) < 8 ? 8 : (capacity) * 2)
-#define GROW_CAPACITY_FAST(capacity) ((capacity) < 32 ? 32 : (capacity) * 2)
-#define GROW_ARRAY(type, pointer, oldCount, count) (type*)reallocate((type*)pointer, sizeof(type) * (oldCount), sizeof(type) * (count))
-#define SHRINK_ARRAY(type, pointer, oldCount, count) (type*)reallocate((type*)pointer, sizeof(type) * (oldCount), sizeof(type) * (count))
-#define FREE_ARRAY(type, pointer, oldCount) reallocate((type*)pointer, sizeof(type) * (oldCount), 0)
+#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)
 
 //implementation details
-void* reallocate(void* pointer, size_t oldSize, size_t newSize);
+void* Toy_reallocate(void* pointer, size_t oldSize, size_t newSize);
 
 //assign the memory allocator
-typedef void* (*MemoryAllocatorFn)(void* pointer, size_t oldSize, size_t newSize);
-TOY_API void setMemoryAllocator(MemoryAllocatorFn);
+typedef void* (*Toy_MemoryAllocatorFn)(void* pointer, size_t oldSize, size_t newSize);
+TOY_API void Toy_setMemoryAllocator(Toy_MemoryAllocatorFn);

source/toy_opcodes.h

@@ -1,87 +1,87 @@
 #pragma once
 
-typedef enum Opcode {
-	OP_EOF,
+typedef enum Toy_Opcode {
+	TOY_OP_EOF,
 
 	//basic statements
-	OP_ASSERT,
-	OP_PRINT,
+	TOY_OP_ASSERT,
+	TOY_OP_PRINT,
 
 	//data
-	OP_LITERAL,
-	OP_LITERAL_LONG, //for more than 256 literals in a chunk
-	OP_LITERAL_RAW, //forcibly get the raw value of the literal
+	TOY_OP_LITERAL,
+	TOY_OP_LITERAL_LONG, //for more than 256 literals in a chunk
+	TOY_OP_LITERAL_RAW, //forcibly get the raw value of the literal
 
 	//arithmetic operators
-	OP_NEGATE,
-	OP_ADDITION,
-	OP_SUBTRACTION,
-	OP_MULTIPLICATION,
-	OP_DIVISION,
-	OP_MODULO,
-	OP_GROUPING_BEGIN,
-	OP_GROUPING_END,
+	TOY_OP_NEGATE,
+	TOY_OP_ADDITION,
+	TOY_OP_SUBTRACTION,
+	TOY_OP_MULTIPLICATION,
+	TOY_OP_DIVISION,
+	TOY_OP_MODULO,
+	TOY_OP_GROUPING_BEGIN,
+	TOY_OP_GROUPING_END,
 
 	//variable stuff
-	OP_SCOPE_BEGIN,
-	OP_SCOPE_END,
+	TOY_OP_SCOPE_BEGIN,
+	TOY_OP_SCOPE_END,
 
-	OP_TYPE_DECL,		//declare a type to be used (as a literal)
-	OP_TYPE_DECL_LONG,	//declare a type to be used (as a long literal)
+	TOY_OP_TYPE_DECL,		//declare a type to be used (as a literal)
+	TOY_OP_TYPE_DECL_LONG,	//declare a type to be used (as a long literal)
 
-	OP_VAR_DECL,		//declare a variable to be used (as a literal)
-	OP_VAR_DECL_LONG,	//declare a variable to be used (as a long literal)
+	TOY_OP_VAR_DECL,		//declare a variable to be used (as a literal)
+	TOY_OP_VAR_DECL_LONG,	//declare a variable to be used (as a long literal)
 
-	OP_FN_DECL,			//declare a function to be used (as a literal)
-	OP_FN_DECL_LONG,	//declare a function to be used (as a long literal)
+	TOY_OP_FN_DECL,			//declare a function to be used (as a literal)
+	TOY_OP_FN_DECL_LONG,	//declare a function to be used (as a long literal)
 
-	OP_VAR_ASSIGN,		//assign to a literal
-	OP_VAR_ADDITION_ASSIGN,
-	OP_VAR_SUBTRACTION_ASSIGN,
-	OP_VAR_MULTIPLICATION_ASSIGN,
-	OP_VAR_DIVISION_ASSIGN,
-	OP_VAR_MODULO_ASSIGN,
+	TOY_OP_VAR_ASSIGN,		//assign to a literal
+	TOY_OP_VAR_ADDITION_ASSIGN,
+	TOY_OP_VAR_SUBTRACTION_ASSIGN,
+	TOY_OP_VAR_MULTIPLICATION_ASSIGN,
+	TOY_OP_VAR_DIVISION_ASSIGN,
+	TOY_OP_VAR_MODULO_ASSIGN,
 
-	OP_TYPE_CAST,		//temporarily change a type of an atomic value
-	OP_TYPE_OF,			//get the type of a variable
+	TOY_OP_TYPE_CAST,		//temporarily change a type of an atomic value
+	TOY_OP_TYPE_OF,			//get the type of a variable
 
-	OP_IMPORT,
-	OP_EXPORT_removed,
+	TOY_OP_IMPORT,
+	TOY_OP_EXPORT_removed,
 
 	//for indexing
-	OP_INDEX,
-	OP_INDEX_ASSIGN,
-	OP_INDEX_ASSIGN_INTERMEDIATE,
-	OP_DOT,
+	TOY_OP_INDEX,
+	TOY_OP_INDEX_ASSIGN,
+	TOY_OP_INDEX_ASSIGN_INTERMEDIATE,
+	TOY_OP_DOT,
 
 	//comparison of values
-	OP_COMPARE_EQUAL,
-	OP_COMPARE_NOT_EQUAL,
-	OP_COMPARE_LESS,
-	OP_COMPARE_LESS_EQUAL,
-	OP_COMPARE_GREATER,
-	OP_COMPARE_GREATER_EQUAL,
-	OP_INVERT, //for booleans
+	TOY_OP_COMPARE_EQUAL,
+	TOY_OP_COMPARE_NOT_EQUAL,
+	TOY_OP_COMPARE_LESS,
+	TOY_OP_COMPARE_LESS_EQUAL,
+	TOY_OP_COMPARE_GREATER,
+	TOY_OP_COMPARE_GREATER_EQUAL,
+	TOY_OP_INVERT, //for booleans
 
 	//logical operators
-	OP_AND,
-	OP_OR,
+	TOY_OP_AND,
+	TOY_OP_OR,
 
 	//jumps, and conditional jumps (absolute)
-	OP_JUMP,
-	OP_IF_FALSE_JUMP,
-	OP_FN_CALL,
-	OP_FN_RETURN,
+	TOY_OP_JUMP,
+	TOY_OP_IF_FALSE_JUMP,
+	TOY_OP_FN_CALL,
+	TOY_OP_FN_RETURN,
 
 	//pop the stack at the end of a complex statement
-	OP_POP_STACK,
+	TOY_OP_POP_STACK,
 
 	//ternary shorthand
-	OP_TERNARY,
+	TOY_OP_TERNARY,
 
 	//meta
-	OP_FN_END, //different from SECTION_END
-	OP_SECTION_END = 255,
+	TOY_OP_FN_END, //different from SECTION_END
+	TOY_OP_SECTION_END = 255,
 	//TODO: add more
-} Opcode;
+} Toy_Opcode;
 

source/toy_parser.h

@@ -1,20 +1,20 @@
 #pragma once
 
 #include "toy_common.h"
-#include "lexer.h"
-#include "ast_node.h"
+#include "toy_lexer.h"
+#include "toy_ast_node.h"
 
 //DOCS: parsers are bound to a lexer, and turn the outputted tokens into AST nodes
 typedef struct {
-	Lexer* lexer;
+	Toy_Lexer* lexer;
 	bool error; //I've had an error
 	bool panic; //I am processing an error
 
 	//track the last two outputs from the lexer
-	Token current;
-	Token previous;
-} Parser;
+	Toy_Token current;
+	Toy_Token previous;
+} Toy_Parser;
 
-TOY_API void initParser(Parser* parser, Lexer* lexer);
-TOY_API void freeParser(Parser* parser);
-TOY_API ASTNode* scanParser(Parser* parser);
+TOY_API void Toy_initParser(Toy_Parser* parser, Toy_Lexer* lexer);
+TOY_API void Toy_freeParser(Toy_Parser* parser);
+TOY_API Toy_ASTNode* Toy_scanParser(Toy_Parser* parser);

source/toy_refstring.c

@@ -1,4 +1,4 @@
-#include "refstring.h"
+#include "toy_refstring.h"
 
 #include <string.h>
 #include <assert.h>
@@ -6,27 +6,27 @@
 //test variable sizes based on platform (safety)
 #define STATIC_ASSERT(test_for_true) static_assert((test_for_true), "(" #test_for_true ") failed")
 
-STATIC_ASSERT(sizeof(RefString) == 12);
+STATIC_ASSERT(sizeof(Toy_RefString) == 12);
 STATIC_ASSERT(sizeof(int) == 4);
 STATIC_ASSERT(sizeof(char) == 1);
 
 //memory allocation
-static RefStringAllocatorFn allocate;
+static Toy_RefStringAllocatorFn allocate;
 
-void setRefStringAllocatorFn(RefStringAllocatorFn allocator) {
+void Toy_setRefStringAllocatorFn(Toy_RefStringAllocatorFn allocator) {
 	allocate = allocator;
 }
 
 //API
-RefString* createRefString(char* cstring) {
+Toy_RefString* Toy_createRefString(char* cstring) {
 	int length = strnlen(cstring, 4096);
 
-	return createRefStringLength(cstring, length);
+	return Toy_createRefStringLength(cstring, length);
 }
 
-RefString* createRefStringLength(char* cstring, int length) {
+Toy_RefString* Toy_createRefStringLength(char* cstring, int length) {
 	//allocate the memory area (including metadata space)
-	RefString* refString = (RefString*)allocate(NULL, 0, sizeof(int) * 2 + sizeof(char) * length + 1);
+	Toy_RefString* refString = (Toy_RefString*)allocate(NULL, 0, sizeof(int) * 2 + sizeof(char) * length + 1);
 
 	//set the data
 	refString->refcount = 1;
@@ -38,7 +38,7 @@ RefString* createRefStringLength(char* cstring, int length) {
 	return refString;
 }
 
-void deleteRefString(RefString* refString) {
+void Toy_deleteRefString(Toy_RefString* refString) {
 	//decrement, then check
 	refString->refcount--;
 	if (refString->refcount <= 0) {
@@ -46,30 +46,30 @@ void deleteRefString(RefString* refString) {
 	}
 }
 
-int countRefString(RefString* refString) {
+int Toy_countRefString(Toy_RefString* refString) {
 	return refString->refcount;
 }
 
-int lengthRefString(RefString* refString) {
+int Toy_lengthRefString(Toy_RefString* refString) {
 	return refString->length;
 }
 
-RefString* copyRefString(RefString* refString) {
+Toy_RefString* Toy_copyRefString(Toy_RefString* refString) {
 	//Cheaty McCheater Face
 	refString->refcount++;
 	return refString;
 }
 
-RefString* deepCopyRefString(RefString* refString) {
+Toy_RefString* Toy_deepCopyRefString(Toy_RefString* refString) {
 	//create a new string, with a new refcount
-	return createRefStringLength(refString->data, refString->length);
+	return Toy_createRefStringLength(refString->data, refString->length);
 }
 
-char* toCString(RefString* refString) {
+char* Toy_toCString(Toy_RefString* refString) {
 	return refString->data;
 }
 
-bool equalsRefString(RefString* lhs, RefString* rhs) {
+bool Toy_equalsRefString(Toy_RefString* lhs, Toy_RefString* rhs) {
 	//same pointer
 	if (lhs == rhs) {
 		return true;
@@ -84,7 +84,7 @@ bool equalsRefString(RefString* lhs, RefString* rhs) {
 	return strncmp(lhs->data, rhs->data, lhs->length) == 0;
 }
 
-bool equalsRefStringCString(RefString* lhs, char* cstring) {
+bool Toy_equalsRefStringCString(Toy_RefString* lhs, char* cstring) {
 	//get the rhs length
 	int length = strnlen(cstring, 4096);
 

source/toy_refstring.h

@@ -4,24 +4,24 @@
 #include <stddef.h>
 
 //memory allocation hook
-typedef void* (*RefStringAllocatorFn)(void* pointer, size_t oldSize, size_t newSize);
-void setRefStringAllocatorFn(RefStringAllocatorFn);
+typedef void* (*Toy_RefStringAllocatorFn)(void* pointer, size_t oldSize, size_t newSize);
+void Toy_setRefStringAllocatorFn(Toy_RefStringAllocatorFn);
 
 //the RefString structure
-typedef struct RefString {
+typedef struct Toy_RefString {
 	int refcount;
 	int length;
 	char data[1];
-} RefString;
+} Toy_RefString;
 
 //API
-RefString* createRefString(char* cstring);
-RefString* createRefStringLength(char* cstring, int length);
-void deleteRefString(RefString* refString);
-int countRefString(RefString* refString);
-int lengthRefString(RefString* refString);
-RefString* copyRefString(RefString* refString);
-RefString* deepCopyRefString(RefString* refString);
-char* toCString(RefString* refString);
-bool equalsRefString(RefString* lhs, RefString* rhs);
-bool equalsRefStringCString(RefString* lhs, char* cstring);
+Toy_RefString* Toy_createRefString(char* cstring);
+Toy_RefString* Toy_createRefStringLength(char* cstring, int length);
+void Toy_deleteRefString(Toy_RefString* refString);
+int Toy_countRefString(Toy_RefString* refString);
+int Toy_lengthRefString(Toy_RefString* refString);
+Toy_RefString* Toy_copyRefString(Toy_RefString* refString);
+Toy_RefString* Toy_deepCopyRefString(Toy_RefString* refString);
+char* Toy_toCString(Toy_RefString* refString);
+bool Toy_equalsRefString(Toy_RefString* lhs, Toy_RefString* rhs);
+bool Toy_equalsRefStringCString(Toy_RefString* lhs, char* cstring);

source/toy_scope.c

@@ -1,9 +1,9 @@
-#include "scope.h"
+#include "toy_scope.h"
 
-#include "memory.h"
+#include "toy_memory.h"
 
 //run up the ancestor chain, freeing anything with 0 references left
-static void freeAncestorChain(Scope* scope) {
+static void freeAncestorChain(Toy_Scope* scope) {
 	scope->references--;
 
 	//free scope chain
@@ -15,65 +15,65 @@ static void freeAncestorChain(Scope* scope) {
 		return;
 	}
 
-	freeLiteralDictionary(&scope->variables);
-	freeLiteralDictionary(&scope->types);
+	Toy_freeLiteralDictionary(&scope->variables);
+	Toy_freeLiteralDictionary(&scope->types);
 
-	FREE(Scope, scope);
+	TOY_FREE(Toy_Scope, scope);
 }
 
 //return false if invalid type
-static bool checkType(Literal typeLiteral, Literal original, Literal value, bool constCheck) {
+static bool checkType(Toy_Literal typeLiteral, Toy_Literal original, Toy_Literal value, bool constCheck) {
 	//for constants, fail if original != value
-	if (constCheck && AS_TYPE(typeLiteral).constant && !literalsAreEqual(original, value)) {
+	if (constCheck && TOY_AS_TYPE(typeLiteral).constant && !Toy_literalsAreEqual(original, value)) {
 		return false;
 	}
 
 	//for any types
-	if (AS_TYPE(typeLiteral).typeOf == LITERAL_ANY) {
+	if (TOY_AS_TYPE(typeLiteral).typeOf == TOY_LITERAL_ANY) {
 		return true;
 	}
 
 	//don't allow null types
-	if (AS_TYPE(typeLiteral).typeOf == LITERAL_NULL) {
+	if (TOY_AS_TYPE(typeLiteral).typeOf == TOY_LITERAL_NULL) {
 		return false;
 	}
 
 	//always allow null values
-	if (IS_NULL(value)) {
+	if (TOY_IS_NULL(value)) {
 		return true;
 	}
 
 	//for each type, if a mismatch is found, return false
-	if (AS_TYPE(typeLiteral).typeOf == LITERAL_BOOLEAN && !IS_BOOLEAN(value)) {
+	if (TOY_AS_TYPE(typeLiteral).typeOf == TOY_LITERAL_BOOLEAN && !TOY_IS_BOOLEAN(value)) {
 		return false;
 	}
 
-	if (AS_TYPE(typeLiteral).typeOf == LITERAL_INTEGER && !IS_INTEGER(value)) {
+	if (TOY_AS_TYPE(typeLiteral).typeOf == TOY_LITERAL_INTEGER && !TOY_IS_INTEGER(value)) {
 		return false;
 	}
 
-	if (AS_TYPE(typeLiteral).typeOf == LITERAL_FLOAT && !IS_FLOAT(value)) {
+	if (TOY_AS_TYPE(typeLiteral).typeOf == TOY_LITERAL_FLOAT && !TOY_IS_FLOAT(value)) {
 		return false;
 	}
 
-	if (AS_TYPE(typeLiteral).typeOf == LITERAL_STRING && !IS_STRING(value)) {
+	if (TOY_AS_TYPE(typeLiteral).typeOf == TOY_LITERAL_STRING && !TOY_IS_STRING(value)) {
 		return false;
 	}
 
-	if (AS_TYPE(typeLiteral).typeOf == LITERAL_ARRAY && !IS_ARRAY(value)) {
+	if (TOY_AS_TYPE(typeLiteral).typeOf == TOY_LITERAL_ARRAY && !TOY_IS_ARRAY(value)) {
 		return false;
 	}
 
-	if (IS_ARRAY(value)) {
+	if (TOY_IS_ARRAY(value)) {
 		//check value's type
-		if (AS_TYPE(typeLiteral).typeOf != LITERAL_ARRAY) {
+		if (TOY_AS_TYPE(typeLiteral).typeOf != TOY_LITERAL_ARRAY) {
 			return false;
 		}
 
 		//if null, assume it's a new array variable that needs checking
-		if (IS_NULL(original)) {
-			for (int i = 0; i < AS_ARRAY(value)->count; i++) {
-				if (!checkType( ((Literal*)(AS_TYPE(typeLiteral).subtypes))[0], TO_NULL_LITERAL, AS_ARRAY(value)->literals[i], constCheck)) {
+		if (TOY_IS_NULL(original)) {
+			for (int i = 0; i < TOY_AS_ARRAY(value)->count; i++) {
+				if (!checkType( ((Toy_Literal*)(TOY_AS_TYPE(typeLiteral).subtypes))[0], TOY_TO_NULL_LITERAL, TOY_AS_ARRAY(value)->literals[i], constCheck)) {
 					return false;
 				}
 			}
@@ -82,36 +82,36 @@ static bool checkType(Literal typeLiteral, Literal original, Literal value, bool
 		}
 
 		//check children
-		for (int i = 0; i < AS_ARRAY(value)->count; i++) {
-			if (AS_ARRAY(original)->count <= i) {
+		for (int i = 0; i < TOY_AS_ARRAY(value)->count; i++) {
+			if (TOY_AS_ARRAY(original)->count <= i) {
 				return true; //assume new entry pushed
 			}
 
-			if (!checkType(((Literal*)(AS_TYPE(typeLiteral).subtypes))[0], AS_ARRAY(original)->literals[i], AS_ARRAY(value)->literals[i], constCheck)) {
+			if (!checkType(((Toy_Literal*)(TOY_AS_TYPE(typeLiteral).subtypes))[0], TOY_AS_ARRAY(original)->literals[i], TOY_AS_ARRAY(value)->literals[i], constCheck)) {
 				return false;
 			}
 		}
 	}
 
-	if (AS_TYPE(typeLiteral).typeOf == LITERAL_DICTIONARY && !IS_DICTIONARY(value)) {
+	if (TOY_AS_TYPE(typeLiteral).typeOf == TOY_LITERAL_DICTIONARY && !TOY_IS_DICTIONARY(value)) {
 		return false;
 	}
 
-	if (IS_DICTIONARY(value)) {
+	if (TOY_IS_DICTIONARY(value)) {
 		//check value's type
-		if (AS_TYPE(typeLiteral).typeOf != LITERAL_DICTIONARY) {
+		if (TOY_AS_TYPE(typeLiteral).typeOf != TOY_LITERAL_DICTIONARY) {
 			return false;
 		}
 
 		//if null, assume it's a new dictionary variable that needs checking
-		if (IS_NULL(original)) {
-			for (int i = 0; i < AS_DICTIONARY(value)->capacity; i++) {
+		if (TOY_IS_NULL(original)) {
+			for (int i = 0; i < TOY_AS_DICTIONARY(value)->capacity; i++) {
 				//check the type of key and value
-				if (!checkType(((Literal*)(AS_TYPE(typeLiteral).subtypes))[0], TO_NULL_LITERAL, AS_DICTIONARY(value)->entries[i].key, constCheck)) {
+				if (!checkType(((Toy_Literal*)(TOY_AS_TYPE(typeLiteral).subtypes))[0], TOY_TO_NULL_LITERAL, TOY_AS_DICTIONARY(value)->entries[i].key, constCheck)) {
 					return false;
 				}
 
-				if (!checkType(((Literal*)(AS_TYPE(typeLiteral).subtypes))[1], TO_NULL_LITERAL, AS_DICTIONARY(value)->entries[i].value, constCheck)) {
+				if (!checkType(((Toy_Literal*)(TOY_AS_TYPE(typeLiteral).subtypes))[1], TOY_TO_NULL_LITERAL, TOY_AS_DICTIONARY(value)->entries[i].value, constCheck)) {
 					return false;
 				}
 			}
@@ -120,17 +120,17 @@ static bool checkType(Literal typeLiteral, Literal original, Literal value, bool
 		}
 
 		//check each child of value against the child of original
-		for (int i = 0; i < AS_DICTIONARY(value)->capacity; i++) {
-			if (IS_NULL(AS_DICTIONARY(value)->entries[i].key)) { //only non-tombstones
+		for (int i = 0; i < TOY_AS_DICTIONARY(value)->capacity; i++) {
+			if (TOY_IS_NULL(TOY_AS_DICTIONARY(value)->entries[i].key)) { //only non-tombstones
 				continue;
 			}
 
 			//find the internal child of original that matches this child of value
-			_entry* ptr = NULL;
+			Toy_private_entry* ptr = NULL;
 
-			for (int j = 0; j < AS_DICTIONARY(original)->capacity; j++) {
-				if (literalsAreEqual(AS_DICTIONARY(original)->entries[j].key, AS_DICTIONARY(value)->entries[i].key)) {
-					ptr = &AS_DICTIONARY(original)->entries[j];
+			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)) {
+					ptr = &TOY_AS_DICTIONARY(original)->entries[j];
 					break;
 				}
 			}
@@ -141,21 +141,21 @@ static bool checkType(Literal typeLiteral, Literal original, Literal value, bool
 			}
 
 			//check the type of key and value
-			if (!checkType(((Literal*)(AS_TYPE(typeLiteral).subtypes))[0], ptr->key, AS_DICTIONARY(value)->entries[i].key, constCheck)) {
+			if (!checkType(((Toy_Literal*)(TOY_AS_TYPE(typeLiteral).subtypes))[0], ptr->key, TOY_AS_DICTIONARY(value)->entries[i].key, constCheck)) {
 				return false;
 			}
 
-			if (!checkType(((Literal*)(AS_TYPE(typeLiteral).subtypes))[1], ptr->value, AS_DICTIONARY(value)->entries[i].value, constCheck)) {
+			if (!checkType(((Toy_Literal*)(TOY_AS_TYPE(typeLiteral).subtypes))[1], ptr->value, TOY_AS_DICTIONARY(value)->entries[i].value, constCheck)) {
 				return false;
 			}
 		}
 	}
 
-	if (AS_TYPE(typeLiteral).typeOf == LITERAL_FUNCTION && !IS_FUNCTION(value)) {
+	if (TOY_AS_TYPE(typeLiteral).typeOf == TOY_LITERAL_FUNCTION && !TOY_IS_FUNCTION(value)) {
 		return false;
 	}
 
-	if (AS_TYPE(typeLiteral).typeOf == LITERAL_TYPE && !IS_TYPE(value)) {
+	if (TOY_AS_TYPE(typeLiteral).typeOf == TOY_LITERAL_TYPE && !TOY_IS_TYPE(value)) {
 		return false;
 	}
 
@@ -163,39 +163,39 @@ static bool checkType(Literal typeLiteral, Literal original, Literal value, bool
 }
 
 //exposed functions
-Scope* pushScope(Scope* ancestor) {
-	Scope* scope = ALLOCATE(Scope, 1);
+Toy_Scope* Toy_pushScope(Toy_Scope* ancestor) {
+	Toy_Scope* scope = TOY_ALLOCATE(Toy_Scope, 1);
 	scope->ancestor = ancestor;
-	initLiteralDictionary(&scope->variables);
-	initLiteralDictionary(&scope->types);
+	Toy_initLiteralDictionary(&scope->variables);
+	Toy_initLiteralDictionary(&scope->types);
 
 	//tick up all scope reference counts
 	scope->references = 0;
-	for (Scope* ptr = scope; ptr != NULL; ptr = ptr->ancestor) {
+	for (Toy_Scope* ptr = scope; ptr != NULL; ptr = ptr->ancestor) {
 		ptr->references++;
 	}
 
 	return scope;
 }
 
-Scope* popScope(Scope* scope) {
+Toy_Scope* Toy_popScope(Toy_Scope* scope) {
 	if (scope == NULL) { //CAN pop a null
 		return NULL;
 	}
 
-	Scope* ret = scope->ancestor;
+	Toy_Scope* ret = scope->ancestor;
 
 	//BUGFIX: when freeing a scope, free the function's scopes manually
 	for (int i = 0; i < scope->variables.capacity; i++) {
 		//handle keys, just in case
-		if (IS_FUNCTION(scope->variables.entries[i].key)) {
-			popScope(AS_FUNCTION(scope->variables.entries[i].key).scope);
-			AS_FUNCTION(scope->variables.entries[i].key).scope = NULL;
+		if (TOY_IS_FUNCTION(scope->variables.entries[i].key)) {
+			Toy_popScope(TOY_AS_FUNCTION(scope->variables.entries[i].key).scope);
+			TOY_AS_FUNCTION(scope->variables.entries[i].key).scope = NULL;
 		}
 
-		if (IS_FUNCTION(scope->variables.entries[i].value)) {
-			popScope(AS_FUNCTION(scope->variables.entries[i].value).scope);
-			AS_FUNCTION(scope->variables.entries[i].value).scope = NULL;
+		if (TOY_IS_FUNCTION(scope->variables.entries[i].value)) {
+			Toy_popScope(TOY_AS_FUNCTION(scope->variables.entries[i].value).scope);
+			TOY_AS_FUNCTION(scope->variables.entries[i].value).scope = NULL;
 		}
 	}
 
@@ -204,28 +204,28 @@ Scope* popScope(Scope* scope) {
 	return ret;
 }
 
-Scope* copyScope(Scope* original) {
-	Scope* scope = ALLOCATE(Scope, 1);
+Toy_Scope* Toy_copyScope(Toy_Scope* original) {
+	Toy_Scope* scope = TOY_ALLOCATE(Toy_Scope, 1);
 	scope->ancestor = original->ancestor;
-	initLiteralDictionary(&scope->variables);
-	initLiteralDictionary(&scope->types);
+	Toy_initLiteralDictionary(&scope->variables);
+	Toy_initLiteralDictionary(&scope->types);
 
 	//tick up all scope reference counts
 	scope->references = 0;
-	for (Scope* ptr = scope; ptr != NULL; ptr = ptr->ancestor) {
+	for (Toy_Scope* ptr = scope; ptr != NULL; ptr = ptr->ancestor) {
 		ptr->references++;
 	}
 
 	//copy the contents of the dictionaries
 	for (int i = 0; i < original->variables.capacity; i++) {
-		if (!IS_NULL(original->variables.entries[i].key)) {
-			setLiteralDictionary(&scope->variables, original->variables.entries[i].key, original->variables.entries[i].value);
+		if (!TOY_IS_NULL(original->variables.entries[i].key)) {
+			Toy_setLiteralDictionary(&scope->variables, original->variables.entries[i].key, original->variables.entries[i].value);
 		}
 	}
 
 	for (int i = 0; i < original->types.capacity; i++) {
-		if (!IS_NULL(original->types.entries[i].key)) {
-			setLiteralDictionary(&scope->types, original->types.entries[i].key, original->types.entries[i].value);
+		if (!TOY_IS_NULL(original->types.entries[i].key)) {
+			Toy_setLiteralDictionary(&scope->types, original->types.entries[i].key, original->types.entries[i].value);
 		}
 	}
 
@@ -233,92 +233,92 @@ Scope* copyScope(Scope* original) {
 }
 
 //returns false if error
-bool declareScopeVariable(Scope* scope, Literal key, Literal type) {
+bool Toy_declareScopeVariable(Toy_Scope* scope, Toy_Literal key, Toy_Literal type) {
 	//don't redefine a variable within this scope
-	if (existsLiteralDictionary(&scope->variables, key)) {
+	if (Toy_existsLiteralDictionary(&scope->variables, key)) {
 		return false;
 	}
 
-	if (!IS_TYPE(type)) {
+	if (!TOY_IS_TYPE(type)) {
 		return false;
 	}
 
 	//store the type, for later checking on assignment
-	setLiteralDictionary(&scope->types, key, type);
+	Toy_setLiteralDictionary(&scope->types, key, type);
 
-	setLiteralDictionary(&scope->variables, key, TO_NULL_LITERAL);
+	Toy_setLiteralDictionary(&scope->variables, key, TOY_TO_NULL_LITERAL);
 	return true;
 }
 
-bool isDelcaredScopeVariable(Scope* scope, Literal key) {
+bool Toy_isDelcaredScopeVariable(Toy_Scope* scope, Toy_Literal key) {
 	if (scope == NULL) {
 		return false;
 	}
 
 	//if it's not in this scope, keep searching up the chain
-	if (!existsLiteralDictionary(&scope->variables, key)) {
-		return isDelcaredScopeVariable(scope->ancestor, key);
+	if (!Toy_existsLiteralDictionary(&scope->variables, key)) {
+		return Toy_isDelcaredScopeVariable(scope->ancestor, key);
 	}
 
 	return true;
 }
 
 //return false if undefined, or can't be assigned
-bool setScopeVariable(Scope* scope, Literal key, Literal value, bool constCheck) {
+bool Toy_setScopeVariable(Toy_Scope* scope, Toy_Literal key, Toy_Literal value, bool constCheck) {
 	//dead end
 	if (scope == NULL) {
 		return false;
 	}
 
 	//if it's not in this scope, keep searching up the chain
-	if (!existsLiteralDictionary(&scope->variables, key)) {
-		return setScopeVariable(scope->ancestor, key, value, constCheck);
+	if (!Toy_existsLiteralDictionary(&scope->variables, key)) {
+		return Toy_setScopeVariable(scope->ancestor, key, value, constCheck);
 	}
 
 	//type checking
-	Literal typeLiteral = getLiteralDictionary(&scope->types, key);
-	Literal original = getLiteralDictionary(&scope->variables, key);
+	Toy_Literal typeLiteral = Toy_getLiteralDictionary(&scope->types, key);
+	Toy_Literal original = Toy_getLiteralDictionary(&scope->variables, key);
 
 	if (!checkType(typeLiteral, original, value, constCheck)) {
-		freeLiteral(typeLiteral);
-		freeLiteral(original);
+		Toy_freeLiteral(typeLiteral);
+		Toy_freeLiteral(original);
 		return false;
 	}
 
 	//actually assign
-	setLiteralDictionary(&scope->variables, key, value);
+	Toy_setLiteralDictionary(&scope->variables, key, value);
 
-	freeLiteral(typeLiteral);
-	freeLiteral(original);
+	Toy_freeLiteral(typeLiteral);
+	Toy_freeLiteral(original);
 
 	return true;
 }
 
-bool getScopeVariable(Scope* scope, Literal key, Literal* valueHandle) {
+bool Toy_getScopeVariable(Toy_Scope* scope, Toy_Literal key, Toy_Literal* valueHandle) {
 	//dead end
 	if (scope == NULL) {
 		return false;
 	}
 
 	//if it's not in this scope, keep searching up the chain
-	if (!existsLiteralDictionary(&scope->variables, key)) {
-		return getScopeVariable(scope->ancestor, key, valueHandle);
+	if (!Toy_existsLiteralDictionary(&scope->variables, key)) {
+		return Toy_getScopeVariable(scope->ancestor, key, valueHandle);
 	}
 
-	*valueHandle = getLiteralDictionary(&scope->variables, key);
+	*valueHandle = Toy_getLiteralDictionary(&scope->variables, key);
 	return true;
 }
 
-Literal getScopeType(Scope* scope, Literal key) {
+Toy_Literal Toy_getScopeType(Toy_Scope* scope, Toy_Literal key) {
 	//dead end
 	if (scope == NULL) {
-		return TO_NULL_LITERAL;
+		return TOY_TO_NULL_LITERAL;
 	}
 
 	//if it's not in this scope, keep searching up the chain
-	if (!existsLiteralDictionary(&scope->types, key)) {
-		return getScopeType(scope->ancestor, key);
+	if (!Toy_existsLiteralDictionary(&scope->types, key)) {
+		return Toy_getScopeType(scope->ancestor, key);
 	}
 
-	return getLiteralDictionary(&scope->types, key);
+	return Toy_getLiteralDictionary(&scope->types, key);
 }

source/toy_scope.h

@@ -1,25 +1,25 @@
 #pragma once
 
-#include "literal_array.h"
-#include "literal_dictionary.h"
+#include "toy_literal_array.h"
+#include "toy_literal_dictionary.h"
 
-typedef struct Scope {
-	LiteralDictionary variables; //only allow identifiers as the keys
-	LiteralDictionary types; //the types, indexed by identifiers
-	struct Scope* ancestor;
+typedef struct Toy_Scope {
+	Toy_LiteralDictionary variables; //only allow identifiers as the keys
+	Toy_LiteralDictionary types; //the types, indexed by identifiers
+	struct Toy_Scope* ancestor;
 	int references; //how many scopes point here
-} Scope;
+} Toy_Scope;
 
-Scope* pushScope(Scope* scope);
-Scope* popScope(Scope* scope);
-Scope* copyScope(Scope* original);
+Toy_Scope* Toy_pushScope(Toy_Scope* scope);
+Toy_Scope* Toy_popScope(Toy_Scope* scope);
+Toy_Scope* Toy_copyScope(Toy_Scope* original);
 
 //returns false if error
-bool declareScopeVariable(Scope* scope, Literal key, Literal type);
-bool isDelcaredScopeVariable(Scope* scope, Literal key);
+bool Toy_declareScopeVariable(Toy_Scope* scope, Toy_Literal key, Toy_Literal type);
+bool Toy_isDelcaredScopeVariable(Toy_Scope* scope, Toy_Literal key);
 
 //return false if undefined
-bool setScopeVariable(Scope* scope, Literal key, Literal value, bool constCheck);
-bool getScopeVariable(Scope* scope, Literal key, Literal* value);
+bool Toy_setScopeVariable(Toy_Scope* scope, Toy_Literal key, Toy_Literal value, bool constCheck);
+bool Toy_getScopeVariable(Toy_Scope* scope, Toy_Literal key, Toy_Literal* value);
 
-Literal getScopeType(Scope* scope, Literal key);
+Toy_Literal Toy_getScopeType(Toy_Scope* scope, Toy_Literal key);

source/toy_token_types.h

@@ -1,93 +1,93 @@
 #pragma once
 
-typedef enum TokenType {
+typedef enum Toy_TokenType {
 	//types
-	TOKEN_NULL,
-	TOKEN_BOOLEAN,
-	TOKEN_INTEGER,
-	TOKEN_FLOAT,
-	TOKEN_STRING,
-	TOKEN_ARRAY,
-	TOKEN_DICTIONARY,
-	TOKEN_FUNCTION,
-	TOKEN_OPAQUE,
-	TOKEN_ANY,
+	TOY_TOKEN_NULL,
+	TOY_TOKEN_BOOLEAN,
+	TOY_TOKEN_INTEGER,
+	TOY_TOKEN_FLOAT,
+	TOY_TOKEN_STRING,
+	TOY_TOKEN_ARRAY,
+	TOY_TOKEN_DICTIONARY,
+	TOY_TOKEN_FUNCTION,
+	TOY_TOKEN_OPAQUE,
+	TOY_TOKEN_ANY,
 
 	//keywords and reserved words
-	TOKEN_AS,
-	TOKEN_ASSERT,
-	TOKEN_BREAK,
-	TOKEN_CLASS,
-	TOKEN_CONST,
-	TOKEN_CONTINUE,
-	TOKEN_DO,
-	TOKEN_ELSE,
-	TOKEN_EXPORT,
-	TOKEN_FOR,
-	TOKEN_FOREACH,
-	TOKEN_IF,
-	TOKEN_IMPORT,
-	TOKEN_IN,
-	TOKEN_OF,
-	TOKEN_PRINT,
-	TOKEN_RETURN,
-	TOKEN_TYPE,
-	TOKEN_ASTYPE,
-	TOKEN_TYPEOF,
-	TOKEN_VAR,
-	TOKEN_WHILE,
+	TOY_TOKEN_AS,
+	TOY_TOKEN_ASSERT,
+	TOY_TOKEN_BREAK,
+	TOY_TOKEN_CLASS,
+	TOY_TOKEN_CONST,
+	TOY_TOKEN_CONTINUE,
+	TOY_TOKEN_DO,
+	TOY_TOKEN_ELSE,
+	TOY_TOKEN_EXPORT,
+	TOY_TOKEN_FOR,
+	TOY_TOKEN_FOREACH,
+	TOY_TOKEN_IF,
+	TOY_TOKEN_IMPORT,
+	TOY_TOKEN_IN,
+	TOY_TOKEN_OF,
+	TOY_TOKEN_PRINT,
+	TOY_TOKEN_RETURN,
+	TOY_TOKEN_TYPE,
+	TOY_TOKEN_ASTYPE,
+	TOY_TOKEN_TYPEOF,
+	TOY_TOKEN_VAR,
+	TOY_TOKEN_WHILE,
 
 	//literal values
-	TOKEN_IDENTIFIER,
-	TOKEN_LITERAL_TRUE,
-	TOKEN_LITERAL_FALSE,
-	TOKEN_LITERAL_INTEGER,
-	TOKEN_LITERAL_FLOAT,
-	TOKEN_LITERAL_STRING,
+	TOY_TOKEN_IDENTIFIER,
+	TOY_TOKEN_LITERAL_TRUE,
+	TOY_TOKEN_LITERAL_FALSE,
+	TOY_TOKEN_LITERAL_INTEGER,
+	TOY_TOKEN_LITERAL_FLOAT,
+	TOY_TOKEN_LITERAL_STRING,
 
 	//math operators
-	TOKEN_PLUS,
-	TOKEN_MINUS,
-	TOKEN_MULTIPLY,
-	TOKEN_DIVIDE,
-	TOKEN_MODULO,
-	TOKEN_PLUS_ASSIGN,
-	TOKEN_MINUS_ASSIGN,
-	TOKEN_MULTIPLY_ASSIGN,
-	TOKEN_DIVIDE_ASSIGN,
-	TOKEN_MODULO_ASSIGN,
-	TOKEN_PLUS_PLUS,
-	TOKEN_MINUS_MINUS,
-	TOKEN_ASSIGN,
+	TOY_TOKEN_PLUS,
+	TOY_TOKEN_MINUS,
+	TOY_TOKEN_MULTIPLY,
+	TOY_TOKEN_DIVIDE,
+	TOY_TOKEN_MODULO,
+	TOY_TOKEN_PLUS_ASSIGN,
+	TOY_TOKEN_MINUS_ASSIGN,
+	TOY_TOKEN_MULTIPLY_ASSIGN,
+	TOY_TOKEN_DIVIDE_ASSIGN,
+	TOY_TOKEN_MODULO_ASSIGN,
+	TOY_TOKEN_PLUS_PLUS,
+	TOY_TOKEN_MINUS_MINUS,
+	TOY_TOKEN_ASSIGN,
 
 	//logical operators
-	TOKEN_PAREN_LEFT,
-	TOKEN_PAREN_RIGHT,
-	TOKEN_BRACKET_LEFT,
-	TOKEN_BRACKET_RIGHT,
-	TOKEN_BRACE_LEFT,
-	TOKEN_BRACE_RIGHT,
-	TOKEN_NOT,
-	TOKEN_NOT_EQUAL,
-	TOKEN_EQUAL,
-	TOKEN_LESS,
-	TOKEN_GREATER,
-	TOKEN_LESS_EQUAL,
-	TOKEN_GREATER_EQUAL,
-	TOKEN_AND,
-	TOKEN_OR,
+	TOY_TOKEN_PAREN_LEFT,
+	TOY_TOKEN_PAREN_RIGHT,
+	TOY_TOKEN_BRACKET_LEFT,
+	TOY_TOKEN_BRACKET_RIGHT,
+	TOY_TOKEN_BRACE_LEFT,
+	TOY_TOKEN_BRACE_RIGHT,
+	TOY_TOKEN_NOT,
+	TOY_TOKEN_NOT_EQUAL,
+	TOY_TOKEN_EQUAL,
+	TOY_TOKEN_LESS,
+	TOY_TOKEN_GREATER,
+	TOY_TOKEN_LESS_EQUAL,
+	TOY_TOKEN_GREATER_EQUAL,
+	TOY_TOKEN_AND,
+	TOY_TOKEN_OR,
 
 	//other operators
-	TOKEN_QUESTION,
-	TOKEN_COLON,
-	TOKEN_SEMICOLON,
-	TOKEN_COMMA,
-	TOKEN_DOT,
-	TOKEN_PIPE,
-	TOKEN_REST,
+	TOY_TOKEN_QUESTION,
+	TOY_TOKEN_COLON,
+	TOY_TOKEN_SEMICOLON,
+	TOY_TOKEN_COMMA,
+	TOY_TOKEN_DOT,
+	TOY_TOKEN_PIPE,
+	TOY_TOKEN_REST,
 
 	//meta tokens
-	TOKEN_PASS,
-	TOKEN_ERROR,
-	TOKEN_EOF,
-} TokenType;
+	TOY_TOKEN_PASS,
+	TOY_TOKEN_ERROR,
+	TOY_TOKEN_EOF,
+} Toy_TokenType;