NewtVM.c

説明を見る。

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

#include "NewtErrs.h"
#include "NewtVM.h"
#include "NewtBC.h"
#include "NewtGC.h"
#include "NewtMem.h"
#include "NewtEnv.h"
#include "NewtObj.h"
#include "NewtFns.h"
#include "NewtStr.h"
#include "NewtFile.h"
#include "NewtIO.h"
#include "NewtPrint.h"
#include "NewtNSOF.h"


/* 型宣言 */
typedef void(*instruction_t)(int16_t b);            
typedef void(*simple_instruction_t)(void);          
typedef newtRef(*nvm_func_t)();                     


/* グローバル変数 */
vm_env_t    vm_env;


#pragma mark -
/* マクロ */

#define START_LOCALARGS     3                                       


#define BC                  (vm_env.bc)                             
#define BCLEN               (vm_env.bclen)                          

#define CALLSTACK           ((vm_reg_t *)vm_env.callstack.stackp)   
#define CALLSP              (vm_env.callstack.sp)                   
#define EXCPSTACK           ((vm_excp_t *)vm_env.excpstack.stackp)  
#define EXCPSP              (vm_env.excpstack.sp)                   
#define CURREXCP            (vm_env.currexcp)                       

#define REG                 (vm_env.reg)                            
#define STACK               ((newtRef *)vm_env.stack.stackp)        

#define FUNC                ((REG).func)                            
#define PC                  ((REG).pc)                              
#define SP                  ((REG).sp)                              
#define LOCALS              ((REG).locals)                          
#define RCVR                ((REG).rcvr)                            
#define IMPL                ((REG).impl)                            


#pragma mark -
/* 関数プロトタイプ */

static newtErr      NVMGetExceptionErrCode(newtRefArg r, bool dump);
static newtRef      NVMMakeExceptionFrame(newtRefArg name, newtRefArg data);
static void         NVMClearCurrException(void);

static void         NVMSetFn(newtRefArg fn);
static void         NVMNoStackFrameForReturn(void);

static void         reg_rewind(int32_t sp);
static void         reg_pop(void);
static void         reg_push(int32_t sp);
static void         reg_save(int32_t sp);

static newtRef      stk_pop0(void);
static newtRef      stk_pop(void);
static void         stk_pop_n(int32_t n, newtRef a[]);
static void         stk_remove(uint16_t n);
static newtRef      stk_top(void);
static void         stk_push(newtRefArg value);

static bool         excp_push(newtRefArg sym, newtRefArg pc);
static void         excp_pop(void);
static vm_excp_t *  excp_top(void);
static void         excp_pop_handlers(void);

static newtRef      liter_get(int16_t n);

static newtRef      iter_new(newtRefArg r, newtRefArg deeply);
static void         iter_next(newtRefArg iter);
static bool         iter_done(newtRefArg iter);

static newtRef      NVMMakeArgsArray(uint16_t numArgs);
static void         NVMBindArgs(uint16_t numArgs);
static void         NVMThrowBC(newtErr err, newtRefArg value, int16_t pop, bool push);
static newtErr      NVMFuncCheck(newtRefArg fn, int16_t numArgs);
static void         NVMCallNativeFn(newtRefArg fn, int16_t numArgs);
static void         NVMCallNativeFunc(newtRefArg fn, newtRefArg rcvr, int16_t numArgs);
static void         NVMFuncCall(newtRefArg fn, int16_t numArgs);
static void         NVMMessageSend(newtRefArg impl, newtRefArg receiver, newtRefArg fn, int16_t numArgs);

static newtRef      vm_send(int16_t b, newtErr * errP);
static newtRef      vm_resend(int16_t b, newtErr * errP);

static void         si_pop(void);
static void         si_dup(void);
static void         si_return(void);
static void         si_pushself(void);
static void         si_set_lex_scope(void);
static void         si_iternext(void);
static void         si_iterdone(void);
static void         si_pop_handlers(void);

