muse_opcodes.h

Go to the documentation of this file.

#ifndef __MUSE_OPCODES_H__
#define __MUSE_OPCODES_H__

#ifndef __MUSE_H__
#include "muse.h"
#endif

BEGIN_MUSE_C_FUNCTIONS

typedef longlong_t muse_int_cell;

typedef double muse_float_cell;

typedef struct { muse_cell head, tail; } muse_cons_cell;

typedef struct { muse_nativefn_t fn; void *context; }   muse_nativefn_cell;

typedef struct { muse_char *start, *end; }  muse_text_cell;

typedef union
{
    muse_int_cell       i;
    muse_float_cell     f;
    muse_cons_cell      cons;
    muse_nativefn_cell  fn;
    muse_text_cell      text;
} muse_cell_data;

typedef struct 
{
    int size;           
    muse_cell *bottom;  
    muse_cell *top;     
} muse_stack;

typedef struct
{
    int                 size_cells; 
    muse_cell_data      *cells;     
    unsigned char       *marks;     
    muse_cell           free_cells;     
    int                 free_cell_count; 
} muse_heap;

struct _muse_env
{
    muse_heap           heap;
    muse_stack          stack;
    muse_stack          symbol_stack;
    int                 num_symbols;
    muse_stack          bindings_stack;
    muse_cell           specials;
    muse_cell           *builtin_symbols;
    int                 *parameters;
    void                *stack_base;
};

extern muse_env *g_muse_env;
extern const char *g_muse_typenames[];

static inline muse_env *_env() 
{ 
    return g_muse_env; 
}

static inline muse_cell _t()
{
    return _env()->builtin_symbols[MUSE_T];
}

static inline muse_cell _celli( muse_cell cell ) 
{ 
    return cell >> 3; 
}

static inline muse_cell _cellati( int i )
{
    return i << 3;
}

