Changeset 426

Timestamp:

07/05/07 04:03:51 (14 months ago)

Author:

krobillard

Message:

Added component! & lit-select! datatypes.
ur_makeBlockT() now has a ptr return argument.

Location:

branches/thune/thread_safe

Files:

• config.t (modified) (1 diff)
• context.c (modified) (1 diff)
• doc/UserManual (modified) (8 diffs)
• eval.c (modified) (9 diffs)
• gc.c (modified) (1 diff)
• gl/project.r (modified) (1 diff)
• internal.h (modified) (1 diff)
• make.c (modified) (4 diffs)
• print.c (modified) (7 diffs)
• read_config.r (modified) (1 diff)
• tests/working/bytecode.good (modified) (1 diff)
• tests/working/bytecode.t (modified) (1 diff)
• thune.c (modified) (2 diffs)
• tokenize.c (modified) (4 diffs)
• urlan.c (modified) (1 diff)
• urlan.h (modified) (5 diffs)

branches/thune/thread_safe/config.t

@@ -6 +6 @@
              enable trig
 [x] macros   "Reader macros"
+[x] net      "UDP socket port"
+[x] dataflow "Component! datatype for dataflow programming"
+
 [ ] dt-code  "Include 'code datatype"
-
-[x] net      "UDP socket port"
-
 [ ] uds      "Library with datatype & gc system only - no eval"
              disable [bzip2 trig math3d dt-code]

branches/thune/thread_safe/context.c

@@ -489 +489 @@
             case UT_SELECT:
             case UT_SETSELECT:
+            case UT_LITSELECT:
             case UT_OPCODE:
                 _bindWord( it );

branches/thune/thread_safe/doc/UserManual

@@ -88 +88 @@
 select!      obj/x my-block/2
 set-select!  :obj/x :my-block/2
+lit-select!  'obj/x 'my-block/2
 slice!
 time!        10:02 -0:0:32.08
 context!
+component!
 ===========  ==========
 
@@ -102 +104 @@
 
 Macros can be used wherever a constant is needed to improve evaluation
-speed.
+speed.  They are also useful for conditional code generation.
 
 Example::
@@ -110 +112 @@
     box-width <border> add
 
+Conditional Example::
+
+    <script-env/os [
+        linux   ["Linux"]
+        solaris ["Solaris"]
+        ["Unsupported OS" error]
+     ] case>
+    print
 
 Currently, macro! values cannot be created by the user.
@@ -243 +253 @@
 .. The Evaluator
    Contexts & Binding
+
+
+Components
+----------
+
+Components are similar to functions, but they operate via a dataflow model.
+They have inputs, outputs which are connected to the inputs of other
+components, and a body which is evaluated when all inputs are set.
+
+Components must have at least one input, but they don't require any outputs.
+
+Here is an example of how to create and connect components::
+
+    [a b -- out] [a b mul :out] component :c1
+    [val] [val .] component :probe
+    'c1/out 'probe/val connect
+
+Now, when the inputs to *c1* are set, *probe* will automatically be invoked::
+
+    3 :c1/a
+    5 :c1/b
+    15
+
+Further changes to the inputs will continue to invoke the *probe* component::
+
+    5 :c1/a
+    25
+
+*Connect* also accepts components as arguments.  This is short-hand for
+refering to the first input or output.
+The following call makes the same connection as the example above::
+
+    c1 probe connect
 
 
@@ -533 +576 @@
 ::
 
-        (logic -- )
+    (logic -- )
 
 Evaluate next value if TOS is true.  To evaluate more than one value use
@@ -558 +601 @@
 ::
 
-        (ser new [part int!] -- ser)
+    (ser new [part int!] -- ser)
 
 Change series at current position.
@@ -568 +611 @@
 ::
 
-        (ser pat -- end series!/none!)
+    (ser pat -- end series!/none!)
 
 Move position to end of matching pattern.
@@ -584 +627 @@
 
 
+Extending The System
+====================
+
+Adding C Functions
+------------------
+
+C functions are defined with the *UR_CALL* macro.
+
+The function is responsible for checking that arguments are of the correct
+type and for reporting any errors.  If type checking were built into the
+evaluator there would be redundant checks for the typical case where the
+function accepts multiple types for a given argument or pattern of
+arguments.
+
+Always access and check stack arguments starting with *tos* and work down.
+Since the bottom of the stack contains *UT_UNSET*, checking in this order
+avoids an extra check to make sure that the stack holds at least the number
+of expected arguments.
+
+

branches/thune/thread_safe/eval.c

