Got hooks working

repl/lib_standard.c

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

repl/lib_standard.h

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

repl/makefile

@@ -0,0 +1,27 @@
+CC=gcc
+
+IDIR+=. ../source
+CFLAGS+=$(addprefix -I,$(IDIR)) -g -Wall -W -pedantic -Wno-unused-parameter -Wno-unused-function -Wno-unused-variable
+LIBS+=-ltoy
+
+ODIR = obj
+SRC = $(wildcard *.c)
+OBJ = $(addprefix $(ODIR)/,$(SRC:.c=.o))
+
+OUT=../$(OUTDIR)/toyrepl
+
+all: $(OBJ)
+	$(CC) -DTOY_IMPORT $(CFLAGS) -o $(OUT) $(OBJ) -L$(realpath $(shell pwd)/../$(OUTDIR)) $(LIBS)
+
+$(OBJ): | $(ODIR)
+
+$(ODIR):
+	mkdir $(ODIR)
+
+$(ODIR)/%.o: %.c
+	$(CC) -c -o $@ $< $(CFLAGS)
+
+.PHONY: clean
+
+clean:
+	$(RM) $(ODIR)

repl/repl_main.c

@@ -0,0 +1,262 @@
+#include "console_colors.h"
+
+#include "lexer.h"
+#include "parser.h"
+#include "compiler.h"
+#include "interpreter.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+//extra libraries
+#include "lib_standard.h"
+
+//IO functions
+char* readFile(char* path, size_t* fileSize) {
+	FILE* file = fopen(path, "rb");
+
+	if (file == NULL) {
+		fprintf(stderr, ERROR "Could not open file \"%s\"\n" RESET, path);
+		exit(-1);
+	}
+
+	fseek(file, 0L, SEEK_END);
+	*fileSize = ftell(file);
+	rewind(file);
+
+	char* buffer = (char*)malloc(*fileSize + 1);
+
+	if (buffer == NULL) {
+		fprintf(stderr, ERROR "Not enough memory to read \"%s\"\n" RESET, path);
+		exit(-1);
+	}
+
+	size_t bytesRead = fread(buffer, sizeof(char), *fileSize, file);
+
+	buffer[*fileSize] = '\0'; //NOTE: fread doesn't append this
+
+	if (bytesRead < *fileSize) {
+		fprintf(stderr, ERROR "Could not read file \"%s\"\n" RESET, path);
+		exit(-1);
+	}
+
+	fclose(file);
+
+	return buffer;
+}
+
+void writeFile(char* path, unsigned char* bytes, size_t size) {
+	FILE* file = fopen(path, "wb");
+
+	if (file == NULL) {
+		fprintf(stderr, ERROR "Could not open file \"%s\"\n" RESET, path);
+		exit(-1);
+	}
+
+	int written = fwrite(bytes, size, 1, file);
+
+	if (written != 1) {
+		fprintf(stderr, ERROR "Could not write file \"%s\"\n" RESET, path);
+		exit(-1);
+	}
+
+	fclose(file);
+}
+
+unsigned char* compileString(char* source, size_t* size) {
+	Lexer lexer;
+	Parser parser;
+	Compiler compiler;
+
+	initLexer(&lexer, source);
+	initParser(&parser, &lexer);
+	initCompiler(&compiler);
+
+	//run the parser until the end of the source
+	Node* node = scanParser(&parser);
+	while(node != NULL) {
+		//pack up and leave
+		if (node->type == NODE_ERROR) {
+			printf(ERROR "error node detected\n" RESET);
+			freeNode(node);
+			freeCompiler(&compiler);
+			freeParser(&parser);
+			return NULL;
+		}
+
+		writeCompiler(&compiler, node);
+		freeNode(node);
+		node = scanParser(&parser);
+	}
+
+	//get the bytecode dump
+	unsigned char* tb = collateCompiler(&compiler, (int*)(size));
+
+	//cleanup
+	freeCompiler(&compiler);
+	freeParser(&parser);
+	//no lexer to clean up
+
+	//finally
+	return tb;
+}
+
+void runBinary(unsigned char* tb, size_t size) {
+	Interpreter interpreter;
+	initInterpreter(&interpreter);
+
+	//inject the libs
+	injectNativeHook(&interpreter, "standard", hookStandard);
+
+	runInterpreter(&interpreter, tb, size);
+	freeInterpreter(&interpreter);
+}
+
+void runBinaryFile(char* fname) {
+	size_t size = 0; //not used
+	unsigned char* tb = (unsigned char*)readFile(fname, &size);
+	if (!tb) {
+		return;
+	}
+	runBinary(tb, size);
+	//interpreter takes ownership of the binary data
+}
+
+void runSource(char* source) {
+	size_t size = 0;
+	unsigned char* tb = compileString(source, &size);
+	if (!tb) {
+		return;
+	}
+
+	runBinary(tb, size);
+}
+
+void runSourceFile(char* fname) {
+	size_t size = 0; //not used
+	char* source = readFile(fname, &size);
+	runSource(source);
+	free((void*)source);
+}
+
+void repl() {
+	//repl does it's own thing for now
+	bool error = false;
+
+	const int size = 2048;
+	char input[size];
+	memset(input, 0, size);
+
+	Interpreter interpreter; //persist the interpreter for the scopes
+	initInterpreter(&interpreter);
+
+	//inject the libs
+	injectNativeHook(&interpreter, "standard", hookStandard);
+
+	for(;;) {
+		printf("> ");
+		fgets(input, size, stdin);
+
+		//setup this iteration
+		Lexer lexer;
+		Parser parser;
+		Compiler compiler;
+
+		initLexer(&lexer, input);
+		initParser(&parser, &lexer);
+		initCompiler(&compiler);
+
+		//run this iteration
+		Node* node = scanParser(&parser);
+		while(node != NULL) {
+			//pack up and restart
+			if (node->type == NODE_ERROR) {
+				printf(ERROR "error node detected\n" RESET);
+				error = true;
+				freeNode(node);
+				break;
+			}
+
+			writeCompiler(&compiler, node);
+			freeNode(node);
+			node = scanParser(&parser);
+		}
+
+		if (!error) {
+			//get the bytecode dump
+			int size = 0;
+			unsigned char* tb = collateCompiler(&compiler, &size);
+
+			//run the bytecode
+			runInterpreter(&interpreter, tb, size);
+		}
+
+		//clean up this iteration
+		freeCompiler(&compiler);
+		freeParser(&parser);
+		error = false;
+	}
+
+	freeInterpreter(&interpreter);
+}
+
+//entry point
+int main(int argc, const char* argv[]) {
+	initCommand(argc, argv);
+
+	//command specific actions
+	if (command.error) {
+		usageCommand(argc, argv);
+		return 0;
+	}
+
+	if (command.help) {
+		helpCommand(argc, argv);
+		return 0;
+	}
+
+	if (command.version) {
+		copyrightCommand(argc, argv);
+		return 0;
+	}
+
+	//TODO: remove this when the interpreter meets the specification
+	if (command.verbose) {
+		printf(WARN "Warning! This interpreter is a work in progress, it does not yet meet the %d.%d.%d specification.\n" RESET, TOY_VERSION_MAJOR, TOY_VERSION_MINOR, TOY_VERSION_PATCH);
+	}
+
+	//run source file
+	if (command.sourcefile) {
+		runSourceFile(command.sourcefile);
+		return 0;
+	}
+
+	//run from stdin
+	if (command.source) {
+		runSource(command.source);
+		return 0;
+	}
+
+	//compile source file
+	if (command.compilefile && command.outfile) {
+		size_t size = 0;
+		char* source = readFile(command.compilefile, &size);
+		unsigned char* tb = compileString(source, &size);
+		if (!tb) {
+			return 1;
+		}
+		writeFile(command.outfile, tb, size);
+		return 0;
+	}
+
+	//run binary
+	if (command.binaryfile) {
+		runBinaryFile(command.binaryfile);
+		return 0;
+	}
+
+	repl();
+
+	return 0;
+}