git.ucc.asn.au / tpg / acess2.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
ARM7 - Removed unneeded div header
[tpg/acess2.git] / Usermode / Libraries / libspiderscript.so_src / exec_ast.c
diff --git a/Usermode/Libraries/libspiderscript.so_src/exec_ast.c b/Usermode/Libraries/libspiderscript.so_src/exec_ast.c
index 5355838..5ba1554 100644 (file)
--- a/Usermode/Libraries/libspiderscript.so_src/exec_ast.c
+++ b/Usermode/Libraries/libspiderscript.so_src/exec_ast.c
@@ -1,4 +1,7 @@
 /*
+ * SpiderScript Library
+ *
+ * AST Execution
  */
 #include <stdlib.h>
 #include <stdio.h>
@@ -13,6 +16,7 @@
 extern tSpiderFunction *gpExports_First;
 
 // === PROTOTYPES ===
+// - Values
 void   Object_Dereference(tSpiderValue *Object);
 void   Object_Reference(tSpiderValue *Object);
 tSpiderValue   *SpiderScript_CreateInteger(uint64_t Value);
@@ -22,16 +26,16 @@ 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);
-
+// - 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, ...);
 
@@ -180,6 +184,7 @@ tSpiderValue *SpiderScript_CastValueTo(int Type, tSpiderValue *Source)
                return Source;
        }
        
+       // Debug
        #if 0
        {
                printf("Casting %i ", Source->Type);
@@ -194,6 +199,7 @@ tSpiderValue *SpiderScript_CastValueTo(int Type, tSpiderValue *Source)
        }
        #endif
        
+       // Object casts
        #if 0
        if( Source->Type == SS_DATATYPE_OBJECT )
        {
@@ -223,7 +229,10 @@ tSpiderValue *SpiderScript_CastValueTo(int Type, tSpiderValue *Source)
        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;
        
@@ -797,12 +806,33 @@ 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;
+                       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;
                }
                
@@ -1012,6 +1042,7 @@ 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;
@@ -1142,7 +1173,7 @@ tSpiderValue *AST_ExecuteNode(tAST_BlockState *Block, tAST_Node *Node)
 
        // 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;
@@ -1378,7 +1409,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
@@ -1386,12 +1416,17 @@ tSpiderValue *AST_ExecuteNode_UniOp(tAST_BlockState *Block, tAST_Node *Node, int
        {
        // 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;
                }
@@ -1487,6 +1522,15 @@ tSpiderValue *AST_ExecuteNode_BinOp(tAST_BlockState *Block, tAST_Node *Node, int
                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;
@@ -1495,23 +1539,28 @@ tSpiderValue *AST_ExecuteNode_BinOp(tAST_BlockState *Block, tAST_Node *Node, int
                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;
                }
@@ -1519,14 +1568,19 @@ tSpiderValue *AST_ExecuteNode_BinOp(tAST_BlockState *Block, tAST_Node *Node, int
        
        // 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;
                }
Acess2 is a semi-POSIX-compatible home-brew OS.

UCC git Repository :: git.ucc.asn.au