NewtObj.c

説明を見る。

/*------------------------------------------------------------------------*/
/* ヘッダファイル */
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#include "NewtCore.h"
#include "NewtGC.h"
#include "NewtIO.h"


/* 関数プロトタイプ */
static newtRef      NewtMakeSymbol0(const char *s);
static bool         NewtBSearchSymTable(newtRefArg r, const char * name, uint32_t hash, int32_t st, int32_t * indexP);
static newtObjRef   NewtObjMemAlloc(newtPool pool, uint32_t n, bool literal);
static newtObjRef   NewtObjRealloc(newtPool pool, newtObjRef obj, uint32_t n);
static void         NewtGetObjData(newtRefArg r, uint8_t * data, uint32_t len);
static newtObjRef   NewtObjBinarySetLength(newtObjRef obj, uint32_t n);
static uint32_t     NewtObjSymbolLength(newtObjRef obj);
static uint32_t     NewtObjStringLength(newtObjRef obj);
static newtObjRef   NewtObjStringSetLength(newtObjRef obj, uint32_t n);
static void         NewtMakeInitSlots(newtRefArg r, uint32_t st, uint32_t n, uint32_t step, newtRefVar v[]);
static newtObjRef   NewtObjSlotsSetLength(newtObjRef obj, uint32_t n, newtRefArg v);
static int          NewtInt32Compare(newtRefArg r1, newtRefArg r2);
static int          NewtRealCompare(newtRefArg r1, newtRefArg r2);
static int          NewtStringCompare(newtRefArg r1, newtRefArg r2);
static int          NewtBinaryCompare(newtRefArg r1, newtRefArg r2);
static uint16_t     NewtArgsType(newtRefArg r1, newtRefArg r2);

static newtRef      NewtMakeThrowSymbol(int32_t err);

static bool         NewtObjHasProto(newtObjRef obj);
static bool         NewtMapIsSorted(newtRefArg r);
static void         NewtObjRemoveArraySlot(newtObjRef obj, int32_t n);
static void         NewtDeeplyCopyMap(newtRef * dst, int32_t * pos, newtRefArg src);
static newtRef      NewtDeeplyCloneMap(newtRefArg map, int32_t len);
static void         NewtObjRemoveFrameSlot(newtObjRef obj, newtRefArg slot);
static bool         NewtStrNBeginsWith(char * str, uint32_t len, char * sub, uint32_t sublen);
static bool         NewtStrIsSubclass(char * sub, uint32_t sublen, char * supr, uint32_t suprlen);
static bool         NewtStrHasSubclass(char * sub, uint32_t sublen, char * supr, uint32_t suprlen);


#pragma mark -
/*------------------------------------------------------------------------*/
uint32_t NewtSymbolHashFunction(const char * name)
{
    uint32_t result = 0;
    char c;

    while (*name)
    {
        c = *name;

        if (c >= 'a' && c <= 'z')
            result = result + c - ('a' - 'A');
        else
            result = result + c;

        name++;
    }

    return result * 2654435769U;
}


/*------------------------------------------------------------------------*/
newtRef NewtMakeSymbol0(const char *s)
{
    newtObjRef  obj;
    uint32_t    size;

    size = sizeof(uint32_t) + strlen(s) + 1;
    obj = NewtObjAlloc(kNewtSymbolClass, size, 0, true);

    if (obj != NULL)
    {
        newtSymDataRef  objData;
        uint32_t    setlen;

        objData = NewtObjToSymbol(obj);

        setlen = NewtObjSize(obj) - size;

        if (0 < setlen)
            memset(objData + size, 0, setlen);

        objData->hash = NewtSymbolHashFunction(s);
        strcpy(objData->name, s);

        return NewtMakePointer(obj);
    }

    return kNewtRefUnbind;
}


/*------------------------------------------------------------------------*/
bool NewtBSearchSymTable(newtRefArg r, const char * name, uint32_t hash,
    int32_t st, int32_t * indexP)
{
    newtSymDataRef  sym;
    newtRef *   slots;
    int32_t len;
    int32_t ed;
    int32_t md = st;
    int16_t comp;

    slots = NewtRefToSlots(r);

    if (hash == 0)
        hash = NewtSymbolHashFunction(name);

    len = NewtArrayLength(r);
    ed = len - 1;

    while (st <= ed)
    {
        md = (st + ed) / 2;

        sym = NewtRefToSymbol(slots[md]);

        if (hash < sym->hash)
            comp = -1;
        else if (hash > sym->hash)
            comp = 1;
        else
            comp = 0;

        if (comp == 0)
            comp = strcasecmp(name, sym->name);

        if (comp == 0)
        {
            *indexP = md;
            return true;
        }

        if (comp < 0)
            ed = md - 1;
        else
            st = md + 1;
    }

    if (len < st)
        *indexP = len;
    else
        *indexP = st;

    return false;
}


