NewtBC.c

説明を見る。

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

#include "NewtCore.h"
#include "NewtBC.h"
#include "NewtVM.h"
#include "NewtIO.h"
#include "NewtMem.h"


/* 型宣言 */

typedef struct nbc_env_t    nbc_env_t;

struct nbc_env_t {
    nbc_env_t * parent;         

    newtStack   bytecode;       
    newtStack   breakstack;     
    newtStack   onexcpstack;    

    newtRefVar  func;           
    newtRefVar  literals;       
    newtRefVar  argFrame;       
    newtRefVar  constant;       
};


typedef struct {
    char *      name;       
    int32_t     numArgs;    
    int16_t     b;          
    newtRefVar  sym;        
} freq_func_t;


/* 関数プロトタイプ */
#define ENV_BC(env)             ((uint8_t*)env->bytecode.stackp)                
#define ENV_CX(env)             (env->bytecode.sp)                              
#define BC                      ENV_BC(newt_bc_env)                             
#define CX                      ENV_CX(newt_bc_env)                             
#define BREAKSTACK              ((uint32_t*)newt_bc_env->breakstack.stackp)     
#define BREAKSP                 (newt_bc_env->breakstack.sp)                    
#define ONEXCPSTACK             ((uint32_t*)newt_bc_env->onexcpstack.stackp)    
#define ONEXCPSP                (newt_bc_env->onexcpstack.sp)                   
#define LITERALS                (newt_bc_env->literals)                         
#define ARGFRAME                (newt_bc_env->argFrame)                         
#define CONSTANT                (newt_bc_env->constant)                         

#define NBCAddLiteral(r)        NBCAddLiteralEnv(newt_bc_env, r)                
#define NBCGenCode(a, b)        NBCGenCodeEnv(newt_bc_env, a, b)                
#define NBCGenCodeL(a, r)       NBCGenCodeEnvL(newt_bc_env, a, r)               
#define NBCGenPushLiteral(r)    NBCGenPushLiteralEnv(newt_bc_env, r)            

#define NBCGenBC_op(stree, r)   NBCGenBC_stmt(stree, r, true)                   
#define NBCGenFreq(b)           NBCGenCode(kNBCFreqFunc, b)                     


#pragma mark -
#pragma mark ローカル変数
/* ローカル変数 */

static nbc_env_t *  newt_bc_env;

static freq_func_t freq_func_tb[] =
    {
//      {"aref",            2,  kNBCAref,           0},
//      {"setAref",         3,  kNBCSetAref,        0},
        {"BAnd",            2,  kNBCBitAnd,         0},
        {"BOr",             2,  kNBCBitOr,          0},
        {"BNot",            1,  kNBCBitNot,         0},
        {"Length",          1,  kNBCLength,         0},
        {"Clone",           1,  kNBCClone,          0},
        {"SetClass",        2,  kNBCSetClass,       0},
        {"AddArraySlot",    2,  kNBCAddArraySlot,   0},
        {"Stringer",        1,  kNBCStringer,       0},
        {"ClassOf",         1,  kNBCClassOf,        0},

        // end
        {NULL,              0,  0,                  0}
    };


#pragma mark -
/* 関数プロトタイプ */
static int16_t          NBCAddLiteralEnv(nbc_env_t * env, newtRefArg r);
static void             NBCGenCodeEnv(nbc_env_t * env, uint8_t a, int16_t b);
static void             NBCGenCodeEnvL(nbc_env_t * env, uint8_t a, newtRefArg r);
static int16_t          NBCGenPushLiteralEnv(nbc_env_t * env, newtRefArg r);