@@ -120 +120 @@
             case UT_CONTEXT:
             case UT_PORT:
+#ifdef UR_CONFIG_DATAFLOW
+            case UT_COMPONENT:
+#endif
             {
                 int wrdN = ur_lookup( val, ur_sel(sel) );
@@ -184 +187 @@
 
 
+#ifdef UR_CONFIG_DATAFLOW
+void ur_setPlug( UThread*, UBlock* cblk, UIndex wrdN, const UCell* nval );
+#endif
+
+
 /**
   Returns non-zero if successful.
@@ -242 +250 @@
             break;
 
+#ifdef UR_CONFIG_DATAFLOW
+        case UT_COMPONENT:
+            if( ur_selIsAtom(sel) )
+            {
+                int wrdN;
+                wrdN = ur_lookup( val, ur_sel(sel) );
+                ur_setPlug( ut, tBlockPtr(val->ctx.valBlk), wrdN, nval );
+                return 1;
+            }
+            break;
+#endif
+
         default:
             if( ! ur_selIsAtom(sel) )
@@ -295 +315 @@
     {
         ur_type(tos) = UT_WORD;
+    }
+    else if( ur_is(tos, UT_LITSELECT) )
+    {
+        ur_type(tos) = UT_SELECT;
     }
     // else leave tos unchanged...
@@ -366 +390 @@
     {
         case UR_BIND_THREAD:
+#ifdef UR_CONFIG_DATAFLOW
+        case UR_BIND_PLUG:      // Each component has its own body for now.
+#endif
             // ur_blockPtr( pc->word.valBlk )
             blk = (((UBlock*) ut->blocks.arr.ptr.v) + pc->word.valBlk);
@@ -404 +431 @@
     }
 
+    _throwUnsetF( ut, pc, "Invalid bind mask" );
     return 0;
+}
+
+
+static int ur_setWord( UThread* ut, const UCell* pc, const UCell* val )
+{
+    UBlock* blk;
+    UCell* dest;
+    int wrdN;
+
+    wrdN = pc->word.index;
+    if( wrdN < 0 )
+    {
+        _throwUnbound( ut, pc);     // UR_UNBOUND
+        return 0;
+    }
+
+    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);
+            dest = blk->ptr.cells + wrdN;
+            break;
+
+        case UR_BIND_GLOBAL:
+            // ur_blockPtr( pc->word.valBlk )
+            blk = (((UBlock*) ut->env->blocks.arr.ptr.v) - pc->word.valBlk);
+            dest = blk->ptr.cells + wrdN;
+            break;
+
+        case UR_BIND_LOCAL:
+        {
+            LocalFrame* it  = UR_LF_BEG;
+            LocalFrame* end = UR_LF_END;
+            while( it != end )
+            {
+                if( it->n == pc->word.wordBlk )
+                {
+                    dest = it->cell + wrdN;
+                    goto set_word;
+                }
+                ++it;
+            }
+            _throwUnsetF( ut, pc, "out-of-scope local" );
+            return 0;
+        }
+
+#ifdef UR_CONFIG_DATAFLOW
+        case UR_BIND_PLUG:
+            // Assuming there are no global components.
+            ur_setPlug( ut, tBlockPtr(pc->word.valBlk), wrdN, val );
+            return 1;
+#endif
+
+        default:
+            _throwUnsetF( ut, pc, "Invalid bind mask" );
+            return 0;
+    }
+
+set_word:
+
+    ur_copyCell(dest, *val);
+    return 1;
 }
 
@@ -1378 +1469 @@
     argc = varc = 0;
 
-    sigN = scell->series.n;
     blk = ur_block( scell );
     it  = blk->ptr.cells;
@@ -1633 +1723 @@
 #ifdef UR_CONFIG_NET
 extern void uc_net_addr( UThread*, UCell* );
+#endif
+#ifdef UR_CONFIG_DATAFLOW
+#include "component.c"
 #endif
 
@@ -1667 +1760 @@
 #endif
 #ifdef LANG_THUNE
+#ifdef UR_CONFIG_DATAFLOW
+    { uc_component,    "component" },
+    { uc_connect,      "connect" },
+#endif
 #ifdef UR_CONFIG_THREADS
     { uc_thread,       "thread" },

branches/thune/thread_safe/gc.c

@@ -285 +285 @@
             case UT_CONTEXT:
             case UT_PORT:
+            case UT_COMPONENT:
                 idx = it->ctx.wordBlk;
                 if( ur_isLocal(idx) )

branches/thune/thread_safe/gl/project.r

@@ -39 +39 @@
 
         libs [%freetype %bz2 %png]
+        libs [%vorbis %vorbisfile]
     ]
     linux [

branches/thune/thread_safe/internal.h

@@ -17 +17 @@
 //#define BLK_DSTACK          4
 
+enum ComponentContextValues
+{
+    COMPONENT_SELF = 0,
+    COMPONENT_COUNTS,
+    COMPONENT_BODY,
+    COMPONENT_CELLS
+};
 
 #define initGCArray(af) \
     (af)->freeCount = 0; \
     (af)->freeList  = -2
+
+
+/* Get block ptr from thread storage */
+#define tBlockPtr(n)    (((UBlock*) ut->blocks.arr.ptr.v) + (n))
+#define tBlock(bc)      tBlockPtr( bc->series.n )
 
 

branches/thune/thread_safe/make.c

@@ -111 +111 @@
   Size is the number of cells to reserve.  Used is set to 0.
 */
-UIndex ur_makeBlockT( UThread* ut, int size )
+UIndex ur_makeBlockT( UThread* ut, int size, UBlock** blkPtr )
 {
     UBlock* ptr;
@@ -144 +144 @@
 
     ur_arrayInit( ptr, sizeof(UCell), size );
+    if( blkPtr )
+        *blkPtr = ptr;
     return ur_blockN( ptr );
 }
@@ -1342 +1344 @@
 
 /*--------------------------------------------------------------------------*/
+
+
+#ifdef UR_CONFG_DATAFLOW
+extern void ur_cloneComponent( UThread*, UCell* result, UCell* proto );
+#endif
 
 
@@ -1869 +1876 @@
 #endif
 
+#ifdef UR_CONFG_DATAFLOW
+        case UT_COMPONENT:
+            if( ! ur_is(tos, UT_COMPONENT) )
+                goto error;
+            ur_cloneComponent( ut, res, tos );
+            break;
+#endif
         default:
             if( ur_datatype(res) < UT_BI_COUNT )

branches/thune/thread_safe/print.c

@@ -291 +291 @@
     else if( braceType == UT_PAREN )
         append1( '(', out );
+#ifdef UR_CONFIG_MARCOS
+    else if( braceType == UT_MACRO )
+        append1( '<', out );
+#endif
 
     if( it != end )
@@ -322 +326 @@
     else if( braceType == UT_PAREN )
         append1( ')', out );
+#ifdef UR_CONFIG_MARCOS
+    else if( braceType == UT_MACRO )
+        append1( '>', out );
+#endif
 }
 