/*------------------------------------------------------------------------*/
newtRef NewtLookupSymbol(newtRefArg r, const char * name, uint32_t hash, int32_t st)
{
    newtRefVar  sym;
    int32_t index;

    if (NewtBSearchSymTable(r, name, 0, st, &index))
        return NewtGetArraySlot(r, index);

    sym = NewtMakeSymbol0(name);
    NewtInsertArraySlot(r, index, sym);

    return sym;
}


/*------------------------------------------------------------------------*/
newtRef NewtLookupSymbolArray(newtRefArg r, newtRefArg name, int32_t st)
{
    newtSymDataRef  sym;

    sym = NewtRefToSymbol(name);

    if (sym != NULL)
        return NewtLookupSymbol(r, sym->name, sym->hash, st);
    else
        return kNewtRefUnbind;
}


const char* NewtSymbolGetName(newtRefArg inSymbol)
{
    return NewtRefToSymbol(inSymbol)->name;
}


#pragma mark -
/*------------------------------------------------------------------------*/
uint16_t NewtGetRefType(newtRefArg r, bool detail)
{
    uint16_t    type = kNewtUnknownType;

    switch (r & 3)
    {
        case 0: // Integer
            type = kNewtInt30;
            break;

        case 1: // Pointer
            if (detail)
                type = NewtGetObjectType(NewtRefToPointer(r), true);
            else
                type = kNewtPointer;
            break;

        case 2: // Character or Special
            switch (r)
            {
                case kNewtRefNIL:
                    type = kNewtNil;
                    break;

                case kNewtRefTRUE:
                    type = kNewtTrue;
                    break;

                case kNewtRefUnbind:
                    type = kNewtUnbind;
                    break;

                case kNewtSymbolClass:
                    type = kNewtSymbol;
                    break;

                default:
                    if ((r & 0xF) == 6)
                        type = kNewtCharacter;
                    else
                        type = kNewtSpecial;
                    break;
            }
            break;

        case 3: // Magic Pointer
            type = kNewtMagicPointer;
            break;
    }

    return type;
}


/*------------------------------------------------------------------------*/
uint16_t NewtGetObjectType(newtObjRef obj, bool detail)
{
    uint16_t    type = kNewtUnknownType;

    switch (NewtObjType(obj))
    {
        case 0: // binary
            type = kNewtBinary;

            if (detail)
            {
                if (obj->as.klass == kNewtSymbolClass)
                    type = kNewtSymbol;
                else if (NewtRefEqual(obj->as.klass, NSSYM0(string)))
                    type = kNewtString;
                else if (NewtRefEqual(obj->as.klass, NSSYM0(int32)))
                    type = kNewtInt32;
                else if (NewtRefEqual(obj->as.klass, NSSYM0(real)))
                    type = kNewtReal;
                else if (NewtIsSubclass(obj->as.klass, NSSYM0(string)))
                    type = kNewtString;
            }
            break;

        case 1: // array
            type = kNewtArray;
            break;

        case 3: // frame
            type = kNewtFrame;
            break;
    }

    return type;
}


#pragma mark -
/*------------------------------------------------------------------------*/
uint32_t NewtObjCalcDataSize(uint32_t n)
{
    if (n < 4)
        return 4;
    else
        return n;
}


/*------------------------------------------------------------------------*/
newtObjRef NewtObjMemAlloc(newtPool pool, uint32_t n, bool literal)
{
    newtObjRef  obj;
    uint32_t    newSize;

    if (literal)
    {
        newSize = NewtAlign(sizeof(newtObj) + n, 4);
        obj = NewtObjChainAlloc(pool, newSize, 0);
    }
    else
    {
        newSize = NewtObjCalcDataSize(n);
        obj = NewtObjChainAlloc(pool, sizeof(newtObj) + sizeof(uint8_t *), newSize);
    }

    return obj;
}


