Changeset 387 for branches/thune/thread_safe/eval.c

Timestamp:

05/17/07 16:25:27 (18 months ago)

Author:

krobillard

Message:

Thread safe Thune -

The only globals are now the static ur_global & ur_envGlobal.
Each thread has own data store.
Series data now accessed through functions which take thread pointer.
Word names now part of UrlanEnv? - no longer a binary!
Hold/release now implemented with a block.

Files:

• branches/thune/thread_safe/eval.c (modified) (49 diffs)

branches/thune/thread_safe/eval.c

@@ -19 +19 @@
 
 
-#include "os.h"
-#include "urlan.h"
+#include "internal.h"
 #include "urlan_atoms.h"
-#include "internal.h"
 #include "bignum.h"
 
 
+extern UContext ur_global;
+extern UContext ur_envGlobal;
+
 extern void uc_console_out( UThread*, UCell* );
 
 
 #ifdef DEBUG
-void ur_dumpBlock( UIndex blkN )
+void ur_dumpBlock( UThread* ut, UIndex blkN )
 {
     UCell* cell;
@@ -58 +59 @@
 
 
-static void _infuseOpcodes( UThread* thr, UIndex blkN )
+static void _infuseOpcodes( UThread* ut, UIndex blkN )
 {
     UBlock* blk;
-    UBlock* gblk;
+    UContext* global;
     const UCell* ctx;
     int wrdN;
 
-    blk = ur_bind( blkN, &ur_global );
-
-    wrdN = ur_lookup( &ur_global, UR_ATOM_KERNEL_OPS );
-    //assert( wrdN > -1 );
-    if( wrdN > -1 )
-    {
-        gblk = ur_blockPtr( GLOBAL_VAL_BLKN );
-        ctx = gblk->ptr.cells + wrdN;
-
-        assert( ctx->id.type == UT_CONTEXT );
-
-        ur_infuse( thr, blk, ctx );
+    global = (ut->env->blocks.arr.used) ? &ur_envGlobal : &ur_global;
+
+    wrdN = ur_lookup( global, UR_ATOM_KERNEL_OPS );
+    assert( wrdN > -1 );
+    //if( wrdN > -1 )
+    {
+        blk = ur_blockPtr( global->ctx.valBlk );
+        ctx = blk->ptr.cells + wrdN;
+
+        assert( ur_is(ctx, UT_CONTEXT) );
+
+        blk = ur_blockPtr( blkN );
+        ur_infuse( ut, blk, ctx );
     }
 }
@@ -86 +88 @@
    returned.
 */
-static int ur_itLen( UCell* cell )
+static int ur_itLen( UThread* ut, UCell* cell )
 {
     int len = ur_seriesLen( cell );
@@ -101 +103 @@
   Res may be the same as sel.
 */
-int ur_getSelector( UThread* ur_thread, const UCell* sel, UCell* res )
+int ur_getSelector( UThread* ut, const UCell* sel, UCell* res )
 {
 #define ATOM_OFF(val,atm)   (((unsigned int) val) - atm)
@@ -107 +109 @@
     UCell* val;
 
-    val = ur_wordCell( ur_thread, sel );
+    val = ur_wordCell( ut, sel );
     if( ! val )
         return 0;
@@ -157 +159 @@
                 if( ur_type(val) >= UT_BI_COUNT )
                 {
-                    UDatatypeSelFunc func = ur_thread->env->customDT
+                    UDatatypeSelFunc func = ut->env->customDT
                                 [ ur_type(val) - UT_BI_COUNT ].selectAtom;
                     if( func )
-                        return func( ur_thread, val, sel, res );
+                        return func( ut, val, sel, res );
                 }
                 goto set_none;
@@ -167 +169 @@
     else
     {
-        if( ur_pick( val, ur_sel(sel) - 1, res ) )
+        if( ur_pick( ut, val, ur_sel(sel) - 1, res ) )
             return 1;
     }
 
-    ur_throwErr( ur_thread, UR_EX_SCRIPT, "Invalid select!" );
+    ur_throwErr( UR_ERR_SCRIPT, "Invalid select!" );
     return 0;
 
@@ -184 +186 @@
   Returns non-zero if successful.
 */
-int ur_setSelector( UThread* ur_thread, const UCell* sel, const UCell* nval )
+int ur_setSelector( UThread* ut, const UCell* sel, const UCell* nval )
 {
     UBlock* blk;
     UCell* val;
 
-    val = ur_wordCell( ur_thread, sel );
+    val = ur_wordCell( ut, sel );
     if( ! val )
         return 0;
@@ -242 +244 @@
             if( ! ur_selIsAtom(sel) )
             {
-                if( ur_poke( val, ur_sel(sel) - 1, nval ) )
-                    return 1;
-            }
-            break;
-    }
-
-    ur_throwErr( ur_thread, UR_EX_SCRIPT, "Invalid select!" );
+                if( ur_poke( ut, val, ur_sel(sel) - 1, nval ) )
+                    return 1;
+            }
+            break;
+    }
+
+    ur_throwErr( UR_ERR_SCRIPT, "Invalid select!" );
     return 0;
 }
@@ -283 +285 @@
     {
         UCell* val;
-        val = ur_wordCell( ur_thread, tos );
+        val = ur_wordCell( ut, tos );
         if( val )
         {
@@ -317 +319 @@
 
 
-static void _appendTraceBlk( UCellError* err, int n, int it )
+static void _appendTraceBlk( UThread* ut, UCellError* err, int n, int it )
 {
     if( err->traceBlk )
@@ -334 +336 @@
 #define _throwUnbound(th,cell)  _throwUnsetF(th,cell,"unbound")
 
-static void _throwUnsetF( UThread* ur_thread, const UCell* wcell,
-                          const char* umsg )
+static void _throwUnsetF( UThread* ut, const UCell* wcell, const char* umsg )
 {
     UString* str;
-    str = ur_binPtr( ur_thread->callTempBinN );
+    str = ur_threadTmp( ut );
     str->used = 0;
     ur_atomStr( ur_atom(wcell), str );
     ur_termCStr( str );
-    ur_throwErr( ur_thread, UR_EX_SCRIPT,
-                 "word '%s is %s", str->ptr.c, umsg );
-}
-
-
-/*
+    ur_throwErr( UR_ERR_SCRIPT, "word '%s is %s", str->ptr.c, umsg );
+}
+
+
+/**
    Returns cell pointer or zero if word does not reference a valid cell.
 */
-UCell* ur_wordCell( UThread* ur_thread, const UCell* pc )
-{
-    UCell* val;
-    int i;
-   
-    i = pc->word.valBlk;
-    if( i < 0 )
-    {
-        // Find function local frame i.
-
-        LocalFrame* it;
-        LocalFrame* end;
-
-        it  = UR_LF_BEG;
-        end = UR_LF_END;
-        while( it != end )
-        {
-            if( it->localFrame.n == i )
-            {
-                val = it->localFrame.cell;
-                goto val_set;
-            }
-            ++it;
-        }
-
-        _throwUnsetF( ur_thread, pc, "out-of-scope local" );
+UCell* ur_wordCell( UThread* ut, const UCell* pc )
+{
+    UBlock* blk;
+    int wrdN;
+
+    wrdN = pc->word.index;
+    if( wrdN < 0 )
+    {
+        _throwUnbound( ut, pc);     // UR_UNBOUND
         return 0;
     }
-    else
-    {
-        val = ur_blockPtr( i )->ptr.cells;
-    }
-
-val_set:
-
-    i = pc->word.index;
-    if( i < 0 )
-    {
-        _throwUnbound(ur_thread, pc);
-        return 0;
-    }
-
-    return val + i;
-}
-
-
-int ur_evalCStr( UThread* ur_thread, const char* cmd, int len )
+
+    switch( pc->word.flags & UR_FLAG_BIND_MASK )
+    {
+        case UR_BIND_THREAD:
+            // ur_blockPtr( pc->word.valBlk )
+            blk = (((UBlock*) ut->blocks.arr.ptr.v) + pc->word.valBlk);
+            return blk->ptr.cells + wrdN;
+
+        case UR_BIND_GLOBAL:
+            // ur_blockPtr( pc->word.valBlk )
+            blk = (((UBlock*) ut->env->blocks.arr.ptr.v) - pc->word.valBlk);
+            return blk->ptr.cells + wrdN;
+
+        case UR_BIND_LOCAL:
+#if 1
+        {
+            LocalFrame* it  = UR_LF_BEG;
+            LocalFrame* end = UR_LF_END;
+            while( it != end )
+            {
+                if( it->n == pc->word.wordBlk )
+                    return it->cell + wrdN;
+                ++it;
+            }
+            _throwUnsetF( ut, pc, "out-of-scope local" );
+            return 0;
+        }
+#else
+            if( pc->word.wordBlk != ut->localWordBlk )
+            {
+                _throwUnsetF( ut, pc, "out-of-scope local" );
+                return 0;
+            }
+#if 0
+            blk = ((UBlock*) ut->blocks.arr.ptr.v) + BLK_DSTACK;
+            return blk->ptr.cells + wrdN + ut->localIdx;
+#else
+            return ut->localPos + wrdN;
+#endif
+#endif
+    }
+
+    return 0;
+}
+
+
+int ur_evalCStr( UThread* ut, const char* cmd, int len )
 {
     const char* end;
@@ -417 +428 @@
     if( end != cmd )
     {
-        blkN = ur_tokenize( ur_thread, cmd, end, 0 );
+        blkN = ur_tokenize( ut, cmd, end, 0 );
         if( blkN )
         {
-            _infuseOpcodes( ur_thread, blkN );
-            return ur_eval( ur_thread, blkN, 0 );
+            _infuseOpcodes( ut, blkN );
+            return ur_eval( ut, blkN, 0 );
         }
         return UR_EVAL_ERROR;
@@ -437 +448 @@
   Returns 1 if equivalent or zero if not.
 */
-int ur_equal( const UCell* a, const UCell* b )
+int ur_equal( UThread* ut, const UCell* a, const UCell* b )
 {
     switch( ur_type(a) )
@@ -581 +592 @@
             int len;
 
-            if( ur_blockSlice( a, &cpA1, &cpA2 ) )
-            {
-                if( ur_blockSlice( b, &cpB1, &cpB2 ) )
+            if( ur_blockSlice( ut, a, &cpA1, &cpA2 ) )
+            {
+                if( ur_blockSlice( ut, b, &cpB1, &cpB2 ) )
                 {
                     len = cpB2 - cpB1;
@@ -592 +603 @@
                         while( cpA1 != cpA2 )
                         {
-                            if( ! ur_equal( cpA1++, cpB1++ ) )
+                            if( ! ur_equal( ut, cpA1++, cpB1++ ) )
                                 return 0;
                         }
@@ -610 +621 @@
             int len;
 
-            if( ur_stringSlice( a, &cpA1, &cpA2 ) )
-            {
-                if( ur_stringSlice( b, &cpB1, &cpB2 ) )
+            if( ur_stringSlice( ut, a, &cpA1, &cpA2 ) )
+            {
+                if( ur_stringSlice( ut, b, &cpB1, &cpB2 ) )
                 {
                     // TODO: Handle different encodings.
@@ -628 +639 @@
                 }
             }
-            else if( ur_binarySlice( a, &cpA1, &cpA2 ) )
-            {
-                if( ur_binarySlice( b, &cpB1, &cpB2 ) )
+            else if( ur_binarySlice( ut, a, &cpA1, &cpA2 ) )
+            {
+                if( ur_binarySlice( ut, b, &cpB1, &cpB2 ) )
                     goto eq_bin_slice;
             }
@@ -643 +654 @@
   Returns 1 if cells are of the same type and value or zero if not.
 */
-int ur_same( const UCell* a, const UCell* b )
-{
+int ur_same( UThread* ut, const UCell* a, const UCell* b )
+{
+    (void) ut;
+
     if( ur_type(a) != ur_type(b) )
         return 0;
@@ -700 +713 @@
 {
     UR_S_DROP;
-    ur_logic(UR_TOS) = ur_equal( UR_TOS, tos );
+    ur_logic(UR_TOS) = ur_equal( ut, UR_TOS, tos );
     ur_initType( UR_TOS, UT_LOGIC );
 }
@@ -713 +726 @@
     UR_S_DROP;
 
-    same = ur_same( res, tos );
+    same = ur_same( ut, res, tos );
     ur_initType( res, UT_LOGIC );
     ur_logic(res) = same;
@@ -761 +774 @@
     ur_initType(tos, UT_WORD);
     tos->word.wordBlk = 0;
-    tos->word.valBlk  = GLOBAL_VAL_BLKN;
+    tos->word.valBlk  = BLK_GLOBAL_VAL;
     tos->word.index   = t;
     tos->word.atom    = t;
@@ -772 +785 @@
 #if 1
     UString* str;
-    str = ur_binPtr( ur_thread->callTempBinN );
+    str = ur_threadTmp( ut );
     str->used = 0;
     ur_toStr( tos, str, 0 );
@@ -781 +794 @@
     tos = UR_TOS;
     ur_initType( tos, UT_STRING );
-    ur_setSeries( tos, ur_thread->callTempBinN, 0 );
-    uc_console_out( ur_thread, tos );
+    ur_setSeries( tos, BIN_THREAD_TMP, 0 );
+    uc_console_out( ut, tos );
 #else
     UString str;
@@ -805 +818 @@
 UR_CALL( uc_showTOS )
 {
-    _probe( ur_thread, tos );
+    _probe( ut, tos );
     UR_S_SAFE_DROP;
 }
@@ -815 +828 @@
 {
     UCell* it = tos;
-    UCell* end = ur_thread->dstack;
+    UCell* end = ut->dstack;
 
     if( it >= (end + UR_DSTACK_SIZE) )
@@ -825 +838 @@
     while( it != end )
     {
-        _probe( ur_thread, it );
+        _probe( ut, it );
         --it;
     }
@@ -857 +870 @@
         if( ur_wordIsUnbound(tos) )
         {
-            if( tos->word.valBlk == GLOBAL_VAL_BLKN )
+            if( tos->word.valBlk == BLK_GLOBAL_VAL )
             {
                 tos->word.index = ur_internWord( &ur_global, ur_atom(tos) );
@@ -863 +876 @@
             else    
             {
-                _throwUnbound( ur_thread, tos );
+                _throwUnbound( ut, tos );
                 return;
             }
         }
 
-        cell = ur_wordCell( ur_thread, tos );
+        cell = ur_wordCell( ut, tos );
         if( ! cell )
             return;
@@ -888 +901 @@
                 if( ur_isAWord(it) )
                 {
-                    cell = ur_wordCell( ur_thread, it );
+                    cell = ur_wordCell( ut, it );
                     if( ! cell )
                         return;
-                    ur_pick( val, n++, cell );
+                    ur_pick( ut, val, n++, cell );
                 }
                 ++it;
@@ -902 +915 @@
                 if( ur_isAWord(it) )
                 {
-                    cell = ur_wordCell( ur_thread, it );
+                    cell = ur_wordCell( ut, it );
                     if( ! cell )
                         return;
@@ -945 +958 @@
     if( ur_isAWord(tos) )
     {
-        val = ur_wordCell( ur_thread, tos );
+        val = ur_wordCell( ut, tos );
         if( val )
         {
@@ -968 +981 @@
                 /*
                 if( ur_is(ctx, UT_UNSET) )
-                    _throwUnset( ur_thread, ctx );
+                    _throwUnset( ut, ctx );
                 */
             }
@@ -981 +994 @@
     }
 
-    ur_throwErr( ur_thread, UR_EX_DATATYPE, "get expected word!" );
+    ur_throwErr( UR_ERR_DATATYPE, "get expected word!" );
 }
 
@@ -1013 +1026 @@
                 char* spA;
                 char* spB;
-                if( ur_stringSlice(val, &spA, &spB) && spA )
+                if( ur_stringSlice(ut, val, &spA, &spB) && spA )
                 {
                     ur_initType(val, UT_WORD);
-                    ur_setUnbound( val, UR_INTERN( spA, spB - spA ) );
+                    ur_setUnbound( val, ur_intern( spA, spB - spA ) );
                 }
             }
@@ -1076 +1089 @@
                     // Must copy so UArray->used will be accurate.
                     UIndex binN;
-                    binN = ur_makeBinaryFrom( val );
+                    binN = ur_makeBinaryFrom( ut, val );
                     ur_setSeries(val, binN, 0);
                 }
@@ -1161 +1174 @@
             if( ur_is(val, UT_STRING) )
             {
-                ur_clone( val, UR_COPY_ALL, 0 );
+                ur_clone( ut, val, UR_COPY_ALL, 0 );
                 UR_S_DROP;
                 return;
@@ -1168 +1181 @@
     }
 
-    uc_as( ur_thread, tos );
+    uc_as( ut, tos );
 }
 
@@ -1191 +1204 @@
     }
 
-    ur_throwErr( ur_thread, UR_EX_DATATYPE, "Invalid bind values" );
+    ur_throwErr( UR_ERR_DATATYPE, "Invalid bind values" );
 }
 
 
 // Find function local frame for N.
-static UCell* _localCells( UThread* ur_thread, int n )
-{
-    LocalFrame* it;
-    LocalFrame* end;
-    it  = UR_LF_BEG;
-    end = UR_LF_END;
+static UCell* _localCells( UThread* ut, UIndex wordBlk )
+{
+#if 0
+    assert( ut->localWordBlk == wordBlk );
+    return ut->localPos;
+#else
+    LocalFrame* it  = UR_LF_BEG;
+    LocalFrame* end = UR_LF_END;
     while( it != end )
     {
-        if( it->localFrame.n == n )
-            return it->localFrame.cell;
+        if( it->n == wordBlk )
+            return it->cell;
         ++it;
     }
     assert( 0 );
     return 0;
+#endif
 }
 
@@ -1217 +1233 @@
   the context.
 */
-void ur_infuse( UThread* thr, UBlock* blk, const UContext* cc )
+void ur_infuse( UThread* ut, UBlock* blk, const UContext* cc )
 {
     UCell* it  = blk->ptr.cells;
@@ -1224 +1240 @@
     int flags;
 
-    if( cc->ctx.valBlk < 0 )
-    {
-        values = _localCells( thr, cc->ctx.valBlk );
+    if( ur_bindType(cc) == UR_BIND_LOCAL )
+    {
+        values = _localCells( ut, cc->ctx.wordBlk );
     }
     else
@@ -1251 +1267 @@
         else if( ur_is(it, UT_BLOCK) || ur_is(it, UT_PAREN) )
         {
-            ur_infuse( thr, ur_blockPtr( it->series.n ), cc );
+            ur_infuse( ut, ur_blockPtr( it->series.n ), cc );
         }
         else if( ur_is(it, UT_SELECT) )
@@ -1295 +1311 @@
     {
         if( ur_is(bc, UT_BLOCK) )
-            ur_infuse( ur_thread, ur_block(bc), tos );
+            ur_infuse( ut, ur_block(bc), tos );
     }
     UR_S_DROP;
@@ -1308 +1324 @@
 static
 #endif
-UIndex _funcSignature( const UCell* scell, int* pArgc, int* pVarc )
+UIndex _funcSignature( UThread* ut, const UCell* scell, int* pArgc, int* pVarc )
 {
     UIndex sigN;
@@ -1421 +1437 @@
 
         // Scan signature
-        sigN = _funcSignature( res, &argc, &varc );
-
-        lctx.ctx.wordBlk =  sigN;
-        lctx.ctx.valBlk  = -sigN;   // Negative valBlk denotes stack storage.
-
-        ur_bind( bodN, &lctx );
+        sigN = _funcSignature( ut, res, &argc, &varc );
+
+        lctx.ctx.wordBlk = sigN;
+        lctx.ctx.valBlk  = 0;   //BLK_DSTACK;
+
+        ur_bindT( ut, bodN, &lctx, UR_BIND_LOCAL );
 
         ur_initType( res, UT_FUNCTION );
@@ -1502 +1518 @@
     {
         UIndex strN = ur_makeBinary( 0 );
-        ur_toStrNatural( tos, ur_binPtr(strN), 0 );
+        ur_toStrNatural( ut, tos, ur_binPtr(strN), 0 );
         ur_initString(tos, strN, 0);
     }
@@ -1517 +1533 @@
     if( ur_isAWord(tos) )
     {
-        hash = ur_atomHash( ur_thread->env, ur_atom(tos) );
-    }
-    else if( ur_stringSlice(tos, &cpA, &cpB) )
+        hash = ur_atomHash( ut->env, ur_atom(tos) );
+    }
+    else if( ur_stringSlice(ut, tos, &cpA, &cpB) )
     {
         hash = ur_hash( cpA, cpB );
@@ -1539 +1555 @@
 {
     UR_CALL_UNUSED_TOS
-    ur_recycle( ur_thread->env );
+    ur_recycle( ut );
 }