@@ -699 +707 @@
         case UT_SELECT:
         case UT_SETSELECT:
+        case UT_LITSELECT:
         case UT_INT:
         case UT_DECIMAL:
@@ -817 +826 @@
 
 
+/*
+   Print words only - no ticks or colons.
+*/
 static void _selectToStr( UThread* ut, const UCell* val, UString* out )
 {
@@ -928 +940 @@
 #endif
 
+        case UT_LITSELECT:
+            append1('\'', out);
+            // Fall through to UT_SELECT...
+
         case UT_SELECT:
             _selectToStr( ut, val, out );
@@ -1160 +1176 @@
         case UT_CONTEXT:
         case UT_PORT:
+#ifdef UR_CONFIG_DATAFLOW
+        case UT_COMPONENT:
+#endif
             if( val->id.flags & UR_FLAG_CTX_RECURSION )
             {
-                append( out, "?context?", 8 );
+                append( out, "?context?", 9 );
             }
             else
@@ -1284 +1303 @@
 #endif
 
+#if 0
+#ifdef UR_CONFIG_DATAFLOW
+        case UT_COMPONENT:
+        {
+            UBlock* wblk = ur_blockPtr( val->ctx.wordBlk );
+            UBlock* vblk = ur_blockPtr( val->ctx.valBlk );
+            UCell* it  = wblk->ptr.cells + 2;
+            UCell* end = it + wblk->used;
+            UCell* vit = vblk->ptr.cells;
+
+            /*
+            while( it != end )
+            {
+                ++it;
+                ++vit;
+            }
+            */
+
+            ur_blockToStr( ut, out,
+                           vblk->ptr.cells + val->series.it,
+                           vblk->ptr.cells + blk->used,
+                           UT_BLOCK, depth );
+            append( out, " component", 10 );
+        }
+            break;
+#endif
+#endif
+
         default:
             if( ur_type(val) < UT_BI_COUNT )

branches/thune/thread_safe/read_config.r

@@ -12 +12 @@
        trig:
        math3d:
+       dataflow:
        dt-code:
        net:

branches/thune/thread_safe/tests/working/bytecode.good

@@ -1 +1 @@
 "nonecathello"
-#{0400000400041300070D000000190E3F800000030103000C61}
+#{0400000400041400070E000000190F3F800000030103000D61}

branches/thune/thread_safe/tests/working/bytecode.t

@@ -29 +29 @@
         nop                                 ; 8 - select
         nop                                 ; 9 - set-select
-        nop                                 ;10 - opcode
-        nop                                 ;11 - hash-id
-        [val int! as emit8]                 ;12 - char
-        [val emit32]                        ;13 - int
-        [val emitf]                         ;14 - decimal
-        nop                                 ;15 - bignum
-        nop                                 ;16 - coord
-        nop                                 ;17 - vec3
-        nop                                 ;18 - binary
-        [val add-word emit16]               ;19 - string
-        [val add-word emit16]               ;20 - block
-        nop                                 ;21 - paren
-        nop                                 ;23 - macro
-        nop                                 ;23 - path
-        nop                                 ;24 - setpath
-        nop                                 ;25 - slice
-        nop                                 ;26 - array
-        nop                                 ;27 - bitset
-        nop                                 ;28 - list
-        nop                                 ;29 - context
-        nop                                 ;30 - function
-        nop                                 ;31 - call
-        nop                                 ;32 - date
-        nop                                 ;33 - time
-        nop                                 ;34 - bitset
-        nop                                 ;35 - error
-        nop                                 ;36 - code
-        nop                                 ;37 - port
-        nop                                 ;38 - struct
+        nop                                 ;10 - lit-select
+        nop                                 ;11 - opcode
+        nop                                 ;12 - hash-id
+        [val int! as emit8]                 ;13 - char
+        [val emit32]                        ;14 - int
+        [val emitf]                         ;15 - decimal
+        nop                                 ;16 - bignum
+        nop                                 ;17 - coord
+        nop                                 ;18 - vec3
+        nop                                 ;19 - binary
+        [val add-word emit16]               ;20 - string
+        [val add-word emit16]               ;21 - block
+        nop                                 ;22 - paren
+        nop                                 ;24 - macro
+        nop                                 ;24 - path
+        nop                                 ;25 - setpath
+        nop                                 ;26 - slice
+        nop                                 ;27 - array
+        nop                                 ;28 - bitset
+        nop                                 ;29 - list
+        nop                                 ;30 - context
+        nop                                 ;31 - function
+        nop                                 ;32 - call
+        nop                                 ;33 - date
+        nop                                 ;34 - time
+        nop                                 ;35 - bitset
+        nop                                 ;36 - error
+        nop                                 ;37 - code
+        nop                                 ;38 - port
+        nop                                 ;39 - struct
     ] :type-convert
 

