root/trunk/orca/bytecode.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 "ovalue.h"
#include "os.h"


/*
  TODO:
    * Save formatting (OR_FLAG_EOL / OR_FLAG_BEOL)?
    * Make word/string table (would make boot.r much smaller)?
*/


#ifdef OR_CONFIG_BYTECODE

#define BIG_VALUE       0x80

#define RESERVE(n) \
    orArrayReserve( bin, 1, bin->used + n ); \
    cp = bin->byteArray + bin->used; \
    bin->used += n


/*
   Appends byte-code representation of value to binary.
*/
void orCompileByteCodes( OBinary* bin, const OValue* val )
{
    uint8_t* cp;

    switch( val->type )
    {
        case OT_WORD:
        case OT_LITWORD:
        case OT_SETWORD:
        case OT_GETWORD:
        case OT_REFINEMENT:
        {
            int pos;
            int atom;

            atom = (val->type == OT_REFINEMENT) ? val->index : val->word.atom;
            pos = bin->used;

            orArrayReserve( bin, 1, bin->used + 2 );
            bin->used += 2;

            orAtomStr( atom, bin );

            // LIMIT: Word names can never be more than 255 characters.
            cp = bin->byteArray + pos;
            *cp++ = val->type;
            *cp   = bin->used - pos - 2;
        }
            break;

        case OT_INTEGER:
        {
            int i = orInt(val);
            if( i > 255 )
            {
                RESERVE( 5 );
                *cp++ = BIG_VALUE | val->type;
                *cp++ = (i >> 24) & 0xff;
                *cp++ = (i >> 16) & 0xff;
                *cp++ = (i >>  8) & 0xff;
            }
            else
            {
                RESERVE( 2 );
                *cp++ = val->type;
            }
            *cp = i & 0xff;
        }
            break;

        case OT_DECIMAL:
        {
            const uint8_t* end;
            uint64_t li;
            int shift = 56;

            RESERVE( 9 );
            *cp++ = val->type;

            end = cp + 8;
            li = *((uint64_t*) &orDecimal(val));
            while( cp != end )
            {
                *cp++ = (uint8_t) (li >> shift) & 0xff;
                shift -= 8;
            }
        }
            break;

        case OT_CHAR:
        case OT_LOGIC:
        case OT_DATATYPE:
            RESERVE( 2 );
            *cp++ = val->type;
            *cp   = orInt(val) & 0xff;
            break;

        case OT_TUPLE:
        {
            int len = val->argc + 2;
            RESERVE( len );
            len -= 2;
            *cp++ = val->type;
            *cp++ = len;
            if( len )
                memCpy( cp, val->tuple, len );
        }
            break;

        //case OT_TIME:

        case OT_BLOCK:
        case OT_PAREN:
        case OT_PATH:
        case OT_LITPATH:
        case OT_SETPATH:
        {
            OBlock* blk = orBLOCKS + val->index;
            OValue* it  = blk->values + val->series.it;
            OValue* end = blk->values + blk->used;
            int len = end - it;

            if( len > 255 )
            {
                RESERVE( 5 );
                *cp++ = BIG_VALUE | val->type;
                *cp++ = (len >> 24) & 0xff;
                *cp++ = (len >> 16) & 0xff;
                *cp++ = (len >>  8) & 0xff;
            }
            else
            {
                RESERVE( 2 );
                *cp++ = val->type;
            }
            *cp = len & 0xff;

            while( it != end )
            {
                orCompileByteCodes( bin, it );
                ++it;
            }
        }
            break;

        case OT_STRING:
        case OT_ISSUE:
        case OT_TAG:
        case OT_FILE:
        case OT_BINARY:
        {
            OString* str = orSTRINGS + val->index;
            int len = str->used - val->series.it;

            if( len > 255 )
            {
                len += 5;
                RESERVE( len );
                len -= 5;
                *cp++ = BIG_VALUE | val->type;
                *cp++ = (len >> 24) & 0xff;
                *cp++ = (len >> 16) & 0xff;
                *cp++ = (len >>  8) & 0xff;
            }
            else
            {
                len += 2;
                RESERVE( len );
                len -= 2;
                *cp++ = val->type;
            }
            *cp++ = len & 0xff;

            memCpy( cp, str->charArray + val->series.it, len );
        }
            break;

        default:
            RESERVE( 1 );
            *cp = val->type;
            break;
    }
}