/*------------------------------------------------------------------------*/
newtObjRef NewtObjAlloc(newtRefArg r, uint32_t n, uint16_t type, bool literal)
{
    newtObjRef  obj;

    obj = NewtObjMemAlloc(NEWT_POOL, n, literal);
    if (obj == NULL) return NULL;

    obj->header.h |= (n << 8) | type;

    if (NEWT_SWEEP)
        obj->header.h |= kNewtObjSweep;

    if ((type & kNewtObjFrame) != 0)
        obj->as.map = r;
    else
        obj->as.klass = r;

    return obj;
}


/*------------------------------------------------------------------------*/
newtObjRef NewtObjRealloc(newtPool pool, newtObjRef obj, uint32_t n)
{
    uint8_t **  datap;
    uint8_t *   data;
    int32_t oldSize;
    int32_t newSize;
    int32_t addSize;

    oldSize = NewtObjCalcDataSize(NewtObjSize(obj));
    newSize = NewtObjCalcDataSize(n);
    addSize = newSize - oldSize;

    if (0 < addSize)
        NewtCheckGC(pool, addSize);

    datap = (uint8_t **)(obj + 1);
    data = NewtMemRealloc(pool, *datap, newSize);
    if (data == NULL) return NULL;

    pool->usesize += addSize;

    if (data != *datap)
        *datap = data;

    obj->header.h = ((n << 8) | (obj->header.h & 0xff));

    return obj;
}


/*------------------------------------------------------------------------*/
newtObjRef NewtObjResize(newtObjRef obj, uint32_t n)
{
    if (NewtObjIsReadonly(obj))
    {
        NewtThrow0(kNErrObjectReadOnly);
        return NULL;
    }

    return NewtObjRealloc(NEWT_POOL, obj, n);
}


/*------------------------------------------------------------------------*/
void * NewtObjData(newtObjRef obj)
{
    void *  data;

    data = (void *)(obj + 1);

    if (NewtObjIsLiteral(obj))
        return data;
    else
        return *((void **)data);
}


/*------------------------------------------------------------------------*/
newtRef NewtObjClone(newtRefArg r)
{
    newtObjRef  obj;

    obj = NewtRefToPointer(r);

    if (obj != NULL)
    {
        newtObjRef  newObj = NULL;
        uint32_t    size;
        uint16_t    type;

        size = NewtObjSize(obj);
        type = NewtObjType(obj);

        switch (NewtGetObjectType(obj, true))
        {
            case kNewtSymbol:
            case kNewtReal:
                return r;

            case kNewtFrame:
                {
                    newtRefVar  map;

                    if (NewtRefIsLiteral(obj->as.map))
                        map = obj->as.map;
                    else
                        map = NcClone(obj->as.map);

                    newObj = NewtObjAlloc(map, size, type, false);
                }
                break;

            default:
                newObj = NewtObjAlloc(obj->as.klass, size, type, false);
                break;
        }

        if (newObj != NULL)
        {
            uint8_t *   src;
            uint8_t *   dst;

            src = NewtObjToBinary(obj);
            dst = NewtObjToBinary(newObj);
            memcpy(dst, src, size);

            return NewtMakePointer(newObj);
        }
    }

    return (newtRef)r;
}


/*------------------------------------------------------------------------*/
newtRef NewtPackLiteral(newtRefArg r)
{
    newtObjRef  obj;

    if (NewtRefIsLiteral(r))
        return r;

    obj = NewtRefToPointer(r);

    if (obj != NULL)
    {
        newtObjRef  newObj = NULL;
        uint32_t    size;
        uint16_t    type;

        size = NewtObjSize(obj);
        type = NewtObjType(obj);

        if (NewtObjIsFrame(obj))
        {
            obj->as.map = NewtPackLiteral(obj->as.map);
            newObj = NewtObjAlloc(obj->as.map, size, type, true);
        }
        else
        {
            newObj = NewtObjAlloc(obj->as.klass, size, type, true);
        }

        if (newObj != NULL)
        {
            uint8_t *   src;
            uint8_t *   dst;

            src = NewtObjToBinary(obj);
            dst = NewtObjToBinary(newObj);
            memcpy(dst, src, size);

            if (NewtObjIsSlotted(newObj))
            {
                newtRef *   slots;
                uint32_t    len;
                uint32_t    i;

                len = NewtObjSlotsLength(newObj);
                slots = NewtObjToSlots(newObj);

                for (i = 0; i < len; i++)
                {
                    slots[i] = NewtPackLiteral(slots[i]);
                }
            }

            newObj->header.h |= kNewtObjLiteral;

            // obj を free してはいけない
            // GC にまかせる

            return NewtMakePointer(newObj);
        }
    }

    return (newtRef)r;
}