branches/thune/thread_safe/thune.c

@@ -379 +379 @@
             UR_S_PUSH( *val );
             ur_type( UR_TOS ) = UT_WORD;
+            break;
+            
+        case UT_LITSELECT:
+            if( UR_TOS >= ut->eos )
+                goto stack_overflow;
+            UR_S_PUSH( *val );
+            ur_type( UR_TOS ) = UT_SELECT;
             break;
             
@@ -822 +829 @@
 
         case UT_SETWORD:
-            val = ur_wordCell( ut, val );
-            if( ! val )
+            if( ! ur_setWord( ut, val, UR_TOS ) )
                 goto throw_cc;
-            ur_copyCell(val, *UR_TOS);
             UR_S_DROP;
             break;

branches/thune/thread_safe/tokenize.c

@@ -539 +539 @@
     }
 
+    mode = UT_LITWORD;
+
     SCAN_LOOP
-        if( ur_bitIsSet( charset_delimiters, ch ) )   // '[' 'word[]
+        if( ch == '/' )
+        {
+            mode = UT_LITSELECT;
+        }
+        else if( ur_bitIsSet( charset_delimiters, ch ) )   // '[' 'word[]
+        {
             break;
+        }
     SCAN_END
 
@@ -549 +557 @@
         if( it == token )
             goto quote_err;
-        cell = ur_appendWord( BLOCK, UT_LITWORD, token, it - token );
+        if( mode == UT_LITWORD )
+        {
+            cell = ur_appendWord( BLOCK, UT_LITWORD, token, it - token );
+        }
+        else
+        {
+            cell = ur_appendCell( BLOCK, UT_UNSET );
+            if( ! ur_makeSelector( ut, cell, token, it ) )
+            {
+                syntaxError( "Invalid lit-select" );
+            }
+            ur_type(cell) = UT_LITSELECT;