static void             NBCGenPUSH(newtRefArg r);
static void             NBCGenGetVar(nps_syntax_node_t * stree, newtRefArg r);
static void             NBCGenCallFn(newtRefArg fn, int16_t numArgs);
static int16_t          NBCMakeFnArgFrame(newtRefArg argFrame, nps_syntax_node_t * stree, nps_node_t r, bool * indefiniteP);
static int16_t          NBCMakeFnArgs(newtRefArg fn, nps_syntax_node_t * stree, nps_node_t r);
static nbc_env_t *      NBCMakeFnEnv(nps_syntax_node_t * stree, nps_node_t args);
static uint32_t         NBCGenBranch(uint8_t a);
static void             NBCDefLocal(newtRefArg type, newtRefArg r, bool init);
static void             NBCBackPatch(uint32_t cx, int16_t b);
static void             NBCPushBreakStack(uint32_t cx);
static void             NBCBreakBackPatchs(uint32_t loop_head, uint32_t cx);
static void             NBCPushOnexcpStack(uint32_t cx);
static void             NBCOnexcpBackPatchs(uint32_t try_head, uint32_t cx);
static void             NBCGenOnexcpPC(int32_t pc);
static void             NBCGenOnexcpBranch(void);
static void             NBCOnexcpBackPatchL(uint32_t sp, int32_t pc);

static newtRef          NBCMakeFn(nbc_env_t * env);
static void             NBCInitFreqFuncTable(void);
static nbc_env_t *      NBCEnvNew(nbc_env_t * parent);
static void             NBCEnvFree(nbc_env_t * env);
static newtRef          NBCFnDone(nbc_env_t ** envP);

static void             NBCInit(void);
static void             NBCCleanup(void);

static void             NBCGenBC_stmt(nps_syntax_node_t * stree, nps_node_t r, bool ret);
static void             NBCGenConstant(nps_syntax_node_t * stree, nps_node_t r);
static void             NBCGenGlobalVar(nps_syntax_node_t * stree, nps_node_t r);
static void             NBCGenLocalVar(nps_syntax_node_t * stree, nps_node_t type, nps_node_t r);
static bool             NBCTypeValid(nps_node_t type);
static int16_t          NBCGenTryPre(nps_syntax_node_t * stree, nps_node_t r);
static int16_t          NBCGenTryPost(nps_syntax_node_t * stree, nps_node_t r, uint32_t * onexcpspP);
static void             NBCGenTry(nps_syntax_node_t * stree, nps_node_t expr, nps_node_t onexception_list);
static void             NBCGenIfThenElse(nps_syntax_node_t * stree, nps_node_t cond, nps_node_t thenelse, bool ret);
static void             NBCGenAnd(nps_syntax_node_t * stree, nps_node_t op1, nps_node_t op2);
static void             NBCGenOr(nps_syntax_node_t * stree, nps_node_t op1, nps_node_t op2);
static void             NBCGenLoop(nps_syntax_node_t * stree, nps_node_t expr);
static newtRef          NBCMakeTempSymbol(newtRefArg index, newtRefArg val, char * s);
static void             NBCGenFor(nps_syntax_node_t * stree, nps_node_t r, nps_node_t expr);
static void             NBCGenForeach(nps_syntax_node_t * stree, nps_node_t r, nps_node_t expr);
static void             NBCGenWhile(nps_syntax_node_t * stree, nps_node_t cond, nps_node_t expr);
static void             NBCGenRepeat(nps_syntax_node_t * stree, nps_node_t expr, nps_node_t cond);
static void             NBCGenBreak(nps_syntax_node_t * stree, nps_node_t expr);
static void             NBCGenStringer(nps_syntax_node_t * stree, nps_node_t op1, nps_node_t op2, char * dlmt);
static void             NBCGenAsign(nps_syntax_node_t * stree, nps_node_t lvalue, nps_node_t expr, bool ret);
static void             NBCGenExists(nps_syntax_node_t * stree, nps_node_t r);
static void             NBCGenReceiver(nps_syntax_node_t * stree, nps_node_t r);
static void             NBCGenMethodExists(nps_syntax_node_t * stree, nps_node_t receiver, nps_node_t name);
static void             NBCGenFn(nps_syntax_node_t * stree, nps_node_t args, nps_node_t expr);
static void             NBCGenGlobalFn(nps_syntax_node_t * stree, nps_node_t name, nps_node_t fn);
static void             NBCGenCall(nps_syntax_node_t * stree, nps_node_t name, nps_node_t args);
static void             NBCGenInvoke(nps_syntax_node_t * stree, nps_node_t fn, nps_node_t args);
static void             NBCGenFunc2(nps_syntax_node_t * stree, newtRefArg name, nps_node_t op1, nps_node_t op2);
static void             NBCGenSend(nps_syntax_node_t * stree, uint32_t code, nps_node_t receiver, nps_node_t r);
static void             NBCGenResend(nps_syntax_node_t * stree, uint32_t code, nps_node_t name, nps_node_t args);
static void             NBCGenMakeArray(nps_syntax_node_t * stree, nps_node_t klass, nps_node_t r);
static void             NBCGenMakeFrame(nps_syntax_node_t * stree, nps_node_t r);
static void             NVCGenNoResult(bool ret);
static void             NBCGenSyntaxCode(nps_syntax_node_t * stree, nps_syntax_node_t * node, bool ret);
static int16_t          NBCCountNumArgs(nps_syntax_node_t * stree, nps_node_t r);
static newtRef          NBCGenMakeFrameSlots_sub(nps_syntax_node_t * stree, nps_node_t r);
static newtRef          NBCGenMakeFrameSlots(nps_syntax_node_t * stree, nps_node_t r);
static void             NBCGenBC_sub(nps_syntax_node_t * stree, uint32_t n, bool ret);


