X-Git-Url: https://git.ucc.asn.au/?a=blobdiff_plain;f=Usermode%2FLibraries%2Flibspiderscript.so_src%2Fexec_ast.c;h=d4c7995f14f5b7b23abf8265efbeb891ac4c6f1a;hb=239f2374299c1471a40b1087725b32f3f163d9b3;hp=22469798d124b28d5e5ed19f0f52af14bb256435;hpb=be6e3ccd05add9ad319a121661c20cb4769f58d7;p=tpg%2Facess2.git

diff --git a/Usermode/Libraries/libspiderscript.so_src/exec_ast.c b/Usermode/Libraries/libspiderscript.so_src/exec_ast.c
index 22469798..d4c7995f 100644
--- a/Usermode/Libraries/libspiderscript.so_src/exec_ast.c
+++ b/Usermode/Libraries/libspiderscript.so_src/exec_ast.c
@@ -1,9 +1,13 @@
 /*
+ * SpiderScript Library
+ *
+ * AST Execution
  */
 #include <stdlib.h>
 #include <stdio.h>
 #include <stdarg.h>
 #include <string.h>
+#include "common.h"
 #include "ast.h"
 
 #define TRACE_VAR_LOOKUPS	0
@@ -13,25 +17,16 @@
 extern tSpiderFunction	*gpExports_First;
 
 // === PROTOTYPES ===
-void	Object_Dereference(tSpiderValue *Object);
-void	Object_Reference(tSpiderValue *Object);
-tSpiderValue	*SpiderScript_CreateInteger(uint64_t Value);
-tSpiderValue	*SpiderScript_CreateReal(double Value);
-tSpiderValue	*SpiderScript_CreateString(int Length, const char *Data);
-tSpiderValue	*SpiderScript_CastValueTo(int Type, tSpiderValue *Source);
- int	SpiderScript_IsValueTrue(tSpiderValue *Value);
-void	SpiderScript_FreeValue(tSpiderValue *Value);
-char	*SpiderScript_DumpValue(tSpiderValue *Value);
-
+// - Node Execution
 tSpiderValue	*AST_ExecuteNode(tAST_BlockState *Block, tAST_Node *Node);
-tSpiderValue	*AST_ExecuteNode_BinOp(tAST_BlockState *Block, tAST_Node *Node, int Operation, tSpiderValue *Left, tSpiderValue *Right);
-tSpiderValue	*AST_ExecuteNode_UniOp(tAST_BlockState *Block, tAST_Node *Node, int Operation, tSpiderValue *Value);
-
+tSpiderValue	*AST_ExecuteNode_BinOp(tSpiderScript *Script, tAST_Node *Node, int Operation, tSpiderValue *Left, tSpiderValue *Right);
+tSpiderValue	*AST_ExecuteNode_UniOp(tSpiderScript *Script, tAST_Node *Node, int Operation, tSpiderValue *Value);
+// - Variables
 tAST_Variable *Variable_Define(tAST_BlockState *Block, int Type, const char *Name, tSpiderValue *Value);
  int	Variable_SetValue(tAST_BlockState *Block, tAST_Node *VarNode, tSpiderValue *Value);
 tSpiderValue	*Variable_GetValue(tAST_BlockState *Block, tAST_Node *VarNode);
 void	Variable_Destroy(tAST_Variable *Variable);
-
+// - Errors
 void	AST_RuntimeMessage(tAST_Node *Node, const char *Type, const char *Format, ...);
 void	AST_RuntimeError(tAST_Node *Node, const char *Format, ...);
 
@@ -39,360 +34,48 @@ void	AST_RuntimeError(tAST_Node *Node, const char *Format, ...);
  int	giNextBlockIdent = 1;
 
 // === CODE ===