#pragma mark -
/*------------------------------------------------------------------------*/
void NewtGetObjData(newtRefArg r, uint8_t * data, uint32_t len)
{
    newtObjRef  obj;
    uint8_t *   objData;

    obj = NewtRefToPointer(r);
    objData = NewtObjToBinary(obj);

    memcpy(data, objData, len);
}


#pragma mark -
/*------------------------------------------------------------------------*/
bool NewtRefIsLiteral(newtRefArg r)
{
    if (NewtRefIsPointer(r))
    {
        newtObjRef  obj;

        obj = NewtRefToPointer(r);

        return NewtObjIsLiteral(obj);
    }

    return true;
}


/*------------------------------------------------------------------------*/
bool NewtRefIsSweep(newtRefArg r, bool mark)
{
    if (NewtRefIsPointer(r))
    {
        newtObjRef  obj;

        obj = NewtRefToPointer(r);

        return NewtObjIsSweep(obj, mark);
    }

    return true;
}


/*------------------------------------------------------------------------*/
bool NewtRefIsNIL(newtRefArg r)
{
    return (kNewtRefNIL == r || kNewtRefUnbind == r);
}


/*------------------------------------------------------------------------*/
bool NewtRefIsSymbol(newtRefArg r)
{
    return (kNewtSymbol == NewtGetRefType(r, true));
}


/*------------------------------------------------------------------------*/
uint32_t NewtRefToHash(newtRefArg r)
{
    newtSymDataRef  sym;

    sym = NewtRefToSymbol(r);

    if (sym != NULL)
        return sym->hash;
    else
        return 0;
}


/*------------------------------------------------------------------------*/
bool NewtRefIsString(newtRefArg r)
{
    return (kNewtString == NewtGetRefType(r, true));
}


/*------------------------------------------------------------------------*/
bool NewtRefIsInteger(newtRefArg r)
{
    return (NewtRefIsInt30(r) || NewtRefIsInt32(r));
}


/*------------------------------------------------------------------------*/
int32_t NewtRefToInteger(newtRefArg r)
{
    int32_t v = 0;

    if (NewtRefIsInt30(r))
        v = NewtRefToInt30(r);
    else
        NewtGetObjData(r, (uint8_t *)&v, sizeof(v));

    return v;
}


/*------------------------------------------------------------------------*/
bool NewtRefIsInt32(newtRefArg r)
{
    return (kNewtInt32 == NewtGetRefType(r, true));
}


/*------------------------------------------------------------------------*/
bool NewtRefIsReal(newtRefArg r)
{
    return (kNewtReal == NewtGetRefType(r, true));
}


/*------------------------------------------------------------------------*/
double NewtRefToReal(newtRefArg r)
{
    double  v = 0.0;

    if (NewtRefIsInteger(r))
        v = NewtRefToInteger(r);
    else
        NewtGetObjData(r, (uint8_t *)&v, sizeof(v));

    return v;
}


/*------------------------------------------------------------------------*/
bool NewtRefIsBinary(newtRefArg r)
{
    if (NewtRefIsPointer(r))
    {
        uint16_t    type;

        type = NewtGetObjectType(NewtRefToPointer(r), false);

        return (type == kNewtBinary);
    }

    return false;
}


/*------------------------------------------------------------------------*/
void * NewtRefToData(newtRefArg r)
{
    newtObjRef  obj;

    obj = NewtRefToPointer(r);

    return NewtObjData(obj);
}


/*------------------------------------------------------------------------*/
bool NewtRefIsArray(newtRefArg r)
{
    return (NewtGetRefType(r, true) == kNewtArray);
}


/*------------------------------------------------------------------------*/
bool NewtRefIsFrame(newtRefArg r)
{
    return (NewtGetRefType(r, true) == kNewtFrame);
}


/*------------------------------------------------------------------------*/
bool NewtRefIsFrameOrArray(newtRefArg r)
{
    uint16_t    type;

    type = NewtGetRefType(r, true);
    return (type == kNewtFrame || type == kNewtArray);
}


