/*
+ * SpiderScript Library
+ *
+ * AST Execution
*/
#include <stdlib.h>
#include <stdio.h>
extern tSpiderFunction *gpExports_First;
// === PROTOTYPES ===
+// - Values
void Object_Dereference(tSpiderValue *Object);
void Object_Reference(tSpiderValue *Object);
tSpiderValue *SpiderScript_CreateInteger(uint64_t Value);
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);
-
+// - 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, ...);
return Source;
}
+ // Debug
#if 0
{
printf("Casting %i ", Source->Type);
}
#endif
+ // Object casts
#if 0
if( Source->Type == SS_DATATYPE_OBJECT )
{
case SS_DATATYPE_UNDEF:
case SS_DATATYPE_ARRAY:
case SS_DATATYPE_OPAQUE:
+ AST_RuntimeError(NULL, "Invalid cast to %i", Type);
+ return ERRPTR;
case SS_DATATYPE_OBJECT:
+ // TODO:
AST_RuntimeError(NULL, "Invalid cast to %i", Type);
return ERRPTR;
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
// 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;
// Perform assignment operation
if( Node->Assign.Operation != NODETYPE_NOP )
{
- tSpiderValue *varVal = Variable_GetValue(Block, Node->Assign.Dest);
- tSpiderValue *value;
+ tSpiderValue *varVal, *value;
+
+ varVal = Variable_GetValue(Block, Node->Assign.Dest);
+ if(varVal == ERRPTR) return ERRPTR;
+ #if 0
+ #else
+ if(varVal && varVal->ReferenceCount == 2) {
+ Object_Dereference(varVal);
+// printf("pre: (%s) varVal->ReferenceCount = %i\n",
+// Node->Assign.Dest->Variable.Name,
+// varVal->ReferenceCount);
+ }
+ #endif
value = AST_ExecuteNode_BinOp(Block, Node, Node->Assign.Operation, varVal, ret);
if(value == ERRPTR) return ERRPTR;
+
if(ret) Object_Dereference(ret);
+ #if 0
if(varVal) Object_Dereference(varVal);
+ #else
+ if(varVal && varVal->ReferenceCount == 1) {
+ Object_Reference(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;
}
// 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;
+ if(!SpiderScript_IsValueTrue(ret)) {
Object_Dereference(ret);
- ret = AST_ExecuteNode(Block, Node->For.Condition);
- if(ret == ERRPTR) return ERRPTR;
- } while( SpiderScript_IsValueTrue(ret) );
+ ret = NULL;
+ break;
+ }
}
- else
+
+ // Perform loop
+ for( ;; )
{
Object_Dereference(ret);
- ret = AST_ExecuteNode(Block, Node->For.Condition);
+
+ // 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;
+ Object_Dereference(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;
+ Object_Dereference(ret);
+
+ // Check condition
+ ret = AST_ExecuteNode(Block, Node->For.Condition);
+ if(ret == ERRPTR) return ERRPTR;
+ if(!SpiderScript_IsValueTrue(ret)) break;
}
Object_Dereference(ret);
ret = NULL;
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 ) {
else {
tmpobj = NULL;
}
+ // TODO: Handle arrays
ret = NULL;
if( Variable_Define(Block, Node->DefVar.DataType, Node->DefVar.Name, tmpobj) == ERRPTR )
ret = ERRPTR;
// 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;
ret = Object_ExecuteMethod(Value->Object, fcnname, );
if( ret != ERRPTR )
return ret;
- // Fall through and try casting (which will usually fail)
}
}
#endif
{
// Integer Operations
case SS_DATATYPE_INTEGER:
+ if( Value->ReferenceCount == 1 )
+ Object_Reference(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);
+ Object_Dereference(ret);
ret = ERRPTR;
break;
}
case NODETYPE_ADD: // Concatenate
ret = Object_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;
break;
// Integer Operations
case SS_DATATYPE_INTEGER:
+ if( Left->ReferenceCount == 1 )
+ Object_Reference(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);
+ Object_Dereference(ret);
ret = ERRPTR;
break;
}
// Real Numbers
case SS_DATATYPE_REAL:
+ if( Left->ReferenceCount == 1 )
+ Object_Reference(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);
+ Object_Dereference(ret);
ret = ERRPTR;
break;
}
*/
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;