#pragma mark -
/*------------------------------------------------------------------------*/
int16_t NBCAddLiteralEnv(nbc_env_t * env, newtRefArg r)
{
    int16_t b;

    b = NewtArrayLength(env->literals);
    NcAddArraySlot(env->literals, r);

    return b;
}


/*------------------------------------------------------------------------*/
void NBCGenCodeEnv(nbc_env_t * env, uint8_t a, int16_t b)
{
    uint8_t *   bc;
    uint32_t    cx;

    cx = ENV_CX(env);

    if (! NewtStackExpand(&env->bytecode, cx + 3))
        return;

    bc = ENV_BC(env);

    if (a == kNBCFieldMask)
        b = 1;

    if (a != kNBCFieldMask &&
        ((a & kNBCFieldMask) == a ||
        (b != kNBCFieldMask && (b & kNBCFieldMask) == b)))
    {
        bc[cx++] = a | b;
    }
    else
    {
        bc[cx++] = a | kNBCFieldMask;
        bc[cx++] = b >> 8;
        bc[cx++] = b & 0xff;
    }

    ENV_CX(env) = cx;
}


/*------------------------------------------------------------------------*/
void NBCGenCodeEnvL(nbc_env_t * env, uint8_t a, newtRefArg r)
{
    newtRefVar  obj;
    int16_t b = 0;

    obj = NewtPackLiteral(r);

    // リテラルを検索
    b = NewtFindArrayIndex(env->literals, obj, 0);

    if (b == -1) // リテラルに追加
        b = NBCAddLiteralEnv(env, obj);

    NBCGenCodeEnv(env, a, b);
}


/*------------------------------------------------------------------------*/
int16_t NBCGenPushLiteralEnv(nbc_env_t * env, newtRefArg r)
{
    newtRefVar  obj;
    int16_t b;

    obj = NewtPackLiteral(r);
    b = NBCAddLiteralEnv(env, obj);

    NBCGenCodeEnv(env, kNBCPush, b);

    return b;
}


#pragma mark -
/*------------------------------------------------------------------------*/
void NBCGenPUSH(newtRefArg r)
{
    switch (NewtGetRefType(r, false))
    {
        case kNewtInt30:
            {
                int32_t n;

                n = NewtRefToInteger(r);

                if (-8192 <= n && n <= 8191)
                    NBCGenCode(kNBCPushConstant, r);
                else
                    NBCGenCodeL(kNBCPush, r);
            }
            break;

        case kNewtNil:
        case kNewtTrue:
        case kNewtUnbind:
            NBCGenCode(kNBCPushConstant, r);
            break;

        case kNewtCharacter:
        case kNewtSpecial:
        case kNewtMagicPointer:
            if ((r & 0xffff0000) == 0)
                NBCGenCode(kNBCPushConstant, r);
            else
                NBCGenCodeL(kNBCPush, r);
            break;

        case kNewtPointer:
        default:
            NBCGenCodeL(kNBCPush, r);
            break;
    }
}