static void         fn_add(void);
static void         fn_subtract(void);
static void         fn_aref(void);
static void         fn_set_aref(void);
static void         fn_equals(void);
static void         fn_not(void);
static void         fn_not_equals(void);
static void         fn_multiply(void);
static void         fn_divide(void);
static void         fn_div(void);
static void         fn_less_than(void);
static void         fn_greater_than(void);
static void         fn_greater_or_equal(void);
static void         fn_less_or_equal(void);
static void         fn_bit_and(void);
static void         fn_bit_or(void);
static void         fn_bit_not(void);
static void         fn_new_iterator(void);
static void         fn_length(void);
static void         fn_clone(void);
static void         fn_set_class(void);
static void         fn_add_array_slot(void);
static void         fn_stringer(void);
static void         fn_has_path(void);
static void         fn_classof(void);

static void         is_dummy(int16_t b);
static void         is_simple_instructions(int16_t b);
static void         is_push(int16_t b);
static void         is_push_constant(int16_t b);
static void         is_call(int16_t b);
static void         is_invoke(int16_t b);
static void         is_send(int16_t b);
static void         is_send_if_defined(int16_t b);
static void         is_resend(int16_t b);
static void         is_resend_if_defined(int16_t b);
static void         is_branch(int16_t b);
static void         is_branch_if_true(int16_t b);
static void         is_branch_if_false(int16_t b);
static void         is_find_var(int16_t b);
static void         is_get_var(int16_t b);
static void         is_make_frame(int16_t b);
static void         is_make_array(int16_t b);
static void         is_get_path(int16_t b);
static void         is_set_path(int16_t b);
static void         is_set_var(int16_t b);
static void         is_find_and_set_var(int16_t b);
static void         is_incr_var(int16_t b);
static void         is_branch_if_loop_not_done(int16_t b);
static void         is_freq_func(int16_t b);
static void         is_new_handlers(int16_t b);

static void         NVMDumpInstResult(FILE * f);
static void         NVMDumpInstCode(FILE * f, uint8_t * bc, uint32_t pc, uint16_t len);

static void         NVMInitREG(void);
static void         NVMInitSTACK(void);
static void         NVMCleanSTACK(void);

static void         NVMInitGlobalFns0(void);
static void         NVMInitGlobalFns1(void);
static void         NVMInitExGlobalFns(void);
static void         NVMInitDebugGlobalFns(void);
static void         NVMInitGlobalFns(void);

static void         NVMInitGlobalVars(void);

static void         NVMInit(void);
static void         NVMClean(void);
static void         NVMLoop(uint32_t callsp);

static newtRef      NVMInterpret2(nps_syntax_node_t * stree, uint32_t numStree, newtErr * errP);


/* ローカル変数 */

static simple_instruction_t simple_instructions[] =
            {
                si_pop,             // 000 pop
                si_dup,             // 001 dup
                si_return,          // 002 return
                si_pushself,        // 003 push-self
                si_set_lex_scope,   // 004 set-lex-scope
                si_iternext,        // 005 iter-next
                si_iterdone,        // 006 iter-done
                si_pop_handlers     // 007 000 001 pop-handlers
            };


static simple_instruction_t fn_instructions[] =
            {
                fn_add,                 //  0 add               |+|
                fn_subtract,            //  1 subtract          |-|
                fn_aref,                //  2 aref              aref
                fn_set_aref,            //  3 set-aref          setAref
                fn_equals,              //  4 equals            |=|
                fn_not,                 //  5 not               |not|
                fn_not_equals,          //  6 not-equals        |<>|
                fn_multiply,            //  7 multiply          |*|
                fn_divide,              //  8 divide            |/|
                fn_div,                 //  9 div               |div|
                fn_less_than,           // 10 less-than         |<|
                fn_greater_than,        // 11 greater-than      |>|
                fn_greater_or_equal,    // 12 greater-or-equal  |>=|
                fn_less_or_equal,       // 13 less-or-equal     |<=|
                fn_bit_and,             // 14 bit-and           BAnd
                fn_bit_or,              // 15 bit-or            BOr
                fn_bit_not,             // 16 bit-not           BNot
                fn_new_iterator,        // 17 new-iterator      newIterator
                fn_length,              // 18 length            Length
                fn_clone,               // 19 clone             Clone
                fn_set_class,           // 20 set-class         SetClass
                fn_add_array_slot,      // 21 add-array-slot    AddArraySlot
                fn_stringer,            // 22 stringer          Stringer
                fn_has_path,            // 23 has-path          none
                fn_classof              // 24 class-of          ClassOf
            };

