interpreter overhaul, should be better

Makefile

@@ -1,23 +1,13 @@
-#CC = gcc -m32
+CFLAGS = -ggdb
-#AR = ar
+CFILES = $(wildcard *.c)
-CC = arm-none-eabi-gcc -mcpu=cortex-m4 -mthumb -mfloat-abi=hard -mfpu=fpv4-sp-d16
+
-AR = arm-none-eabi-ar
+all:
-
+	@echo $(CFILES)
-CFLAGS = -Wall -Wextra -Werror -pedantic \
+	@gcc -m32 $(CFLAGS) $(CFILES) -o shell
-	-Wno-discarded-qualifiers \
+
-	-I. -fsigned-char -fno-builtin -ggdb
+arm:
-
+	@mv shell.c shell.c.bak
-FILES = $(wildcard *.c)
+	@arm-none-eabi-gcc -mcpu=cortex-m4 -mthumb -mfloat-abi=hard -mfpu=fpv4-sp-d16 $(CFLAGS) -c *.c
-OUTFILES = $(patsubst %.c, %.o, $(FILES))
+	@arm-none-eabi-ar r libinterp.a *.o
-
+	@mv shell.c.bak shell.c
-all: $(OUTFILES)
+	@rm *.o
-	@#$(CC) $(CFLAGS) *.o -o shell
-	@$(AR) r libinterp.a *.o
-
-clean:
-	@echo "  CLEAN"
-	@rm -f *.o shell libinterp.a
-
-%.o: %.c
-	@echo "  CC     " $<
-	@$(CC) $(CFLAGS) -c $< -o $@

README.md

@@ -1,24 +1,23 @@
 # interpreter
-This project aims to provide a very minimal scripting language for embedded systems. Many other languages already exist, such as Lua, Tcl, or BASIC; however, most implementations require certain system calls like a read() and write(), as they expect a filesystem. This interpreter aims to be as independent and portable as possible: parsing script from strings one at a time, having minimal built-in functions (so the user can define their own prints and such), and only requiring a few standard library functions.  
+This project aims to provide a very minimal scripting language for embedded systems. Many other languages already exist, such as Lua, Tcl, or BASIC; however, most implementations require certain system calls like read() and write(), as they expect a filesystem. This interpreter wants to be as system-independent and portable as possible: parsing script from strings one at a time, having minimal built-in functions (so the user can define their own IO calls and such), and only requiring a few standard library functions.  
   
-To use this program with your own device, you need some malloc/free implementation, and string functions like those in string.h, atoi, and snprintf. Some of these functions may become coded in so that a standard library isn't required.  
+To use this program with your own device, you'll need some malloc/free implementation, and a freestanding standard library. Newlib works well for this; however, functions like atoi() and snprintf() will probably need to be rewritten (if you don't have an \_sbrk defined).  
   
-Only a few commands are built in to the interpreter:  
+Interpreter features:
-* set - set variables
+* Variable/function definition - in C and in script
-* func/end - define functions
+* if/else and while loops
-* if/end - if conditional
+* a solve function to parse strings at runtime
-* do/while
-* ret - return value from function
 
-Other features:  
+Inconvenient features: 
-* function/variable defining in c
-* expression solving  
 * no local variables
-* whitespace hopefully ignored
+* whitespace sometimes ignored
   
-Soon:  
+Some TODO items: 
-* error messages
+* fix all memory leaks
+* add better error messages
 * arrays?
-* maybe for loops
+* for loops 
-  
+ 
-This project is still in heavy development, so don't expect much. To include it in your own project, just link in parser.o and use the header files.
+
+This project can be made for the host system (```make```) or an ARM system (```make arm```). 
+This project is still in heavy development, so don't expect much. To include it in your own project, just link in libinterp.a (for ARM) and use the header files.

builtins.c

@@ -1,179 +1,124 @@
 #include "builtins.h"
-#include "stack.h"
+
-#include "shelpers.h"
+#include <stdlib.h>
-
+
-#include <memory.h>
+#define IF_SIG    (uint32_t)-1
-#include <string.h>
+#define WHILE_SIG (uint32_t)-2
-
+#define ELSE_SIG  (uint32_t)-3
-int ifunc_set(interpreter *it);
+#define FUNC_SIG  (uint32_t)-4
-int ifunc_label(interpreter *it);
+
-int ifunc_end(interpreter *it);
+int bn_set(instance *it);
-int ifunc_if(interpreter *it);
+int bn_if(instance *it);
-int ifunc_do(interpreter *it);
+int bn_else(instance *it);
-int ifunc_while(interpreter *it);
+int bn_end(instance *it);
-int ifunc_ret(interpreter *it);
+int bn_while(instance *it);
-int ifunc_else(interpreter *it);
+int bn_func(instance *it);
-int ifunc_solve(interpreter *it);
+int bn_solve(instance *it);
-
+
-const func_t indent_up[IUP_COUNT] = {
+void iload_builtins(instance *it)
-	ifunc_if, ifunc_do, ifunc_label
-};
-
-const func_t indent_down[IDOWN_COUNT] = {
-	ifunc_else, ifunc_end, ifunc_while, 
-};
-
-void iload_core(interpreter *interp)
 {
-	inew_cfunc(interp, "set", ifunc_set);
+	inew_cfunc(it, "set", bn_set);
-	inew_cfunc(interp, "func", ifunc_label);
+	inew_cfunc(it, "if", bn_if);
-	inew_cfunc(interp, "end", ifunc_end);
+	inew_cfunc(it, "else", bn_else);
-	inew_cfunc(interp, "if", ifunc_if);
+	inew_cfunc(it, "while", bn_while);
-	inew_cfunc(interp, "do", ifunc_do);
+	inew_cfunc(it, "func", bn_func);
-	inew_cfunc(interp, "while", ifunc_while);
+	inew_cfunc(it, "solve", bn_solve);
-	inew_cfunc(interp, "ret", ifunc_ret);
-	inew_cfunc(interp, "else", ifunc_else);
-	inew_cfunc(interp, "solve", ifunc_solve);
 }
 
-int ifunc_solve(interpreter *it)
+int bn_set(instance *it)
 {
-	const char *expr = igetarg_string(it, 0);
+	variable *var = igetarg(it, 0);
-	int len = strlen(expr);
+	variable *value = igetarg(it, 1);
-	char *buf = (char *)malloc(len + 2);
+	var->type = value->type;
-	strcpy(buf, expr);
+	var->value.p = value->value.p;
-	buf[len] = ')';
+	ipush(it, (uint32_t)var);
-	buf[len + 1] = '\0';
-	variable *r = idoexpr(it, buf);
-	free(buf);
-	if (r == 0)
-		r = make_varn(0, 0.0f);
-	iret(it, r);
-	free(r);
 	return 0;
 }
 
-int ifunc_set(interpreter *it)
+int bn_if(instance *it)
 {
-	variable *n = igetarg(it, 0);
+	variable *cond = (variable *)ipop(it);
-	variable *v = igetarg(it, 1);
+	uint32_t result = cond->value.p;
 
-	if (n == 0)
+	ipush(it, result);
-		return -1;
+	ipush(it, IF_SIG);
+	if (result == 0)
+		it->sindent = SKIP | it->indent;
+	ipush(it, 0);
+	ipush(it, 0); // need to return because stack modify
 
-	if (n->valtype == STRING)
-		free((void *)n->value.p);
-	n->valtype = v->valtype;
-	n->value.p = v->value.p;
 	return 0;
 }
 
-int ifunc_label(interpreter *it)
+static uint32_t if_cond = 0;
+int bn_else(instance *it)
 {
-	variable *n = igetarg(it, 0);
+	uint32_t cond = if_cond;
-	
+	if (cond != 0)
-	if (n == 0)
+		it->sindent = SKIP | it->indent;
-		return -1;
+	ipush(it, ELSE_SIG);
-
+	ipush(it, 0); // for ret
-	n->valtype = FUNC;
-	n->value.p = it->lnidx;
-	iskip(it);
 	return 0;
 }
 