/*------------------------------------------------------------------------*/
void NBCGenGetVar(nps_syntax_node_t * stree, newtRefArg r)
{
    if (NewtHasSlot(CONSTANT, r))
    {
        // 定数の場合
        newtRefVar  c;

        c = NcGetSlot(CONSTANT, r);

        if (! NPSRefIsSyntaxNode(c) && NewtRefIsLiteral(c))
            NBCGenPUSH(c);
        else
            NBCGenBC_op(stree, c);
    }
    else
    {
        int16_t b;

        // ローカル変数を検索
        b = NewtFindSlotIndex(ARGFRAME, r);
    
        if (b != -1)
            NBCGenCode(kNBCGetVar, b);
        else
            NBCGenCodeL(kNBCFindVar, r);
    }
}


/*------------------------------------------------------------------------*/
void NBCGenCallFn(newtRefArg fn, int16_t numArgs)
{
    int i;

    // freq-func の場合
    for (i = 0; freq_func_tb[i].name != NULL; i++)
    {
        if (NewtRefEqual(fn, freq_func_tb[i].sym))
        {
            if (numArgs != freq_func_tb[i].numArgs)
            {
                NBError(kNErrWrongNumberOfArgs);
                return;
            }

            NBCGenFreq(freq_func_tb[i].b);
            return;
        }
    }

    // call function
    NBCGenPUSH(fn);
    NBCGenCode(kNBCCall, numArgs);
}


/*------------------------------------------------------------------------*/
int16_t NBCMakeFnArgFrame(newtRefArg argFrame, nps_syntax_node_t * stree, nps_node_t r, bool * indefiniteP)
{
    int16_t numArgs = 1;

    if (r == kNewtRefUnbind)
        return 0;

    if (*indefiniteP == true)
    {
        NBError(kNErrSyntaxError);
        return 0;
    }

    if (NPSRefIsSyntaxNode(r))
    {
        nps_syntax_node_t * node;

        node = &stree[NPSRefToSyntaxNode(r)];

        switch (node->code)
        {
            case kNPSCommaList:
                numArgs = NBCMakeFnArgFrame(argFrame, stree, node->op1, indefiniteP)
                            + NBCMakeFnArgFrame(argFrame, stree, node->op2, indefiniteP);
                break;

            case kNPSArg:
                // type (node->op1) はとりあえず無視
                NcSetSlot(argFrame, node->op2, kNewtRefUnbind);
                break;

            case kNPSIndefinite:
                // 不定長
                NcSetSlot(argFrame, node->op1, kNewtRefUnbind);
                *indefiniteP = true;
                numArgs = 0;
                break;

            default:
                NBError(kNErrSyntaxError);
                break;
        }
    }
    else
    {
        NcSetSlot(argFrame, r, kNewtRefUnbind);
    }

    return numArgs;
}


/*------------------------------------------------------------------------*/
int16_t NBCMakeFnArgs(newtRefArg fn, nps_syntax_node_t * stree, nps_node_t r)
{
    int16_t numArgs = 0;

    if (r != kNewtRefUnbind)
    {
        newtRefVar  argFrame;
        bool        indefinite = false;

        argFrame = NcGetSlot(fn, NSSYM0(argFrame));
        numArgs = NBCMakeFnArgFrame(argFrame, stree, r, &indefinite);

        if (0 < numArgs)
            NcSetSlot(fn, NSSYM0(numArgs), NewtMakeInteger(numArgs));
 
        if (indefinite)
            NcSetSlot(fn, NSSYM0(indefinite), kNewtRefTRUE);
    }

    return numArgs;
}


/*------------------------------------------------------------------------*/
nbc_env_t * NBCMakeFnEnv(nps_syntax_node_t * stree, nps_node_t args)
{
    newt_bc_env = NBCEnvNew(newt_bc_env);

    if (newt_bc_env != NULL)
        NBCMakeFnArgs(newt_bc_env->func, stree, args);

    return newt_bc_env;
}


/*------------------------------------------------------------------------*/
uint32_t NBCGenBranch(uint8_t a)
{
    uint32_t    cx;

    cx = CX;
    NBCGenCode(a, 0xffff);  // 0xffff is dummy

    return cx;
}