static instruction_t    is_instructions[] =
            {
                is_simple_instructions,     // 00x simple instructions
                is_dummy,                   // 01x
                is_dummy,                   // 02x
                is_push,                    // 03x push
                is_push_constant,           // 04x (B signed) push-constant
                is_call,                    // 05x call
                is_invoke,                  // 06x invoke
                is_send,                    // 07x send
                is_send_if_defined,         // 10x send-if-defined
                is_resend,                  // 11x resend
                is_resend_if_defined,       // 12x resend-if-defined
                is_branch,                  // 13x branch
                is_branch_if_true,          // 14x branch-if-true
                is_branch_if_false,         // 15x branch-if-false
                is_find_var,                // 16x find-var
                is_get_var,                 // 17x get-var
                is_make_frame,              // 20x make-frame
                is_make_array,              // 21x make-array
                is_get_path,                // 220/221 get-path
                is_set_path,                // 230/231 set-path
                is_set_var,                 // 24x set-var
                is_find_and_set_var,        // 25x find-and-set-var
                is_incr_var,                // 26x incr-var
                is_branch_if_loop_not_done, // 27x branch-if-loop-not-done
                is_freq_func,               // 30x freq-func
                is_new_handlers             // 31x new-handlers
            };

static char *   simple_instruction_names[] =
            {
                "pop",              // 000 pop
                "dup",              // 001 dup
                "return",           // 002 return
                "push-self",        // 003 push-self
                "set-lex-scope",    // 004 set-lex-scope
                "iter-next",        // 005 iter-next
                "iter-done",        // 006 iter-done
                "pop-handlers"      // 007 000 001 pop-handlers
            };

static char *   fn_instruction_names[] =
            {
                "add",              //  0 add       |+|
                "subtract",         //  1 subtract      |-|
                "aref",             //  2 aref      aref
                "set-aref",         //  3 set-aref      setAref
                "equals",           //  4 equals        |=|
                "not",              //  5 not       |not|
                "not-equals",       //  6 not-equals    |<>|
                "multiply",         //  7 multiply      |*|
                "divide",           //  8 divide        |/|
                "div",              //  9 div       |div|
                "less-than",        // 10 less-than     |<|
                "greater-than",     // 11 greater-than  |>|
                "greateror-equal",  // 12 greater-or-equal  |>=|
                "lessor-equal",     // 13 less-or-equal |<=|
                "bit-and",          // 14 bit-and       BAnd
                "bit-or",           // 15 bit-or        BOr
                "bit-not",          // 16 bit-not       BNot
                "new-iterator",     // 17 new-iterator  newIterator
                "length",           // 18 length        Length
                "clone",            // 19 clone     Clone
                "set-class",        // 20 set-class     SetClass
                "add-array-slot",   // 21 add-array-slot    AddArraySlot
                "stringer",         // 22 stringer      Stringer
                "has-path",         // 23 has-path      none
                "class-of"          // 24 class-of      ClassOf
            };

static char *   vm_instruction_names[] =
            {
                "simple-instructions",      // 00x simple instructions
                NULL,                       // 01x
                NULL,                       // 02x
                "push",                     // 03x push
                "push-constant",            // 04x (B signed) push-constant
                "call",                     // 05x call
                "invoke",                   // 06x invoke
                "send",                     // 07x send
                "send-if-defined",          // 10x send-if-defined
                "resend",                   // 11x resend
                "resend-if-defined",        // 12x resend-if-defined
                "branch",                   // 13x branch
                "branch-if-true",           // 14x branch-if-true
                "branch-if-false",          // 15x branch-if-false
                "find-var",                 // 16x find-var
                "get-var",                  // 17x get-var
                "make-frame",               // 20x make-frame
                "make-array",               // 21x make-array
                "get-path",                 // 220/221 get-path
                "set-path",                 // 230/231 set-path
                "set-var",                  // 24x set-var
                "find-and-set-var",         // 25x find-and-set-var
                "incr-var",                 // 26x incr-var
                "branch-if-loop-not-done",  // 27x branch-if-loop-not-done
                "freq-func",                // 30x freq-func
                "new-handlers"              // 31x new-handlers
            };


