root/trunk/thune/component.c

/*============================================================================
    Thune Interpreter
    Copyright (C) 2005-2007  Karl Robillard

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
===========================================================================*/


#include "internal.h"
#include "component.h"
#include "urlan_atoms.h"


/*
  Returns zero if signature is invalid.
*/
static UIndex _makeComponent( UThread* ut, UCell* res,
                              const UCell* sigCell,
                              const UCell* bodCell )
{
    //UIndex sigN;
    UBlock* blk;
    UCell* start;
    UCell* it;
    UCell* end;
    int inC, outC, localC;
    int* counter;
    UAtom atom;
    uint32_t special = 0;


    blk = ur_blockSlice( ut, sigCell, &start, &end );
    if( ! blk || ! start )
        return 0;

    // Count words in context.
    inC = outC = localC = 0;
    counter = &inC;
    it = start;
    while( it != end )
    {
        if( ur_is(it, UT_WORD) || ur_is(it, UT_OPCODE) )
        {
            if( ur_atom(it) == UR_ATOM_DDASH )
                counter = &outC;
            else if( ur_atom(it) == UR_ATOM_BAR )
                counter = &localC;
            else if( ur_atom(it) >= UT_BI_COUNT )
                *counter = *counter + 1;
        }
        else if( ur_is(it, UT_SELECT) )
        {
            if( ur_atom(it) >= UT_BI_COUNT )
            {
                if( ur_selIsAtom(it) && (counter == &inC) )
                {
                    const char* str = ur_atomCStr( ur_sel(it), 0 );
                    if( *str == 'q' )
                        special |= 1 << inC;        // Quiet
                    else if( *str == 's' )
                        special |= 0x10000 << inC;  // Strobe
                }
                *counter = *counter + 1;
            }
        }
        ++it;
    }


    ur_makeContext( res, COMPONENT_CELLS + inC + outC + localC );
    ur_type(res) = UT_COMPONENT;

    ur_internWord( res, UR_ATOM_SELF );
    ur_internWord( res, ur_intern("component-counts", 16) );
    ur_internWord( res, ur_intern("component-body", 14) );

    // Create words in context.
    it = start;
    while( it != end )
    {
        if( ur_is(it, UT_WORD) || ur_is(it, UT_OPCODE) ||
            ur_is(it, UT_SELECT) )
        {
            atom = ur_atom(it);
            if( (atom >= UT_BI_COUNT) &&
                (atom != UR_ATOM_DDASH) &&
                (atom != UR_ATOM_BAR) )
            {
                ur_internWord( res, atom );
            }
        }
        ++it;
    }

    blk = ur_blockPtr( res->ctx.valBlk );
    it = blk->ptr.cells;

    ur_copyCell( it, *res );        // self
    ++it;
    ur_initType( it, UT_COORD );    // component-counts
    it->coord.len = 6;
    ur_ccIn(it)   = inC;
    ur_ccOut(it)  = outC;
    ur_ccLoc(it)  = localC;
    ur_ccMask(it) = 0xffff << inC;
    ur_ccSpec(it) = special;
    ++it;
    ur_copyCell( it, *bodCell );    // component-body

    if( localC )
    {
        // Initialize locals to none.
        it += inC + outC + 1;
        end = it + localC;
        while( it != end )
        {
            ur_setNone(it);
            ++it;
        }
    }

    ur_bindT( ut, bodCell->series.n, res, UR_BIND_PLUG );

    return 0; //sigN;
}


/*
   (sig body -- comp)
*/
UR_CALL( uc_component )
{
    UCell* res;

    if( ur_is(tos, UT_BLOCK) )
    {
        res = ur_s_prev(tos);
        if( ur_is(res, UT_BLOCK) )
        {
            _makeComponent( ut, res, res, tos );
            UR_S_DROP;
            return;
        }
    }

    ur_throwErr( UR_ERR_DATATYPE,
                 "component expected signature & body blocks" );
}


static void initConnectWord( UCell* link, UAtom atom, const UCell* cc, int wrd )
{
    link->word.atom    = atom;
    link->word.wordBlk = cc->ctx.wordBlk;
    link->word.valBlk  = cc->ctx.valBlk;
    link->word.index   = wrd;
    link->word.sel     = 0;
}