#pragma mark -
/*------------------------------------------------------------------------*/
void NBCDefLocal(newtRefArg type, newtRefArg r, bool init)
{
    NcSetSlot(ARGFRAME, r, kNewtRefUnbind);

    if (init)
    {
        int16_t b;
    
        // ローカル変数を検索
        b = NewtFindSlotIndex(ARGFRAME, r);

        if (b != -1)
            NBCGenCode(kNBCSetVar, b);
        else
            NewtFprintf(stderr, "Not inpriment");
    }
}


#pragma mark -
/*------------------------------------------------------------------------*/
void NBCBackPatch(uint32_t cx, int16_t b)
{
    BC[cx + 1] = b >> 8;
    BC[cx + 2] = b & 0xff;
}


/*------------------------------------------------------------------------*/
void NBCPushBreakStack(uint32_t cx)
{
    if (BREAKSTACK == NULL)
        NewtStackSetup(&newt_bc_env->breakstack, NEWT_POOL, sizeof(uint32_t), NEWT_NUM_BREAKSTACK);

    if (! NewtStackExpand(&newt_bc_env->breakstack, BREAKSP + 1))
        return;

    BREAKSTACK[BREAKSP] = cx;
    BREAKSP++;
}


/*------------------------------------------------------------------------*/
void NBCBreakBackPatchs(uint32_t loop_head, uint32_t cx)
{
    uint32_t    branch;

    for (; 0 < BREAKSP; BREAKSP--)
    {
        branch = BREAKSTACK[BREAKSP - 1];

        if (branch < loop_head)
            break;

        NBCBackPatch(branch, cx);   // ブランチをバックパッチ
    }
}


#pragma mark -
/*------------------------------------------------------------------------*/
void NBCPushOnexcpStack(uint32_t cx)
{
    if (ONEXCPSTACK == NULL)
        NewtStackSetup(&newt_bc_env->onexcpstack, NEWT_POOL, sizeof(uint32_t), NEWT_NUM_ONEXCPSTACK);

    if (! NewtStackExpand(&newt_bc_env->onexcpstack, ONEXCPSP + 1))
        return;

    ONEXCPSTACK[ONEXCPSP] = cx;
    ONEXCPSP++;
}


/*------------------------------------------------------------------------*/
void NBCOnexcpBackPatchs(uint32_t try_head, uint32_t cx)
{
    uint32_t    branch;

    for (; 0 < ONEXCPSP; ONEXCPSP--)
    {
        branch = ONEXCPSTACK[ONEXCPSP - 1];

        if (branch < try_head)
            break;

        NBCBackPatch(branch, cx);   // ブランチをバックパッチ
    }
}


/*------------------------------------------------------------------------*/
void NBCGenOnexcpPC(int32_t pc)
{
    newtRefVar  r;
    int16_t b;

    r = NewtMakeInteger(pc);
    b = NBCGenPushLiteral(r);

    NBCPushOnexcpStack(b);  // バックパッチのためにスタックにプッシュする
}


/*------------------------------------------------------------------------*/
void NBCGenOnexcpBranch(void)
{
    uint32_t    cx;
    
    cx = NBCGenBranch(kNBCBranch);  // ブランチ
    NBCPushOnexcpStack(cx);         // バックパッチのためにスタックにプッシュする
}


/*------------------------------------------------------------------------*/
void NBCOnexcpBackPatchL(uint32_t sp, int32_t pc)
{
    newtRefVar  r;

    if (ONEXCPSTACK == NULL || ONEXCPSP <= sp)
        return;

    r = NewtMakeInteger(pc);
    NewtSetArraySlot(LITERALS, ONEXCPSTACK[sp], r);
}