#pragma mark -
/*------------------------------------------------------------------------*/
newtRef NVMSelf(void)
{
    return RCVR;
}


/*------------------------------------------------------------------------*/
newtRef NVMCurrentFunction(void)
{
    return FUNC;
}


/*------------------------------------------------------------------------*/
newtRef NVMCurrentImplementor(void)
{
    return IMPL;
}


/*------------------------------------------------------------------------*/
bool NVMHasVar(newtRefArg name)
{
    if (NewtHasLexical(LOCALS, name))
        return true;

    if (NewtHasVariable(RCVR, name))
        return true;

    if (NewtHasGlobalVar(name))
        return true;

    return false;
}


/*------------------------------------------------------------------------*/
newtErr NVMGetExceptionErrCode(newtRefArg r, bool dump)
{
    newtRefVar  err;

    if (NewtRefIsNIL(r))
        return kNErrNone;

    if (dump)
        NewtPrintObject(stderr, r);

    err = NcGetSlot(r, NSSYM0(error));

    if (NewtRefIsNotNIL(err))
        return NewtRefToInteger(err);

    return kNErrBadExceptionName;
}


/*------------------------------------------------------------------------*/
newtRef NVMMakeExceptionFrame(newtRefArg name, newtRefArg data)
{
    newtRefVar  r;

    r = NcMakeFrame();
    NcSetSlot(r, NSSYM0(name), name);

    if (NewtHasSubclass(name, NSSYM0(type.ref)))
        NcSetSlot(r, NSSYM0(data), data);
    else if (NewtHasSubclass(name, NSSYM0(ext.ex.msg)))
        NcSetSlot(r, NSSYM0(message), data);
    else
        NcSetSlot(r, NSSYM0(error), data);

    return r;
}


/*------------------------------------------------------------------------*/
void NVMThrowData(newtRefArg name, newtRefArg data)
{
    vm_excp_t * excp;
    uint32_t    i;

    // 例外処理中ならクリアする
    NVMClearCurrException();

    CURREXCP = data;

    for (i = EXCPSP; 0 < i; i--)
    {
        excp = &EXCPSTACK[i - 1];

        if (NewtHasSubclass(name, excp->sym))
        {
            reg_rewind(excp->callsp);
            PC = excp->pc;
            return;
        }
    }

    NVMNoStackFrameForReturn();
}


/*------------------------------------------------------------------------*/
void NVMThrow(newtRefArg name, newtRefArg data)
{
    newtRefVar  r;

    r = NVMMakeExceptionFrame(name, data);
    NVMThrowData(name, r);
}


/*------------------------------------------------------------------------*/
void NVMRethrow(void)
{
    if (NewtRefIsNotNIL(CURREXCP))
    {
        newtRefVar  currexcp;
        newtRefVar  name;

        currexcp = CURREXCP;
        name = NcGetSlot(currexcp, NSSYM0(name));

//        excp_pop_handlers();
        NVMThrowData(name, currexcp);
    }
}


/*------------------------------------------------------------------------*/
newtRef NVMCurrentException(void)
{
    return CURREXCP;
}


/*------------------------------------------------------------------------*/
void NVMClearCurrException(void)
{
    if (NewtRefIsNotNIL(CURREXCP))
    {
        excp_pop_handlers();
        CURREXCP = kNewtRefUnbind;
    }
}


/*------------------------------------------------------------------------*/
void NVMClearException(void)
{
    CURREXCP = kNewtRefUnbind;
}