-/**
- * \brief Dereference a created object
- */
-void Object_Dereference(tSpiderValue *Object)
-{
-	if(!Object)	return ;
-	if(Object == ERRPTR)	return ;
-	Object->ReferenceCount --;
-//	printf("%p Dereferenced (%i)\n", Object, Object->ReferenceCount);
-	if( Object->ReferenceCount == 0 ) {
-		switch( (enum eSpiderScript_DataTypes) Object->Type )
-		{
-		case SS_DATATYPE_OBJECT:
-			Object->Object->Type->Destructor( Object->Object );
-			break;
-		case SS_DATATYPE_OPAQUE:
-			Object->Opaque.Destroy( Object->Opaque.Data );
-			break;
-		default:
-			break;
-		}
-		free(Object);
-	}
-}
-
-void Object_Reference(tSpiderValue *Object)
+tSpiderValue *AST_ExecuteFunction(tSpiderScript *Script, tScript_Function *Fcn, int NArguments, tSpiderValue **Arguments)
 {
-	if(!Object)	return ;
-	Object->ReferenceCount ++;
-//	printf("%p Referenced (%i)\n", Object, Object->ReferenceCount);
-}
-
-/**
- * \brief Allocate and initialise a SpiderScript object
- */
-tSpiderObject *SpiderScript_AllocateObject(tSpiderObjectDef *Class, int ExtraBytes)
-{
-	 int	size = sizeof(tSpiderObject) + Class->NAttributes * sizeof(tSpiderValue*) + ExtraBytes;
-	tSpiderObject	*ret = malloc(size);
-	
-	ret->Type = Class;
-	ret->ReferenceCount = 1;
-	ret->OpaqueData = &ret->Attributes[ Class->NAttributes ];
-	memset( ret->Attributes, 0, Class->NAttributes * sizeof(tSpiderValue*) );
-	
-	return ret;
-}
-
-/**
- * \brief Create an integer object
- */
-tSpiderValue *SpiderScript_CreateInteger(uint64_t Value)
-{
-	tSpiderValue	*ret = malloc( sizeof(tSpiderValue) );
-	ret->Type = SS_DATATYPE_INTEGER;
-	ret->ReferenceCount = 1;
-	ret->Integer = Value;
-	return ret;
-}
-
-/**
- * \brief Create an real number object
- */
-tSpiderValue *SpiderScript_CreateReal(double Value)
-{
-	tSpiderValue	*ret = malloc( sizeof(tSpiderValue) );
-	ret->Type = SS_DATATYPE_REAL;
-	ret->ReferenceCount = 1;
-	ret->Real = Value;
-	return ret;
-}
-
-/**
- * \brief Create an string object
- */
-tSpiderValue *SpiderScript_CreateString(int Length, const char *Data)
-{
-	tSpiderValue	*ret = malloc( sizeof(tSpiderValue) + Length + 1 );
-	ret->Type = SS_DATATYPE_STRING;
-	ret->ReferenceCount = 1;
-	ret->String.Length = Length;
-	if( Data )
-		memcpy(ret->String.Data, Data, Length);
-	else
-		memset(ret->String.Data, 0, Length);
-	ret->String.Data[Length] = '\0';
-	return ret;
-}
-
-/**
- * \brief Concatenate two strings
- */
-tSpiderValue *Object_StringConcat(const tSpiderValue *Str1, const tSpiderValue *Str2)
-{
-	 int	newLen = 0;
+	tAST_BlockState	bs;
 	tSpiderValue	*ret;
-	if(Str1)	newLen += Str1->String.Length;
-	if(Str2)	newLen += Str2->String.Length;
-	ret = malloc( sizeof(tSpiderValue) + newLen + 1 );
-	ret->Type = SS_DATATYPE_STRING;
-	ret->ReferenceCount = 1;
-	ret->String.Length = newLen;
-	if(Str1)
-		memcpy(ret->String.Data, Str1->String.Data, Str1->String.Length);
-	if(Str2) {
-		if(Str1)
-			memcpy(ret->String.Data+Str1->String.Length, Str2->String.Data, Str2->String.Length);
-		else
-			memcpy(ret->String.Data, Str2->String.Data, Str2->String.Length);
-	}
-	ret->String.Data[ newLen ] = '\0';
-	return ret;
-}
-
-/**
- * \brief Cast one object to another
- * \brief Type	Destination type
- * \brief Source	Input data
- */
-tSpiderValue *SpiderScript_CastValueTo(int Type, tSpiderValue *Source)
-{
-	tSpiderValue	*ret = ERRPTR;
-	 int	len = 0;
-
-	if( !Source )
-	{
-		switch(Type)
-		{
-		case SS_DATATYPE_INTEGER:	return SpiderScript_CreateInteger(0);
-		case SS_DATATYPE_REAL:	return SpiderScript_CreateReal(0);
-		case SS_DATATYPE_STRING:	return SpiderScript_CreateString(4, "null");
-		}
-		return NULL;
-	}
-	
-	// Check if anything needs to be done
-	if( Source->Type == Type ) {
-		Object_Reference(Source);
-		return Source;
-	}
-	
-	#if 0
+	 int	i = 0;
+	
+	// Build a block State
+	bs.FirstVar = NULL;
+	bs.RetVal = NULL;
+	bs.Parent = NULL;
+	bs.BaseNamespace = &Script->Variant->RootNamespace;
+	bs.CurNamespace = NULL;
+	bs.Script = Script;
+	bs.Ident = giNextBlockIdent ++;
+	
+	// Parse arguments
+	for( i = 0; i < Fcn->ArgumentCount; i ++ )
 	{
-		printf("Casting %i ", Source->Type);
-		switch(Source->Type)
-		{
-		case SS_DATATYPE_INTEGER:	printf("0x%lx", Source->Integer);	break;
-		case SS_DATATYPE_STRING:	printf("\"%s\"", Source->String.Data);	break;
-		case SS_DATATYPE_REAL:	printf("%f", Source->Real);	break;
-		default:	break;
-		}
-		printf(" to %i\n", Type);
+		if( i >= NArguments )	break;	// TODO: Return gracefully
+		// TODO: Type checks
+		Variable_Define(&bs,
+			Fcn->Arguments[i].Type, Fcn->Arguments[i].Name,
+			Arguments[i]);
 	}
-	#endif
-	
-	#if 0
-	if( Source->Type == SS_DATATYPE_OBJECT )
+			
+	// Execute function
+	ret = AST_ExecuteNode(&bs, Fcn->ASTFcn);
+	if(ret != ERRPTR)
 	{
-		const char	*name = NULL;
-		switch(Type)
-		{
-		case SS_DATATYPE_INTEGER:	name = "cast Integer";	break;
-		case SS_DATATYPE_REAL:  	name = "cast Real";	break;
-		case SS_DATATYPE_STRING:	name = "cast String";	break;
-		case SS_DATATYPE_ARRAY: 	name = "cast Array";	break;
-		default:
-			AST_RuntimeError(NULL, "Invalid cast to %i from Object", Type);
-			return ERRPTR;
-		}
-		if( fcnname )
-		{
-			ret = Object_ExecuteMethod(Left->Object, fcnname, Right);
-			if( ret != ERRPTR )
-				return ret;
-			// Fall through and try casting (which will usually fail)
-		}
+		SpiderScript_DereferenceValue(ret);	// Dereference output of last block statement
+		ret = bs.RetVal;	// Set to return value of block
 	}
-	#endif
-	
-	switch( (enum eSpiderScript_DataTypes)Type )
+			
+	while(bs.FirstVar)
 	{
-	case SS_DATATYPE_UNDEF:
-	case SS_DATATYPE_ARRAY:
-	case SS_DATATYPE_OPAQUE:
-	case SS_DATATYPE_OBJECT:
-		AST_RuntimeError(NULL, "Invalid cast to %i", Type);
-		return ERRPTR;
-	
-	case SS_DATATYPE_INTEGER:
-		ret = malloc(sizeof(tSpiderValue));
-		ret->Type = SS_DATATYPE_INTEGER;
-		ret->ReferenceCount = 1;
-		switch(Source->Type)
-		{
-		case SS_DATATYPE_INTEGER:	break;	// Handled above
-		case SS_DATATYPE_STRING:	ret->Integer = atoi(Source->String.Data);	break;
-		case SS_DATATYPE_REAL:	ret->Integer = Source->Real;	break;
-		default:
-			AST_RuntimeError(NULL, "Invalid cast from %i to Integer", Source->Type);
-			free(ret);
-			ret = ERRPTR;
-			break;
-		}
-		break;
-	
-	case SS_DATATYPE_REAL:
-		ret = malloc(sizeof(tSpiderValue));
-		ret->Type = SS_DATATYPE_REAL;
-		ret->ReferenceCount = 1;
-		switch(Source->Type)
-		{
-		case SS_DATATYPE_STRING:	ret->Real = atof(Source->String.Data);	break;
-		case SS_DATATYPE_INTEGER:	ret->Real = Source->Integer;	break;
-		default:
-			AST_RuntimeError(NULL, "Invalid cast from %i to Real", Source->Type);
-			free(ret);
-			ret = ERRPTR;
-			break;
-		}
-		break;
-	
-	case SS_DATATYPE_STRING:
-		switch(Source->Type)
-		{
-		case SS_DATATYPE_INTEGER:	len = snprintf(NULL, 0, "%li", Source->Integer);	break;
-		case SS_DATATYPE_REAL:	len = snprintf(NULL, 0, "%g", Source->Real);	break;
-		default:	break;
-		}
-		ret = malloc(sizeof(tSpiderValue) + len + 1);
-		ret->Type = SS_DATATYPE_STRING;
-		ret->ReferenceCount = 1;
-		ret->String.Length = len;
-		switch(Source->Type)
-		{
-		case SS_DATATYPE_INTEGER:	sprintf(ret->String.Data, "%li", Source->Integer);	break;
-		case SS_DATATYPE_REAL:
-			sprintf(ret->String.Data, "%g", Source->Real);	break;
-		default:
-			AST_RuntimeError(NULL, "Invalid cast from %i to String", Source->Type);
-			free(ret);
-			ret = ERRPTR;
-			break;
-		}
-		break;
-	
-	default:
-		AST_RuntimeError(NULL, "BUG - BUG REPORT: Unimplemented cast target %i", Type);
-		ret = ERRPTR;
-		break;
+		tAST_Variable	*nextVar = bs.FirstVar->Next;
+		Variable_Destroy( bs.FirstVar );
+		bs.FirstVar = nextVar;
 	}
-	
 	return ret;
 }
 