#pragma mark -
/*------------------------------------------------------------------------*/
newtRef NBCMakeFn(nbc_env_t * env)
{
    newtRefVar  fnv[] = {
                            NS_CLASS,               NSSYM0(CodeBlock),
                            NSSYM0(instructions),   kNewtRefNIL,
                            NSSYM0(literals),       kNewtRefNIL,
                            NSSYM0(argFrame),       kNewtRefNIL,
                            NSSYM0(numArgs),        kNewtRefNIL
                        };

    newtRefVar  afv[] = {
                            NSSYM0(_nextArgFrame),  kNewtRefNIL,
                            NSSYM0(_parent),        kNewtRefNIL,
                            NSSYM0(_implementor),   kNewtRefNIL
                        };

    newtRefVar  fn;
    int32_t numArgs = 0;

    // literals
    env->literals = NewtMakeArray(NSSYM0(literals), 0);

    // argFrame
    env->argFrame = NewtMakeFrame2(sizeof(afv) / (sizeof(newtRefVar) * 2), afv);

    // function
    fn = NewtMakeFrame2(sizeof(fnv) / (sizeof(newtRefVar) * 2), fnv);

//    NcSetClass(fn, NSSYM0(CodeBlock));
    NcSetSlot(fn, NSSYM0(instructions), kNewtRefNIL);
    NcSetSlot(fn, NSSYM0(literals), env->literals);
    NcSetSlot(fn, NSSYM0(argFrame), env->argFrame);
    NcSetSlot(fn, NSSYM0(numArgs), NewtMakeInteger(numArgs));

    env->func = fn;

    // constant
    if (env->parent)
    {   // 親があれば定数フレームを共有する
        env->constant = env->parent->constant;
    }
    else
    {   // 親がなければ新規に定数フレームを作成
        env->constant = NcMakeFrame();
    }

    return fn;
}


/*------------------------------------------------------------------------*/
void NBCInitFreqFuncTable(void)
{
    int i;

    for (i = 0; freq_func_tb[i].name != NULL; i++)
    {
        freq_func_tb[i].sym = NewtMakeSymbol(freq_func_tb[i].name);
    }
}


/*------------------------------------------------------------------------*/
nbc_env_t * NBCEnvNew(nbc_env_t * parent)
{
    nbc_env_t * env;

    env = (nbc_env_t *)NewtMemCalloc(NEWT_POOL, 1, sizeof(nbc_env_t));

    if (env != NULL)
    {
        env->parent = parent;
        NewtStackSetup(&env->bytecode, NEWT_POOL, sizeof(uint8_t), NEWT_NUM_BYTECODE);

        NBCMakeFn(env);
    }

    return env;
}


/*------------------------------------------------------------------------*/
void NBCEnvFree(nbc_env_t * env)
{
    if (env != NULL)
    {
        NewtStackFree(&env->bytecode);
        NewtStackFree(&env->breakstack);
        NewtStackFree(&env->onexcpstack);

        NewtMemFree(env);
    }
}


/*------------------------------------------------------------------------*/
newtRef NBCFnDone(nbc_env_t ** envP)
{
    nbc_env_t * env = *envP;
    newtRefVar  fn = kNewtRefNIL;

    if (env != NULL)
    {
        newtRefVar  instr;
        newtRefVar  literals;

        NBCGenCodeEnv(env, kNBCReturn, 0);

        fn = env->func;
        instr = NewtMakeBinary(kNewtRefNIL, ENV_BC(env), ENV_CX(env), true);
        NcSetSlot(fn, NSSYM0(instructions), instr);
    
        literals = NcGetSlot(fn, NSSYM0(literals));

        if (NewtRefIsNotNIL(literals) && NcLength(literals) == 0)
            NcSetSlot(fn, NSSYM0(literals), kNewtRefNIL);

        *envP = env->parent;
        NBCEnvFree(env);
    }

    return fn;
}


/*------------------------------------------------------------------------*/
void NBCInit(void)
{
    NBCInitFreqFuncTable();
}


/*------------------------------------------------------------------------*/
void NBCCleanup(void)
{
    nbc_env_t * env;

    while (newt_bc_env != NULL)
    {
        env = newt_bc_env;
        newt_bc_env = env->parent;
        NBCEnvFree(env);
    }
}


#pragma mark -
/*------------------------------------------------------------------------*/
void NBCGenBC_stmt(nps_syntax_node_t * stree, nps_node_t r, bool ret)
{
    if (NPSRefIsSyntaxNode(r))
    {
        NBCGenBC_sub(stree, NPSRefToSyntaxNode(r), ret);
        return;
    }

    if (r != kNewtRefUnbind)
        NBCGenPUSH(r);
}


