root/NEWT0/trunk/src/newt_core/NewtObj.c

/*------------------------------------------------------------------------*/
/**
 * @file    NewtObj.c
 * @brief   オブジェクトシステム
 *
 * @author  M.Nukui
 * @date    2003-11-07
 *
 * Copyright (C) 2003-2004 M.Nukui All rights reserved.
 */


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

#include "config.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, const 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);


#if 0
#pragma mark -
#endif
/*------------------------------------------------------------------------*/
/** シンボルのハッシュ値を計算
 *
 * @param name      [in] シンボル名
 *
 * @return          ハッシュ値
 */

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;
}


/*------------------------------------------------------------------------*/
/** シンボルオブジェクトの作成
 *
 * @param s         [in] 文字列
 *
 * @return          シンボルオブジェクト
 */

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;
}


/*------------------------------------------------------------------------*/
/** シンボルテーブルの位置検索
 *
 * @param r         [in] シンボルテーブル
 * @param name      [in] シンボル文字列
 * @param hash      [in] ハッシュ値
 * @param st        [in] 開始位置
 * @param indexP    [out]位置
 *
 * @retval          true    成功
 * @retval          false   失敗
 */

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;
}


/*------------------------------------------------------------------------*/
/** シンボルのルックアップ
 *
 * @param r         [in] シンボルテーブル
 * @param name      [in] シンボル文字列
 * @param hash      [in] ハッシュ値
 * @param st        [in] 開始位置
 *
 * @return          シンボルオブジェクト
 *
 * @note            未登録の場合はシンボルオブジェクトを作成しシンボルテーブルに登録する
 */

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;
}


/*------------------------------------------------------------------------*/
/** シンボルのルックアップ
 *
 * @param r         [in] シンボルテーブル
 * @param name      [in] シンボル文字列
 * @param st        [in] 開始位置
 *
 * @return          シンボルオブジェクト
 */

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;
}


/**
 * Return the ASCII string associated with a symbol ref.
 * Remark: doesn't check that the passed object is indeed a symbol.
 *
 * @param inSymbol  symbol object
 * @return a pointer to the name of the symbol
 */
 
const char* NewtSymbolGetName(newtRefArg inSymbol)
{
    return NewtRefToSymbol(inSymbol)->name;
}


#if 0
#pragma mark -
#endif
/*------------------------------------------------------------------------*/
/** オブジェクトのオブジェクトタイプの取得
 *
 * @param r         [in] オブジェクト
 * @param detail    [in] リテラルフラグ
 *
 * @return          オブジェクトタイプ
 */

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;
}


/*------------------------------------------------------------------------*/
/** オブジェクトデータのオブジェクトタイプの取得
 *
 * @param obj       [in] オブジェクトデータ
 * @param detail    [in] ディテイルフラグ
 *
 * @return          オブジェクトタイプ
 */

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;
}


#if 0
#pragma mark -
#endif
/*------------------------------------------------------------------------*/
/** オブジェクトデータの実データサイズを計算
 *
 * @param n         [in] データサイズ
 *
 * @return          実データサイズ
 */

uint32_t NewtObjCalcDataSize(uint32_t n)
{
    if (n < 4)
        return 4;
    else
        return n;
}


/*------------------------------------------------------------------------*/
/** オブジェクトデータのメモリ確保
 *
 * @param pool      [in] メモリプール
 * @param n         [in] データサイズ
 * @param literal   [in] リテラルフラグ
 *
 * @return          オブジェクトデータ
 */

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;
}


/*------------------------------------------------------------------------*/
/** オブジェクトのメモリ確保
 *
 * @param r         [in] クラス／マップ
 * @param n         [in] サイズ
 * @param type      [in] オブジェクトタイプ
 * @param literal   [in] リテラルフラグ
 *
 * @return          オブジェクト
 */

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;
}


/*------------------------------------------------------------------------*/
/** オブジェクトデータのメモリ再確保
 *
 * @param pool      [in] メモリプール
 * @param obj       [in] オブジェクトデータ
 * @param n         [in] サイズ
 *
 * @return          オブジェクトデータ
 */

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;
}