#pragma mark -
/*------------------------------------------------------------------------*/
void NVMSetFn(newtRefArg fn)
{
    FUNC = fn;

    if (NewtRefIsNIL(FUNC) || ! NewtRefIsCodeBlock(FUNC))
    {
        BC = NULL;
        BCLEN = 0;
    }
    else
    {
        newtRefVar  instr;

        instr = NcGetSlot(FUNC, NSSYM0(instructions));
        BC = NewtRefToBinary(instr);
        BCLEN = NewtLength(instr);
    }
}


/*------------------------------------------------------------------------*/
void NVMNoStackFrameForReturn(void)
{
    BC = NULL;
    BCLEN = 0;
    CALLSP = 0;
}


#pragma mark *** 呼出しスタック
/*------------------------------------------------------------------------*/
void reg_rewind(int32_t sp)
{
    if (sp == CALLSP)
        return;

    if (sp < CALLSP)
    {
        CALLSP = sp;
        REG = CALLSTACK[CALLSP];
        NVMSetFn(FUNC);
    }
    else
    {
        NVMNoStackFrameForReturn();
    }
}


/*------------------------------------------------------------------------*/
void reg_pop(void)
{
    reg_rewind(CALLSP - 1);
}


/*------------------------------------------------------------------------*/
void reg_push(int32_t sp)
{
    if (! NewtStackExpand(&vm_env.callstack, CALLSP + 1))
        return;

    CALLSTACK[CALLSP] = REG;
    CALLSTACK[CALLSP].sp = sp;
    CALLSP++;
}


/*------------------------------------------------------------------------*/
void reg_save(int32_t sp)
{
//    PC++;
    reg_push(sp);
}


#pragma mark *** スタック
/*------------------------------------------------------------------------*/
newtRef stk_pop0(void)
{
    newtRefVar  x = kNewtRefUnbind;

    if (0 < SP)
    {
        SP--;
        x = STACK[SP];
    }

    return x;
}


/*------------------------------------------------------------------------*/
newtRef stk_pop(void)
{
    return NcResolveMagicPointer(stk_pop0());
}


/*------------------------------------------------------------------------*/
void stk_pop_n(int32_t n, newtRef a[])
{
    for (n--; 0 <= n; n--)
    {
        a[n] = stk_pop();
    }
}


/*------------------------------------------------------------------------*/
void stk_remove(uint16_t n)
{
    if (n < SP)
        SP -= n;
    else
        SP = 0;
}


/*------------------------------------------------------------------------*/
newtRef stk_top(void)
{
    if (0 < SP)
        return STACK[SP - 1];
    else
        return kNewtRefNIL;
}


/*------------------------------------------------------------------------*/
void stk_push(newtRefArg value)
{
    if (! NewtStackExpand(&vm_env.stack, SP + 1))
        return;

    STACK[SP] = value;
    SP++;
}


#pragma mark *** 例外ハンドラスタック
/*------------------------------------------------------------------------*/
bool excp_push(newtRefArg sym, newtRefArg pc)
{
    vm_excp_t * excp;

    if (! NewtRefIsSymbol(sym))
        return false;

    if (! NewtRefIsInteger(pc))
        return false;

    if (! NewtStackExpand(&vm_env.excpstack, EXCPSP + 1))
        return false;

    excp = &EXCPSTACK[EXCPSP];

    excp->callsp = CALLSP;
    excp->excppc = PC;
    excp->sym = sym;
    excp->pc = NewtRefToInteger(pc);

    EXCPSP++;

    return true;
}

/*------------------------------------------------------------------------*/
void excp_pop(void)
{
    if (0 < EXCPSP)
        EXCPSP--;
}

/*------------------------------------------------------------------------*/
vm_excp_t * excp_top(void)
{
    if (0 < EXCPSP)
        return &EXCPSTACK[EXCPSP - 1];
    else
        return NULL;
}


/*------------------------------------------------------------------------*/
void excp_pop_handlers(void)
{
    vm_excp_t * excp;

    excp = excp_top();

    if (excp != NULL)
    {
        uint32_t    excppc;

        excppc = excp->excppc;

        while (excp != NULL)
        {
            if (excp->excppc != excppc)
                break;

            excp_pop();
            excp = excp_top();
        }
    }
}