/*------------------------------------------------------------------------*/
bool NewtRefIsImmediate(newtRefArg r)
{
#ifdef __NAMED_MAGIC_POINTER__
    if (NewtRefIsMagicPointer(r))
        return false;
#endif /* __NAMED_MAGIC_POINTER__ */

    return ! NewtRefIsPointer(r);
}


/*------------------------------------------------------------------------*/
bool NewtRefIsCodeBlock(newtRefArg r)
{
    if (NewtRefIsFrame(r))
    {
        newtRefVar  klass;

        klass = NcClassOf(r);

        if (NewtRefEqual(klass, NSSYM0(CodeBlock)))
            return true;
    }

    return false;
}


/*------------------------------------------------------------------------*/
bool NewtRefIsNativeFn(newtRefArg r)
{
    if (NewtRefIsFrame(r))
        return NewtRefEqual(NcClassOf(r), NSSYM0(_function.native0));
    else
        return false;
}


/*------------------------------------------------------------------------*/
bool NewtRefIsNativeFunc(newtRefArg r)
{
    if (NewtRefIsFrame(r))
        return NewtRefEqual(NcClassOf(r), NSSYM0(_function.native));
    else
        return false;
}


/*------------------------------------------------------------------------*/
bool NewtRefIsFunction(newtRefArg r)
{
    return (NewtRefFunctionType(r) != kNewtNotFunction);
}


/*------------------------------------------------------------------------*/
int NewtRefFunctionType(newtRefArg r)
{
    if (NewtRefIsFrame(r))
    {
        newtRefVar  klass;

        klass = NcClassOf(r);

        if (NewtRefEqual(klass, NSSYM0(CodeBlock)))
            return kNewtCodeBlock;

        if (NewtRefEqual(klass, NSSYM0(_function.native0)))
            return kNewtNativeFn;

        if (NewtRefEqual(klass, NSSYM0(_function.native)))
            return kNewtNativeFunc;
    }

    return kNewtNotFunction;
}


/*------------------------------------------------------------------------*/
bool NewtRefIsRegex(newtRefArg r)
{
    if (NewtRefIsFrame(r))
    {
        newtRefVar  klass;

        klass = NcClassOf(r);

        if (NewtRefEqual(klass, NSSYM0(regex)))
            return true;
    }

    return false;
}


/*------------------------------------------------------------------------*/
void * NewtRefToAddress(newtRefArg r)
{
    if (NewtRefIsInteger(r))
        return (void *)(((uint32_t)NewtRefToInteger(r)) << NOBJ_ADDR_SHIFT);
    else
        return NULL;
}


#pragma mark -
/*------------------------------------------------------------------------*/
newtRef NewtMakeBinary(newtRefArg klass, uint8_t * data, uint32_t size, bool literal)
{
    newtObjRef  obj;

    obj = NewtObjAlloc(klass, size, 0, literal);

    if (obj != NULL)
    {
        uint8_t *   objData;

        objData = NewtObjToBinary(obj);

        if (data != NULL && 0 < size)
        {
            uint32_t    setlen;

            setlen = NewtObjSize(obj) - size;

            if (0 < setlen)
                memset(objData + size, 0, setlen);

            memcpy(objData, data, size);
        }
        else
        {
            memset(objData, 0, NewtObjSize(obj));
        }

        return NewtMakePointer(obj);
    }

    return kNewtRefUnbind;
}


/*------------------------------------------------------------------------*/
newtObjRef NewtObjBinarySetLength(newtObjRef obj, uint32_t n)
{
    return NewtObjResize(obj, n);
}


/*------------------------------------------------------------------------*/
newtRef NewtBinarySetLength(newtRefArg r, uint32_t n)
{
    newtObjRef  obj;

    obj = NewtRefToPointer(r);
    NewtObjBinarySetLength(obj, n);

    return r;
}


/*------------------------------------------------------------------------*/
newtRef NewtMakeSymbol(const char *s)
{
    return NewtLookupSymbolTable(s);
}


/*------------------------------------------------------------------------*/
uint32_t NewtObjSymbolLength(newtObjRef obj)
{
    newtSymDataRef  sym;

    sym = NewtObjToSymbol(obj);
    return strlen(sym->name);
}


/*------------------------------------------------------------------------*/
newtRef NewtMakeString(const char *s, bool literal)
{
    return NewtMakeBinary(NSSYM0(string), (uint8_t *)s, strlen(s) + 1, literal); 
}


