# HG changeset patch
# User Mike Pavone <pavone@retrodev.com>
# Date 1243308876 14400
# Node ID 31f8182f343371ad18aaaec7808a3e42696997d7
# Parent  3021dac0d8f546475bb2053067f521a8b7901b7d
Finished fib test and did some small work on the c backend

diff -r 3021dac0d8f5 -r 31f8182f3433 backendutils.rhope
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/backendutils.rhope	Mon May 25 23:34:36 2009 -0400
@@ -0,0 +1,15 @@
+
+Escape Rhope Name[name:escaped]
+{
+	escaped <- [[[[[[[[[[[name]Replace["_","__"]
+		]Replace["@","_AT_"]
+		]Replace[" ","_SP_"]
+		]Replace[":","_CN_"]
+		]Replace["?","_QN_"]
+		]Replace["+","_PL_"]
+		]Replace["-","_MN_"]
+		]Replace["*","_TM_"]
+		]Replace["/","_DV_"]
+		]Replace["<","_LT_"]
+		]Replace["<","_GT_"]
+}
diff -r 3021dac0d8f5 -r 31f8182f3433 cbackend.rhope
--- a/cbackend.rhope	Tue May 19 23:29:55 2009 -0400
+++ b/cbackend.rhope	Mon May 25 23:34:36 2009 -0400
@@ -1,3 +1,5 @@
+Import extendlib.rhope
+Import backendutils.rhope
 
 Blueprint Blueprint Def
 {
@@ -40,7 +42,7 @@
 
 Add Statement@C Function[func,statement:out]
 {
-	out <- [func]Statements <<[ [[func]Statements >>]Append[[statement]Append[";"]] ]
+	out <- [func]Statements <<[ [[func]Statements >>]Append[["\t"]Append[[statement]Append[";\n"]]] ]
 }
 
 Add Operator Statement@C Function[func,source1,source2,dest,op:out]
@@ -73,6 +75,26 @@
 	out <- [func]Add Statement[[[dest]Append[" = "]]Append[source]]
 }
 