#pragma mark *** Literals
/*------------------------------------------------------------------------*/
newtRef liter_get(int16_t n)
{
    newtRefVar  literals;

    literals = NcGetSlot(FUNC, NSSYM0(literals));

    if (NewtRefIsNotNIL(literals))
        return NewtGetArraySlot(literals, n);
    else
        return kNewtRefNIL;
}


#pragma mark *** Iterator
/*------------------------------------------------------------------------*/
newtRef iter_new(newtRefArg r, newtRefArg deeply)
{
    newtRefVar  iter;

    iter = NewtMakeArray(NSSYM0(forEachState), kIterALength);

    NewtSetArraySlot(iter, kIterObj, r);

    if (NewtRefIsNIL(deeply))
        NewtSetArraySlot(iter, kIterDeeply, deeply);
    else
        NewtSetArraySlot(iter, kIterDeeply, NcDeeplyLength(r));

    NewtSetArraySlot(iter, kIterPos, NSINT(-1));
    NewtSetArraySlot(iter, kIterMax, NcLength(r));

    if (NewtRefIsFrame(r))
        NewtSetArraySlot(iter, kIterMap, NewtFrameMap(r));
    else
        NewtSetArraySlot(iter, kIterMap, kNewtRefNIL);

    iter_next(iter);

    return iter;
}


/*------------------------------------------------------------------------*/
void iter_next(newtRefArg iter)
{
    newtRefVar  deeply;
    newtRefVar  obj;
    newtRefVar  index = kNewtRefUnbind;
    newtRefVar  value = kNewtRefUnbind;
    newtRefVar  map;
    int32_t pos;
    int32_t len;

    obj = NewtGetArraySlot(iter, kIterObj);
    deeply = NewtGetArraySlot(iter, kIterDeeply);
    pos = NewtRefToInteger(NewtGetArraySlot(iter, kIterPos));
    len = NewtRefToInteger(NewtGetArraySlot(iter, kIterMax));
    map = NewtGetArraySlot(iter, kIterMap);

    if (NewtRefIsNIL(deeply) || NewtRefIsNIL(map))
    {
        pos++;

        if (pos < len)
        {
            if (NewtRefIsNIL(map))
            {
                index = NewtMakeInteger(pos);
                value = NewtARef(obj, pos);
            }
            else
            {
                index = NewtGetArraySlot(map, pos + 1);
                value = NewtGetFrameSlot(obj, pos);
            }
        }
    }
    else
    {
        while (true)
        {
            pos++;

            if (len <= pos)
            {
                obj = NcGetSlot(obj, NSSYM0(_proto));

                if (NewtRefIsNIL(obj))
                {
                    index = kNewtRefUnbind;
                    break;
                }

                map = NewtFrameMap(obj);
                len = NewtLength(obj);

                NewtSetArraySlot(iter, kIterObj, obj);
                NewtSetArraySlot(iter, kIterMap, map);
                NewtSetArraySlot(iter, kIterMax, NewtMakeInteger(len));

                pos = -1;
                continue;
            }

            index = NewtGetArraySlot(map, pos + 1);

            if (index != NSSYM0(_proto))
            {
                value = NewtGetFrameSlot(obj, pos);
                break;
            }
        }
    }

    NewtSetArraySlot(iter, kIterIndex, index);
    NewtSetArraySlot(iter, kIterPos, NewtMakeInteger(pos));
    NewtSetArraySlot(iter, kIterValue, value);
}


/*------------------------------------------------------------------------*/
bool iter_done(newtRefArg iter)
{
    int32_t pos;
    int32_t len;

    pos = NewtRefToInteger(NewtGetArraySlot(iter, kIterPos));
    len = NewtRefToInteger(NewtGetArraySlot(iter, kIterMax));

    return (len <= pos);
}


#pragma mark -
/*------------------------------------------------------------------------*/
newtRef NVMMakeArgsArray(uint16_t numArgs)
{
    newtRefVar  args;
    int16_t     i;

    args = NewtMakeArray(kNewtRefUnbind, numArgs);

    for (i = numArgs - 1; 0 <= i; i--)
    {
        NewtSetArraySlot(args, i, stk_pop());
    }

    return args;
}