/*------------------------------------------------------------------------*/
/** オブジェクトデータのサイズ変更
 *
 * @param obj       [in] オブジェクトデータ
 * @param n         [in] サイズ
 *
 * @return          オブジェクトデータ
 */

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

    return NewtObjRealloc(NEWT_POOL, obj, n);
}


/*------------------------------------------------------------------------*/
/** オブジェクトデータのデータ部を取得
 *
 * @param obj       [in] オブジェクトデータ
 *
 * @return          データ部
 */

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

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

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


/*------------------------------------------------------------------------*/
/** オブジェクのクローン複製
 *
 * @param r         [in] オブジェクト
 *
 * @return          クローン複製されたオブジェクト
 */

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;
}


/*------------------------------------------------------------------------*/
/** オブジェクのリテラル化
 *
 * @param r         [in] オブジェクト
 *
 * @return          リテラル化されたオブジェクト
 */

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;
}


#if 0
#pragma mark -
#endif
/*------------------------------------------------------------------------*/
/** オブジェクのデータ部をバッファに取出す
 *
 * @param r         [in] オブジェクト
 * @param data      [out]バッファ
 * @param len       [in] バッファ長
 *
 * @return          なし
 */

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);
}


#if 0
#pragma mark -
#endif
/*------------------------------------------------------------------------*/
/** オブジェクトがリテラルかチェックする
 *
 * @param r         [in] オブジェクト
 *
 * @retval          true    リテラル
 * @retval          false   リテラルでない
 */

bool NewtRefIsLiteral(newtRefArg r)
{
    if (NewtRefIsPointer(r))
    {
        newtObjRef  obj;

        obj = NewtRefToPointer(r);

        return NewtObjIsLiteral(obj);
    }

    return true;
}


/*------------------------------------------------------------------------*/
/** オブジェクにスウィープフラグが立っているかチェックする
 *
 * @param r         [in] オブジェクト
 * @param mark      [in] マーク
 *
 * @retval          true    スウィープフラグが立っている
 * @retval          false   スウィープフラグが立っていない
 */

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

        obj = NewtRefToPointer(r);

        return NewtObjIsSweep(obj, mark);
    }

    return true;
}


/*------------------------------------------------------------------------*/
/** オブジェクトが NIL かチェックする
 *
 * @param r         [in] オブジェクト
 *
 * @retval          true    NIL または #UNBIND
 * @retval          false   NIL でない
 */

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


/*------------------------------------------------------------------------*/
/** オブジェクトがシンボルかチェックする
 *
 * @param r         [in] オブジェクト
 *
 * @retval          true    シンボル
 * @retval          false   シンボルでない
 */

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


/*------------------------------------------------------------------------*/
/** オブジェクトのハッシュ値を取得する
 *
 * @param r         [in] オブジェクト
 *
 * @return          ハッシュ値
 */

uint32_t NewtRefToHash(newtRefArg r)
{
    newtSymDataRef  sym;

    sym = NewtRefToSymbol(r);

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


/*------------------------------------------------------------------------*/
/** オブジェクトが文字列かチェックする
 *
 * @param r         [in] オブジェクト
 *
 * @retval          true    文字列
 * @retval          false   文字列でない
 */

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


/*------------------------------------------------------------------------*/
/** オブジェクトが整数かチェックする
 *
 * @param r         [in] オブジェクト
 *
 * @retval          true    整数
 * @retval          false   整数でない
 */

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


/*------------------------------------------------------------------------*/
/** 整数オブジェクを整数にする
 *
 * @param r         [in] オブジェクト
 *
 * @return          整数
 */

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;
}


/*------------------------------------------------------------------------*/
/** オブジェクトが32bit整数かチェックする
 *
 * @param r         [in] オブジェクト
 *
 * @retval          true    32bit整数
 * @retval          false   32bit整数でない
 */

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


