Пример #1
0
 private void exp2reg(Expdesc e, int reg)
 {
     discharge2reg(e, reg);
     if (e.k == Expdesc.VJMP)
     {
         e.t = kConcat(e.t, e.info_Renamed);   // put this jump in `t' list
     }
     if (e.hasjumps())
     {
         int p_f = NO_JUMP;   // position of an eventual LOAD false
         int p_t = NO_JUMP;   // position of an eventual LOAD true
         if (need_value(e.t) || need_value(e.f))
         {
             int fj = (e.k == Expdesc.VJMP) ? NO_JUMP : kJump();
             p_f = code_label(reg, 0, 1);
             p_t = code_label(reg, 1, 0);
             kPatchtohere(fj);
         }
         int finalpos = kGetlabel();   // position after whole expression
         patchlistaux(e.f, finalpos, reg, p_f);
         patchlistaux(e.t, finalpos, reg, p_t);
     }
     e.init(Expdesc.VNONRELOC, reg);
 }
Пример #2
0
        /// <summary>
        /// Equivalent to luaK_posfix. </summary>
        internal void kPosfix(int op, Expdesc e1, Expdesc e2)
        {
            switch (op)
            {
            case Syntax.OPR_AND:
                /* list must be closed */
                //# assert e1.t == NO_JUMP
                kDischargevars(e2);
                e2.f = kConcat(e2.f, e1.f);
                e1.init(e2);
                break;

            case Syntax.OPR_OR:
                /* list must be closed */
                //# assert e1.f == NO_JUMP
                kDischargevars(e2);
                e2.t = kConcat(e2.t, e1.t);
                e1.init(e2);
                break;

            case Syntax.OPR_CONCAT:
                kExp2val(e2);
                if (e2.k == Expdesc.VRELOCABLE && Lua.OPCODE(getcode(e2)) == Lua.OP_CONCAT)
                {
                    //# assert e1.info == Lua.ARGB(getcode(e2))-1
                    freeexp(e1);
                    setcode(e2, Lua.SETARG_B(getcode(e2), e1.info_Renamed));
                    e1.k            = e2.k;
                    e1.info_Renamed = e2.info_Renamed;
                }
                else
                {
                    kExp2nextreg(e2);       // operand must be on the 'stack'
                    codearith(Lua.OP_CONCAT, e1, e2);
                }
                break;

            case Syntax.OPR_ADD:
                codearith(Lua.OP_ADD, e1, e2);
                break;

            case Syntax.OPR_SUB:
                codearith(Lua.OP_SUB, e1, e2);
                break;

            case Syntax.OPR_MUL:
                codearith(Lua.OP_MUL, e1, e2);
                break;

            case Syntax.OPR_DIV:
                codearith(Lua.OP_DIV, e1, e2);
                break;

            case Syntax.OPR_MOD:
                codearith(Lua.OP_MOD, e1, e2);
                break;

            case Syntax.OPR_POW:
                codearith(Lua.OP_POW, e1, e2);
                break;

            case Syntax.OPR_EQ:
                codecomp(Lua.OP_EQ, true, e1, e2);
                break;

            case Syntax.OPR_NE:
                codecomp(Lua.OP_EQ, false, e1, e2);
                break;

            case Syntax.OPR_LT:
                codecomp(Lua.OP_LT, true, e1, e2);
                break;

            case Syntax.OPR_LE:
                codecomp(Lua.OP_LE, true, e1, e2);
                break;

            case Syntax.OPR_GT:
                codecomp(Lua.OP_LT, false, e1, e2);
                break;

            case Syntax.OPR_GE:
                codecomp(Lua.OP_LE, false, e1, e2);
                break;

            default:
                //# assert false
                break;
            }
        }