+Init Outputs@C Function[func]
+{
+	If[[[[func]Outputs >>]Length ] > [0]]
+	{
+		out <- [["\tlocals->"]Append[ [[func]Outputs >>]Join[" = NULL;\n\tlocals->"] ]]Append[" = NULL;\n"]
+	}{
+		out <- ""
+	}
+}
+
+Release Inputs@C Function[func]
+{
+	If[[[[func]Inputs >>]Length ] > [0]]
+	{
+		out <- [["\trelease_ref(->"]Append[ [[func]Outputs >>]Join[" = NULL;\n\tlocals->"] ]]Append[" = NULL;\n"]
+	}{
+		out <- ""
+	}
+}
+
 Definitions@C Function[func:out]
 {
 	
@@ -80,5 +102,13 @@
 
 Text@C Function[func:out]
 {
-	
+	cname <- Escape Rhope Name[[func]Name >>]
+	out <- [[[[[[["Func("
+		]Append[cname]
+		]Append[",\n\tNumParams "]
+		]Append[ [[func]Inputs >>]Length ]
+		]Append[",\n\tCallSpace 32,\n\t"]//TODO: Fill in with calculated callspace value
+		]Append[["l_"]Append[cname]]
+		]Append[")\n\n"]
+		]Append[[func]Init Outputs]
 }
\ No newline at end of file
diff -r 3021dac0d8f5 -r 31f8182f3433 genasm.rhope
--- a/genasm.rhope	Tue May 19 23:29:55 2009 -0400
+++ b/genasm.rhope	Mon May 25 23:34:36 2009 -0400
@@ -1,16 +1,5 @@
 //Import extendlib.rhope
-Escape Rhope Name[name:escaped]
-{
-	escaped <- [[[[[[[[[name]Replace["_","__"]
-		]Replace["@","_AT_"]
-		]Replace[" ","_SP_"]
-		]Replace[":","_CN_"]
-		]Replace["?","_QN_"]
-		]Replace["+","_PL_"]
-		]Replace["-","_MN_"]
-		]Replace["*","_TM_"]
-		]Replace["/","_DV_"]
-}
+Import backendutils.rhope
 
 Blueprint Registers
 {
diff -r 3021dac0d8f5 -r 31f8182f3433 runtime/bool.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/runtime/bool.c	Mon May 25 23:34:36 2009 -0400
@@ -0,0 +1,24 @@
+#include "bool.h"
+#include "func.h"
+#include "builtin.h"
+#include "context.h"
+#include <stddef.h>
+
+t_Boolean * val_yes;
+t_Boolean * val_no;
+#define lval ((t_Boolean *)(cdata->params[0]))->val
+
+MethodNoLocals(If,Boolean,
+	NumParams 1,
+	CallSpace 1)
+	
+	Param(0, TYPE_BOOLEAN)
+	
+	if(lval)
+	{
+		Ret(1, NULL)
+	} else {
+		Ret(1, cdata->params[0]);
+		Ret(0, NULL)
+	}
+EndFunc
diff -r 3021dac0d8f5 -r 31f8182f3433 runtime/bool.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/runtime/bool.h	Mon May 25 23:34:36 2009 -0400
@@ -0,0 +1,17 @@
+#ifndef BOOL_H_
+#define BOOL_H_
+#include "object.h"
+
+OBegin
+	int32_t val;
+Object(Boolean)
+
+#define Yes add_ref((object *)val_yes)
+#define No add_ref((object *)val_no)
+
+extern t_Boolean * val_yes;
+extern t_Boolean * val_no;
+
+MethodDef(If,Boolean)
+
+#endif //BOOL_H_
diff -r 3021dac0d8f5 -r 31f8182f3433 runtime/builtin.c
--- a/runtime/builtin.c	Tue May 19 23:29:55 2009 -0400
+++ b/runtime/builtin.c	Mon May 25 23:34:36 2009 -0400
@@ -1,6 +1,7 @@
 #include "builtin.h"
 #include "object.h"
 #include "integer.h"
+#include "bool.h"
 #include <stddef.h>
 
 void register_builtin_type(uint32_t type)
@@ -12,6 +13,16 @@
 		bp = register_type_byid(TYPE_INT32, sizeof(int32_t), NULL, NULL, NULL);
 		add_method(bp, METHOD_ADD, MethodName(_PL_,Int32));
 		add_method(bp, METHOD_SUB, MethodName(_MN_,Int32));
+		add_method(bp, METHOD_LESS, MethodName(_LT_,Int32));
+		add_method(bp, METHOD_GREATER, MethodName(_GT_,Int32));
+		break;
+	case TYPE_BOOLEAN:
+		bp = register_type_byid(TYPE_BOOLEAN, sizeof(int32_t), NULL, NULL, NULL);
+		add_method(bp, METHOD_IF, MethodName(If,Boolean));
+		val_yes = (t_Boolean *)new_object(TYPE_BOOLEAN);
+		val_yes->val = 1;
+		val_no = (t_Boolean *)new_object(TYPE_BOOLEAN);
+		val_no->val = 0;
 		break;
 	}
 }
diff -r 3021dac0d8f5 -r 31f8182f3433 runtime/builtin.h
--- a/runtime/builtin.h	Tue May 19 23:29:55 2009 -0400
+++ b/runtime/builtin.h	Mon May 25 23:34:36 2009 -0400
@@ -12,6 +12,7 @@
 	TYPE_INT16,
 	TYPE_INT32,
 	TYPE_INT64,
+	TYPE_BOOLEAN,
 	TYPE_FLOAT32,
 	TYPE_FLOAT64,
 	TYPE_ARRAY,
@@ -23,9 +24,7 @@
 
 //Builtin Methods
 enum {
-	METHOD_SETFIELDMISSING=1,
-	METHOD_GETFIELDMISSING,
-	METHOD_ADD,
+	METHOD_ADD=1,
 	METHOD_SUB,
 	METHOD_DIV,
 	METHOD_MUL,
@@ -34,6 +33,9 @@
 	METHOD_EQUALS,
 	METHOD_GREATER,
 	METHOD_LESS,
+	METHOD_IF,
+	METHOD_SETFIELDMISSING,
+	METHOD_GETFIELDMISSING,
 	METHOD_MISSING,//Insert new builtin methods before this one
 	METHOD_FIRST_USER 
 };