/*------------------------------------------------------------------------*/
void NVMBindArgs(uint16_t numArgs)
{
    newtRefVar  indefinite;
    int32_t     minArgs;
    int16_t     i;
    newtRefVar  v;

    minArgs = NewtRefToInteger(NcGetSlot(FUNC, NSSYM0(numArgs)));
    indefinite = NcGetSlot(FUNC, NSSYM0(indefinite));

    if (NewtRefIsNotNIL(indefinite))
    {
        newtRefVar  args;

        args = NVMMakeArgsArray(numArgs - minArgs);
        NewtSetFrameSlot(LOCALS, START_LOCALARGS + minArgs, args);
    }

    for (i = START_LOCALARGS + minArgs - 1; START_LOCALARGS <= i; i--)
    {
        v = stk_pop();
        NewtSetFrameSlot(LOCALS, i, v);
    }
}


/*------------------------------------------------------------------------*/
void NVMThrowBC(newtErr err, newtRefArg value, int16_t pop, bool push)
{
    stk_remove(pop);

    if (push)
        stk_push(kNewtRefUnbind);

    if (NewtRefIsSymbol(value))
        NewtThrowSymbol(err, value);
    else
        NewtThrow(err, value);
}


/*------------------------------------------------------------------------*/
bool NVMFuncCheckNumArgs(newtRefArg fn, int16_t numArgs)
{
    newtRefVar  indefinite;
    int32_t     minArgs;

    minArgs = NewtRefToInteger(NcGetSlot(fn, NSSYM0(numArgs)));
    indefinite = NcGetSlot(fn, NSSYM0(indefinite));

    if (NewtRefIsNIL(indefinite))
        return (minArgs == numArgs);
    else
        return (minArgs <= numArgs);
}


/*------------------------------------------------------------------------*/
newtErr NVMFuncCheck(newtRefArg fn, int16_t numArgs)
{
    // 1. 関数オブジェクトでなければ例外を発生

    if (! NewtRefIsFunction(fn))
        return kNErrInvalidFunc;

    // 2. 引数の数が一致さなければ WrongNumberOfArgs 例外を発生

    if (! NVMFuncCheckNumArgs(fn, numArgs))
        return kNErrWrongNumberOfArgs;

    return kNErrNone;
}


/*------------------------------------------------------------------------*/
void NVMCallNativeFn(newtRefArg fn, int16_t numArgs)
{
    newtRefVar  r = kNewtRefUnbind;
    newtRefVar  indefinite;
    nvm_func_t  funcPtr;
    int32_t     minArgs;

    funcPtr = (nvm_func_t)NewtRefToAddress(NcGetSlot(fn, NSSYM0(funcPtr)));

    if (funcPtr == NULL)
        return;

    minArgs = NewtRefToInteger(NcGetSlot(fn, NSSYM0(numArgs)));
    indefinite = NcGetSlot(fn, NSSYM0(indefinite));

    if (NewtRefIsNIL(indefinite))
    {
        switch (minArgs)
        {
            case 0:
                r = (*funcPtr)();
                break;

            case 1:
                {
                    newtRefVar  a;

                    a = stk_pop();
                    r = (*funcPtr)(a);
                }
                break;

            case 2:
                {
                    newtRefVar  a[2];

                    stk_pop_n(2, a);
                    r = (*funcPtr)(a[0], a[1]);
                }
                break;

            case 3:
                {
                    newtRefVar  a[3];

                    stk_pop_n(3, a);
                    r = (*funcPtr)(a[0], a[1], a[2]);
                }
                break;

            case 4:
                {
                    newtRefVar  a[4];

                    stk_pop_n(4, a);
                    r = (*funcPtr)(a[0], a[1], a[2], a[3]);
                }
                break;

            case 5:
                {
                    newtRefVar  a[5];

                    stk_pop_n(5, a);
                    r = (*funcPtr)(a[0], a[1], a[2], a[3], a[4]);
                }
                break</