root/trunk/orca/ovalue.c

/*============================================================================
    ORCA Interpreter
    Copyright (C) 2005-2006  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 "os.h"
#include "ovalue.h"
#include "internal.h"
#include "orca_atoms.h"

#ifdef OR_CONFIG_MATH3D
#include <math3d.h>
#endif


//#define MAKE_ATOM_HEADER    1


static const char* _datatypes[] =
{
    "unset",
    "none",
    "word",
    "lit-word",
    "set-word",
    "get-word",
    "refinement",
    "op",
    "native",
    "number",
    "integer",
    "decimal",
    "pair",
    "tuple",
    "char",
    "logic",
    "datatype",
    "time",
    "date",
    "action",

    "block",
    "paren",
    "path",
    "lit-path",
    "set-path",
    "string",
    "unicode",
    "issue",
    "tag",
    "file",
    "binary",
    "list",
    "hash",
    "dec-array",
    "int-array",
    "series",
    "object",
    "function",
    "bitset",
    "error",
    "port",
    "struct",

    "image",
    "sound",
    "widget",
    "vec2",
    "vec3",
    "matrix",
    "resource"
};


const char* orDatatypeName( int type )
{
    return _datatypes[ type ];
}


/*--------------------------------------------------------------------------*/


OEnv* orEnv = 0;
char  orTmp[ OR_TMP_SIZE ];


#include "boot.c"


extern OBlock* orTokenize( const char*, const char* );
extern const char* orAtomCString( OAtom );

extern void orBindNative( OValue* );
extern void orProtectNative( OValue* );
extern void orInNative( OValue* );
extern void orUseNative( OValue* );
extern void orForeachNative( OValue* );

extern void orRemoveEachNative();

extern void orFileNatives();
extern void orFormNative( OValue* );
extern void orMoldNative( OValue* );
extern void orPrintNative( OValue* );
extern void orPrinNative( OValue* );
extern void orParseNative( OValue* );
extern void orDisarmNative( OValue* );
extern void orMakeOps();
extern void orSeriesNatives();
extern void orInstallExceptionHandlers();
extern void orMathNatives();

extern void orFreeBlock( OIndex );
extern void orFreeContext( OIndex );

#ifdef TRACK_MALLOC
extern void orMemoryNative( OValue* );
#endif

void orBaseNatives();
void orNativeNative( OValue* );


OR_NATIVE( orNop )
{
    //cprint( "KR nop %p %d\n", orEnv->dataStack.buf, orEnv->dataStack.used );
    orResultUNSET;
}


#ifdef DEBUG
static void orSizeofNative()
{
    cprint( "sizeof(OValue)     %d\n", (int) sizeof(OValue) );
    cprint( "sizeof(OArray)     %d\n", (int) sizeof(OArray) );
    cprint( "sizeof(OWord)      %d\n", (int) sizeof(OWord) );
    cprint( "sizeof(CallRecord) %d\n", (int) sizeof(CallRecord) );
}
#endif


static void _appendWord( OBlock* blk, const char* name, int len )
{
    OValue* val;
    OA_EXPAND1( OValue, blk, val );
    orSetTF( val, OT_WORD );
    orSetWord( val, GLOBAL_WORDS_BLKN, GLOBAL_CTXN,
               OT_UNSET, orInternAtom( name, len ) );
}


static void makeGlobalContext()
{
    int i;
    const char* in;
    char* out;
    OBlock* wblk;
    OBlock* vblk;


    // Global context uses first two blocks.
    vblk = orMakeBlock( 4096 );    // 0 - Values (GLOBAL_CTXN)
    wblk = orMakeBlock( 4096 );    // 1 - Words  (GLOBAL_WORDS_BLKN)


    // Add datatypes first so OT_ define matches the index & atom.
    // orTypeQNative() depends on this.

    for( i = 0; i < OT_COUNT; ++i )
    {
        in  = orDatatypeName( i );
        out = orTmp;
        while( *in != '\0' )
            *out++ = *in++;
        *out++ = '!';

        _appendWord( wblk, orTmp, out - orTmp );
        orAppendValue( vblk, OT_DATATYPE, i );
    }

    _appendWord( wblk, "none", 4 );
    orAppendNone( vblk );

    {
        OBlock* dtBlk;

        dtBlk = orMakeBlock( OT_COUNT );

        _appendWord( wblk, "datatypes", 9 );
        orAppendBlock( vblk, orBlockN(dtBlk) );

        for( i = 0; i < OT_COUNT; ++i )
            orAppendValue( dtBlk, OT_DATATYPE, i );
    }
}