/*------------------------------------------------------------------------*/
newtRef NewtMakeString2(const char *s, uint32_t len, bool literal)
{
    newtRefVar  r;

    r = NewtMakeBinary(NSSYM0(string), (uint8_t *)s, len + 1, literal); 

    if (NewtRefIsNotNIL(r))
    {
        char *  objData;

        objData = NewtRefToString(r);

        if (s != NULL && 0 < len)
        {
//          strncpy(objData, s, len);
            objData[len] = '0';
        }
        else
        {
            objData[0] = '0';
        }
    }

    return r;
}


/*------------------------------------------------------------------------*/
uint32_t NewtObjStringLength(newtObjRef obj)
{
    char *  s;

    s = NewtObjToString(obj);
    return strlen(s);
}


/*------------------------------------------------------------------------*/
newtObjRef NewtObjStringSetLength(newtObjRef obj, uint32_t n)
{
    return NewtObjBinarySetLength(obj, n + 1);
}


/*------------------------------------------------------------------------*/
newtRef NewtStringSetLength(newtRefArg r, uint32_t n)
{
    newtObjRef  obj;

    obj = NewtRefToPointer(r);
    NewtObjStringSetLength(obj, n);

    return r;
}


/*------------------------------------------------------------------------*/
newtRef NewtMakeInteger(int32_t v)
{
    if (-536870912 <= v && v <= 536870911)
    {   // 30bit 以内の場合
        return NewtMakeInt30(v);
    }
    else
    {
        return NewtMakeInt32(v);
    }
}


/*------------------------------------------------------------------------*/
newtRef NewtMakeInt32(int32_t v)
{
    return NewtMakeBinary(NSSYM0(int32), (uint8_t *)&v, sizeof(v), true); 
}


/*------------------------------------------------------------------------*/
newtRef NewtMakeReal(double v)
{
    return NewtMakeBinary(NSSYM0(real), (uint8_t *)&v, sizeof(v), true); 
}


/*------------------------------------------------------------------------*/
newtRef NewtMakeArray(newtRefArg klass, uint32_t n)
{
    return NewtMakeSlotsObj(klass, n, 0);
}

void NewtMakeInitSlots(newtRefArg r, uint32_t st, uint32_t n, uint32_t step, newtRefVar v[])
{
    if (v != NULL)
    {
        newtRef *   slots;
        uint32_t    i;
    
        slots = NewtRefToSlots(r);
    
        for (i = 0; i < n; i++)
        {
            slots[st + i] = *v;
            v += step;
        }
    }
}


/*------------------------------------------------------------------------*/
newtRef NewtMakeArray2(newtRefArg klass, uint32_t n, newtRefVar v[])
{
    newtRefVar  r;

    r = NewtMakeSlotsObj(klass, n, 0);

    if (NewtRefIsNotNIL(r))
        NewtMakeInitSlots(r, 0, n, 1, v);

    return r;
}


/*------------------------------------------------------------------------*/
newtRef NewtMakeMap(newtRefArg superMap, uint32_t n, newtRefVar v[])
{
    newtRefVar  r;
    int32_t flags = 0;

    r = NewtMakeSlotsObj(NewtMakeInteger(flags), n + 1, 0);
    NewtSetArraySlot(r, 0, superMap);

    if (NewtRefIsNotNIL(superMap))
    {
        flags = NewtRefToInteger(NcClassOf(superMap));
        flags &=  kNewtMapSorted;
    }

    if (NewtRefIsNotNIL(r) && v != NULL)
    {
//        NewtMakeInitSlots(r, 1, n, 2, v);

        newtRef *   slots;
        uint32_t    i;
    
        slots = NewtRefToSlots(r);
    
        for (i = 1; i <= n; i++)
        {
            slots[i] = *v;

            if (slots[i] == NSSYM0(_proto))
                flags |= kNewtMapProto;

            v += 2;
        }
    }

    NcSetClass(r, NewtMakeInteger(flags));

    return r;
}


/*------------------------------------------------------------------------*/
void NewtSetMapFlags(newtRefArg map, int32_t bit)
{
    int32_t flags;

    flags = NewtRefToInteger(NcClassOf(map));
    flags |= bit;
    NcSetClass(map, NewtMakeInteger(flags));
}