/*------------------------------------------------------------------------*/
/** オブジェクトが浮動小数点かチェックする
 *
 * @param r         [in] オブジェクト
 *
 * @retval          true    浮動小数点
 * @retval          false   浮動小数点でない
 */

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


/*------------------------------------------------------------------------*/
/** 数値オブジェクを浮動小数点にする
 *
 * @param r         [in] オブジェクト
 *
 * @return          浮動小数点
 */

double NewtRefToReal(newtRefArg r)
{
    double  v = 0.0;

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

    return v;
}


/*------------------------------------------------------------------------*/
/** オブジェクトがバイナリオブジェクトかチェックする
 *
 * @param r         [in] オブジェクト
 *
 * @retval          true    バイナリオブジェクト
 * @retval          false   バイナリオブジェクトでない
 */

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

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

        return (type == kNewtBinary);
    }

    return false;
}


/*------------------------------------------------------------------------*/
/** オブジェクトのオブジェクトデータを取得する
 *
 * @param r         [in] オブジェクト
 *
 * @return          オブジェクトデータ
 */

void * NewtRefToData(newtRefArg r)
{
    newtObjRef  obj;

    obj = NewtRefToPointer(r);

    return NewtObjData(obj);
}


/*------------------------------------------------------------------------*/
/** オブジェクトが配列オブジェクトかチェックする
 *
 * @param r         [in] オブジェクト
 *
 * @retval          true    配列オブジェクト
 * @retval          false   配列オブジェクトでない
 */

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


/*------------------------------------------------------------------------*/
/** オブジェクトがフレームオブジェクトかチェックする
 *
 * @param r         [in] オブジェクト
 *
 * @retval          true    フレームオブジェクト
 * @retval          false   フレームオブジェクトでない
 */

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


/*------------------------------------------------------------------------*/
/** オブジェクトがフレームまたは配列オブジェクトかチェックする
 *
 * @param r         [in] オブジェクト
 *
 * @retval          true    フレームまたは配列オブジェクト
 * @retval          false   フレームまたは配列オブジェクトでない
 */

bool NewtRefIsFrameOrArray(newtRefArg r)
{
    uint16_t    type;

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


/*------------------------------------------------------------------------*/
/** オブジェクトがイミディエイト（即値）かチェックする
 *
 * @param r         [in] オブジェクト
 *
 * @retval          true    イミディエイトである
 * @retval          false   イミディエイトでない
 */

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

    return ! NewtRefIsPointer(r);
}


/*------------------------------------------------------------------------*/
/** オブジェクトがコードブロック（関数オブジェクト）かチェックする
 *
 * @param r         [in] オブジェクト
 *
 * @retval          true    コードブロック
 * @retval          false   コードブロックでない
 */

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

        klass = NcClassOf(r);

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

    return false;
}


/*------------------------------------------------------------------------*/
/** オブジェクトがネイティブ関数（rcvrなし関数オブジェクト）かチェックする
 *
 * @param r         [in] オブジェクト
 *
 * @retval          true    ネイティブ関数
 * @retval          false   ネイティブ関数でない
 */

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


/*------------------------------------------------------------------------*/
/** オブジェクトがネイティブ関数（rcvrあり関数オブジェクト）かチェックする
 *
 * @param r         [in] オブジェクト
 *
 * @retval          true    ネイティブ関数
 * @retval          false   ネイティブ関数でない
 */

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


/*------------------------------------------------------------------------*/
/** オブジェクトが関数オブジェクトかチェックする
 *
 * @param r         [in] オブジェクト
 *
 * @retval          true    関数オブジェクト
 * @retval          false   関数オブジェクトでない
 */

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


/*------------------------------------------------------------------------*/
/** 関数オブジェクトのタイプを取得する
 *
 * @param r         [in] オブジェクト
 *
 * @retval          kNewtNotFunction    関数オブジェクトでない
 * @retval          kNewtCodeBlock      バイトコード関数
 * @retval          kNewtNativeFn       ネイティブ関数（rcvrなし、Old Style）
 * @retval          kNewtNativeFunc     ネイティブ関数（rcvrあり、New Style）
 */

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;