/*
   (from to -- )
*/
UR_CALL( uc_connect )
{
    UCell* arg1;
    UCell* cc1;
    UCell* cc2;
    UCell* conn;
    UCell* val;
    UBlock* b1;
    UAtom atom;
    int wrd;
    int wrd2;

    // Connect to this component...
    if( ur_is(tos, UT_SELECT) && ur_selIsAtom(tos) )
    {
        cc2 = ur_wordCell( ut, tos );
        if( ! cc2 )
            return;
        if( ! ur_is(cc2, UT_COMPONENT) )
            goto dt_err;
        wrd2 = ur_lookup( cc2, ur_sel(tos) );
        if( wrd2 < 0 )
            goto dt_err;
        atom = ur_sel(tos);
    }
    else if( ur_is(tos, UT_COMPONENT) )
    {
        // Use first input.
        cc2  = tos;
        wrd2 = COMPONENT_CELLS;

        b1 = ur_blockPtr( cc2->ctx.wordBlk );
        atom = b1->ptr.cells[ COMPONENT_CELLS ].word.atom;
    }
    else
        goto dt_err;


    // ...from this component.
    arg1 = ur_s_prev(tos);
    if( ur_is(arg1, UT_SELECT) && ur_selIsAtom(arg1) )
    {
        cc1 = ur_wordCell( ut, arg1 );
        if( ! cc1 )
            return;
        if( ! ur_is(cc1, UT_COMPONENT) )
            goto dt_err;
        wrd = ur_lookup( cc1, ur_sel(arg1) );
        if( wrd < 0 )
            goto dt_err;
        b1 = ur_blockPtr( cc1->ctx.valBlk );
        cc1 = b1->ptr.cells + COMPONENT_COUNTS;
        if( wrd < (COMPONENT_CELLS + ur_ccIn(cc1)) )
            goto out_err;
        if( wrd >= (COMPONENT_CELLS + ur_ccIn(cc1) + ur_ccOut(cc1)) )
            goto out_err;
        conn = b1->ptr.cells + wrd;
    }
    else if( ur_is(arg1, UT_COMPONENT) )
    {
        // Use first output.
        b1 = ur_blockPtr( arg1->ctx.valBlk );
        cc1 = b1->ptr.cells + COMPONENT_COUNTS;
        if( ur_ccOut(cc1) < 1 )
            goto out_err;
        conn = b1->ptr.cells + COMPONENT_CELLS + ur_ccIn(cc1);
    }
    else
        goto dt_err;

        
    if( ur_is(conn, UT_BLOCK) )
    {
        // Two or more connections exist.
        val = ur_appendCell( tBlock( conn ), UT_WORD );
        initConnectWord( val, atom, cc2, wrd2 );
    }
    else if( ur_is(conn, UT_WORD) )
    {
        // A single connection exists; create a block to hold more.
        UBlock* connBlk;
        UIndex n;

        n = ur_makeBlockT( ut, 2, &connBlk );
        connBlk->used = 2;

        val = connBlk->ptr.cells;
        ur_copyCell( val, *conn );

        ++val;
        ur_initType( val, UT_WORD );
        initConnectWord( val, atom, cc2, wrd2 );

        ur_initBlock( conn, n, 0 );
    }
    else
    {
        // No existing connections.
        ur_initType( conn, UT_WORD );
        initConnectWord( conn, atom, cc2, wrd2 );
    }

    UR_S_DROPN( 2 );
    return;

dt_err:

    ur_throwErr( UR_ERR_DATATYPE,
                 "connect expected select! select! bound to components" );
    return;

out_err:

    ur_throwErr( UR_ERR_SCRIPT, "Must connect to a component output" );
}