/*------------------------------------------------------------------------*/
void NBCGenConstant(nps_syntax_node_t * stree, nps_node_t r)
{
    if (NPSRefIsSyntaxNode(r))
    {
        nps_syntax_node_t * node;

        node = &stree[NPSRefToSyntaxNode(r)];

        switch (node->code)
        {
            case kNPSCommaList:
                NBCGenConstant(stree, node->op1);
                NBCGenConstant(stree, node->op2);
                break;

            case kNPSAsign:
                // node->op2 がオブジェクトでない場合の処理を行うこと
                NcSetSlot(CONSTANT, node->op1, node->op2);
                break;
        }
    }
    else
    {
        NBError(kNErrSyntaxError);
    }
}


/*------------------------------------------------------------------------*/
void NBCGenGlobalVar(nps_syntax_node_t * stree, nps_node_t r)
{
    if (NPSRefIsSyntaxNode(r))
    {
        nps_syntax_node_t * node;

        node = &stree[NPSRefToSyntaxNode(r)];

        switch (node->code)
        {
            case kNPSCommaList:
                NBCGenGlobalVar(stree, node->op1);
                NBCGenGlobalVar(stree, node->op2);
                break;

            case kNPSAsign:
                NBCGenPUSH(node->op1);
                NBCGenBC_op(stree, node->op2);

                // defGlobalVar を呼出す
                NBCGenCallFn(NSSYM0(defGlobalVar), 2);
                break;
        }
    }
    else if (NewtRefIsSymbol(r))
    {
        NBCGenPUSH(r);
        NBCGenPUSH(kNewtRefUnbind);

        // defGlobalVar を呼出す
        NBCGenCallFn(NSSYM0(defGlobalVar), 2);
    }
    else
    {
        NBError(kNErrSyntaxError);
    }
}


/*------------------------------------------------------------------------*/
void NBCGenLocalVar(nps_syntax_node_t * stree, nps_node_t type, nps_node_t r)
{
    if (NPSRefIsSyntaxNode(r))
    {
        nps_syntax_node_t * node;

        node = &stree[NPSRefToSyntaxNode(r)];

        switch (node->code)
        {
            case kNPSCommaList:
                NBCGenLocalVar(stree, type, node->op1);
                NBCGenLocalVar(stree, type, node->op2);
                break;

            case kNPSAsign:
                NBCGenBC_op(stree, node->op2);
                NBCDefLocal(type, node->op1, true);
                break;
        }
    }
    else if (NewtRefIsSymbol(r))
    {
        NBCDefLocal(type, r, false);
    }
    else
    {
        NBError(kNErrSyntaxError);
    }
}


/*------------------------------------------------------------------------*/
bool NBCTypeValid(nps_node_t type)
{
    if (type == kNewtRefUnbind)
        return true;

    if (type == NS_INT)
        return true;

    if (type == NSSYM0(array))
        return true;

    NBError(kNErrSyntaxError);

    return false;
}


/*------------------------------------------------------------------------*/
int16_t NBCGenTryPre(nps_syntax_node_t * stree, nps_node_t r)
{
    int16_t numExcps = 0;

    if (NPSRefIsSyntaxNode(r))
    {
        nps_syntax_node_t * node;

        node = &stree[NPSRefToSyntaxNode(r)];

        switch (node->code)
        {
            case kNPSOnexception:
                NBCGenPUSH(node->op1);  // シンボル
                NBCGenOnexcpPC(-1); // PC（ダミー）

                numExcps = 1;
                break;

            case kNPSOnexceptionList:
                numExcps = NBCGenTryPre(stree, node->op1)
                            + NBCGenTryPre(stree, node->op2);
                break;
        }
    }

    return numExcps;
}


