root/trunk/thune/internal.h

#ifndef INTERNAL_H
#define INTERNAL_H


#include "env.h"


#define UR_CTERM_LEN        1

// UR_CTX_UNORDERED is only used on the first word (sel member) of a context
// word block to mark the context as being unsorted.
#define UR_CTX_UNORDERED    -1

#define BIN_THREAD_TMP      0

#define BLK_THREAD_HOLD     0
#define BLK_GLOBAL_WORD     1
#define BLK_GLOBAL_VAL      2
#define BLK_CTX_STACK       3
//#define BLK_DSTACK          4


#define isGlobalIndex(n)    (n < 0)


#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 )


#define LOCK_GLOBAL     mutexLock( ut->env->mutex );
#define UNLOCK_GLOBAL   mutexUnlock( ut->env->mutex );

#define LOCK_ATOMS      LOCK_GLOBAL
#define UNLOCK_ATOMS    UNLOCK_GLOBAL


#define UR_IS_ANY2(cell, t1, t2) \
        (ur_is(cell, t1) || ur_is(cell, t2))

#define UR_IS_ANY3(cell, t1, t2, t3) \
        ((1 << ur_type(cell)) & ((1<<t1) | (1<<t2) | (1<<t3)))


#define CUSTOM_DT(type)     ut->env->customDT[type - UT_BI_COUNT]


typedef struct
{
    uint32_t hash;
    uint16_t nameIndex;     // Index into atomNames.ptr.c
    uint16_t nameLen;

    uint16_t head;
    uint16_t chain;
}
AtomRec;


/*
typedef struct
{
    uint8_t  type;
    uint8_t  flags;
    uint16_t _pad0;
    uint32_t _pad1;
    OSThread thread;
}
UCellThread;
*/


#define UR_EXPAND_1(type,arr,elem) \
    ur_arrayReserve(arr, sizeof(type), arr->used+1); \
    elem = ((type*) (arr->ptr.v)) + arr->used; \
    ++arr->used


#define ur_portDev(cell) \
    (((UPortDevice**) ur_env->devices.ptr.v)[(cell)->port.deviceId])


#ifdef LANG_THUNE
/* Control Stack */

typedef struct
{
    int16_t code;
    int16_t _pad;
}
CEId;

typedef struct
{
    int16_t code;
    int16_t skip;
    int32_t n;
    UCell*  cell;
}
CECell;

typedef struct
{
    int16_t code;
    int16_t _pad;
    int32_t blkN;
}
CEEnd;

typedef struct
{
    int16_t  code;
    int16_t  _pad;
    uint32_t n;
    uint32_t it;
}
CEEval;

typedef struct
{
    int16_t  code;
    uint16_t flags;
    int32_t  n;
    int32_t  it;
}
CELoop;

typedef struct
{
    int16_t code;
    int16_t locals;
    int32_t bodyN;
    int32_t sigN;
    //int32_t lpos;
}
CEFunc;

typedef union
{
    UCell  cell;
    CEId   id;
    CECell cp;
    CEEnd  end;
    CEEval eval;
    CELoop loop;
    CECell iter;
    CECell reduce;
    CEFunc func;
}
CEntry;


#define CC_FUNC             0
#define CC_FUNC_LOOP        1
#define CC_EVAL             2
#define CC_EVAL_RUNNING     3
#define CC_REDUCE           4
#define CC_FOREVER          5
#define CC_LOOP             6
#define CC_ITER             7
#define CC_EACH             8
#define CC_CATCH            9
#define CC_TERM             10
#define CC_END              11
#define CC_COUNT            (CC_END+1)


#define CC_LEN_FUNC         1
#define CC_LEN_EVAL         1
#define CC_LEN_FOREVER      1
#define CC_LEN_LOOP         2
#define CC_LEN_REDUCE       1
#define CC_LEN_ITER         2
#define CC_LEN_CATCH        3
#define CC_LEN_TERM         1
#define CC_LEN_END          1


#if 0
#define CEHOLD_COUNT(ce)      (ce->hold.types & 15)
#define CEHOLD_TYPE_0(ce)    ((ce->hold.types >> 4) & 15)
#define CEHOLD_TYPE_1(ce)    ((ce->hold.types >> 8) & 15)
#define CEHOLD_TYPE_2(ce)    ((ce->hold.types >> 12) & 15)

#define PUSHC_HOLD_S1(s1) \
    UR_TOC->code  = CC_HOLD; \
    UR_TOC->types = (_holdMap[s1->type] << 4) | 1; \
    UR_TOC->n[0]  = s1->series.n; \
    UR_C_GROW

#define PUSHC_HOLD_S2(s1,s2) \
    UR_TOC->code  = CC_HOLD; \
    UR_TOC->types = (_holdMap[s2->type] << 8) | (_holdMap[s1->type] << 4) | 2; \
    UR_TOC->n[0]  = s1->series.n; \
    UR_TOC->n[1]  = s2->series.n; \
    UR_C_GROW

#define POPC_HOLD   UR_C_DEC
#endif


#define OP_NOP              0
//#define OP_MODE_RUN         1
//#define OP_MODE_COMPILE     2
#define OP_DROP             3
#define OP_DUP              4
#define OP_DUP2             5
#define OP_OVER             6
#define OP_SWAP             7
#define OP_NIP              8
#define OP_TUCK             9
#define OP_ROT              10
#define OP_ROT_R            11
#define OP_DO               12
#define OP_PROC             13
#define OP_ITER             14
#define OP_EACH             15
#define OP_RECURSE          16
#define OP_RETURN           17
#define OP_THROW            18
#define OP_TRY              19
#define OP_IF_TRUE          20
#define OP_IF_SOME          21
#define OP_IF_FALSE         22
#define OP_OR_ELSE          23
#define OP_IF               24
#define OP_HALT             25
#define OP_QUIT             26
#define OP_INCREMENT        27
#define OP_DECREMENT        28
#define OP_INC_WORD         29
#define OP_DEC_WORD         30
#define OP_VERIFY           31
#define OP_FOREVER          32
#define OP_LOOP             33
#define OP_REDUCE           34
#define OP_DO_FUNC          35
//#define OP_END              255


#define UR_TOC              ((CEntry*) ut->toc)
#define UR_BOC              ((CEntry*) ut->cstack)

#ifdef DEBUG
#define UR_C_GROW \
    ++ut->toc; \
    assert( (char*)ut->toc < (char*)ut->localFT )
#else
#define UR_C_GROW           ++ut->toc
#endif

#define UR_C_DEC            --ut->toc
#define UR_C_DECN(n)        ut->toc -= n
#endif


#ifdef LANG_RUNE
/* Control Stack */

#define OP_NOP              0
#define OP_DO               1
#define OP_THROW            2
#define OP_REDUCE           3
#define OP_HALT             4
#define OP_QUIT             5


#define UR_TOC              ut->toc
#define UR_BOC              ut->cstack
#define UR_C_GROW           ++ut->toc
#define UR_C_DEC            --ut->toc
#endif


#define UR_CALL_OP          ut->callOp


struct LocalFrame
{
    UCell*  cell;   // Points into data stack.
    int32_t n;
};


#define UR_LF_BEG           ((LocalFrame*) ut->localFT)
#define UR_LF_END           ((LocalFrame*)(ut->cstack + UR_CSTACK_SIZE))
#define UR_LF_PUSH          --ut->localFT
#define UR_LF_POP           ++ut->localFT


#endif  /* INTERNAL_H */