diff -r 3021dac0d8f5 -r 31f8182f3433 runtime/context.c
--- a/runtime/context.c	Tue May 19 23:29:55 2009 -0400
+++ b/runtime/context.c	Mon May 25 23:34:36 2009 -0400
@@ -31,7 +31,10 @@
 	while(current && STACK_CHUNK_SIZE - current->used < size)
 	{
 		if(!current->next)
+		{
 			current->next = new_stack();
+			current->next->prev = current;
+		}
 		current = current->next;
 	}
 	if(!current)
@@ -53,9 +56,14 @@
 void free_stack(context * ct, void * data)
 {
 	char * cdata = data;
-	if(cdata < ct->current_stack->data || cdata >= ct->current_stack->data+STACK_CHUNK_SIZE) {
-		fputs("Tried to free stack data from outside of current stack chunk!", stderr);
-		exit(-1);
+	while(cdata < ct->current_stack->data || cdata >= ct->current_stack->data+STACK_CHUNK_SIZE) {
+		if(ct->current_stack == ct->stack_begin)
+		{
+			fprintf(stderr, "Attempt to free memory at %X using free_stack, but %X doesn't appear to be stack allocated\n", data, data);
+			exit(-1);
+		}
+		ct->current_stack->used = 0;
+		ct->current_stack = ct->current_stack->prev;
 	}
 	ct->current_stack->used = cdata-ct->current_stack->data;
 	if(!ct->current_stack->used && ct->current_stack->prev)
diff -r 3021dac0d8f5 -r 31f8182f3433 runtime/func.h
--- a/runtime/func.h	Tue May 19 23:29:55 2009 -0400
+++ b/runtime/func.h	Mon May 25 23:34:36 2009 -0400
@@ -13,10 +13,10 @@
 typedef returntype (*rhope_func)(struct calldata *);
 typedef void (*special_func) (struct object *);
 
-#define MethodName(name,type) _f_ ## name ## _AT_ ## type
+#define MethodName(name,type) f_ ## name ## _AT_ ## type
 
 #define Func(name,numparams,callspace,localtype) \
-	returntype _f_ ## name (calldata * cdata)\
+	returntype f_ ## name (calldata * cdata)\
 	{\
 		localtype *locals;\
 		calldata *call;\
@@ -24,8 +24,8 @@
 		int idx;\
 		if(cdata->resume)\
 		{\
+			call = cdata->call;\
 			locals = cdata->locals;\
-			call = (calldata *)(((char *)cdata->locals) + sizeof(localtype));\
 		}\
 		switch(cdata->resume)\
 		{\
@@ -33,10 +33,11 @@
 			for(idx = numparams; idx < cdata->num_params; ++idx)\
 				release_ref(cdata->params[idx]); cdata->num_params = numparams;\
 			cdata->num_params = numparams;\
-			cdata->locals = call = alloc_cdata(cdata->ct, callspace);
+			cdata->call = call = alloc_cdata(cdata->ct, callspace);\
+			cdata->locals = locals = alloc_stack(cdata->ct, sizeof(localtype));
 
 #define FuncNoLocals(name,numparams,callspace) \
-	returntype _f_ ## name (calldata * cdata)\
+	returntype f_ ## name (calldata * cdata)\
 	{\
 		calldata *call;\
 		returntype ret;\
@@ -52,6 +53,7 @@
 			cdata->locals = call = alloc_cdata(cdata->ct, callspace);
 
 #define EndFunc	\
+			free_stack(cdata->ct, call);\
 			return NORMAL_RETURN;\
 		}\
 	}
@@ -65,8 +67,8 @@
 		int idx;\
 		if(cdata->resume)\
 		{\
+			call = cdata->call;\
 			locals = cdata->locals;\
-			call = (calldata *)(((char *)cdata->locals) + sizeof(localtype));\
 		}\
 		switch(cdata->resume)\
 		{\
@@ -74,7 +76,8 @@
 			for(idx = numparams; idx < cdata->num_params; ++idx)\
 				release_ref(cdata->params[idx]); cdata->num_params = numparams;\
 			cdata->num_params = numparams;\
-			cdata->locals = call = alloc_cdata(cdata->ct, callspace);
+			cdata->call = call = alloc_cdata(cdata->ct, callspace);\
+			cdata->locals = locals = alloc_stack(cdata->ct, sizeof(localtype));
 
 #define MethodNoLocals(name,type,numparams,callspace) \
 	returntype MethodName(name,type) (calldata * cdata)\
@@ -95,7 +98,7 @@
 #define NumParams
 #define CallSpace
 
-#define ParamBase(num,var,type,convtypeid) \
+#define Param(num,convtypeid) \
 	call->params[0] = cdata->params[num];\
 	call->resume = 0;\
 	ret = coerce_value(convtypeid, call);\
@@ -104,32 +107,34 @@
 	if(ret == EXCEPTION_RETURN)\
 	{\
 		for(idx = 0; idx < cdata->num_params; ++idx)\
-			if(idx != num)\
+			if(idx != num && cdata->params[idx])\
 				release_ref(cdata->params[idx]);\
 		cdata->params[0] = call->params[0];\
+		free_stack(cdata->ct, call);\
 		return ret;\
 	}\
 	cdata->params[num] = call->params[0];
 
-#define Param(num,var,type,convtypeid) ParamBase(num,var,type,convtypeid) var = (_t_##type *)(cdata->params[num]);
-#define CopiedParam(num,var,type,convtypeid) ParamBase(num,var,type,convtypeid) cdata->params[num] = copy_object(cdata->params[num]); var = (_t_##type *)(cdata->params[num]);
+#define CopiedParam(num,convtypeid) Param(num,convtypeid) cdata->params[num] = copy_object(cdata->params[num]);
 #define Ret(num,val) cdata->params[num] = (object *)(val);
 #define Return return NORMAL_RETURN;
 #define Exception
-#define FuncDef(name) returntype _f_ ## name (calldata * cdata);
+#define FuncDef(name) returntype f_ ## name (calldata * cdata);
 #define MethodDef(name,type) returntype MethodName(name,type) (calldata * cdata);
 
 #define Call(func, numparams)\
 	call->num_params = numparams;\
 	call->resume = 0;\
-	ret = _f_ ## func (call);\
+	ret = f_ ## func (call);\
 	while(ret == TAIL_RETURN)\
 		ret = call->tail_func(call);\
 	if(ret == EXCEPTION_RETURN)\
 	{\
 		for(idx = 0; idx < cdata->num_params; ++idx)\
-			release_ref(cdata->params[idx]);\
+			if(cdata->params[idx])\
+				release_ref(cdata->params[idx]);\
 		cdata->params[0] = call->params[0];\
+		free_stack(cdata->ct, call);\
 		return ret;\
 	}
 	
@@ -142,9 +147,26 @@
 	if(ret == EXCEPTION_RETURN)\
 	{\
 		for(idx = 0; idx < cdata->num_params; ++idx)\
-			release_ref(cdata->params[idx]);\
+			if(cdata->params[idx])\
+				release_ref(cdata->params[idx]);\
 		cdata->params[0] = call->params[0];\
+		free_stack(cdata->ct, call);\
 		return ret;\
 	}
 
+#define TMCall(methodid, numparams)\
+	free_stack(cdata->ct, call);\
+	cdata->num_params = numparams;\
+	cdata->resume = 0;\
+	ret = call_method(methodid, cdata);\
+	return ret;
+	
+#define TCall(func, numparams)\
+	free_stack(cdata->ct, call);\
+	cdata->num_params = numparams;\
+	cdata->resume = 0;\
+	cdata->tail_func = f_ ## func;\
+	return TAIL_RETURN;
+	
+	
 #endif //_FUNC_H_
\ No newline at end of file
diff -r 3021dac0d8f5 -r 31f8182f3433 runtime/integer.c
--- a/runtime/integer.c	Tue May 19 23:29:55 2009 -0400
+++ b/runtime/integer.c	Mon May 25 23:34:36 2009 -0400
@@ -1,16 +1,17 @@
 #include "integer.h"
 #include "builtin.h"
 #include "context.h"
+#include "bool.h"
 
-#define left ((_t_Int32 *)cdata->params[0])
-#define right ((_t_Int32 *)cdata->params[1])
+#define left ((t_Int32 *)cdata->params[0])
+#define right ((t_Int32 *)cdata->params[1])
 
 MethodNoLocals(_PL_,Int32,
     NumParams 2,
     CallSpace 1)
     
-	CopiedParam(0, left, Int32, TYPE_INT32)
-	Param(1, right, Int32, TYPE_INT32)
+	CopiedParam(0, TYPE_INT32)
+	Param(1, TYPE_INT32)
 	
 	left->num += right->num;
 	
@@ -21,19 +22,55 @@
     NumParams 2,
     CallSpace 1)
     
-	CopiedParam(0, left, Int32, TYPE_INT32)
-	Param(1, right, Int32, TYPE_INT32)
+	CopiedParam(0, TYPE_INT32)
+	Param(1, TYPE_INT32)
 	
 	left->num -= right->num;
 	
 	release_ref((object *)right);
 EndFunc
 
+MethodNoLocals(_LT_,Int32,
+	NumParams 2,
+	CallSpace 1)
+	
+	Param(0, TYPE_INT32)
+	Param(1, TYPE_INT32)
+	
+	if(left->num < right->num)
+	{
+		release_ref(cdata->params[0]);
+		Ret(0, Yes)
+	} else {
+		release_ref(cdata->params[0]);
+		Ret(0, No)
+	}
+	release_ref(cdata->params[0]);
+EndFunc
+
+MethodNoLocals(_GT_,Int32,
+	NumParams 2,
+	CallSpace 1)
+	
+	Param(0, TYPE_INT32)
+	Param(1, TYPE_INT32)
+	
+	if(left->num > right->num)
+	{
+		release_ref(cdata->params[0]);
+		Ret(0, Yes)
+	} else {
+		release_ref(cdata->params[0]);
+		Ret(0, No)
+	}
+	release_ref(cdata->params[0]);
+EndFunc
+
 object * make_Int32(int32_t val)
 {
-	_t_Int32 * obj;
+	t_Int32 * obj;
 	object * ret = new_object(TYPE_INT32);
-	obj = (_t_Int32 *)ret;
+	obj = (t_Int32 *)ret;
 	obj->num = val;
 	return ret;
 }
diff -r 3021dac0d8f5 -r 31f8182f3433 runtime/integer.h
--- a/runtime/integer.h	Tue May 19 23:29:55 2009 -0400
+++ b/runtime/integer.h	Mon May 25 23:34:36 2009 -0400
@@ -10,6 +10,8 @@
 
 MethodDef(_PL_,Int32)
 MethodDef(_MN_,Int32)
+MethodDef(_LT_,Int32)
+MethodDef(_GT_,Int32)
 
 object * make_Int32(int32_t val);
 
diff -r 3021dac0d8f5 -r 31f8182f3433 runtime/object.c
--- a/runtime/object.c	Tue May 19 23:29:55 2009 -0400
+++ b/runtime/object.c	Mon May 25 23:34:36 2009 -0400
@@ -307,7 +307,7 @@
 			fprintf(stderr, "Couldn't allocate %d bytes for method lookup table\n", sizeof(rhope_func) * INITIAL_METHOD_LOOKUP);
 			exit(-1);
 		}
-		if(methodid - BELOW_INITIAL_METHOD < 1) {
+		if(BELOW_INITIAL_METHOD > methodid) {
 			bp->first_methodid = 1;
 			bp->last_methodid = 1+INITIAL_METHOD_LOOKUP;
 		} else {
@@ -336,7 +336,7 @@
 				exit(-1);
 			}
 			memset(bp->method_lookup+bp->last_methodid, '\0', (methodid+1)-bp->last_methodid);
-			bp->last_methodid = methodid;
+			bp->last_methodid = methodid+1;
 		}
 	}
 	bp->method_lookup[methodid-bp->first_methodid] = impl;
diff -r 3021dac0d8f5 -r 31f8182f3433 runtime/object.h
--- a/runtime/object.h	Tue May 19 23:29:55 2009 -0400
+++ b/runtime/object.h	Mon May 25 23:34:36 2009 -0400
@@ -1,5 +1,5 @@
-#ifndef _OBJECT_H_
-#define _OBJECT_H_
+#ifndef OBJECT_H_
+#define OBJECT_H_
 
 #include "plat_types.h"
 #include "thread.h"
@@ -41,23 +41,24 @@
 
 
 typedef struct calldata {
-	rhope_func      tail_func;
-	struct context  *ct;
-	void            *locals;
-	uint32_t        original_methodid;
-	uint16_t        num_params;
-	uint16_t        resume;
-	object          *params[1];
+	rhope_func       tail_func;
+	struct context   *ct;
+	void             *locals;
+	struct calldata  *call;
+	uint32_t         original_methodid;
+	uint16_t         num_params;
+	uint16_t         resume;
+	object           *params[1];
 } calldata;
 
 #define OBegin typedef struct { object header;
-#define Object(name) } _t_ ## name;
+#define Object(name) } t_ ## name;
 
 #define MOBegin typedef struct { multisize header;
 
 #define get_blueprint(object) (object)->bprint
 
-#define add_ref(object) rh_atomic_add(&(object->header), refcount, 1)
+#define add_ref(object) (rh_atomic_add((object), refcount, 1),object)
 
 returntype call_method(uint32_t methodid, calldata * params);
 returntype set_field(uint32_t setfieldid, calldata * params);
@@ -79,4 +80,4 @@
 #define INITIAL_METHOD_LOOKUP	8
 #define BELOW_INITIAL_METHOD	3
 
-#endif //_OBJECT_H_
+#endif //OBJECT_H_
diff -r 3021dac0d8f5 -r 31f8182f3433 test/build.bat
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/build.bat	Mon May 25 23:34:36 2009 -0400
@@ -0,0 +1,13 @@
+@echo off
+cd ..\build
+
+for %%f in (..\test\*.c ..\runtime\object.c ..\runtime\context.c ..\runtime\builtin.c ..\runtime\bool.c ..\runtime\integer.c) do (
+	cl /c /Ox /I..\runtime %%f
+	if errorlevel 1 goto end
+)
+
+cl /Ox test.obj object.obj context.obj builtin.obj bool.obj integer.obj
+cl /Ox fib.obj object.obj context.obj builtin.obj bool.obj integer.obj winmm.lib
+
+:end
+cd ..\test
\ No newline at end of file
diff -r 3021dac0d8f5 -r 31f8182f3433 test/fib.c
--- a/test/fib.c	Tue May 19 23:29:55 2009 -0400
+++ b/test/fib.c	Mon May 25 23:34:36 2009 -0400
@@ -1,14 +1,15 @@
 #include <stdio.h>
 #include "builtin.h"
 #include "object.h"
-#include "integer.h"
 #include "context.h"
 #include "func.h"
+#include "integer.h"
 
 typedef struct
 {
 	object * work1;
 	object * work2;
+	object * out;
 } fib_t;
 
 object * const_1;
@@ -19,58 +20,97 @@
 	CallSpace 2,
 	fib_t);
 	