/*------------------------------------------------------------------------*/
int16_t NBCGenTryPost(nps_syntax_node_t * stree, nps_node_t r,
            uint32_t * onexcpspP)
{
    int16_t numExcps = 0;

    if (NPSRefIsSyntaxNode(r))
    {
        nps_syntax_node_t * node;

        node = &stree[NPSRefToSyntaxNode(r)];

        switch (node->code)
        {
            case kNPSOnexception:
                // new-handler の引数をバックパッチ
                NBCOnexcpBackPatchL(*onexcpspP, CX);
                (*onexcpspP)++;

                // onexception のコード生成
                NBCGenBC_stmt(stree, node->op2, true);
                NBCGenOnexcpBranch();

                numExcps = 1;
                break;

            case kNPSOnexceptionList:
                numExcps = NBCGenTryPost(stree, node->op1, onexcpspP)
                            + NBCGenTryPost(stree, node->op2, onexcpspP);
                break;
        }
    }

    return numExcps;
}


/*------------------------------------------------------------------------*/
void NBCGenTry(nps_syntax_node_t * stree, nps_node_t expr,
        nps_node_t onexception_list)
{
    uint32_t    onexcp_cx;
    uint32_t    branch_cx;
    uint32_t    onexcpsp;
    int16_t numExcps = 0;

    onexcpsp = ONEXCPSP;
    numExcps = NBCGenTryPre(stree, onexception_list);
    NBCGenCode(kNBCNewHandlers, numExcps);

    // 実行文
    NBCGenBC_op(stree, expr);
    NBCGenCode(kNBCPopHandlers, 0);

    branch_cx = CX;
    branch_cx = NBCGenBranch(kNBCBranch);

    // onexception
    onexcp_cx = CX;
    NBCGenTryPost(stree, onexception_list, &onexcpsp);

    // onexception の終了
    NBCOnexcpBackPatchs(onexcp_cx, CX); // onexception の終了をバックパッチ
    NBCGenCode(kNBCPopHandlers, 0);

    // ONEXCPSP を戻す
    ONEXCPSP = onexcpsp;

    // バックパッチ
    NBCBackPatch(branch_cx, CX);    // branch をバックパッチ
}


/*------------------------------------------------------------------------*/
void NBCGenIfThenElse(nps_syntax_node_t * stree, nps_node_t cond,
        nps_node_t thenelse, bool ret)
{
    nps_node_t  ifthen;
    nps_node_t  ifelse = kNewtRefUnbind;
    uint32_t    cond_cx;

    NBCGenBC_op(stree, cond);
    cond_cx = NBCGenBranch(kNBCBranchIfFalse);

    if (NewtRefIsArray(thenelse))
    {
        ifthen = NewtGetArraySlot(thenelse, 0);
        ifelse = NewtGetArraySlot(thenelse, 1);
    }
    else
    {
        ifthen = thenelse;
    }

    // THEN 文
    NBCGenBC_stmt(stree, ifthen, ret);

    if (ifelse == kNewtRefUnbind)
    {
        NBCBackPatch(cond_cx, CX);              // 条件文をバックパッチ
    }
    else
    {
        uint32_t    then_done;

        then_done = NBCGenBranch(kNBCBranch);   // THEN 文の終了
        NBCBackPatch(cond_cx, CX);              // 条件文をバックパッチ

        // ELSE 文
        NBCGenBC_stmt(stree, ifelse, ret);

        NBCBackPatch(then_done, CX);            // THEN 文終了のブランチをバックパッチ
    }
}


/*------------------------------------------------------------------------*/
void NBCGenAnd(nps_syntax_node_t * stree, nps_node_t op1, nps_node_t op2)
{
    uint32_t    cx1;
    uint32_t    cx2;

    // オペランド１
    NBCGenBC_op(stree, op1);

    // NIL なら分岐
    cx1 = NBCGenBranch(kNBCBranchIfFalse);

    // オペランド２
    NBCGenBC_op(stree, op2);
    // 式の最後へ分岐
    cx2 = NBCGenBranch(kNBCBranch);

    // 戻り値をプッシュ
    NBCBackPatch(cx1, CX);      // 分岐をバックパッチ
    NBCGenPUSH(kNewtRefNIL);    // 戻り値は NIL

    // 式の最後
    NBCBackPatch(cx2, CX);      // 分岐をバックパッチ
}


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