static inline muse_cell_t _cellt( muse_cell cell ) 
{ 
    return (muse_cell_t)(cell & 7); 
}
static inline const char *_typename( muse_cell cell )
{
    return g_muse_typenames[_cellt(cell)];
}
static inline muse_boolean _isnumbert( int cell_t )
{
    return (cell_t == MUSE_INT_CELL || cell_t == MUSE_FLOAT_CELL) ? MUSE_TRUE : MUSE_FALSE;
}
static inline muse_boolean _isnumber( muse_cell cell )
{
    return _isnumbert(_cellt(cell));
}
static inline muse_boolean _isfn( muse_cell cell )
{
    int t = _cellt(cell);
    return (t == MUSE_NATIVEFN_CELL || t == MUSE_LAMBDA_CELL) ? MUSE_TRUE : MUSE_FALSE;
}
static inline muse_boolean _isquote( muse_cell cell )
{
    return (cell == _env()->builtin_symbols[MUSE_QUOTE]) ? MUSE_TRUE : MUSE_FALSE;
}
static inline muse_cell _setcellt( muse_cell cell, muse_cell_t t ) 
{ 
    return (muse_cell)((cell & ~7) | t); 
}
static inline muse_cell_data *_ptr( muse_cell cell )
{
    muse_assert( cell >= 0 );
    muse_assert( _celli(cell) < _env()->heap.size_cells );
    return _env()->heap.cells + _celli(cell);
}
static inline muse_functional_object_t *_fnobjdata( muse_cell c )
{
    if ( _cellt(c) == MUSE_NATIVEFN_CELL )
    {
        muse_functional_object_t *d = (muse_functional_object_t*)_ptr(c)->fn.context;
        if ( d && d->magic_word == 'muSE' )
            return d;
    }

    return NULL;
}
static inline muse_int _intvalue( muse_cell c )
{
    switch ( _cellt(c) )
    {
        case MUSE_INT_CELL : return _ptr(c)->i;
        case MUSE_FLOAT_CELL : return (muse_int)_ptr(c)->f;
        default : return 0;
    }
}
static inline muse_float _floatvalue( muse_cell c )
{
    switch ( _cellt(c) )
    {
        case MUSE_INT_CELL : return (muse_float)_ptr(c)->i;
        case MUSE_FLOAT_CELL : return _ptr(c)->f;
        default : return 0.0;
    }
}
static inline muse_heap *_heap()
{
    return &_env()->heap;
}
static inline muse_stack *_stack()
{
    return &_env()->stack;
}
static inline muse_cell _spush( muse_cell cell )
{
    if ( cell )
    {
        muse_assert( _env()->stack.top - _env()->stack.bottom < _env()->stack.size );
        muse_assert( _celli(cell) >= 0 && _celli(cell) < _env()->heap.size_cells );
        return *(_env()->stack.top++) = cell;
    }
    else
        return MUSE_NIL;
}
static inline int _spos()
{
    return (int)(_env()->stack.top - _env()->stack.bottom);
}
static inline void _unwind( int stack_pos )
{
    _env()->stack.top = _env()->stack.bottom + stack_pos;
}
static inline muse_stack *_symstack()
{
    return &_env()->symbol_stack;
}
static inline muse_cell _head( muse_cell c )
{
    muse_assert( _cellt(c) == MUSE_CONS_CELL || _cellt(c) == MUSE_SYMBOL_CELL || _cellt(c) == MUSE_LAMBDA_CELL );
    return _ptr(c)->cons.head;
}
static inline muse_cell _tail( muse_cell c )
{
    muse_assert( _cellt(c) == MUSE_CONS_CELL || _cellt(c) == MUSE_SYMBOL_CELL || _cellt(c) == MUSE_LAMBDA_CELL );
    return _ptr(c)->cons.tail;
}
static inline muse_cell _symname( muse_cell sym )
{
    return _tail(_head(_tail(sym)));
}
static inline muse_cell _step( muse_cell *c )
{
    muse_cell _c = *c;
    (*c) = _tail(*c);
    return _c;
}
static inline muse_cell _next( muse_cell *c )
{
    return _head(_step(c));
}
static inline void _lpush( muse_cell h, muse_cell *l )
{
    _ptr(h)->cons.tail = *l;
    (*l) = h;
}
static inline void _seth( muse_cell c, muse_cell h )
{
    muse_assert( _cellt(c) == MUSE_CONS_CELL || _cellt(c) == MUSE_SYMBOL_CELL || _cellt(c) == MUSE_LAMBDA_CELL );
    muse_assert( h < 0 || _celli(h) < _env()->heap.size_cells );
    _ptr(c)->cons.head = h;
}
static inline void _sett( muse_cell c, muse_cell t )
{
    muse_assert( _cellt(c) == MUSE_CONS_CELL || _cellt(c) == MUSE_SYMBOL_CELL || _cellt(c) == MUSE_LAMBDA_CELL );
    muse_assert( t < 0 || _celli(t) < _env()->heap.size_cells );
    _ptr(c)->cons.tail = t;
}
static inline void _setht( muse_cell c, muse_cell h, muse_cell t )
{
    muse_cell_data *p = _ptr(c);
    muse_assert( _cellt(c) == MUSE_CONS_CELL || _cellt(c) == MUSE_SYMBOL_CELL || _cellt(c) == MUSE_LAMBDA_CELL );
    p->cons.head = h;
    p->cons.tail = t;
}
static inline muse_cell _def( muse_cell symbol, muse_cell value )
{
    _seth(symbol,value);
    return value;
}
static inline muse_cell _symval( muse_cell symbol )
{
    return _head(symbol);
}
static inline int _bspos()
{
    return (int)(_env()->bindings_stack.top - _env()->bindings_stack.bottom);
}
static inline void _push_binding( muse_cell symbol )
{
    muse_stack *s = &_env()->bindings_stack;
    muse_assert( s->top - s->bottom < s->size - 1 );
    *(s->top++) = symbol;
    *(s->top++) = _symval(symbol);
}
static inline void _unwind_bindings( int pos )
{
    muse_stack *s = &_env()->bindings_stack;
    muse_assert( pos >= 0 && pos <= s->top - s->bottom );

    {
        muse_cell *p = s->bottom + pos;
        while ( s->top > p )
        {
            s->top -= 2;
            _def( s->top[0], s->top[1] );
        }
    }
}
static inline void _mark( muse_cell c )
{
    int ci = _celli(c);
    unsigned char *m = _heap()->marks + (ci >> 3);
    muse_assert( ci >= 0 && ci < _heap()->size_cells );
    (*m) |= (1 << (ci & 7));
}
static inline void _unmark( muse_cell c )
{
    int ci = _celli(c);
    unsigned char *m = _heap()->marks + (ci >> 3);
    muse_assert( ci >= 0 && ci < _heap()->size_cells );
    (*m) &= ~(1 << (ci & 7));
}
static inline int _ismarked( muse_cell c )
{
    int ci = _celli(c);
    const unsigned char *m = _heap()->marks + (ci >> 3);
    muse_assert( ci >= 0 && ci < _heap()->size_cells );
    return (*m) & (1 << (ci & 7));
}
static inline int _iscompound( muse_cell c )
{
    return _cellt(c) < MUSE_NATIVEFN_CELL;
}
static inline muse_cell _takefreecell()
{
    muse_cell c;
    c = _step( &(_env()->heap.free_cells) );
    _sett(c,MUSE_NIL);
    _env()->heap.free_cell_count--;
    return c;
}
static inline void _returncell( muse_cell c )
{
    muse_cell *f = &_env()->heap.free_cells;
    _setht(c, MUSE_NIL, *f);
    (*f) = c;
    _env()->heap.free_cell_count++;
}
static inline muse_cell _qq( muse_cell c )
{
    return c > 0 ? -c : c;
}
static inline muse_cell _quq( muse_cell c )
{
    return c < 0 ? -c : c;
}

END_MUSE_C_FUNCTIONS

#endif /* __MUSE_OPCODES_H__ */

---