-	MCall(METHOD_SUB, 
+	locals->out = NULL;
+	
+	
+	call->params[0] = add_ref(cdata->params[0]);
+	call->params[1] = add_ref(const_2);
+	MCall(METHOD_LESS, 2)
+	
+	MCall(METHOD_IF, 1)
+	
+	if(call->params[0])
+		locals->out = add_ref(const_1);
+	
+	if(call->params[1])
+	{
+		call->params[0] = add_ref(cdata->params[0]);
+		call->params[1] = add_ref(const_1);
+		MCall(METHOD_SUB, 2)
+		locals->work1 = call->params[0];
+		
+		call->params[0] = add_ref(cdata->params[0]);
+		call->params[1] = add_ref(const_2);
+		MCall(METHOD_SUB, 2)
+		locals->work2 = call->params[0];
+		
+		call->params[0] = locals->work1;
+		Call(Fib, 1)
+		locals->work1 = call->params[0];
+		
+		call->params[0] = locals->work2;
+		Call(Fib, 1)
+		locals->work2 = call->params[0];
+		
+		if(!locals->out)
+		{
+			release_ref(cdata->params[0]);
+			cdata->params[0] = locals->work1;
+			cdata->params[1] = locals->work2;
+			TMCall(METHOD_ADD, 2)
+		}
+	}
+	release_ref(cdata->params[0]);
+	Ret(0, locals->out)
+	
 EndFunc
 
 FuncNoLocals(Main,
-	NumParams 0,
+	NumParams 1,
 	CallSpace 2)
 	
-	call->params[0] = make_Int32(2);
-	call->params[1] = make_Int32(3);
-	call->num_params = 2;
-	call->resume = 0;
-	ret = call_method(METHOD_ADD, call);
-	while(ret == TAIL_RETURN)
-		ret = call->tail_func(call);
-	if(ret == EXCEPTION_RETURN) {
-		Ret(0,call->params[0]);
-		return ret;
-	}
-	call->params[1] = make_Int32(1);
-	call->resume = 0;
-	ret = call_method(METHOD_SUB, call);
-	while(ret == TAIL_RETURN)
-		ret = call->tail_func(call);
-	if(ret == EXCEPTION_RETURN) {
-		Ret(0,call->params[0]);
-		return ret;
-	}
-	Ret(0,call->params[0])
+	TCall(Fib, 1)
 EndFunc
 
+#ifdef _WIN32
+	#include "windows.h"
+#endif
 
 int main(int argc, char ** argv)
 {
 	returntype ret;
 	calldata *cdata;
 	context * ct;
+	#ifdef _WIN32
+		DWORD dur;
+		dur = timeGetTime();
+	#endif
+	if(argc < 2)
+	{
+		puts("not enought arguments");
+		return -1;
+	}
 	register_builtin_types();
 	ct = new_context();
 	cdata = alloc_cdata(ct, 1);
-	cdata->num_params = 0;
+	cdata->num_params = 1;
 	cdata->resume = 0;
 	
 	const_1 = make_Int32(1);
 	const_2 = make_Int32(2);
-	ret = _f_Main(cdata);
+	cdata->params[0] = make_Int32(atoi(argv[1]));
+	ret = f_Main(cdata);
 	while(ret == TAIL_RETURN)
 		ret = cdata->tail_func(cdata);
 	if(ret == EXCEPTION_RETURN) {
 		puts("Exception!");
 		return -1;
 	}
-	printf("Result: %d\n", ((_t_Int32 *)cdata->params[0])->num);
+	printf("Result: %d\n", ((t_Int32 *)cdata->params[0])->num);
+	#ifdef _WIN32
+		dur = timeGetTime()-dur;
+		printf("Took %d milliseconds\n", dur);
+	#endif
 	return 0;
 }
 
diff -r 3021dac0d8f5 -r 31f8182f3433 test/test.c
--- a/test/test.c	Tue May 19 23:29:55 2009 -0400
+++ b/test/test.c	Mon May 25 23:34:36 2009 -0400
@@ -28,14 +28,14 @@
 	cdata = alloc_cdata(ct, 1);
 	cdata->num_params = 0;
 	cdata->resume = 0;
-	ret = _f_Main(cdata);
+	ret = f_Main(cdata);
 	while(ret == TAIL_RETURN)
 		ret = cdata->tail_func(cdata);
 	if(ret == EXCEPTION_RETURN) {
 		puts("Exception!");
 		return -1;
 	}
-	printf("Result: %d\n", ((_t_Int32 *)cdata->params[0])->num);
+	printf("Result: %d\n", ((t_Int32 *)cdata->params[0])->num);
 	return 0;
 }