/*------------------------------------------------------------------------*/
void NewtClearMapFlags(newtRefArg map, int32_t bit)
{
    int32_t flags;

    flags = NewtRefToInteger(NcClassOf(map));
    flags &=  bit;
    NcSetClass(map, NewtMakeInteger(flags));
}


/*------------------------------------------------------------------------*/
uint32_t NewtMapLength(newtRefArg map)
{
    uint32_t    len = 0;
    newtRefVar  r;

    r = (newtRef)map;

    while (NewtRefIsNotNIL(r))
    {
        len += NewtLength(r) - 1;
        r = NewtGetArraySlot(r, 0);
    }

    return len;
}


/*------------------------------------------------------------------------*/
newtRef NewtMakeFrame(newtRefArg map, uint32_t n)
{
    newtRefVar  m;

    m = (newtRef)map;

    if (NewtRefIsNIL(m))
        m = NewtMakeMap(kNewtRefNIL, n, NULL);

    return NewtMakeSlotsObj(m, n, kNewtObjFrame);
}


/*------------------------------------------------------------------------*/
newtRef NewtMakeFrame2(uint32_t n, newtRefVar v[])
{
    newtRefVar  m;
    newtRefVar  r;

    m = NewtMakeMap(kNewtRefNIL, n, v);
    r = NewtMakeFrame(m, n);

    if (NewtRefIsNotNIL(r))
        NewtMakeInitSlots(r, 0, n, 2, v + 1);

    return r;
}


/*------------------------------------------------------------------------*/
newtRef NewtMakeSlotsObj(newtRefArg r, uint32_t n, uint16_t type)
{
    newtObjRef  obj;
    uint32_t    size;

    size = sizeof(newtRef) * n;
    obj = NewtObjAlloc(r, size, kNewtObjSlotted | type, false);

    if (obj != NULL)
    {
        newtRef *   slots;
        uint32_t    i;

        slots = NewtObjToSlots(obj);

        for (i = 0; i < n; i++)
        {
            slots[i] = kNewtRefUnbind;
        }

        return NewtMakePointer(obj);
    }

    return kNewtRefNIL;
}


/*------------------------------------------------------------------------*/
uint32_t NewtObjSlotsLength(newtObjRef obj)
{
    return NewtObjSize(obj) / sizeof(newtRef);
}


/*------------------------------------------------------------------------*/
newtObjRef NewtObjSlotsSetLength(newtObjRef obj, uint32_t n, newtRefArg v)
{
    uint32_t    size;
    uint32_t    len;

    len = NewtObjSlotsLength(obj);
    size = sizeof(newtRef) * n;
    obj = NewtObjResize(obj, size);

    if (obj != NULL)
    {
        newtRef *   slots;
        uint32_t    i;

        slots = NewtObjToSlots(obj);

        for (i = len; i < n; i++)
        {
            slots[i] = v;
        }
    }

    return obj;
}


/*------------------------------------------------------------------------*/
newtRef NewtObjAddArraySlot(newtObjRef obj, newtRefArg v)
{
    uint32_t    len;

    len = NewtObjSlotsLength(obj);
    NewtObjSlotsSetLength(obj, len + 1, v);

    return v;
}


/*------------------------------------------------------------------------*/
newtRef NewtSlotsSetLength(newtRefArg r, uint32_t n, newtRefArg v)
{
    newtObjRef  obj;

    obj = NewtRefToPointer(r);
    NewtObjSlotsSetLength(obj, n, v);

    return r;
}


/*------------------------------------------------------------------------*/
newtRef NewtSetLength(newtRefArg r, uint32_t n)
{
    uint16_t    type;

    type = NewtGetRefType(r, true);

    switch (type)
    {
        case kNewtBinary:
            NewtBinarySetLength(r, n);
            break;

        case kNewtString:
            NewtStringSetLength(r, n);
            break;

        case kNewtArray:
        case kNewtFrame:
            NewtSlotsSetLength(r, n, kNewtRefUnbind);
            break;
    }

    return r;
}


/*------------------------------------------------------------------------*/
newtRef NewtMakeAddress(void * addr)
{
    return NewtMakeInteger(((uint32_t)addr) >> NOBJ_ADDR_SHIFT);
}


#pragma mark -
/*------------------------------------------------------------------------*/
newtRef NewtThrow0(int32_t err)
{
    return NewtThrow(err, kNewtRefUnbind);
}


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