/**
  Declares a native function.
*/
void orNative( void* func, const char* name )
{
    OContext ctx;
    const char* cp;
    int wrdN;

    cp = name;
    while( *cp != '\0' )
        ++cp;

    orGlobalCtx( ctx );
    wrdN = orLookup( &ctx, orInternAtom( name, cp - name ) );
    if( wrdN > -1 )
    {
        OBlock* blk = orBlockPtr( ctx.vblkN );
        blk->values[ wrdN ].native.addr = func;
    }
    else
    {
        dprint( "orNative() - no spec defined for %s\n", name );
    }
}


void orMakeOp( void* func, const char* name )
{
    OContext ctx;
    OValue* val;
    const char* cp;

    cp = name;
    while( *cp != '\0' )
        ++cp;

    orGlobalCtx( ctx );
    val = orIntern( &ctx, name, cp - name, 0 );

    orSetTF( val, OT_OP );
    val->native.addr = func;
}


static void orInitAGC( OArrayGC* af )
{
    af->count = 0;
    af->sweepStart = 0;
    af->freeList = -2;
}


#ifdef BOOT_BYTECODE
void evalByteCode( const uint8_t* code )
{
    OIndex len;
    if( orByteCodeBlock( &code, &len ) )
    {
        OBlock* blk = orMakeBlock( len );
        orRevaluateByteCodes( code, len, blk );
        orEvalBlock( blk, 0 );
        orArrayFree( blk );
    }
    else
    {
        cprint( "** Boot Error: Invalid bytecode\n" );
    }
}
#endif


#ifdef DEBUG
static void _validateEnv()
{
    int i;
    OValue val;

#if 0
    printf( "sizeof(OValue)      %d\n", sizeof(OValue) );
    printf( "sizeof(double)      %d\n", sizeof(double) );
    printf( "sizeof(OWordRef)    %d\n", sizeof(OWordRef) );
    printf( "sizeof(OSeriesRef)  %d\n", sizeof(OSeriesRef) );
    printf( "sizeof(ONativeFunc) %d\n", sizeof(ONativeFunc) );
    printf( "sizeof(OTime)       %d\n", sizeof(OTime) );
#endif

    assert( sizeof(OValue) == 16 );

    // Make sure endianess is correct.
    i = 1;
#if defined(__BIG_ENDIAN__)
    assert(0 == *(char*)&i && "Undefine __BIG_ENDIAN__");
#else
    assert(1 == *(char*)&i && "Define __BIG_ENDIAN__");
#endif

    // Make sure double is aligned on 8 byte boundary.
    assert( ((char*) &val) + 8 == ((char*) &orDecimal(&val)) );
}
#endif