-/**
- * \brief Condenses a value down to a boolean
- */
-int SpiderScript_IsValueTrue(tSpiderValue *Value)
-{
-	if( Value == ERRPTR )	return 0;
-	if( Value == NULL )	return 0;
-	
-	switch( (enum eSpiderScript_DataTypes)Value->Type )
-	{
-	case SS_DATATYPE_UNDEF:
-		return 0;
-	
-	case SS_DATATYPE_INTEGER:
-		return !!Value->Integer;
-	
-	case SS_DATATYPE_REAL:
-		return (-.5f < Value->Real && Value->Real < 0.5f);
-	
-	case SS_DATATYPE_STRING:
-		return Value->String.Length > 0;
-	
-	case SS_DATATYPE_OBJECT:
-		return Value->Object != NULL;
-	
-	case SS_DATATYPE_OPAQUE:
-		return Value->Opaque.Data != NULL;
-	
-	case SS_DATATYPE_ARRAY:
-		return Value->Array.Length > 0;
-	default:
-		AST_RuntimeError(NULL, "Unknown type %i in SpiderScript_IsValueTrue", Value->Type);
-		return 0;
-	}
-	return 0;
-}
-
-/**
- * \brief Free a value
- * \note Just calls Object_Dereference
- */
-void SpiderScript_FreeValue(tSpiderValue *Value)
-{
-	Object_Dereference(Value);
-}
-
-/**
- * \brief Dump a value into a string
- * \return Heap string
- */
-char *SpiderScript_DumpValue(tSpiderValue *Value)
-{
-	char	*ret;
-	if( Value == ERRPTR )
-		return strdup("ERRPTR");
-	if( Value == NULL )
-		return strdup("null");
-	
-	switch( (enum eSpiderScript_DataTypes)Value->Type )
-	{
-	case SS_DATATYPE_UNDEF:	return strdup("undefined");
-	
-	case SS_DATATYPE_INTEGER:
-		ret = malloc( sizeof(Value->Integer)*2 + 3 );
-		sprintf(ret, "0x%lx", Value->Integer);
-		return ret;
-	
-	case SS_DATATYPE_REAL:
-		ret = malloc( sprintf(NULL, "%f", Value->Real) + 1 );
-		sprintf(ret, "%f", Value->Real);
-		return ret;
-	
-	case SS_DATATYPE_STRING:
-		ret = malloc( Value->String.Length + 3 );
-		ret[0] = '"';
-		strcpy(ret+1, Value->String.Data);
-		ret[Value->String.Length+1] = '"';
-		ret[Value->String.Length+2] = '\0';
-		return ret;
-	
-	case SS_DATATYPE_OBJECT:
-		ret = malloc( sprintf(NULL, "{%s *%p}", Value->Object->Type->Name, Value->Object) + 1 );
-		sprintf(ret, "{%s *%p}", Value->Object->Type->Name, Value->Object);
-		return ret;
-	
-	case SS_DATATYPE_OPAQUE:
-		ret = malloc( sprintf(NULL, "*%p", Value->Opaque.Data) + 1 );
-		sprintf(ret, "*%p", Value->Opaque.Data);
-		return ret;
-	
-	case SS_DATATYPE_ARRAY:
-		return strdup("Array");
-	
-	default:
-		AST_RuntimeError(NULL, "Unknown type %i in Object_Dump", Value->Type);
-		return NULL;
-	}
-	
-}
-
 /**
  * \brief Execute a script function
  * \param Script	Script context to execute in
@@ -407,63 +90,27 @@ tSpiderValue *SpiderScript_ExecuteFunction(tSpiderScript *Script,
 {
 	 int	bFound = 0;	// Used to keep nesting levels down
 	tSpiderValue	*ret = ERRPTR;
-	tSpiderFunction	*fcn;
 	
 	// First: Find the function in the script
 	{
-		tAST_Function	*astFcn;
-		for( astFcn = Script->Script->Functions; astFcn; astFcn = astFcn->Next )
+		tScript_Function	*fcn;
+		for( fcn = Script->Functions; fcn; fcn = fcn->Next )
 		{
-			if( strcmp(astFcn->Name, Function) == 0 )
+			if( strcmp(fcn->Name, Function) == 0 )
 				break;
 		}
 		// Execute!
-		if(astFcn)
+		if(fcn)
 		{
-			tAST_BlockState	bs;
-			tAST_Node	*arg;
-			 int	i = 0;
-			
-			// Build a block State
-			bs.FirstVar = NULL;
-			bs.RetVal = NULL;
-			bs.Parent = NULL;
-			bs.BaseNamespace = &Script->Variant->RootNamespace;
-			bs.CurNamespace = NULL;
-			bs.Script = Script;
-			bs.Ident = giNextBlockIdent ++;
-			
-			// Parse arguments
-			for( arg = astFcn->Arguments; arg; arg = arg->NextSibling, i++ )
-			{
-				if( i >= NArguments )	break;	// TODO: Return gracefully
-				// TODO: Type checks
-				Variable_Define(&bs,
-					arg->DefVar.DataType, arg->DefVar.Name,
-					Arguments[i]);
-			}
-			
-			// Execute function
-			ret = AST_ExecuteNode(&bs, astFcn->Code);
-			if(ret != ERRPTR)
-			{
-				Object_Dereference(ret);	// Dereference output of last block statement
-				ret = bs.RetVal;	// Set to return value of block
-			}
+			ret = AST_ExecuteFunction(Script, fcn, NArguments, Arguments);
 			bFound = 1;
-			
-			while(bs.FirstVar)
-			{
-				tAST_Variable	*nextVar = bs.FirstVar->Next;
-				Variable_Destroy( bs.FirstVar );
-				bs.FirstVar = nextVar;
-			}
 		}
 	}
 	
 	// Didn't find it in script?
 	if(!bFound)
 	{
+		tSpiderFunction	*fcn;
 		fcn = NULL;	// Just to allow the below code to be neat
 		
 		// Second: Scan current namespace
@@ -508,7 +155,8 @@ tSpiderValue *SpiderScript_ExecuteFunction(tSpiderScript *Script,
 	// Not found?
 	if(!bFound)
 	{
-		fprintf(stderr, "Undefined reference to function '%s'\n", Function);
+		fprintf(stderr, "Undefined reference to function '%s' (ns='%s')\n",
+			Function, Namespace->Name);
 		return ERRPTR;
 	}
 	
@@ -630,7 +278,7 @@ tSpiderValue *SpiderScript_CreateObject(tSpiderScript *Script,
 			ret = AST_ExecuteNode(&bs, astFcn->Code);
 			if( ret != ERRPTR )
 			{
-				Object_Dereference(ret);	// Dereference output of last block statement
+				SpiderScript_DereferenceValue(ret);	// Dereference output of last block statement
 				ret = bs.RetVal;	// Set to return value of block
 			}
 			bFound = 1;
@@ -650,6 +298,9 @@ tSpiderValue *SpiderScript_CreateObject(tSpiderScript *Script,
 	{
 		class = NULL;	// Just to allow the below code to be neat
 		
+		//if( !Namespace )
+		//	Namespace = &Script->Variant->RootNamespace;
+		
 		// Second: Scan current namespace
 		if( !class && Namespace )
 		{
@@ -745,14 +396,17 @@ tSpiderValue *AST_ExecuteNode(tAST_BlockState *Block, tAST_Node *Node)
 			blockInfo.RetVal = NULL;
 			blockInfo.BaseNamespace = Block->BaseNamespace;
 			blockInfo.CurNamespace = NULL;
+			blockInfo.BreakTarget = NULL;
 			blockInfo.Ident = giNextBlockIdent ++;
 			ret = NULL;
 			// Loop over all nodes, or until the return value is set
-			for(node = Node->Block.FirstChild; node && !blockInfo.RetVal; node = node->NextSibling )
+			for(node = Node->Block.FirstChild;
+				node && !blockInfo.RetVal && !blockInfo.BreakTarget;
+				node = node->NextSibling )
 			{
 				ret = AST_ExecuteNode(&blockInfo, node);
 				if(ret == ERRPTR)	break;	// Error check
-				if(ret != NULL)	Object_Dereference(ret);	// Free unused value
+				if(ret != NULL)	SpiderScript_DereferenceValue(ret);	// Free unused value
 			}
 			// Clean up variables
 			while(blockInfo.FirstVar)
@@ -767,6 +421,12 @@ tSpiderValue *AST_ExecuteNode(tAST_BlockState *Block, tAST_Node *Node)
 			// Set parent's return value if needed
 			if( blockInfo.RetVal )
 				Block->RetVal = blockInfo.RetVal;
+			if( blockInfo.BreakTarget ) {
+				Block->BreakTarget = blockInfo.BreakTarget;
+				Block->BreakType = blockInfo.BreakType;
+			}
+			
+			// TODO: Unset break if break type deontes a block break
 		}
 		
 		break;
@@ -784,18 +444,39 @@ tSpiderValue *AST_ExecuteNode(tAST_BlockState *Block, tAST_Node *Node)
 		// Perform assignment operation
 		if( Node->Assign.Operation != NODETYPE_NOP )
 		{
-			tSpiderValue	*varVal = Variable_GetValue(Block, Node->Assign.Dest);
-			tSpiderValue	*value;
-			value = AST_ExecuteNode_BinOp(Block, Node, Node->Assign.Operation, varVal, ret);
+			tSpiderValue	*varVal, *value;
+
+			varVal = Variable_GetValue(Block, Node->Assign.Dest);
+			if(varVal == ERRPTR)	return ERRPTR;
+			#if 0
+			#else
+			if(varVal && varVal->ReferenceCount == 2) {
+				SpiderScript_DereferenceValue(varVal);
+//				printf("pre: (%s) varVal->ReferenceCount = %i\n",
+//					Node->Assign.Dest->Variable.Name,
+//					varVal->ReferenceCount);
+			}
+			#endif
+			value = AST_ExecuteNode_BinOp(Block->Script, Node, Node->Assign.Operation, varVal, ret);
 			if(value == ERRPTR)	return ERRPTR;
-			if(ret)	Object_Dereference(ret);
-			if(varVal)	Object_Dereference(varVal);
+
+			if(ret)	SpiderScript_DereferenceValue(ret);
+			#if 0
+			if(varVal)	SpiderScript_DereferenceValue(varVal);
+			#else
+			if(varVal && varVal->ReferenceCount == 1) {
+				SpiderScript_ReferenceValue(varVal);
+//				printf("post: varVal->ReferenceCount = %i\n", varVal->ReferenceCount);
+				break;	// If varVal was non-null, it has been updated by _BinOp
+			}
+			#endif
+			// Else, it was NULL, so has to be assigned
 			ret = value;
 		}
 		
 		// Set the variable value
 		if( Variable_SetValue( Block, Node->Assign.Dest, ret ) ) {
-			Object_Dereference( ret );
+			SpiderScript_DereferenceValue( ret );
 			return ERRPTR;
 		}
 		break;
@@ -821,19 +502,19 @@ tSpiderValue *AST_ExecuteNode(tAST_BlockState *Block, tAST_Node *Node)
 			varVal = Variable_GetValue(Block, Node->UniOp.Value);
 			
 			if( Node->Type == NODETYPE_POSTDEC )
-				value = AST_ExecuteNode_BinOp(Block, Node, NODETYPE_SUBTRACT, varVal, &one);
+				value = AST_ExecuteNode_BinOp(Block->Script, Node, NODETYPE_SUBTRACT, varVal, &one);
 			else
-				value = AST_ExecuteNode_BinOp(Block, Node, NODETYPE_ADD, varVal, &one);
+				value = AST_ExecuteNode_BinOp(Block->Script, Node, NODETYPE_ADD, varVal, &one);
 			if( value == ERRPTR )
 				return ERRPTR;
 			
 			ret = varVal;
 		
 			if( Variable_SetValue( Block, Node->UniOp.Value, value ) ) {
-				Object_Dereference( ret );
+				SpiderScript_DereferenceValue( ret );
 				return ERRPTR;
 			}
-			Object_Dereference( value );
+			SpiderScript_DereferenceValue( value );
 		}
 		break;
 	
@@ -843,27 +524,27 @@ tSpiderValue *AST_ExecuteNode(tAST_BlockState *Block, tAST_Node *Node)
 	case NODETYPE_CREATEOBJECT:
 		// Logical block (used to allocate `params`)
 		{
+			tSpiderNamespace	*ns = Block->CurNamespace;
 			tSpiderValue	*params[Node->FunctionCall.NumArgs];
 			i = 0;
 			for(node = Node->FunctionCall.FirstArg; node; node = node->NextSibling)
 			{
 				params[i] = AST_ExecuteNode(Block, node);
 				if( params[i] == ERRPTR ) {
-					while(i--)	Object_Dereference(params[i]);
+					while(i--)	SpiderScript_DereferenceValue(params[i]);
 					ret = ERRPTR;
 					goto _return;
 				}
 				i ++;
 			}
 			
-			if( !Block->CurNamespace )
-				Block->CurNamespace = Block->BaseNamespace;
+			if( !ns )	ns = Block->BaseNamespace;
 			
 			// Call the function
 			if( Node->Type == NODETYPE_CREATEOBJECT )
 			{
 				ret = SpiderScript_CreateObject(Block->Script,
-					Block->CurNamespace,
+					ns,
 					Node->FunctionCall.Name,
 					Node->FunctionCall.NumArgs, params
 					);
@@ -874,7 +555,7 @@ tSpiderValue *AST_ExecuteNode(tAST_BlockState *Block, tAST_Node *Node)
 				if( !obj || obj == ERRPTR || obj->Type != SS_DATATYPE_OBJECT ) {
 					AST_RuntimeError(Node->FunctionCall.Object,
 						"Type Mismatch - Required SS_DATATYPE_OBJECT for method call");
-					while(i--)	Object_Dereference(params[i]);
+					while(i--)	SpiderScript_DereferenceValue(params[i]);
 					ret = ERRPTR;
 					break;
 				}
@@ -882,19 +563,19 @@ tSpiderValue *AST_ExecuteNode(tAST_BlockState *Block, tAST_Node *Node)
 					obj->Object, Node->FunctionCall.Name,
 					Node->FunctionCall.NumArgs, params
 					);
-				Object_Dereference(obj);
+				SpiderScript_DereferenceValue(obj);
 			}
 			else
 			{
 				ret = SpiderScript_ExecuteFunction(Block->Script,
-					Block->CurNamespace, Node->FunctionCall.Name,
+					ns, Node->FunctionCall.Name,
 					Node->FunctionCall.NumArgs, params
 					);
 			}
 
 			
 			// Dereference parameters
-			while(i--)	Object_Dereference(params[i]);
+			while(i--)	SpiderScript_DereferenceValue(params[i]);
 			
 			// falls out
 		}
@@ -910,48 +591,69 @@ tSpiderValue *AST_ExecuteNode(tAST_BlockState *Block, tAST_Node *Node)
 		else {
 			tmpobj = AST_ExecuteNode(Block, Node->If.False);
 		}
-		Object_Dereference(ret);
+		SpiderScript_DereferenceValue(ret);
 		if( tmpobj == ERRPTR )	return ERRPTR;
-		Object_Dereference(tmpobj);
+		SpiderScript_DereferenceValue(tmpobj);
 		ret = NULL;
 		break;
 	
 	// Loop
 	case NODETYPE_LOOP:
+		// Initialise
 		ret = AST_ExecuteNode(Block, Node->For.Init);
 		if(ret == ERRPTR)	break;
-		if( Node->For.bCheckAfter )
+		
+		// Check initial condition
+		if( !Node->For.bCheckAfter )
 		{
-			do {
-				Object_Dereference(ret);
-				ret = AST_ExecuteNode(Block, Node->For.Code);
-				if(ret == ERRPTR)	return ERRPTR;
-				Object_Dereference(ret);
-				ret = AST_ExecuteNode(Block, Node->For.Increment);
-				if(ret == ERRPTR)	return ERRPTR;
-				Object_Dereference(ret);
-				ret = AST_ExecuteNode(Block, Node->For.Condition);
-				if(ret == ERRPTR)	return ERRPTR;
-			} while( SpiderScript_IsValueTrue(ret) );
+			SpiderScript_DereferenceValue(ret);
+		
+			ret = AST_ExecuteNode(Block, Node->For.Condition);
+			if(ret == ERRPTR)	return ERRPTR;
+			if(!SpiderScript_IsValueTrue(ret)) {
+				SpiderScript_DereferenceValue(ret);
+				ret = NULL;
+				break;
+			}
 		}
-		else
+	
+		// Perform loop
+		for( ;; )
 		{
-			Object_Dereference(ret);
-			ret = AST_ExecuteNode(Block, Node->For.Condition);
+			SpiderScript_DereferenceValue(ret);
+			
+			// Code
+			ret = AST_ExecuteNode(Block, Node->For.Code);
 			if(ret == ERRPTR)	return ERRPTR;
-			while( SpiderScript_IsValueTrue(ret) ) {
-				Object_Dereference(ret);
-				ret = AST_ExecuteNode(Block, Node->For.Code);
-				if(ret == ERRPTR)	return ERRPTR;
-				Object_Dereference(ret);
-				ret = AST_ExecuteNode(Block, Node->For.Increment);
-				if(ret == ERRPTR)	return ERRPTR;
-				Object_Dereference(ret);
-				ret = AST_ExecuteNode(Block, Node->For.Condition);
-				if(ret == ERRPTR)	return ERRPTR;
+			SpiderScript_DereferenceValue(ret);
+			
+			if(Block->BreakTarget)
+			{
+				if( Block->BreakTarget[0] == '\0' || strcmp(Block->BreakTarget, Node->For.Tag) == 0 )
+				{
+					// Ours
+					free((void*)Block->BreakTarget);	Block->BreakTarget = NULL;
+					if( Block->BreakType == NODETYPE_CONTINUE ) {
+						// Continue, just keep going
+					}
+					else
+						break;
+				}
+				else
+					break;	// Break out of this loop
 			}
+			
+			// Increment
+			ret = AST_ExecuteNode(Block, Node->For.Increment);
+			if(ret == ERRPTR)	return ERRPTR;
+			SpiderScript_DereferenceValue(ret);
+			
+			// Check condition
+			ret = AST_ExecuteNode(Block, Node->For.Condition);
+			if(ret == ERRPTR)	return ERRPTR;
+			if(!SpiderScript_IsValueTrue(ret))	break;
 		}
-		Object_Dereference(ret);
+		SpiderScript_DereferenceValue(ret);
 		ret = NULL;
 		break;
 	
@@ -963,6 +665,12 @@ tSpiderValue *AST_ExecuteNode(tAST_BlockState *Block, tAST_Node *Node)
 		ret = NULL;	// the `return` statement does not return a value
 		break;
 	
+	case NODETYPE_BREAK:
+	case NODETYPE_CONTINUE:
+		Block->BreakTarget = strdup(Node->Variable.Name);
+		Block->BreakType = Node->Type;
+		break;
+	
 	// Define a variable
 	case NODETYPE_DEFVAR:
 		if( Node->DefVar.InitialValue ) {
@@ -972,10 +680,11 @@ tSpiderValue *AST_ExecuteNode(tAST_BlockState *Block, tAST_Node *Node)
 		else {
 			tmpobj = NULL;
 		}
+		// TODO: Handle arrays
 		ret = NULL;
 		if( Variable_Define(Block, Node->DefVar.DataType, Node->DefVar.Name, tmpobj) == ERRPTR )
 			ret = ERRPTR;
-		Object_Dereference(tmpobj);
+		SpiderScript_DereferenceValue(tmpobj);
 		break;
 	
 	// Scope
@@ -1033,7 +742,7 @@ tSpiderValue *AST_ExecuteNode(tAST_BlockState *Block, tAST_Node *Node)
 			if( strcmp(Node->Scope.Name, tmpobj->Object->Type->AttributeDefs[i].Name) == 0 )
 			{
 				ret = tmpobj->Object->Attributes[i];
-				Object_Reference(ret);
+				SpiderScript_ReferenceValue(ret);
 				break;
 			}
 		}
@@ -1051,7 +760,7 @@ tSpiderValue *AST_ExecuteNode(tAST_BlockState *Block, tAST_Node *Node)
 		tmpobj = AST_ExecuteNode(Block, Node->Cast.Value);
 		if(tmpobj == ERRPTR) return ERRPTR;
 		ret = SpiderScript_CastValueTo( Node->Cast.DataType, tmpobj );
-		Object_Dereference(tmpobj);
+		SpiderScript_DereferenceValue(tmpobj);
 		}
 		break;
 
@@ -1061,7 +770,7 @@ tSpiderValue *AST_ExecuteNode(tAST_BlockState *Block, tAST_Node *Node)
 		if(op1 == ERRPTR)	return ERRPTR;
 		op2 = AST_ExecuteNode(Block, Node->BinOp.Right);	// Offset
 		if(op2 == ERRPTR) {
-			Object_Dereference(op1);
+			SpiderScript_DereferenceValue(op1);
 			return ERRPTR;
 		}
 		
@@ -1082,7 +791,7 @@ tSpiderValue *AST_ExecuteNode(tAST_BlockState *Block, tAST_Node *Node)
 		if( !op2 || op2->Type != SS_DATATYPE_INTEGER )
 		{
 			tmpobj = SpiderScript_CastValueTo(SS_DATATYPE_INTEGER, op2);
-			Object_Dereference(op2);
+			SpiderScript_DereferenceValue(op2);
 			op2 = tmpobj;
 		}
 		
@@ -1094,15 +803,15 @@ tSpiderValue *AST_ExecuteNode(tAST_BlockState *Block, tAST_Node *Node)
 		}
 		
 		ret = op1->Array.Items[ op2->Integer ];
-		Object_Reference(ret);
+		SpiderScript_ReferenceValue(ret);
 		
-		Object_Dereference(op1);
-		Object_Dereference(op2);
+		SpiderScript_DereferenceValue(op1);
+		SpiderScript_DereferenceValue(op2);
 		break;
 
 	// TODO: Implement runtime constants
 	case NODETYPE_CONSTANT:
-		// TODO: Scan namespace for function
+		// TODO: Scan namespace for constant name
 		AST_RuntimeError(Node, "TODO - Runtime Constants");
 		ret = ERRPTR;
 		break;
@@ -1112,7 +821,7 @@ tSpiderValue *AST_ExecuteNode(tAST_BlockState *Block, tAST_Node *Node)
 	case NODETYPE_INTEGER:
 	case NODETYPE_REAL:
 		ret = &Node->Constant;
-		Object_Reference(ret);
+		SpiderScript_ReferenceValue(ret);
 		break;
 	
 	// --- Operations ---
@@ -1121,7 +830,7 @@ tSpiderValue *AST_ExecuteNode(tAST_BlockState *Block, tAST_Node *Node)
 		op1 = AST_ExecuteNode(Block, Node->UniOp.Value);
 		if(op1 == ERRPTR)	return ERRPTR;
 		ret = SpiderScript_CreateInteger( !SpiderScript_IsValueTrue(op1) );
-		Object_Dereference(op1);
+		SpiderScript_DereferenceValue(op1);
 		break;
 	case NODETYPE_LOGICALAND:	// Logical AND (&&)
 	case NODETYPE_LOGICALOR:	// Logical OR (||)
@@ -1130,7 +839,7 @@ tSpiderValue *AST_ExecuteNode(tAST_BlockState *Block, tAST_Node *Node)
 		if(op1 == ERRPTR)	return ERRPTR;
 		op2 = AST_ExecuteNode(Block, Node->BinOp.Right);
 		if(op2 == ERRPTR) {
-			Object_Dereference(op1);
+			SpiderScript_DereferenceValue(op1);
 			return ERRPTR;
 		}
 		
@@ -1149,8 +858,8 @@ tSpiderValue *AST_ExecuteNode(tAST_BlockState *Block, tAST_Node *Node)
 		}
 		
 		// Free intermediate objects
-		Object_Dereference(op1);
-		Object_Dereference(op2);
+		SpiderScript_DereferenceValue(op1);
+		SpiderScript_DereferenceValue(op2);
 		break;
 	
 	// Comparisons
@@ -1163,15 +872,15 @@ tSpiderValue *AST_ExecuteNode(tAST_BlockState *Block, tAST_Node *Node)
 		if(op1 == ERRPTR)	return ERRPTR;
 		op2 = AST_ExecuteNode(Block, Node->BinOp.Right);
 		if(op2 == ERRPTR) {
-			Object_Dereference(op1);
+			SpiderScript_DereferenceValue(op1);
 			ret = ERRPTR;
 			break;
 		}
 		
 		if( !op1 || !op2 ) {
 			AST_RuntimeError(Node, "NULL Comparison (%p and %p)", op1, op2);
-			if(op1)	Object_Dereference(op1);
-			if(op2)	Object_Dereference(op2);
+			if(op1)	SpiderScript_DereferenceValue(op1);
+			if(op2)	SpiderScript_DereferenceValue(op2);
 			ret = SpiderScript_CreateInteger( !op1 && !op2 );
 			break;
 		}
@@ -1183,9 +892,9 @@ tSpiderValue *AST_ExecuteNode(tAST_BlockState *Block, tAST_Node *Node)
 			{
 				tmpobj = op2;
 				op2 = SpiderScript_CastValueTo(op1->Type, op2);
-				Object_Dereference(tmpobj);
+				SpiderScript_DereferenceValue(tmpobj);
 				if(op2 == ERRPTR) {
-					Object_Dereference(op1);
+					SpiderScript_DereferenceValue(op1);
 					return ERRPTR;
 				}
 			}
@@ -1238,8 +947,8 @@ tSpiderValue *AST_ExecuteNode(tAST_BlockState *Block, tAST_Node *Node)
 		}
 		
 		// Free intermediate objects
-		Object_Dereference(op1);
-		Object_Dereference(op2);
+		SpiderScript_DereferenceValue(op1);
+		SpiderScript_DereferenceValue(op2);
 		
 		// Error check
 		if( ret == ERRPTR )
@@ -1265,8 +974,8 @@ tSpiderValue *AST_ExecuteNode(tAST_BlockState *Block, tAST_Node *Node)
 	case NODETYPE_NEGATE:	// Negation (-)
 		op1 = AST_ExecuteNode(Block, Node->UniOp.Value);
 		if(op1 == ERRPTR)	return ERRPTR;
-		ret = AST_ExecuteNode_UniOp(Block, Node, Node->Type, op1);
-		Object_Dereference(op1);
+		ret = AST_ExecuteNode_UniOp(Block->Script, Node, Node->Type, op1);
+		SpiderScript_DereferenceValue(op1);
 		break;
 	
 	// General Binary Operations
@@ -1286,15 +995,15 @@ tSpiderValue *AST_ExecuteNode(tAST_BlockState *Block, tAST_Node *Node)
 		if(op1 == ERRPTR)	return ERRPTR;
 		op2 = AST_ExecuteNode(Block, Node->BinOp.Right);
 		if(op2 == ERRPTR) {
-			Object_Dereference(op1);
+			SpiderScript_DereferenceValue(op1);
 			return ERRPTR;
 		}
 		
-		ret = AST_ExecuteNode_BinOp(Block, Node, Node->Type, op1, op2);
+		ret = AST_ExecuteNode_BinOp(Block->Script, Node, Node->Type, op1, op2);
 		
 		// Free intermediate objects
-		Object_Dereference(op1);
-		Object_Dereference(op2);
+		SpiderScript_DereferenceValue(op1);
+		SpiderScript_DereferenceValue(op2);
 		break;
 	
 	//default:
@@ -1303,6 +1012,10 @@ tSpiderValue *AST_ExecuteNode(tAST_BlockState *Block, tAST_Node *Node)
 	//	break;
 	}
 _return:
+	// Reset namespace when no longer needed
+	if( Node->Type != NODETYPE_SCOPE )
+		Block->CurNamespace = NULL;
+
 	#if TRACE_NODE_RETURNS
 	if(ret && ret != ERRPTR) {
 		AST_RuntimeError(Node, "Ret type of %p %i is %i", Node, Node->Type, ret->Type);
@@ -1315,7 +1028,7 @@ _return:
 	return ret;
 }
 
-tSpiderValue *AST_ExecuteNode_UniOp(tAST_BlockState *Block, tAST_Node *Node, int Operation, tSpiderValue *Value)
+tSpiderValue *AST_ExecuteNode_UniOp(tSpiderScript *Script, tAST_Node *Node, int Operation, tSpiderValue *Value)
 {
 	tSpiderValue	*ret;
 	#if 0
@@ -1334,7 +1047,6 @@ tSpiderValue *AST_ExecuteNode_UniOp(tAST_BlockState *Block, tAST_Node *Node, int
 			ret = Object_ExecuteMethod(Value->Object, fcnname, );
 			if( ret != ERRPTR )
 				return ret;
-			// Fall through and try casting (which will usually fail)
 		}
 	}
 	#endif
@@ -1342,12 +1054,17 @@ tSpiderValue *AST_ExecuteNode_UniOp(tAST_BlockState *Block, tAST_Node *Node, int
 	{
 	// Integer Operations
 	case SS_DATATYPE_INTEGER:
+		if( Value->ReferenceCount == 1 )
+			SpiderScript_ReferenceValue(ret = Value);
+		else
+			ret = SpiderScript_CreateInteger(0);
 		switch(Operation)
 		{
-		case NODETYPE_NEGATE:	ret = SpiderScript_CreateInteger( -Value->Integer );	break;
-		case NODETYPE_BWNOT:	ret = SpiderScript_CreateInteger( ~Value->Integer );	break;
+		case NODETYPE_NEGATE:	ret->Integer = -Value->Integer;	break;
+		case NODETYPE_BWNOT:	ret->Integer = ~Value->Integer;	break;
 		default:
 			AST_RuntimeError(Node, "SpiderScript internal error: Exec,UniOP,Integer unknown op %i", Operation);
+			SpiderScript_DereferenceValue(ret);
 			ret = ERRPTR;
 			break;
 		}
@@ -1373,7 +1090,7 @@ tSpiderValue *AST_ExecuteNode_UniOp(tAST_BlockState *Block, tAST_Node *Node, int
 	return ret;
 }
 
-tSpiderValue *AST_ExecuteNode_BinOp(tAST_BlockState *Block, tAST_Node *Node, int Operation, tSpiderValue *Left, tSpiderValue *Right)
+tSpiderValue *AST_ExecuteNode_BinOp(tSpiderScript *Script, tAST_Node *Node, int Operation, tSpiderValue *Left, tSpiderValue *Right)
 {
 	tSpiderValue	*preCastValue = Right;
 	tSpiderValue	*ret;
@@ -1414,7 +1131,7 @@ tSpiderValue *AST_ExecuteNode_BinOp(tAST_BlockState *Block, tAST_Node *Node, int
 		#endif
 		
 		// If implicit casts are allowed, convert Right to Left's type
-		if(Block->Script->Variant->bImplicitCasts)
+		if(Script->Variant->bImplicitCasts)
 		{
 			Right = SpiderScript_CastValueTo(Left->Type, Right);
 			if(Right == ERRPTR)
@@ -1441,8 +1158,17 @@ tSpiderValue *AST_ExecuteNode_BinOp(tAST_BlockState *Block, tAST_Node *Node, int
 		switch(Operation)
 		{
 		case NODETYPE_ADD:	// Concatenate
-			ret = Object_StringConcat(Left, Right);
+			ret = SpiderScript_StringConcat(Left, Right);
 			break;
+		// TODO: Support python style 'i = %i' % i ?
+		// Might do it via a function call
+		// Implement it via % with an array, but getting past the cast will be fun
+//		case NODETYPE_MODULUS:
+//			break;
+		// TODO: Support string repititions
+//		case NODETYPE_MULTIPLY:
+//			break;
+
 		default:
 			AST_RuntimeError(Node, "SpiderScript internal error: Exec,BinOP,String unknown op %i", Operation);
 			ret = ERRPTR;
@@ -1451,23 +1177,28 @@ tSpiderValue *AST_ExecuteNode_BinOp(tAST_BlockState *Block, tAST_Node *Node, int
 		break;
 	// Integer Operations
 	case SS_DATATYPE_INTEGER:
+		if( Left->ReferenceCount == 1 )
+			SpiderScript_ReferenceValue(ret = Left);
+		else
+			ret = SpiderScript_CreateInteger(0);
 		switch(Operation)
 		{
-		case NODETYPE_ADD:	ret = SpiderScript_CreateInteger( Left->Integer + Right->Integer );	break;
-		case NODETYPE_SUBTRACT:	ret = SpiderScript_CreateInteger( Left->Integer - Right->Integer );	break;
-		case NODETYPE_MULTIPLY:	ret = SpiderScript_CreateInteger( Left->Integer * Right->Integer );	break;
-		case NODETYPE_DIVIDE:	ret = SpiderScript_CreateInteger( Left->Integer / Right->Integer );	break;
-		case NODETYPE_MODULO:	ret = SpiderScript_CreateInteger( Left->Integer % Right->Integer );	break;
-		case NODETYPE_BWAND:	ret = SpiderScript_CreateInteger( Left->Integer & Right->Integer );	break;
-		case NODETYPE_BWOR: 	ret = SpiderScript_CreateInteger( Left->Integer | Right->Integer );	break;
-		case NODETYPE_BWXOR:	ret = SpiderScript_CreateInteger( Left->Integer ^ Right->Integer );	break;
-		case NODETYPE_BITSHIFTLEFT:	ret = SpiderScript_CreateInteger( Left->Integer << Right->Integer );	break;
-		case NODETYPE_BITSHIFTRIGHT:ret = SpiderScript_CreateInteger( Left->Integer >> Right->Integer );	break;
+		case NODETYPE_ADD:	ret->Integer = Left->Integer + Right->Integer;	break;
+		case NODETYPE_SUBTRACT:	ret->Integer = Left->Integer - Right->Integer;	break;
+		case NODETYPE_MULTIPLY:	ret->Integer = Left->Integer * Right->Integer;	break;
+		case NODETYPE_DIVIDE:	ret->Integer = Left->Integer / Right->Integer;	break;
+		case NODETYPE_MODULO:	ret->Integer = Left->Integer % Right->Integer;	break;
+		case NODETYPE_BWAND:	ret->Integer = Left->Integer & Right->Integer;	break;
+		case NODETYPE_BWOR: 	ret->Integer = Left->Integer | Right->Integer;	break;
+		case NODETYPE_BWXOR:	ret->Integer = Left->Integer ^ Right->Integer;	break;
+		case NODETYPE_BITSHIFTLEFT: ret->Integer = Left->Integer << Right->Integer;	break;
+		case NODETYPE_BITSHIFTRIGHT:ret->Integer = Left->Integer >> Right->Integer;	break;
 		case NODETYPE_BITROTATELEFT:
-			ret = SpiderScript_CreateInteger( (Left->Integer << Right->Integer) | (Left->Integer >> (64-Right->Integer)) );
+			ret->Integer = (Left->Integer << Right->Integer) | (Left->Integer >> (64-Right->Integer));
 			break;
 		default:
 			AST_RuntimeError(Node, "SpiderScript internal error: Exec,BinOP,Integer unknown op %i", Operation);
+			SpiderScript_DereferenceValue(ret);
 			ret = ERRPTR;
 			break;
 		}
@@ -1475,14 +1206,19 @@ tSpiderValue *AST_ExecuteNode_BinOp(tAST_BlockState *Block, tAST_Node *Node, int
 	
 	// Real Numbers
 	case SS_DATATYPE_REAL:
+		if( Left->ReferenceCount == 1 )
+			SpiderScript_ReferenceValue(ret = Left);
+		else
+			ret = SpiderScript_CreateReal(0);
 		switch(Operation)
 		{
-		case NODETYPE_ADD:	ret = SpiderScript_CreateReal( Left->Real + Right->Real );	break;
-		case NODETYPE_SUBTRACT:	ret = SpiderScript_CreateReal( Left->Real - Right->Real );	break;
-		case NODETYPE_MULTIPLY:	ret = SpiderScript_CreateReal( Left->Real * Right->Real );	break;
-		case NODETYPE_DIVIDE:	ret = SpiderScript_CreateReal( Left->Real / Right->Real );	break;
+		case NODETYPE_ADD:	ret->Real = Left->Real + Right->Real;	break;
+		case NODETYPE_SUBTRACT:	ret->Real = Left->Real - Right->Real;	break;
+		case NODETYPE_MULTIPLY:	ret->Real = Left->Real * Right->Real;	break;
+		case NODETYPE_DIVIDE:	ret->Real = Left->Real / Right->Real;	break;
 		default:
 			AST_RuntimeError(Node, "SpiderScript internal error: Exec,BinOP,Real unknown op %i", Operation);
+			SpiderScript_DereferenceValue(ret);
 			ret = ERRPTR;
 			break;
 		}
@@ -1522,7 +1258,7 @@ tAST_Variable *Variable_Define(tAST_BlockState *Block, int Type, const char *Nam
 	var->Next = NULL;
 	var->Type = Type;
 	var->Object = Value;
-	if(Value)	Object_Reference(Value);
+	if(Value)	SpiderScript_ReferenceValue(Value);
 	strcpy(var->Name, Name);
 	
 	if(prev)	prev->Next = var;
@@ -1593,7 +1329,9 @@ tAST_Variable *Variable_Lookup(tAST_BlockState *Block, tAST_Node *VarNode, int C
  */
 int Variable_SetValue(tAST_BlockState *Block, tAST_Node *VarNode, tSpiderValue *Value)
 {
-	tAST_Variable	*var = Variable_Lookup(Block, VarNode, Value->Type);
+	tAST_Variable	*var;
+	
+	var = Variable_Lookup(Block, VarNode, (Value ? Value->Type : SS_DATATYPE_UNDEF));
 	
 	if( !var )	return -1;
 	
@@ -1605,8 +1343,8 @@ int Variable_SetValue(tAST_BlockState *Block, tAST_Node *VarNode, tSpiderValue *
 	}
 
 //	printf("Assign %p to '%s'\n", Value, var->Name);
-	Object_Reference(Value);
-	Object_Dereference(var->Object);
+	SpiderScript_ReferenceValue(Value);
+	SpiderScript_DereferenceValue(var->Object);
 	var->Object = Value;
 	return 0;
 }
@@ -1620,7 +1358,7 @@ tSpiderValue *Variable_GetValue(tAST_BlockState *Block, tAST_Node *VarNode)
 	
 	if( !var )	return ERRPTR;
 	
-	Object_Reference(var->Object);
+	SpiderScript_ReferenceValue(var->Object);
 	return var->Object;
 }
 
@@ -1630,7 +1368,7 @@ tSpiderValue *Variable_GetValue(tAST_BlockState *Block, tAST_Node *VarNode)
 void Variable_Destroy(tAST_Variable *Variable)
 {
 //	printf("Variable_Destroy: (%p'%s')\n", Variable, Variable->Name);
-	Object_Dereference(Variable->Object);
+	SpiderScript_DereferenceValue(Variable->Object);
 	free(Variable);
 }