/*
   (from to -- )

   TODO:
     (from 'all -- )
     ('all to -- )   ; This will be costly - must check all components.
                     ; May want to save blkN of all connected input components.
*/
UR_CALL( uc_disconnect )
{
    UCell* arg1;
    UCell* cc1;
    UCell* cc2;
    UCell* conn;
    UCell* it;
    UCell* end;
    UBlock* b1;
    UAtom atom;
    int wrd;

    // Disconnect this component input...
    if( ur_is(tos, UT_SELECT) && ur_selIsAtom(tos) )
    {
        cc2 = ur_wordCell( ut, tos );
        if( ! cc2 )
            return;
        if( ! ur_is(cc2, UT_COMPONENT) )
            goto dt_err;
        atom = ur_sel(tos);
    }
    else if( ur_is(tos, UT_COMPONENT) )
    {
        // Use first input.
        cc2  = tos;
        b1   = ur_blockPtr( cc2->ctx.wordBlk );
        atom = b1->ptr.cells[ COMPONENT_CELLS ].word.atom;
    }
    else
        goto dt_err;


    // ...from this component output.
    arg1 = ur_s_prev(tos);
    if( ur_is(arg1, UT_SELECT) && ur_selIsAtom(arg1) )
    {
        cc1 = ur_wordCell( ut, arg1 );
        if( ! cc1 )
            return;
        if( ! ur_is(cc1, UT_COMPONENT) )
            goto dt_err;
        wrd = ur_lookup( cc1, ur_sel(arg1) );
        if( wrd < 0 )
            goto dt_err;
        b1 = ur_blockPtr( cc1->ctx.valBlk );
        cc1 = b1->ptr.cells + COMPONENT_COUNTS;
        if( wrd < (COMPONENT_CELLS + ur_ccIn(cc1)) )
            goto out_err;
        if( wrd >= (COMPONENT_CELLS + ur_ccIn(cc1) + ur_ccOut(cc1)) )
            goto out_err;
        conn = b1->ptr.cells + wrd;
    }
    else if( ur_is(arg1, UT_COMPONENT) )
    {
        // Use first output.
        b1 = ur_blockPtr( arg1->ctx.valBlk );
        cc1 = b1->ptr.cells + COMPONENT_COUNTS;
        if( ur_ccOut(cc1) < 1 )
            goto out_err;
        conn = b1->ptr.cells + COMPONENT_CELLS + ur_ccIn(cc1);
    }
    else
        goto dt_err;

        
    if( ur_is(conn, UT_BLOCK) )
    {
        // Multiple connections may exist.
        b1 = tBlock( conn );
        it  = b1->ptr.cells;
        end = it + b1->used;
        while( it != end )
        {
            assert( ur_is(it, UT_WORD) );
            if( (ur_atom(it) == atom) &&
                (it->word.valBlk == cc2->ctx.valBlk) )
            {
                ur_arrayErase( b1, sizeof(UCell), it - b1->ptr.cells, 1 );
                break;
            }
            ++it;
        }
    }
    else if( ur_is(conn, UT_WORD) )
    {
        // A single connection exists.
        if( (ur_atom(conn) == atom) &&
            (conn->word.valBlk == cc2->ctx.valBlk) )
        {
            ur_setNone( conn );
        }
    }
    // Else no existing connections.

    UR_S_DROPN( 2 );
    return;

dt_err:

    ur_throwErr( UR_ERR_DATATYPE,
                 "disconnect expected select! select! bound to components" );
    return;

out_err:

    ur_throwErr( UR_ERR_SCRIPT, "Must disconnect from a component output" );
}


/**
  \param blk   Component value block.
  \param wrdN  Index into blk.
  \param nval  Value to send through all connections.
*/
void ur_setPlug( UThread* ut, UBlock* blk, UIndex wrdN, const UCell* nval )
{
    UCell* plugCnts;
    UCell* val;
    int trigger;
    uint32_t mask;
    uint32_t special;

    if( wrdN < COMPONENT_CELLS )
        return;

    val      = blk->ptr.cells + wrdN;
    plugCnts = blk->ptr.cells + COMPONENT_COUNTS;

    wrdN -= COMPONENT_CELLS;
    if( wrdN < ur_ccIn(plugCnts) )
    {
        // Input

        ur_copyCell( val, *nval );

        mask = 0x10001 << wrdN;
        special = ur_ccSpec(plugCnts) & mask;

        trigger = ur_ccMask(plugCnts);
        if( trigger != -1 )
        {
            trigger |= mask;

            if( special < 0x10000 )             // Not Strobe
                ur_ccMask(plugCnts) = trigger;

            if( trigger != -1 )
                return;
        }

        if( special & 0xffff )                  // Quiet
            return;

        // All inputs are set; add to execute list...
#if 1
        // Just eval immediately for now.
        val = blk->ptr.cells + COMPONENT_BODY;
        ur_eval( ut, val->series.n, 0 );
        //if( ok == UR_EVAL_ERROR )
#endif
        return;
    }

    wrdN -= ur_ccIn(plugCnts);
    if( wrdN < ur_ccOut(plugCnts) )
    {
        // Output

        if( ur_is(val, UT_WORD) )
        {
            ur_setPlug( ut, tBlockPtr(val->word.valBlk),
                        val->word.index, nval );
        }
        else if( ur_is(val, UT_BLOCK) )
        {
            UCell* end;
            blk = tBlock( val );
            val = blk->ptr.cells;
            end = val + blk->used;
            while( val != end )
            {
                if( ur_is(val, UT_WORD) )
                {
                    ur_setPlug( ut, tBlockPtr(val->word.valBlk),
                                val->word.index, nval );
                }
                ++val;
            }
        }
    }
    else
    {
        // Local
        ur_copyCell( val, *nval );
    }
}


/*EOF*/