#if MAKE_ATOM_HEADER
#define FIXED_ATOM(str,len,def) \
    printf( "#define %s\t\t%d\n", #def, orInternAtom(str,len) );
#else
#ifdef DEBUG
#define FIXED_ATOM(str,len,def)     assert( orInternAtom(str,len) == def );
#else
#define FIXED_ATOM(str,len,def)     orInternAtom(str,len);
#endif
#endif


// Intern commonly used atoms.
static void _createFixedAtoms()
{
#if MAKE_ATOM_HEADER
    printf( "// This file is automatically generated - do not edit.\n\n" );
#endif

    FIXED_ATOM( "self",         4, OR_ATOM_SELF )
    FIXED_ATOM( "system",       6, OR_ATOM_SYSTEM )
    FIXED_ATOM( "script",       6, OR_ATOM_SCRIPT )
    FIXED_ATOM( "parent",       6, OR_ATOM_PARENT )
    FIXED_ATOM( "error",        5, OR_ATOM_ERROR )
    FIXED_ATOM( "error-types", 11, OR_ATOM_ERROR_TYPES )
    FIXED_ATOM( "catch",        5, OR_ATOM_CATCH )
    FIXED_ATOM( "throw",        5, OR_ATOM_THROW )
    FIXED_ATOM( "x",            1, OR_ATOM_X )
    FIXED_ATOM( "y",            1, OR_ATOM_Y )
    FIXED_ATOM( "z",            1, OR_ATOM_Z )
    FIXED_ATOM( "-",            1, OR_ATOM_DASH )
    FIXED_ATOM( "func",         4, OR_ATOM_FUNC )
    FIXED_ATOM( "does",         4, OR_ATOM_DOES )

    // Atoms used by parse.
    FIXED_ATOM( "|",     1, OR_ATOM_BAR )
    FIXED_ATOM( "opt",   3, OR_ATOM_OPT )
    FIXED_ATOM( "some",  4, OR_ATOM_SOME )
    FIXED_ATOM( "any",   3, OR_ATOM_ANY )
    FIXED_ATOM( "break", 5, OR_ATOM_BREAK )
    FIXED_ATOM( "skip",  4, OR_ATOM_SKIP )
    FIXED_ATOM( "set",   3, OR_ATOM_SET )
    FIXED_ATOM( "copy",  4, OR_ATOM_COPY )
    FIXED_ATOM( "to",    2, OR_ATOM_TO )
    FIXED_ATOM( "thru",  4, OR_ATOM_THRU )


#if MAKE_ATOM_HEADER
    exit(0);
#endif
}


/**
  Initialize scripting environment.
  Call orFreeEnv() when finished with the interpreter.

  If dataStackSize is less than 512 it will be set to 512.
  If callStackSize is less than 64 it will be set to 64.
*/
void orInitEnv( OEnv* env, int dataStackSize, int callStackSize )
{
    OValue* res;

#ifdef DEBUG
    _validateEnv();
#endif

    orEnv = env;

    env->error     = 0;
    env->gcEnabled = 1;
    env->secure    = 0;

    env->quickHolds     = memAlloc( sizeof(OHold) * OR_MAX_QHOLDS );
    env->quickHoldsUsed = 0;

    // NOTE: The data & call stacks are never resized so that it is safe
    // to keep pointers to values on them.

    if( dataStackSize < 512 )
        dataStackSize = 512;
    if( callStackSize < 64 )
        callStackSize = 64;

    orArrayInit( &env->atoms,        sizeof(OIndex),     4096 );
    orArrayInit( &env->dataStack,    sizeof(OValue),     dataStackSize );
    orArrayInit( &env->callStack,    sizeof(CallRecord), callStackSize );
    orArrayInit( &env->holds,        sizeof(OHold),      0 );
    orArrayInit( &env->loaders,      sizeof(void**),     0 );
    orArrayInit( &env->devices,      sizeof(void**),     0 );

    orArrayInit( &env->blocks,       sizeof(OBlock),   1024 );
    orArrayInit( &env->strings,      sizeof(OString),  2048 );

    orInitAGC( &env->freeBlocks );
    orInitAGC( &env->freeStrings );
    orInitAGC( &env->freeHolds );

#ifdef OR_CONFIG_NUMBER_ARRAYS
    orArrayInit( &env->decArr, sizeof(OArray), 0 );
    orArrayInit( &env->intArr, sizeof(OArray), 0 );

    orInitAGC( &env->freeDecArr );
    orInitAGC( &env->freeIntArr );
#endif

    orMakeString( 2048 );     // BIN_ATOM_NAMES

    makeGlobalContext();

    _createFixedAtoms();


    {
    // Must manually load native spec.
    // native: native [spec [block!]]
    OBlock* blk;
    OBlock* typeBlk;
    OValue* wval;
    OContext ctx;

    blk     = orMakeBlock( 2 );
    typeBlk = orMakeBlock( 1 );

    orAppendWord( blk, OT_WORD, "spec", 4 );
    orAppendBlock( blk, orBlockN(typeBlk) );

    orAppendBlock( typeBlk, 0 );

    res = orEnv->dataStack.values;
    orSetTF( res, OT_BLOCK );
    orSetSeries( res, orBlockN(blk), 0 );
    orNativeNative( res );

    orGlobalCtx( ctx );
    wval = orIntern( &ctx, "native", 6, 0 );
    *wval = *res;

    orNative( orNativeNative, "native" );
    }

#ifdef BOOT_BYTECODE
    evalByteCode( _natives );
#else
    orEvalCStr( _natives, sizeof(_natives) );
#endif
    if( orErrorThrown )
    {
        cprint( "** Boot Error: " );
        orPrintNative( res );
    }

    orMakeOps();
    orBaseNatives();
    orSeriesNatives();
    orMathNatives();
    orFileNatives();

    orInstallExceptionHandlers();

#ifdef BOOT_BYTECODE
    evalByteCode( _boot );
#else
    orEvalCStr( _boot, sizeof(_boot) );
#endif
    if( orErrorThrown )
    {
        cprint( "** Boot Error: " );
        orPrintNative( res );
    }

    {
    OValue* val;

    // Set system/words to global context.
    val = orLookupPath( OT_WORD, OR_ATOM_SYSTEM,
                        OT_WORD, orInternAtom( "words", 5 ),
                        OR_LPATH_END );
    if( val )
    {
        orSetTF( val, OT_OBJECT );
        orGlobalCtx( val->ctx );
    }

    // Set system/os.
    val = orLookupPath( OT_WORD, OR_ATOM_SYSTEM,
                        OT_WORD, orInternAtom( "os", 2 ),
                        OR_LPATH_END );
    if( val )
    {
        OAtom os_atom =
#if   defined(__linux)
        orInternAtom( "linux", 5 );
#elif defined(_WIN32)
        orInternAtom( "windows", 7 );
#elif defined(__APPLE__)
        orInternAtom( "macx", 4 );
#elif defined(__SUN__)
        orInternAtom( "solaris", 7 );
#else
        0;
#endif
        if( os_atom )
        {
            orSetTF( val, OT_WORD );
            val->word.context = GLOBAL_CTXN;
            val->word.index   = OT_UNSET;
            val->word.atom    = os_atom;
        }
    }
    }

    // NOTE: Must lock garbage collector after natives are created so that
    // any spec blocks do not get collected.

    orLockGarbageCollector();
}


static void orFreeArrayOfArray( OArray* arr )
{
    if( arr->used )
    {
        OArray* it  = (OArray*) arr->buf;
        OArray* end = it + arr->used;
        while( it != end )
        {
            // Quick version of orArrayFree().
            if( it->buf )
                memFree( it->buf );

            ++it;
        }
    }

    orArrayFree( arr );
}


void orFreeEnv( OEnv* env )
{
    if( orEnv == env )
        orEnv = 0;

    orFreeArrayOfArray( &env->blocks );
    orFreeArrayOfArray( &env->strings );

    orArrayFree( &env->devices );
    orArrayFree( &env->loaders );
    orArrayFree( &env->holds );
    orArrayFree( &env->callStack );
    orArrayFree( &env->dataStack );
    orArrayFree( &env->atoms );

#ifdef OR_CONFIG_NUMBER_ARRAYS
    orFreeArrayOfArray( &env->decArr );
    orFreeArrayOfArray( &env->intArr );
#endif

    memFree( env->quickHolds );

#ifdef TRACK_MALLOC
    extern void memReport( int );
    memReport( 1 );
#endif
}


/**
  Recover from an error.  It does not modify any existing values; nothing
  is freed and no files are closed.
  This should only be used from outside a top-level eval call.
*/
void orResetEnv( OEnv* env )
{
    env->callStack.used = 0;
    env->dataStack.used = 0;
    env->quickHoldsUsed = 0;
    env->error = 0;      //orErrorClear;
}


OBlock* orMakeList( int len )
{
    OBlock* blk;
    OValue* it;
    OValue* end;
    OValue* next;

    len = len * 2 + 2;

    blk = orMakeBlock( len );
    blk->used = 2;

    it  = blk->values;
    end = it + len;

    orSetTF( it, OT_UNSET );
    it->LIST_PREV = -1;
    it->LIST_NEXT = 1;
    it->LIST_FREE = (len == blk->avail) ? 0 : 2;
    ++it;

    orSetTF( it, OT_UNSET );
    it->LIST_PREV = 0;
    it->LIST_NEXT = 0;
    ++it;

    while( it != end )
    {
        next = it + 2;

        orSetTF( it, OT_UNSET );
        it->LIST_PREV = -1;
        it->LIST_NEXT = -1;
        it->LIST_FREE = (next == end) ? 0 : next - blk->values;

        it = next;
    }

    return blk;
}


void orListInsertValue( OBlock* blk, int nodeIndex, OValue* newVal ) 
{
    int nodeN;
    OValue* node;
    OValue* prev;
    OValue* it = blk->values;

    nodeN = it->LIST_FREE;
    if( nodeN )
    {
        it->LIST_FREE = it[ nodeN ].LIST_FREE;
    }
    else
    {
        orArrayReserve( blk, sizeof(OValue), blk->used + 2 );
        nodeN = blk->used;
        blk->used += 2;
        it = blk->values;
    }

    it += nodeIndex;

    prev = blk->values + it->LIST_PREV;
    prev->LIST_NEXT = nodeN;
    it->LIST_PREV = nodeN;

    node = blk->values + nodeN;
    orSetTF( node, OT_UNSET );
    node->LIST_LINKED = 1;
    node->LIST_PREV   = prev - blk->values;
    node->LIST_NEXT   = it - blk->values;
    node->LIST_FREE   = -1;

    ++node;
    orCopyV( node, *newVal );
}


/*
   Returns non-zero of successful.
*/
static int orMake( int type, OValue* from, OValue* res )
{
    switch( type )
    {
        case OT_WORD:
        case OT_SETWORD:
        case OT_GETWORD:
        case OT_LITWORD:
            if( orIs(from, OT_STRING) )
            {
                OContext ctx;
                OString* str = orSTRING( from );
                int start = from->series.it;

                orGlobalCtx( ctx );
                orIntern( &ctx, str->charArray + start,
                          str->used - start, res );
                orSetTF( res, type );
                return 1;
            }
            else if( orIs(from, OT_WORD) )
            {
                orSetTF( res, type );
                res->word = from->word;
                return 1;
            }
            break;

#if 0
        case OT_ACTION:
            if( from->type == OT_INTEGER )
            {
                orResult( OT_ACTION, orInt(from) );
                return 1;
            }
            break;
#endif
        case OT_LOGIC:
            orSetTF( res, OT_LOGIC );
            orInt(res) =  orInt(from) ? 1 : 0;
            return 1;

        case OT_INTEGER:
            if( orIs(from, OT_LOGIC) )
            {
                orSetTF( res, type );
                orInt(res) = orInt(from);
                return 1;
            }
            else if( orIs(from, OT_DECIMAL) )
            {
                orSetTF( res, type );
                orInt(res) = (int) orDecimal(from);
                return 1;
            }
            else if( orIs(from, OT_STRING) )
            {
                OString* str = orSTRING(from);
                char* it  = str->charArray + from->series.it;
                char* end = str->charArray + str->used;
                const char* fin;
                int n;
                n = orStringToInt( it, end, &fin );
                if( fin == end )
                {
                    orSetTF( res, type );
                    orInt(res) = n;
                    return 1;
                }
            }
            break;

        case OT_DECIMAL:
            if( orIs(from, OT_INTEGER) ||
                orIs(from, OT_LOGIC) )
            {
                orSetTF( res, type );
                orDecimal(res) = (double) orInt(from);
                return 1;
            }
            else
            {
                OString* str = orSTRING(from);
                char* it  = str->charArray + from->series.it;
                char* end = str->charArray + str->used;
                const char* fin;
                double n;
                n = orStringToDec( it, end, &fin );
                if( fin == end )
                {
                    orSetTF( res, type );
                    orDecimal(res) = n;
                    return 1;
                }
            }
            break;

        case OT_PAIR:
            if( orIs(from, OT_BLOCK) )
            {
                OBlock* blk = orBLOCK( from );
                OValue* it  = blk->values + from->series.it;
                OValue* end = blk->values + blk->used;
                if( (end - it) == 2 &&
                    (it[0].type == OT_INTEGER) &&
                    (it[1].type == OT_INTEGER) )
                {
                    orSetTF( res, OT_PAIR );
                    res->pair[0] = it[0].integer;
                    res->pair[1] = it[1].integer;
                    return 1;
                }
            }
            break;

        case OT_TUPLE:
            if( orIs(from, OT_BLOCK) )
            {
                OBlock* blk = orBLOCK( from );
                OValue* it  = blk->values + from->series.it;
                OValue* end = blk->values + blk->used;
                uint8_t* tuple = res->tuple;
                int used = end - it;
                if( used <= OR_TUPLE_MAX ) 
                {
                    while( it != end )
                    {
                        if( it->type != OT_INTEGER )
                            break;
                        *tuple++ = orInt(it);
                        ++it;
                    }
                    if( it == end )
                    {
                        orSetTF( res, OT_TUPLE );
                        res->argc = tuple - res->tuple;
                        return 1;
                    }
                }
            }
            break;

        case OT_BINARY:
            if( orIs(from, OT_STRING) )
            {
                OString* str;
                OBinary* bin;
                int len;

                str = orSTRING( from );
                len = str->used - from->series.it;

                bin = orMakeBinary( len );
                bin->used = len;
                memCpy(bin->byteArray, str->charArray + from->series.it, len); 

                orSetTF( res, OT_BINARY );
                orSetSeries( res, orBinaryN(bin), 0 );
                return 1;
            }
            break;
    }

    return 0;
}


extern int orMakeClone( const OContext*, OContext*, OIndex blkN, OIndex blkI );
static OBinary* _makeBitset( OBlock* blk, int index );

OR_NATIVE( orMakeNative )
{
    OValue* a2 = a1 + 1;
    if( a1->type == OT_DATATYPE )
    {
        if( orMake( orInt(a1), a2, a1 ) )
            return;

        switch( orInt(a1) )
        {
            case OT_BLOCK:
                if( a2->type == OT_INTEGER )
                {
                    OBlock* blk = orMakeBlock( orInt(a2) );
                    orResultBLOCK( blk - orBLOCKS );
                    return;
                }
                break;

            case OT_STRING:
                if( a2->type == OT_INTEGER )
                {
                    OString* str = orMakeString( orInt(a2) );
                    orResultSTRING( str - orSTRINGS );
                    return;
                }
                break;

            case OT_OBJECT:
                if( a2->type == OT_BLOCK )
                {
                    OContext ctx;
                    if( orMakeObject( orBLOCK(a2), a2->series.it, &ctx ) )
                    {
                        orSetTF( a1, OT_OBJECT );
                        a1->ctx = ctx;
                        return;
                    }
                }
                break;

            case OT_BITSET:
            {
                OBinary* bin = 0;

                switch( a2->type )
                {
                case OT_STRING:
                    bin = orMakeCharset( orSTRING(a2), a2->series.it );
                    break;

                case OT_BINARY:
                    bin = orCopyString( a2->index, a2->series.it );
                    break;

                case OT_BLOCK:
                    bin = _makeBitset( orBLOCK(a2), a2->series.it );
                    break;
                }

                if( bin )
                {
                    orResultSeries( OT_BITSET, orBinaryN(bin), 0 );
                    return;
                }
            }
                break;

            case OT_LIST:
                if( a2->type == OT_BLOCK )
                {
                    OBlock* blk = orBLOCK( a2 );
                    OValue* it  = blk->values + a2->series.it;
                    OValue* end = blk->values + blk->used;
                    int len = end - it;

                    blk = orMakeList( len );
                    while( it != end )
                    {
                        orListInsertValue( blk, LIST_TAIL, it );
                        ++it;
                    }
                    orResultSeries( OT_LIST, orBlockN(blk),
                                    len ? 2 : LIST_TAIL );
                    return;
                }
                else if( a2->type == OT_INTEGER )
                {
                    OBlock* blk = orMakeList( orInt(a2) );
                    orResultSeries( OT_LIST, orBlockN(blk), LIST_TAIL );
                    return;
                }
                break;
#if 0
            case OT_FUNCTION:
                {
                // Return curried function to pick up body argument.
                // Too bad we have no way of executing this native.
                a1->type  = OT_NATIVE;
                a1->flags = 0;
                a1->argc  = 1;
                a1->refc  = 0;
                a1->native.addr    = orFuncNative;
                a1->native.specBlk = 0;
                }
                return;
#endif

#ifdef OR_CONFIG_MATH3D
            case OT_VEC2:
            case OT_VEC3:
                orSetTF( a1, orInt(a1) );
                a1->vec3.x = 0.0f;
                a1->vec3.y = 0.0f;
                a1->vec3.z = 0.0f;
                if( a2->type == OT_BLOCK )
                    orLoadVectorBlock( &a1->vec3.x, 3, a2 ); 
                return;

            case OT_MATRIX:
            {
                int len = 16 * sizeof(float);
                OString* str = orMakeString( len );
                str->used = len;
                orLoadIdentity( str->floats );
                if( a2->type == OT_BLOCK )<