/*
   Returns value length of block.
   Sets lenp to value length and codep to start of value byte-code.
*/
OIndex orByteCodeBlock( const uint8_t** codep, OIndex* lenp )
{
    int type;
    int big;
    OIndex len = 0;
    const uint8_t* cp = *codep;

    type = *cp++;
    big = type & BIG_VALUE;
    if( big )
        type &= ~BIG_VALUE;

    if( type == OT_BLOCK )
    {
        if( big )
        {
            len  = *cp++ << 24;
            len += *cp++ << 16;
            len += *cp++ <<  8;
            len += *cp++;
        }
        else
        {
            len = *cp++;
        }

        *codep = cp;
    }

    *lenp = len;
    return len;
}


/*
   Appends value representation of byte-codes to block.
*/
const uint8_t* orRevaluateByteCodes( const uint8_t* cp, int valueCount,
                                     OBlock* blk )
{
    OIndex blkN;
    int type;
    int len;
    int big;

    blkN = orBlockN( blk );

    while( valueCount-- )
    {
        type = *cp++;

        big = type & BIG_VALUE;
        if( big )
            type &= ~BIG_VALUE;

        switch( type )
        {
            case OT_WORD:
            case OT_LITWORD:
            case OT_SETWORD:
            case OT_GETWORD:
            {
                len = *cp++;
                orAppendWord( blk, type, (const char*) cp, len );
                cp += len;
            }
                break;

            case OT_REFINEMENT:
            {
                int n;
                len = *cp++;
                n = orInternAtom( (const char*) cp, len );
                cp += len;
                orAppendValue( blk, type, n );
            }
                break;

            case OT_INTEGER:
                if( big )
                {
                    len  = *cp++ << 24;
                    len += *cp++ << 16;
                    len += *cp++ <<  8;
                    len += *cp++;
                }
                else
                {
                    len = *cp++;
                }
                orAppendValue( blk, type, len );
                break;

            case OT_DECIMAL:
            {
                const uint8_t* end;
                double n;
                union {
                    uint64_t i;
                    double   d;
                } num;

                num.i = *cp++; 
                end = cp + 7;
                while( cp != end )
                {
                    num.i <<= 8;
                    num.i += *cp++; 
                }
                n = num.d;
                orAppendDecimal( blk, n );
            }
                break;

            case OT_CHAR:
            case OT_LOGIC:
            case OT_DATATYPE:
                orAppendValue( blk, type, *cp++ );
                break;

            case OT_TUPLE:
                len = *cp++;
                orAppendTuple( blk, cp, len );
                cp += len;
                break;

            case OT_BLOCK:
            case OT_PAREN:
            case OT_PATH:
            case OT_LITPATH:
            case OT_SETPATH:
            {
                if( big )
                {
                    len  = *cp++ << 24;
                    len += *cp++ << 16;
                    len += *cp++ <<  8;
                    len += *cp++;
                }
                else
                {
                    len = *cp++;
                }

                blk = orMakeBlock( len );
                orAppendValue( orBLOCKS + blkN, type, blk - orBLOCKS );
                cp = orRevaluateByteCodes( cp, len, blk );

                // Re-acquire blk.
                blk = orBLOCKS + blkN;
            }
                break;

            case OT_STRING:
            case OT_ISSUE:
            case OT_TAG:
            case OT_FILE:
            case OT_BINARY:
                if( big )
                {
                    len  = *cp++ << 24;
                    len += *cp++ << 16;
                    len += *cp++ <<  8;
                    len += *cp++;
                }
                else
                {
                    len = *cp++;
                }
                orAppendValue( blk, type, orMakeCString((const char*) cp, len) );
                cp += len;
                break;

            case OT_NONE:
                orAppendNone( blk );
                break;

            default:
                break;
        }
    }

    return cp;
}

#endif


/*EOF*/