-int ifunc_if(interpreter *it)
+int bn_end(instance *it)
 {
-	int v = igetarg(it, 0)->value.p;
+	uint32_t sig = ipop(it);
-	if (v == 0)
+	if (sig == IF_SIG) {
-		iskip(it);
+		if_cond = ipop(it);
-	void *arg = ipop(it);
+	} else if (sig == WHILE_SIG) {
-	ipush(it, (void *)v);
+		uint32_t lnidx = ipop(it);
-	ipush(it, (void *)-1);
+		if (lnidx != (int32_t)-1)
-	ipush(it, arg);
+			it->lnidx = lnidx - 1;
-	return 0;
+	} else if (sig == CALL_SIG) {
+		it->lnidx = ipop(it);
+		it->indent++;
+	}
+ 	return 0;
 }
 
-int ifunc_end(interpreter *it)
+int bn_while(instance *it)
 {
-	if (it->stidx == 0)
+	variable *cond = (variable *)ipop(it);
-		return 0;
+	uint32_t result = cond->value.p;
 
-	uint32_t lnidx = (uint32_t)ipop(it) + 1;
+	if (result == 0) {
-	if (lnidx == 0) { // from an if, have conditional
+		it->sindent = SKIP | it->indent;
-		ipop(it); // whatever
+		ipush(it, (uint32_t)-1);
 	} else {
-		if (lnidx == (uint32_t)-1) {
+		ipush(it, it->lnidx);
-			// script-func call
-			lnidx = (uint32_t)ipop(it);
-			it->indent = (uint32_t)ipop(it);
-		}
-		it->lnidx = lnidx;
 	}
-	return 0;
+	ipush(it, WHILE_SIG);
-}
-
-int ifunc_else(interpreter *it)
-{
-	if (it->stidx == 0)
-		return 0;
-
-	ipop(it); // the -1
-	int cond = (int)ipop(it);
-	it->indent++;
-	if (cond != 0)
-		iskip(it);
-	// otherwise it's whatever?
 	ipush(it, 0);
-	ipush(it, (void *)-1);
+	ipush(it, 0); // need to ret
-
 	return 0;
 }
 
-int ifunc_do(interpreter *it)
+int bn_func(instance *it)
 {
-	ipush(it, (void *)it->lnidx);
+	variable *f = igetarg(it, 0);
-	return 0;
+	if (f == 0)
-}
+		return -1;
 
-int ifunc_while(interpreter *it)
+	f->type = FUNC;
-{
+	f->value.p = it->lnidx;
-	int c = igetarg(it, 0)->value.p;
+	it->sindent = SKIP | it->indent;
-	ipop(it);
+	ipush(it, FUNC_SIG);
-	int nidx = (int)ipop(it);
+	ipush(it, 0); // for ret
-	if (c != 0) {
-		//ipush(it, (void *)nidx);
-		it->lnidx = nidx - 1;
-	}
-	ipush(it, 0);
 	return 0;
 }
 
-void iret(interpreter *it, variable *v)
+int bn_solve(instance *it)
 {
-	switch (v->valtype) {
+	variable *s = igetarg(it, 0);
-	case NUMBER:
+	variable **ops = iparse(it, (const char *)s->value.p);
-		inew_number(it, "RET", v->value.f);
+	if (ops == 0)
-		break;
+		return -1;
-	case STRING:
-		inew_string(it, "RET", (char *)v->value.p);
-		break;
-	default:
-		return;
-		break;
-	}
-	if (it->ret != 0) {
-		if (it->ret->valtype == STRING && it->ret->value.p != 0)
-			free((void *)it->ret->value.p);
-		it->ret->valtype = v->valtype;
-		it->ret->value.p = v->value.p;
-		it->ret = 0;
-	}
-}
 
-int ifunc_ret(interpreter *it)
+	variable *a = isolve(it, ops, 0);
-{
+	free(ops);
-	variable *v = igetarg(it, 0);
+
-	iret(it, v);
+	ipush(it, (uint32_t)a);
 	return 0;
 }
 

builtins.h

@@ -3,14 +3,11 @@
 
 #include "parser.h"
 
-#define IUP_COUNT 3
+#define SKIP_SIG (uint32_t)-5
-#define IDOWN_COUNT 3
+#define CALL_SIG (uint32_t)-6
 
-void iload_core(interpreter *it);
+void iload_builtins(instance *it);
 
-void iret(interpreter *it, variable *v);
+int bn_end(instance *it);
-
-const func_t indent_up[IUP_COUNT];
-const func_t indent_down[IDOWN_COUNT];
 
 #endif // BUILTINS_H_

memory.h

@@ -1,8 +0,0 @@
-#ifndef MEMORY_H_
-#define MEMORY_H_
-
-void *malloc(unsigned int);
-void *calloc(unsigned int, unsigned int);
-void free(void *);
-
-#endif // MEMORY_H_

ops.c

@@ -1,117 +1,197 @@
 #include "ops.h"
 
+#include <stdlib.h>
 #include <string.h>
 
-void iop_add(variable *, variable *, variable *);
+#define OP_DEF(o) int op_##o(variable *r, variable *a, variable *b)
-void iop_sub(variable *, variable *, variable *);
+#define OP_VAR(o) {0, OPERATOR, 0, {.p = (uint32_t)op_##o}}
-void iop_mult(variable *, variable *, variable *);
+#define OP_NONE   {0, OPERATOR, 0, {.p = 0x0BADCAFE}}
-void iop_div(variable *, variable *, variable *);
+
-void iop_and(variable *, variable *, variable *);
+extern char *strclone(const char *s);
-void iop_or(variable *, variable *, variable *);
+
-void iop_xor(variable *, variable *, variable *);
+OP_DEF(mul);
-void iop_shr(variable *, variable *, variable *);
+OP_DEF(div);
-void iop_shl(variable *, variable *, variable *);
+OP_DEF(mod);
-void iop_eq(variable *, variable *, variable *);
+OP_DEF(add);
-void iop_lt(variable *, variable *, variable *);
+OP_DEF(sub);
-void iop_gt(variable *, variable *, variable *);
+OP_DEF(shl);
-void iop_lte(variable *, variable *, variable *);
+OP_DEF(shr);
-void iop_gte(variable *, variable *, variable *);
+OP_DEF(lte);
-void iop_ne(variable *, variable *, variable *);
+OP_DEF(lt);
-void iop_mod(variable *, variable *, variable *);
+OP_DEF(gte);
-
+OP_DEF(gt);
-char *iops[IOPS_COUNT] = {
+OP_DEF(eq);
-	"*", "/", "%", "+", "-", "<<", ">>", "<=",
+OP_DEF(ne);
-	"<", ">=", ">", "==", "!=", "&", "^", "|"
+OP_DEF(and);
+OP_DEF(xor);
+OP_DEF(or);
+OP_DEF(set);
+
+variable opvars[] = {
+	OP_VAR(mul), OP_VAR(div), OP_VAR(mod), OP_NONE,
+	OP_VAR(add), OP_VAR(sub), OP_VAR(shl), OP_VAR(shr),
+	OP_VAR(lte), OP_VAR(lt), OP_VAR(gte), OP_VAR(gt),
+	OP_VAR(eq), OP_VAR(ne), OP_VAR(and), OP_VAR(xor),
+	OP_VAR(or), OP_VAR(set)
 };
 
-operation_t iopfuncs[IOPS_COUNT] = {
+const char *opnames[] = {
-	iop_mult, iop_div, iop_mod, iop_add, iop_sub,
+	"*", "/", "%", 0,
-	iop_shl, iop_shr, iop_lte, iop_lt, iop_gte,
+	"+", "-", "<<", ">>",
-	iop_gt, iop_eq, iop_ne, iop_and, iop_xor,
+	"<=", "<", ">=", ">",
-	iop_or
+	"==", "!=", "&", "^",
+	"|", "=" 
 };
 
-
+OP_DEF(mul)
-void iop_add(variable *r, variable *a, variable *b)
-{
-	r->value.f = a->value.f + b->value.f;
-}
-
-void iop_sub(variable *r, variable *a, variable *b)
-{
-	r->value.f = a->value.f - b->value.f;
-}
-
-void iop_mult(variable *r, variable *a, variable *b)
 {
+	if (a->type != NUMBER || b->type != NUMBER)
+		return -1;
+	r->type = NUMBER;
 	r->value.f = a->value.f * b->value.f;
+	return 0;
 }
-
+OP_DEF(div)
-void iop_div(variable *r, variable *a, variable *b)
 {
+	if (a->type != NUMBER || b->type != NUMBER)
+		return -1;
+	r->type = NUMBER;
 	r->value.f = a->value.f / b->value.f;
+	return 0;
 }
-
+OP_DEF(mod)
-void iop_and(variable *r, variable *a, variable *b)
 {
-	r->value.f = (float)((int)a->value.f & (int)b->value.f);
+	if (a->type != NUMBER || b->type != NUMBER)
+		return -1;
+	r->type = NUMBER;
+	r->value.f = (int)a->value.f % (int)b->value.f;
+	return 0;
 }
-
+OP_DEF(add)
-void iop_or(variable *r, variable *a, variable *b)
 {
-	r->value.f = (float)((int)a->value.f | (int)b->value.f);
+	if (a->type != NUMBER || b->type != NUMBER)
+		return -1;
+	r->type = NUMBER;
+	r->value.f = a->value.f + b->value.f;
+	return 0;
 }
-
+OP_DEF(sub)
-void iop_xor(variable *r, variable *a, variable *b)
 {
-	r->value.f = (float)((int)a->value.f ^ (int)b->value.f);
+	if (a->type != NUMBER || b->type != NUMBER)
+		return -1;
+	r->type = NUMBER;
+	r->value.f = a->value.f - b->value.f;
+	return 0;
 }
-
+OP_DEF(shl)
-void iop_shr(variable *r, variable *a, variable *b)
 {
-	r->value.f = (float)((int)a->value.f >> (int)b->value.f);
+	if (a->type != NUMBER || b->type != NUMBER)
+		return -1;
+	r->type = NUMBER;
+	r->value.f = (int)a->value.f << (int)b->value.f;
+	return 0;
 }
-
+OP_DEF(shr)
-void iop_shl(variable *r, variable *a, variable *b)
 {
-	r->value.f = (float)((int)a->value.f << (int)b->value.f);
+	if (a->type != NUMBER || b->type != NUMBER)
+		return -1;
+	r->type = NUMBER;
+	r->value.f = (int)a->value.f >> (int)b->value.f;
+	return 0;
 }
-
+OP_DEF(lte)
-void iop_eq(variable *r, variable *a, variable *b)
 {
-	if (a->valtype == STRING && b->valtype == STRING)
+	if (a->type != NUMBER || b->type != NUMBER)
-		r->value.f = (float)!strcmp((char *)a->value.p, (char *)b->value.p);
+		return -1;
-	else
+	r->type = NUMBER;
-		r->value.f = a->value.f == b->value.f;
+	r->value.f = a->value.f <= b->value.f;
+	return 0;
 }
-
+OP_DEF(lt)
-void iop_lt(variable *r, variable *a, variable *b)
 {
+	if (a->type != NUMBER || b->type != NUMBER)
+		return -1;
+	r->type = NUMBER;
 	r->value.f = a->value.f < b->value.f;
+	return 0;
 }
-
+OP_DEF(gte)
-void iop_gt(variable *r, variable *a, variable *b)
 {
-	r->value.f = a->value.f > b->value.f;
+	if (a->type != NUMBER || b->type != NUMBER)
+		return -1;
+	r->type = NUMBER;
+	r->value.f = a->value.f >= b->value.f;
+	return 0;
 }
-
+OP_DEF(gt)
-void iop_lte(variable *r, variable *a, variable *b)
 {
-	r->value.f = a->value.f <= b->value.f;
+	if (a->type != NUMBER || b->type != NUMBER)
+		return -1;
+	r->type = NUMBER;
+	r->value.f = a->value.f > b->value.f;
+	return 0;
 }
-
+OP_DEF(eq)
-void iop_gte(variable *r, variable *a, variable *b)
 {
-	r->value.f = a->value.f >= b->value.f;
+	r->type = NUMBER;
-}
+	if (a->type == NUMBER && b->type == NUMBER)
+		r->value.f = a->value.f == b->value.f;
+	else if (a->type == STRING && b->type == STRING)
+		r->value.f = !strcmp((const char *)a->value.p, (const char *)b->value.p);
+	else
+		return -1;
 
-void iop_ne(variable *r, variable *a, variable *b)
+	return 0;
-{
-	r->value.f = a->value.f != b->value.f;
 }
-
+OP_DEF(ne)
-void iop_mod(variable *r, variable *a, variable *b)
 {
-	r->value.f = (float)((int)a->value.f % (int)b->value.f);
+	if (a->type != NUMBER || b->type != NUMBER)
+		return -1;
+	r->type = NUMBER;
+	r->value.f = a->value.f != b->value.f;
+	return 0;
+}
+OP_DEF(and)
+{
+	if (a->type != NUMBER || b->type != NUMBER)
+		return -1;
+	r->type = NUMBER;
+	r->value.f = (int)a->value.f & (int)b->value.f;
+	return 0;
+}
+OP_DEF(xor)
+{
+	if (a->type != NUMBER || b->type != NUMBER)
+		return -1;
+	r->type = NUMBER;
+	r->value.f = (int)a->value.f ^ (int)b->value.f;
+	return 0;
+}
+OP_DEF(or)
+{
+	if (a->type != NUMBER || b->type != NUMBER)
+		return -1;
+	r->type = NUMBER;
+	r->value.f = (int)a->value.f | (int)b->value.f;
+	return 0;
+}
+OP_DEF(set)
+{
+	if (b->type == NUMBER) {
+		a->type = NUMBER;
+		a->value.f = b->value.f;
+		r->type = NUMBER;
+		r->value.f = a->value.f;
+	} else if (b->type == STRING) {
+		a->type = STRING;
+		if (a->value.p != 0)
+			free((void *)a->value.p);
+		a->value.p = (uint32_t)strclone((char *)b->value.p);
+		r->type = STRING;
+		r->value.p = (uint32_t)strclone((char *)a->value.p);
+	} else {
+		return -1;
+	}
+	return 0;
 }
 

ops.h

@@ -1,13 +1,14 @@
 #ifndef OPS_H_
 #define OPS_H_
 
-#include "parser.h"
+#include "variable.h"
 
-#define IOPS_COUNT 16
+#define OPS_COUNT 18
+#define OP_MAGIC  0xCAFE3900
 
-typedef void (*operation_t)(variable *, variable *, variable *);
+typedef int (*opfunc_t)(variable *, variable *, variable *);
 
-extern char *iops[IOPS_COUNT];
+extern variable opvars[];
-extern operation_t iopfuncs[IOPS_COUNT];
+extern const char *opnames[];
 
 #endif // OPS_H_

parser.c

@@ -1,478 +1,486 @@
-#include <parser.h>
+#include "parser.h"
 
-#include "shelpers.h"
 #include "builtins.h"
-#include "stack.h"
 #include "ops.h"
 
 #include <ctype.h>
 #include <stdlib.h>
-#include <memory.h>
+#include <stdio.h>
 #include <string.h>
 
-#define MAX_VARS  100
+#define MAX_VARS  256
-#define MAX_STACK 32
+#define MAX_STACK 64
 #define MAX_LINES 1000
 
-void iinit(interpreter *interp)
+char *strnclone(const char *s, size_t c)
 {
-	interp->vars = (variable *)calloc(MAX_VARS, sizeof(variable));
+	char *b = strncpy((char *)malloc(c + 1), s, c);
-	interp->vnames = (char **)calloc(MAX_VARS, sizeof(char *));
+	b[c] = '\0';
-	interp->stack = (stack_t *)calloc(MAX_STACK, sizeof(stack_t));
+	return b;
-	interp->stidx = 0;
-	interp->lines = (variable ***)calloc(MAX_LINES, sizeof(variable **));
-	interp->lnidx = 0;
-	interp->indent = 0;
-	interp->sindent = 0;
-	interp->ret = 0;
-
-	iload_core(interp);
 }
-
+char *strclone(const char *s)
-void iend(interpreter *it)
 {
-	for (unsigned int i = 0; i < MAX_VARS; i++) {
+	return strnclone(s, strlen(s)); 
-		if (it->vars[i].used == 1) {
+}
-			if (it->vars[i].valtype == STRING ||
+char *fixstring(const char *s)
-				it->vars[i].valtype == EXPR)
+{
-				free((void *)it->vars[i].value.p);
+	char *n = malloc(strlen(s) + 1 - 2);
-			free(it->vnames[i]);
+	int j = 0;
-		}
+	for (int i = 1; s[i] != '\"'; i++, j++) {
-	}
+		if (s[i] == '\\') {
-	for (unsigned int i = 0; i < MAX_LINES; i++) {
+			if (s[i + 1] == 'n')
-		if (it->lines[i] != 0) {
+				n[j] = '\n';
-			for (unsigned int j = 0; (int32_t)it->lines[i][j] > 0; j++) {
+			i++;
-				switch (it->lines[i][j]->valtype) {
+		} else {
-				case STRING:
+			n[j] = s[i];
-					if (!it->lines[i][j]->used)
-						free(it->lines[i][j]);
-					break;
-				case EXPR:
-					free((void *)it->lines[i][j]->value.p);
-					free(it->lines[i][j]);
-					break;
-				case NUMBER:
-					if (!it->lines[i][j]->used)
-						free(it->lines[i][j]);
-					break;
-				}
-			}
 		}
-		free(it->lines[i]);
 	}
+	n[j] = '\0';
+	return n;
+}
+
+void itryfree(variable *v)
+{
+	if (v == 0 || v->tmp == 0)
+		return;
+	if (v->type == STRING)
+		free((void *)v->value.p);
+	free(v);
+}
+
+instance *inewinstance(void)
+{
+	instance *it = (instance *)malloc(sizeof(instance));
+	it->vars = (variable *)calloc(MAX_VARS, sizeof(variable));
+	it->names = (char **)calloc(MAX_VARS, sizeof(char *));
+	it->stack = (uint32_t *)malloc(MAX_STACK * sizeof(uint32_t));
+	it->stidx = 0;
+	it->lines = (char **)calloc(MAX_LINES, sizeof(char *));
+	it->lnidx = 0;
+	it->ret = 0;
+	it->indent = 0;
+	it->sindent = 0;
+
+	iload_builtins(it);
+	return it;
+}
+
+void idelinstance(instance *it)
+{
 	free(it->vars);
-	free(it->vnames);
+	for (uint32_t i = 0; i < MAX_VARS; i++)
+		free(it->names[i]);
+	free(it->names);
 	free(it->stack);
+	for (uint32_t i = 0; i < MAX_VARS; i++)
+		free(it->lines[i]);
 	free(it->lines);
+	itryfree(it->ret);
+	free(it);
 }
 
-void iskip(interpreter *it)
+void ipush(instance *it, uint32_t v)
 {
-	if (!(it->sindent & SKIP))
+	it->stack[it->stidx++] = v;
-		it->sindent = it->indent | SKIP;
 }
 
-variable *interpreter_get_variable(interpreter *interp, const char *name)
+uint32_t ipop(instance *it)
 {
-	for (uint32_t i = 0; i < MAX_VARS; i++) {
+	return it->stack[--it->stidx];
-		if (!interp->vars[i].used) {
-			variable *v = make_vars(&interp->vars[i], 0);
-			v->used = 1;
-			interp->vnames[i] = strclone(name);
-			return v;
-		} else if (interp->vnames[i] != 0 && !strcmp(interp->vnames[i], name)) {
-			return &interp->vars[i];
-		}
-	}
-	return 0;
 }
 
-char *interpreter_get_name(interpreter *interp, variable *v)
+void ipopm(instance *it, uint32_t count)
 {
-	for (uint32_t i = 0; i < MAX_VARS; i++) {
+	it->stidx -= count;
-		if (v == &interp->vars[i])
-			return interp->vnames[i];
-	}
-	return "(undefined)";
 }
 
-variable *inew_string(interpreter *interp, const char *name, const char *value)
+variable *igetarg(instance *it, uint32_t n)
 {
-	variable *v = interpreter_get_variable(interp, name);
+	return (variable *)it->stack[it->stidx - n - 1];
-	if (v != 0) {
-		if (v->valtype == STRING && v->value.p != 0)
-			free((void *)v->value.p);
-		v->valtype = STRING;
-		v->value.p = (uint32_t)strclone(value);
-	}
-	return v;
 }
 
-variable *inew_number(interpreter *interp, const char *name, float value)
+variable *igetvar(instance *it, const char *name);
+void inew_cfunc(instance *it, const char *name, func_t func)
 {
-	variable *v = interpreter_get_variable(interp, name);
+	variable *v = igetvar(it, name);
-	if (v != 0) {
+	v->type = CFUNC;
-		v->valtype = NUMBER;
+	v->value.p = (uint32_t)func;
-		v->value.f = value;
+}
-	}
+
+void inew_number(instance *it, const char *name, float f)
+{
+	variable *v = igetvar(it, name);
+	v->type = NUMBER;
+	v->value.f = f;
+}
+
+void inew_string(instance *it, const char *name, const char *s)
+{
+	variable *v = igetvar(it, name);
+	v->type = STRING;
+	v->value.p = (uint32_t)strclone(s);
+}
+
+variable *varclone(variable *n)
+{
+	variable *v = (variable *)malloc(sizeof(variable));
+	v->tmp = 1;
+	v->type = n->type;
+	if (n->type == STRING)
+		v->value.p = (uint32_t)strclone((char *)n->value.p);
+	else
+		v->value.p = n->value.p;
 	return v;
 }
 
-variable *inew_cfunc(interpreter *interp, const char *name, func_t func)
+variable *make_varf(variable *v, float f)
 {
-	variable *v = interpreter_get_variable(interp, name);
+	if (v == 0) {
-	if (v != 0) {
+		v = (variable *)malloc(sizeof(variable));
-		v->fromc = 1;
+		v->tmp = 1;
-		v->valtype = FUNC;
-		v->value.p = (uint32_t)func;
 	}
+	v->type = NUMBER;
+	v->value.f = f;
 	return v;
 }
 
-variable *make_var(interpreter *interp, const char *line, uint32_t *next)
+variable *make_vars(variable *v, const char *s)
 {
-	if (line[0] == '\"') { // string literal
+	if (v == 0) {
-		uint32_t end = 1;
+		v = (variable *)malloc(sizeof(variable));
-		while (!eol(line[end])) {
+		v->tmp = 1;
-			if (line[end] == '\"'/* && line[end - 1] != '\\'*/) {
-				if (!eot(line[end + 1]))
-					return 0;
-				// TODO string breakdown
-				*next = end + 1;
-				char *str = strnclone(line + 1, end - 1);
-				variable *v = make_vars(0, str);
-				free(str);
-				return v;
-			}
-			end++;
-		}
-		return 0;
-	} else if (line[0] == '(') { // equation literal
-		uint32_t end = findend(line, '(', ')');
-		if (eot(line[end]))
-			return 0;
-		*next = end + 1;
-		char *expr = strnclone(line + 1, end);
-		variable *v = make_vare(0, expr);
-		free(expr);
-		return v;
-	} else {
-		variable *v = make_varn(0, 0.0f);
-		int inc = try_number(v, line);
-		if (inc != 0) {
-			*next = inc;
-			return v;
-		}
-		free(v);
-		char *name = 0;
-		inc = try_variable(&name, line);
-		if (inc != 0) {
-			*next = (inc > 0) ? inc : -inc;
-			variable *v = interpreter_get_variable(interp, name);
-			free(name);
-			return v;
-		}
 	}
-	return 0;
+	v->type = STRING;
+	v->value.p = (uint32_t)strclone(s);
+	return v;
 }
 
-int idoline(interpreter *interp, const char *line)
+variable *make_num(const char *text)
 {
-	uint32_t ooffset = 0, offset = 0, next;
+	int decimal = -1;
-	int fret = 0;
+	char valid = 0;
-
+
-	if (line[0] == '\0')
+	int i = 0;
-		return 0;
+	if (text[0] == '-')
-	skipblank(line, eol, &offset);
+		i++;
-	if (line[offset] == '#' || eol(line[offset]))
+	do {
-		return 0;
+		if (text[i] == '.') {
-
+			if (decimal >= 0) {
-	variable **linebuf = (variable **)calloc(8, sizeof(variable *));
+				valid = 0;
-	interp->lines[interp->lnidx] = linebuf;
+				break;
-	variable **ops = interp->lines[interp->lnidx];
+			}
-
+			decimal = i;
-	// step 1 - convert to tokens
+		} else if (isdigit(text[i])) {
-	while (!eol(line[offset])) {
+			valid |= 1;
-		if (offset > 0 && line[offset] == '>') {
-			offset++;
-			skipblank(line, eol, &offset);
-			variable *r = make_var(interp, line + offset, &next);
-			ops[ooffset] = (void *)-1;
-			ops[ooffset + 1] = r;
-			offset += next;
-			skipblank(line, eol, &offset);
-			continue;
-		}
-		variable *v = make_var(interp, line + offset, &next);
-		ops[ooffset] = v;
-		if (ops[ooffset] == 0) {
-			fret = -4;
-			goto fail;
 		} else {
-			ooffset++;
+			break;
-			offset += next;
 		}
-		skipblank(line, eol, &offset);
+	} while (text[++i] != '\0');
-	}
 
-	// step 2 - execute
+	if (valid == 0)
-	if (ooffset == 0) {
+		return 0;
-		fret = -1;
-		goto fail;
-	}
-
-	if (ops[0]->valtype != FUNC) {
-		fret = -2;
-		goto fail;
-	}
 
-	if (ops[0]->fromc && ops[0]->value.p == 0) {
+	char *buf = (char *)malloc(i + 1);
-		fret = -3;
+	strncpy(buf, text, i);
-		goto fail;
+	buf[i] = '\0';
-	}
 
-	if (ops[ooffset] != (void *)-1)
+	variable *v = make_varf(0, strtof(buf, 0));
-		ops[ooffset] = 0;
+	free(buf);
+	return v;
+}
 
-loop:
+variable *igetop(instance *it, const char *name)
-	for (uint8_t i = 0; i < IUP_COUNT; i++) {
+{
-		if (interp->lines[interp->lnidx][0]->value.p
+	for (uint32_t i = 0; i < OPS_COUNT; i++) {
-			== (uint32_t)indent_up[i]) {
+		if (opnames[i] != 0 && !strcmp(name, opnames[i])) {
-			interp->indent++;
+			return &opvars[i];
-			goto cont;
 		}
 	}
-	for (uint8_t i = 0; i < IDOWN_COUNT; i++) {
+	return 0;
-		if (interp->lines[interp->lnidx][0]->value.p
+}
-			== (uint32_t)indent_down[i]) {
+variable *igetvar(instance *it, const char *name)
-			if (--interp->indent < 0) {
+{
-				fret = -6;
+	if (isalpha(name[0])) {
-				goto fail;
+		for (uint32_t i = 0; i < MAX_VARS; i++) {
+			if (it->names[i] == 0) {
+				it->names[i] = strclone(name);
+				// default to 0 float
+				return make_varf(&it->vars[i], 0.0f);
+			} else if (!strcmp(name, it->names[i])) {
+				return &it->vars[i];
 			}
-			if (interp->indent < (interp->sindent & ~(SKIP)))
-				interp->sindent &= ~(SKIP);
-			else
-				goto cont;
-			break;
 		}
 	}
 
-cont:
+	return igetop(it, name);
-	if (interp->indent > 0 && interp->sindent & SKIP)
+}
-		goto norun;
-
-	ops = (variable **)malloc(8 * sizeof(variable *));
-	for (uint8_t i = 0; i < 8; i++)
-		ops[i] = interp->lines[interp->lnidx][i];
-	uint32_t oldLnidx = interp->lnidx;
-	
-	// eval expressions
-	ooffset = 1;
-	for (; ops[ooffset] != 0 && ops[ooffset] != (void *)-1; ooffset++) {
-		if (ops[ooffset]->valtype == EXPR) {
-			char *expr = strclone((char *)ops[ooffset]->value.p);
-			variable *r = idoexpr(interp, expr);
-			ops[ooffset] = r;
-			free(expr);
-		}
-	}
 
-	if (ops[ooffset] == (void *)-1)
+int idoline(instance *it, const char *s)
-		interp->ret = ops[ooffset + 1];
+{
-
+	it->lines[it->lnidx] = strclone(s);
-	if (ops[0]->fromc) {
+	variable **ops;
-		for (uint32_t i = ooffset; --i > 0;)
+loop:
-			ipush(interp, ops[i]);
+	ops = iparse(it, it->lines[it->lnidx]);
-
-		int ret = ((func_t)ops[0]->value.p)(interp);
-		if (ret != 0)
-			return ret;
-		ipopm(interp, ooffset - 1);
-	} else {
-		char an[6];
-		for (uint32_t i = 1; i < ooffset; i++) {
-			snprintf(an, 6, "arg%d", (int)(i - 1));
-			switch (ops[i]->valtype) {
-			case STRING:
-				inew_string(interp, an, (char *)ops[i]->value.p);
-				break;
-			case NUMBER:
-				inew_number(interp, an, ops[i]->value.f);
-				break;
-			default:
-				break;
-			}
-		}
 
-		ipush(interp, (void *)(uint32_t)interp->indent);
+	if (it->ret != 0)
-		ipush(interp, (void *)interp->lnidx);
+		itryfree(it->ret);
-		ipush(interp, (void *)-2); // magic
+	it->ret = 0;
-		interp->lnidx = ops[0]->value.p;
-		interp->indent++;
-	}
 
-	if ((int32_t)interp->stidx < 0) {
+	if (ops == 0)
-		interp->stidx = 0;
+		goto next;
-		return -5;
+	it->ret = isolve(it, ops, 0);
-	}
 
-	for (uint32_t i = 1; i < ooffset; i++) {
+next:
-		if (ops[i] != interp->lines[oldLnidx][i]) {
-			if (ops[i]->valtype == STRING || ops[i]->valtype == EXPR)
-				free((void *)ops[i]->value.p);
-			free(ops[i]);
-		}
-	}
 	free(ops);
-norun:
+	it->lnidx++;
-	interp->lnidx++;
+	if (it->lines[it->lnidx] != 0)
-	if (interp->lines[interp->lnidx] != 0)
 		goto loop;
 
 	return 0;
+}
+
+variable *isolve_(instance *it, variable **ops, uint32_t count);
+variable *isolve(instance *it, variable **ops, uint32_t count)
+{
+	if (count == 0)
+		for (count = 0; ops[count] != 0; count++);
+
+	for (uint32_t i = 0; i < count; i++) {
+		if (((uint32_t)ops[i] & OP_MAGIC) == OP_MAGIC) {
+			uint32_t count_ = (uint32_t)ops[i] & 0xFF;
+			ops[i] = isolve(it, ops + i + 1, count_);
+			for (uint32_t j = 1; j <= count_; j++)
+				ops[i + j] = 0;
+		}
+	}
 
-fail:
+	return isolve_(it, ops, count);
-	free(interp->lines[interp->lnidx]);
-	interp->lines[interp->lnidx] = 0;
-	return fret;
 }
 
-variable *idoexpr(interpreter *interp, const char *line)
+variable *isolve_(instance *it, variable **ops, uint32_t count)
 {
-	void *ops[16];
+	// first, look for functions
-	uint32_t ooffset = 0;
+	for (uint32_t i = 0; i < count; i++) {
-	uint32_t offset = 0;
+		if (ops[i] == 0)
-
+			continue;
-	// step 1 - break apart line
+		if (ops[i]->type == CFUNC || ops[i]->type == FUNC) {
-	for (uint8_t i = 0; i < 16; i++)
+			uint32_t nargs = (uint32_t)ops[i + 1];
-		ops[i] = 0;
+			uint32_t start = i;
-
+			i += 2;
-	// skip whitespace
+			int32_t j;
-	skipblank(line, eol, &offset);
+			for (j = nargs; j > 0 && i < count; i++) {
-	while (!eoe(line[offset])) {
+				if (ops[i] != 0) {
-		if (line[offset] == '(') {
+					if (ops[start]->type == CFUNC) {
-			uint8_t indent = 0;
+						it->stack[it->stidx + j - 1] = (uint32_t)ops[i];
-			uint32_t i;
-			for (i = offset + 1; !eol(line[i]); i++) {
-				if (line[i] == '(') {
-					indent++;
-				} else if (line[i] == ')') {
-					if (indent == 0) {
-						break;
 					} else {
-						indent--;
+						char namebuf[6];
-					}
+						snprintf(namebuf, 6, "arg%d", nargs - j);
+						if (ops[i]->type == NUMBER)
+							inew_number(it, namebuf, ops[i]->value.f);
+						else
+							inew_string(it, namebuf,
+								(const char *)ops[i]->value.p);
+					}				
+					j--;
 				}
 			}
-			if (eol(line[i]))
+			if (j != 0)
 				return 0;
-			ops[ooffset] = idoexpr(interp, line + offset + 1);
+
-			offset = i + 1;
+			if (ops[start]->type == CFUNC) {
-		} else {
+				func_t func = (func_t)ops[start]->value.p;
-			variable *v = make_varn(0, 0.0f);
+				it->stidx += nargs;
-			int inc = try_number(v, line + offset);
+
-			if (inc != 0) {
+				uint32_t sidx = it->stidx;
-				ops[ooffset] = v;
+				int ret = 0;
-				offset += inc;
+				if (!(it->sindent & SKIP))
-			} else {
+					ret = func(it);
-				free(v);
+				if (ret != 0)
-				char *name;
-				inc = try_variable(&name, line + offset);
-				if (inc != 0) {
-					v = interpreter_get_variable(interp, name);
-					ops[ooffset] = v;
-					free(name);
-					if (inc < 0) {
-						inc = -inc;
-						ops[ooffset + 2] = v;
-						ops[ooffset + 1] = (void *)5; // -
-						ops[ooffset] = make_varn(0, 0.0f);
-						ooffset += 2;
-					}
-					offset += inc;
-				} else {
 					return 0;
-				}
+				if (it->stidx > sidx)
+					ops[start] = (variable *)ipop(it);
+				else
+					ops[start] = 0;
+				ipopm(it, nargs);
+			} else {
+				ipush(it, it->lnidx);
+				ipush(it, CALL_SIG);
+				it->lnidx = ops[start]->value.p;
+			}
+
+			ops[start + 1] = 0;
+			for (uint32_t j = start + 2; j < i; j++) {
+				itryfree(ops[j]);
+				ops[j] = 0;
 			}
 		}
+	}
 
-		if (ops[ooffset] == 0)
+	// next, operators
-			return 0;
+	for (uint32_t j = 0; j < OPS_COUNT; j += 2) {
-		
+		for (uint32_t i = 0; i < count; i++) {
-		ooffset++;
+			if (ops[i] == 0)
+				continue;
+			if (ops[i]->type == OPERATOR) {
+				if (ops[i]->value.p != (uint32_t)opvars[j].value.p) {
+					if (ops[i]->value.p != (uint32_t)opvars[j + 1].value.p)
+						continue;
+				}
 
-		// skip whitespace
+				opfunc_t func = (opfunc_t)ops[i]->value.p;
-		skipblank(line, eoe, &offset);
+				uint32_t aidx = i - 1;
-		if (eoe(line[offset]))
+				while (ops[aidx] == 0 && aidx != 0)
-			break;
+					aidx--;
+				if (ops[aidx] == 0)
+					return 0;
+				uint32_t bidx = i + 1;
+				while (ops[bidx] == 0 && ++bidx < count);
+				if (bidx == count)
+					return 0;
 
-		for (uint32_t i = 0; i < IOPS_COUNT; i++) {
+				if (it->sindent & SKIP) {
-			int len = strlen(iops[i]);
+					itryfree(ops[aidx]);
-			if (!strncmp(iops[i], line + offset, len)) {
+					itryfree(ops[bidx]);
-				ops[ooffset] = (void *)(i + 1);
+					ops[aidx] = 0;
-				offset += len;
+				} else {
-				break;
+					variable *v = varclone(ops[aidx]);
+					if (func(v, ops[aidx], ops[bidx]) != 0)
+						return 0;
+					itryfree(ops[aidx]);
+					ops[aidx] = v;
+					itryfree(ops[bidx]);
+				}
+				ops[i] = 0;
+				ops[bidx] = 0;
 			}
 		}
+	}
 
-		if (ops[ooffset] == 0) // implicit multiply
+	return ops[0];
-			ops[ooffset] = (void *)1;
+}
 
-		ooffset++;
+variable **iparse(instance *it, const char *s)
-		// skip whitespace
+{
-		skipblank(line, eol, &offset);
+	uint32_t ooffset = 0;
-	}
+	size_t offset = 0;
 
-	if (ooffset % 2 == 0)
+	while (isblank(s[offset]))
+		offset++;
+	if (s[offset] == '#' || s[offset] == '\0' || s[offset] == '\n')
 		return 0;
 
-	// step 2 - do operations
+	variable **ops = (variable **)calloc(32, sizeof(variable *));
-	// for every operator, ordered by importance
+	while (s[offset] != '\0' && s[offset] != '\n') {
-	for (uint32_t i = 0; i < IOPS_COUNT; i++) {
+		if (isalpha(s[offset])) {
-		// find instances of the operation
+			size_t end = offset + 1;
-		for (uint32_t j = 1; j < ooffset; j += 2) {
+			while (isalnum(s[end]))
-			// if a match
+				end++;
-			if ((uint32_t)ops[j] == i + 1) {
+			char *name = strnclone(s + offset, end - offset);
-				// find args
+			ops[ooffset++] = igetvar(it, name);
-				uint32_t ai = j - 1;
+			free(name);
-				uint32_t bi = j + 1;
+			while (isblank(s[end]))
-				while (ops[ai] == 0)
+				end++;
-					ai--;
+			if (s[end] == '(') {
-				while (ops[bi] == 0)
+				uint32_t argidx = ooffset;
-					bi++;
+				uint32_t argcount = 0;
-
+				ooffset++;
-				variable *r = (variable *)calloc(1, sizeof(variable));
+				end++;
-				iopfuncs[i](r, ops[ai], ops[bi]);
+				for (int last = end, c = 0; c >= 0; end++) {
-
+					if (s[end] == '(')
-				variable *v = (variable *)ops[ai];
+						c++;
-				if (!v->used)
+					if (c == 0 && last != end && (s[end] == ',' || s[end] == ')')) {
-					free(v);
+						argcount++;
-				ops[ai] = r;
+						char *arg = strnclone(s + last, end - last);
-				v = (variable *)ops[bi];
+						uint32_t parenidx = ooffset;
-				if (!v->used)
+						ooffset++;
-					free(v);
+						variable **moreops = iparse(it, arg);
-				ops[bi] = 0;
+						uint32_t count = 0;
-				ops[j] = 0;
+						if (moreops != 0) {
+							for (uint32_t i = 0; moreops[i] != 0; count++, i++)
+								ops[ooffset++] = moreops[i];
+							free(moreops);
+						}
+						free(arg);
+						ops[parenidx] = (variable *)(OP_MAGIC | count);
+						last = end + 1;
+					}
+					if (s[end] == ')')
+						c--;
+				}
+				if (s[end] != '\0')
+					end++;
+				ops[argidx] = (variable *)argcount;
+			}
+			offset = end;
+		} else if (isdigit(s[offset])) {
+			size_t end = offset + 1;
+			while (isdigit(s[end]) || s[end] == '.')
+				end++;
+			char *word = strnclone(s + offset, end - offset);
+			ops[ooffset++] = make_num(word);
+			free(word);
+			offset = end;
+		} else if (s[offset] == '\"') {
+			size_t end = offset + 1;
+			while (s[end] != '\"')// && s[end - 1] == '\\')
+				end++;
+			end++;
+			char *word = strnclone(s + offset, end - offset);
+			char *fword = fixstring(word);
+			ops[ooffset++] = make_vars(0, fword);
+			free(word);
+			free(fword);
+			offset = end;
+		} else if (s[offset] == '(') {
+			size_t i = offset + 1;
+			for (int c = 0; s[i] != ')' || --c >= 0; i++) {
+				if (s[i] == '(')
+					c++;
 			}
+			i++;
+			char *word = strnclone(s + offset + 1, i - offset - 2);
+			uint32_t parenidx = ooffset;
+			ooffset++;
+			variable **moreops = iparse(it, word);
+			uint32_t count = 0;
+			if (moreops != 0) {
+				for (uint32_t i = 0; moreops[i] != 0; count++, i++)
+					ops[ooffset++] = moreops[i];
+				free(moreops);
+			}
+			free(word);
+			ops[parenidx] = (variable *)(OP_MAGIC | count);
+			offset = i;
+		} else if (!isblank(s[offset])) {
+			size_t end = offset + 1;
+			while (!isblank(s[end]) && s[end] != '\0')
+				end++;
+			char *word = strnclone(s + offset, end - offset);
+
+			// bracket?
+			if (!strcmp(word, "{")) {
+				it->indent++;
+				if (it->sindent & SKIP)
+					ipush(it, SKIP_SIG);
+			} else if (!strcmp(word, "}")) {
+				it->indent--;
+				if (it->indent < (it->sindent & ~(SKIP)))
+					it->sindent = 0;
+				bn_end(it);
+			} else {
+				variable *v = igetop(it, word);
+				if (v == 0)
+					return 0;
+				ops[ooffset++] = v;
+			}
+			free(word);
+			offset = end;
+		} else {
+			offset++;
 		}
 	}
 
-	variable *result = make_varn(0, ((variable *)ops[0])->value.f);
+	// mark end
-	if (!((variable *)ops[0])->used)
+	ops[ooffset] = 0;
-		free(ops[0]);
+	return ops;
-
-	//for (uint32_t i = 1; i < ooffset; i += 2)
-	//	iopfuncs[(uint32_t)ops[i] - 1](result, result, ops[i + 1]);
-	
-	//for (uint32_t i = 0; i < ooffset; i += 2) {
-	//	variable *v = (variable *)ops[i];
-	//	if (!v->used) {
-	//		if (v->valtype == STRING || v->valtype == EXPR)
-	//			free((void *)v->value.p);
-	//		free(ops[i]);
-	//	}
-	//}
-
-	return result;
 }
-

parser.h

@@ -1,36 +1,40 @@
 #ifndef PARSER_H_
 #define PARSER_H_
 
-#include <variable.h>
+#include "variable.h"
 
-typedef variable *stack_t;
+#include <stdint.h>
 
 typedef struct {
 	variable *vars;
-	char **vnames;
+	char **names;
-	stack_t *stack;
+	uint32_t *stack;
 	uint32_t stidx;
-	variable ***lines;
+	char **lines;
 	uint32_t lnidx;
-	int8_t indent;
-	uint8_t sindent;
 	variable *ret;
-} interpreter;
+	uint8_t indent;
+	uint8_t sindent;
+} instance;
 
 #define SKIP (1 << 7)
 
-typedef int (*func_t)(interpreter *);
+typedef int (*func_t)(instance *);
+
+instance *inewinstance(void);
+void idelinstance(instance *it);
 
-void iinit(interpreter *);
+int idoline(instance *it, const char *s);
-void iend(interpreter *);
+variable **iparse(instance *it, const char *s);
+variable *isolve(instance *it, variable **ops, uint32_t count);
 
-void iskip(interpreter *);
+void inew_cfunc(instance *it, const char *name, func_t func);
 
-variable *inew_string(interpreter *, const char *, const char *);
+variable *make_varf(variable *v, float f);
-variable *inew_number(interpreter *, const char *, float);
+variable *make_vars(variable *v, const char *s);
-variable *inew_cfunc(interpreter *, const char *, func_t);
 
-int idoline(interpreter *, const char *);
+uint32_t ipop(instance *it);
-variable *idoexpr(interpreter *, const char *);
+void ipush(instance *it, uint32_t v);
+variable *igetarg(instance *it, uint32_t n);
 
 #endif // PARSER_H_

script

@@ -1,7 +0,0 @@
-set x 42
-set eq ".a/a"
-
-solve eq > ans
-
-print ans
-print "\n"

shell.c

@@ -1,27 +1,24 @@
-#include <parser.h>
-#include <builtins.h>
-
-#include "stack.h"
-
-#include <memory.h>
 #include <stdio.h>
-//#include <stdlib.h>
 #include <string.h>
 
-int s_put(interpreter *it)
+#include "parser.h"
+
+int print(instance *it)
 {
-	variable *v = igetarg(it, 0);
+	variable *s = igetarg(it, 0);
-	if (v->valtype == NUMBER)
+	if (s->type == NUMBER) {
-		printf("%.f", v->value.f);
+		if (s->value.f == (int)s->value.f)
-	else
+			printf("%d\n", (int)s->value.f);
-		printf("%s", (char *)v->value.p);
+		else
+			printf("%.3f\n", s->value.f);
+	} else if (s->value.p != 0) {
+		printf("%s\n", (char *)s->value.p);
+	}
 	return 0;
 }
 
 int main(int argc, char **argv)
 {
-	interpreter interp;
-
 	if (argc != 2) {
 		printf("Usage: %s file\n", argv[0]);
 		return -1;
@@ -33,20 +30,23 @@ int main(int argc, char **argv)
 		return -1;
 	}
 
-	iinit(&interp);
+	instance *it = inewinstance();
-	inew_cfunc(&interp, "print", s_put);
+	inew_cfunc(it, "print", print);
 
 	char *line = 0;
-	unsigned int size;
+	size_t size;
 	int result;
 	while (getline(&line, &size, fp) != -1) {
 		*strchr(line, '\n') = '\0';
-		result = idoline(&interp, line);
+		result = idoline(it, line);
 		if (result != 0)
 			printf("Error: %d\n", result);
+		//if (it->ret != 0)
+		//	printf("%s = %f\n", line, it->ret->value.f);
 	}
 
 	fclose(fp);
-	iend(&interp);
+	idelinstance(it);
 	return 0;
 }
+

shelpers.c

@@ -1,64 +0,0 @@
-#include "shelpers.h"
-
-#include <memory.h>
-#include <string.h>
-
-char *strclone(const char *s)
-{
-	char *clone = (char *)malloc(strlen(s) + 1);
-	strcpy(clone, s);
-	return clone;
-}
-
-char *strnclone(const char *s, uint32_t n)
-{
-	char *clone = (char *)malloc(n + 1);
-	strncpy(clone, s, n);
-	clone[n] = '\0';
-	return clone;
-}
-
-uint8_t eol(int c)
-{
-	return c == '\n' || c == '\0';
-}
-
-uint8_t eot(int c)
-{
-	return eol(c) || c == ' ';
-}
-
-uint8_t eoe(int c)
-{
-	return eol(c) || c == ')';
-}
-
-uint32_t findend(const char *s, char o, char c)
-{
-	uint8_t indent = 0;
-	uint32_t i;
-	for (i = 1; !eol(s[i]); i++) {
-		if (s[i] == o) {
-			indent++;
-		} else if (s[i] == c) {
-			if (indent == 0)
-				break;
-			else
-				indent--;
-		}
-	}
-
-	return i;
-}
-
-void skipblank(const char *s, uint8_t (*cmp)(int), uint32_t *offset)
-{
-	uint32_t i = *offset;
-	while (!cmp(s[i])) {
-		if (s[i] != ' ' && s[i] != '\t')
-			break;
-		i++;
-	}
-	*offset = i;
-}
-

shelpers.h

@@ -1,62 +0,0 @@
-#ifndef SHELPERS_H_
-#define SHELPERS_H_
-
-#include <stdint.h>
-
-/**
- * Clones the given string, malloc'ing a new one.
- * @param s the string to clone
- * @return the malloc'd copy
- */
-char *strclone(const char *s);
-
-/**
- * Clones the given string until the given count.
- * @param s the string to clone
- * @param n the number of characters to clone
- * @return the malloc'd copy
- */
-char *strnclone(const char *s, uint32_t n);
-
-
-/**
- * Returns non-zero if the character is considered an end-of-line.
- * @param c a character
- * @return non-zero if eol, zero if not
- */
-uint8_t eol(int c);
-
-/**
- * Returns non-zero if the character is considered an end-of-token.
- * @param c a character
- * @return non-zero if eot, zero if not
- */
-uint8_t eot(int c);
-
-/**
- * Returns non-zero if the character is considered an end-of-expression.
- * @param c a character
- * @return non-zero if eoe, zero if not
- */
-uint8_t eoe(int c);
-
-
-/**
- * Finds the matching end character in a string, e.g. matching parens.
- * @param s the string to search
- * @param o the starting, opening character (e.g. '(')
- * @param c the end, closing character (e.g. ')')
- * @return offset of the end character in the string
- */
-uint32_t findend(const char *s, char o, char c);
-
-/**
- * Increments offset until the character in the string is not blank or fails
- * the given comparison.
- * @param s the string to use
- * @param cmp a comparing function, stops search if returns true
- * @param offset the variable to increment while searching
- */
-void skipblank(const char *s, uint8_t (*cmp)(int), uint32_t *offset);
-
-#endif // SHELPERS_H_

stack.c

@@ -1,38 +0,0 @@
-#include "stack.h"
-
-void ipush(interpreter *it, void *v)
-{
-	it->stack[it->stidx++] = v;
-}
-
-void *ipop(interpreter *it)
-{
-	return it->stack[--it->stidx];
-}
-
-void ipopm(interpreter *it, uint32_t count)
-{
-	it->stidx -= count;
-}
-
-variable *igetarg(interpreter *interp, uint32_t index)
-{
-	return interp->stack[interp->stidx - index - 1];
-}
-
-const char *igetarg_string(interpreter *interp, uint32_t index)
-{
-	if (index >= interp->stidx)
-		return 0;
-	variable *v = igetarg(interp, index);
-	return (const char *)v->value.p;
-}
-
-float igetarg_number(interpreter *interp, uint32_t index)
-{
-	if (index >= interp->stidx)
-		return 0;
-	variable *v = igetarg(interp, index);
-	return v->value.f;
-}
-

stack.h

@@ -1,16 +0,0 @@
-#ifndef STACK_H_
-#define STACK_H_
-
-#include "parser.h"
-
-void ipush(interpreter *it, void *v);
-void *ipop(interpreter *it);
-void ipopm(interpreter *it, uint32_t count);
-
-variable *igetarg(interpreter *interp, uint32_t index);
-const char *igetarg_string(interpreter *interp, uint32_t index);
-float igetarg_number(interpreter *interp, uint32_t index);
-
-#define igetarg_integer(i, x) (int)igetarg_number(i, x)
-
-#endif // STACK_H_

stdlib.h

@@ -1,9 +0,0 @@
-#ifndef STDLIB_H_
-#define STDLIB_H_
-
-char *snprintf(char *buf, unsigned int max, const char *format, ...);
-float strtof(const char *s, char **endptr);
-
-int atoi(const char *);
-
-#endif // STDLIB_H_

test1

@@ -0,0 +1,13 @@
+# test1
+# arithmetic tests
+# looking for proper basic function, respect for order of ops,
+# and respect for parentheses
+
+2 + 5
+14 - 9
+3 * 8 + 3
+9 - 3 / 2
+3 * (8 + 3)
+(9 - 3) / 2
+(4 + 5) * ((9 - 1) + 3)
+5 - 3 + 4

test2

@@ -0,0 +1,16 @@
+# test2
+# variable and function tests
+# show variable recognition and proper c-function handling
+
+a * 1
+3 + b
+
+set(a, 5)
+a * 1
+
+set(c, 4)
+a / c
+
+set(b, 2) set(d, 8)
+
+d + set(e, 4)

test3

@@ -0,0 +1,25 @@
+# test3
+# verify builtin functions, conditionals and such
+
+a = 5
+
+func(checka) {
+	if (a == 5) {
+		print("a == 5")
+	} else {
+		print("a != 5")
+	}
+}
+
+checka
+
+print("Increment a...")
+a = a + 1
+checka
+
+d = 0
+while (d < 10) {
+	print(d)
+	d = d + 1
+}
+

test4

@@ -0,0 +1,6 @@
+# test4
+# find memory leaks
+
+x = 4
+y = solve("x-2")
+print(y)

variable.c

@@ -1,135 +0,0 @@
-#include "variable.h"
-#include "parser.h"
-
-#include <ctype.h>
-#include <stdlib.h>
-#include <memory.h>
-#include <string.h>
-#include <shelpers.h>
-
-extern int atoi(const char *);
-
-char *fixstring(char *s)
-{
-	char *n = malloc(strlen(s) + 1);
-	int j = 0;
-	for (int i = 0; s[i] != '\0'; i++, j++) {
-		if (s[i] == '\\') {
-			if (s[i + 1] == 'n')
-				n[j] = '\n';
-			i++;
-		} else {
-			n[j] = s[i];
-		}
-	}
-	n[j] = '\0';
-	return n;
-}
-
-variable *make_varn(variable *v, float value)
-{
-	if (v == 0)
-		v = (variable *)malloc(sizeof(variable));
-	v->used = 0;
-	v->fromc = 0;
-	v->valtype = NUMBER;
-	v->value.f = value;
-	return v;
-}
-
-variable *make_vars(variable *v, const char *value)
-{
-	if (v == 0)
-		v = (variable *)malloc(sizeof(variable));
-	v->used = 0;
-	v->fromc = 0;
-	v->valtype = STRING;
-	v->value.p = (value != 0) ? (uint32_t)fixstring(value) : 0;
-	return v;
-}
-
-variable *make_varf(variable *v, uint8_t fromc, uint32_t func)
-{
-	if (v == 0)
-		v = (variable *)malloc(sizeof(variable));
-	v->used = 0;
-	v->fromc = fromc;
-	v->valtype = FUNC;
-	v->value.p = func;
-	return v;
-}
-
-variable *make_vare(variable *v, const char *expr)
-{
-	if (v == 0)
-		v = (variable *)malloc(sizeof(variable));
-	v->used = 0;
-	v->fromc = 0;
-	v->valtype = EXPR;
-	v->value.p = (uint32_t)strclone(expr);
-	return v;
-}
-
-int try_variable(char **name, const char *text)
-{
-	if (name == 0)
-		return 0;
-
-	int neg = 1;
-	int i = 0;
-
-	if (text[0] == '-') {
-		neg = -1;
-		i++;
-	}
-	if (!isalpha(text[i]))
-		return 0;
-
-	for (i++; isalnum(text[i]); i++);
-
-	int o = (neg < 0);
-	if (neg < 0)
-		i--;
-	*name = (char *)malloc(i + 1);
-	strncpy(*name, text + o, i);
-	(*name)[i] = '\0';
-	return (neg > 0) ? i : -(i + 1);
-}
-
-int try_number(variable *v, const char *text)
-{
-	if (v == 0)
-		return 0;
-
-	int decimal = -1;
-	char valid = 0;
-
-	int i = 0;
-	if (text[0] == '-')
-		i++;
-	do {
-		if (text[i] == '.') {
-			if (decimal >= 0) {
-				valid = 0;
-				break;
-			}
-			decimal = i;
-		} else if (isdigit(text[i])) {
-			valid |= 1;
-		} else {
-			break;
-		}
-	} while (text[++i] != '\0');
-
-	if (valid == 0)
-		return 0;
-
-	char *buf = (char *)malloc(i + 1);
-	strncpy(buf, text, i);
-	buf[i] = '\0';
-
-	make_varn(v, strtof(buf, 0));
-
-	free(buf);
-	return i;
-}

variable.h

@@ -4,28 +4,21 @@
 #include <stdint.h>
 
 typedef struct {
-	uint8_t used :1;
+	uint8_t tmp    :1;
-	uint8_t fromc :1;
+	uint8_t type   :3;
-	uint8_t valtype :4;
+	uint8_t unused :4;
 	union {
 		float f;
 		uint32_t p;
 	} value;
 } variable;
 
-enum valtype {
+enum VARTYPE {
-	STRING = 0,
+	NUMBER = 0,
-	NUMBER,
+	STRING,
+	OPERATOR,
 	FUNC,
-	EXPR
+	CFUNC,
 };
 
-variable *make_varn(variable *v, float value);
-variable *make_vars(variable *v, const char *s);
-variable *make_varf(variable *v, uint8_t fromc, uint32_t func);
-variable *make_vare(variable *v, const char *e);
-
-int try_number(variable *v, const char *text);
-int try_variable(char **name, const char *text);
-
 #endif // VARIABLE_H_