예제 #1
0
 public static decimal FromDecimal(Proto.Seto.Decimal sDecimal)
 {
     var val = new decimal(sDecimal.Value);
     // Annoyingly, there is no integer exponentiation
     var divisor = new decimal((long)Math.Pow(10, sDecimal.Exponent));
     return Math.Round(val / divisor, (int)sDecimal.Exponent);
 }
예제 #2
0
 public static void LuaFFreeProto(LuaState L, Proto f)
 {
     LuaMFreeArray<Instruction>(L, f.code);
     LuaMFreeArray<Proto>(L, f.p);
     LuaMFreeArray<TValue>(L, f.k);
     LuaMFreeArray<Int32>(L, f.lineinfo);
     LuaMFreeArray<LocVar>(L, f.locvars);
     LuaMFreeArray<TString>(L, f.upvalues);
     LuaMFree(L, f);
 }
예제 #3
0
파일: lfunc.cs 프로젝트: raymanyu/kopilua
 public static void luaF_freeproto(lua_State L, Proto f)
 {
     luaM_freearray<Instruction>(L, f.code);
       luaM_freearray<Proto>(L, f.p);
       luaM_freearray<TValue>(L, f.k);
       luaM_freearray<Int32>(L, f.lineinfo);
       luaM_freearray<LocVar>(L, f.locvars);
       luaM_freearray<TString>(L, f.upvalues);
       luaM_free(L, f);
 }
예제 #4
0
 internal static MarketQuotes FromSeto(Proto.Seto.MarketQuotes setoQuotes)
 {
     var quantityType = Quantity.QuantityTypeFromSeto(setoQuotes.QuantityType);
     var priceType = Price.PriceTypeFromSeto(setoQuotes.PriceType);
     return new MarketQuotes(
         Uid.FromUuid128(setoQuotes.Market),
         ContractQuotesMap.FromSeto(
             setoQuotes.ContractQuotes, priceType, quantityType),
         priceType,
         quantityType);
 }
예제 #5
0
파일: lfunc.cs 프로젝트: GSharpDevs/RunG
 /*
 ** Look for n-th local variable at line `line' in function `func'.
 ** Returns null if not found.
 */
 public static CharPtr LuaFGetLocalName(Proto f, int local_number, int pc)
 {
     int i;
       for (i = 0; i<f.sizelocvars && f.locvars[i].startpc <= pc; i++) {
     if (pc < f.locvars[i].endpc) {  /* is variable active? */
       local_number--;
       if (local_number == 0)
         return GetStr(f.locvars[i].varname);
     }
       }
       return null;  /* not found */
 }
예제 #6
0
 public static int LuaUDump(LuaState L, Proto f, lua_Writer w, object data, int strip)
 {
     DumpState D = new DumpState();
      D.L=L;
      D.writer=w;
      D.data=data;
      D.strip=strip;
      D.status=0;
      DumpHeader(D);
      DumpFunction(f,null,D);
      return D.status;
 }
예제 #7
0
 public static void PrintFunction(Proto f, int full)
 {
     int i,n=f.sizep;
      PrintHeader(f);
      PrintCode(f);
      if (full != 0)
      {
       PrintConstants(f);
       PrintLocals(f);
       PrintUpvalues(f);
      }
      for (i=0; i<n; i++) PrintFunction(f.p[i],full);
 }
예제 #8
0
		private static void PrintConstant(Proto f, int i)
		{
		 /*const*/ TValue o=f.k[i];
		 switch (TType(o))
		 {
		  case LUA_TNIL:
			printf("nil");
			break;
		  case LUA_TBOOLEAN:
			printf(BValue(o) != 0 ? "true" : "false");
			break;
		  case LUA_TNUMBER:
			printf(LUA_NUMBER_FMT,NValue(o));
			break;
		  case LUA_TSTRING:
			PrintString(RawTSValue(o));
			break;
		  default:				/* cannot happen */
			printf("? type=%d",TType(o));
			break;
		 }
		}
 /// <summary>Helper: put the buffer into a MemoryStream before deserializing</summary>
 public static Proto.Test.Nullables.MyMessage Deserialize(byte[] buffer, Proto.Test.Nullables.MyMessage instance)
 {
     using (var ms = new MemoryStream(buffer))
         Deserialize(ms, instance);
     return instance;
 }
        /// <summary>Read the given number of bytes from the stream and deserialze it into the instance.</summary>
        public static Proto.Test.Nullables.Data DeserializeLength(Stream stream, int length, Proto.Test.Nullables.Data instance)
        {
            var br = new BinaryReader(stream);
            long limit = stream.Position + length;
            while (true)
            {
                if (stream.Position >= limit)
                {
                    if (stream.Position == limit)
                        break;
                    else
                        throw new global::SilentOrbit.ProtocolBuffers.ProtocolBufferException("Read past max limit");
                }
                int keyByte = stream.ReadByte();
                if (keyByte == -1)
                    throw new System.IO.EndOfStreamException();
                // Optimized reading of known fields with field ID < 16
                switch (keyByte)
                {
                    // Field 1 Fixed64
                    case 9:
                        instance.Somefield = br.ReadDouble();
                        continue;
                }

                var key = global::SilentOrbit.ProtocolBuffers.ProtocolParser.ReadKey((byte)keyByte, stream);

                // Reading field ID > 16 and unknown field ID/wire type combinations
                switch (key.Field)
                {
                    case 0:
                        throw new global::SilentOrbit.ProtocolBuffers.ProtocolBufferException("Invalid field id: 0, something went wrong in the stream");
                    default:
                        global::SilentOrbit.ProtocolBuffers.ProtocolParser.SkipKey(stream, key);
                        break;
                }
            }

            return instance;
        }
 /// <summary>Helper: put the buffer into a MemoryStream before deserializing</summary>
 public static Proto.Test.Nullables.Container.Nested Deserialize(byte[] buffer, Proto.Test.Nullables.Container.Nested instance)
 {
     using (var ms = new MemoryStream(buffer))
         Deserialize(ms, instance);
     return instance;
 }
예제 #12
0
 public static int checkopenop(Proto pt, int pc)
 {
     return(luaG_checkopenop(pt.code[pc + 1]));
 }
예제 #13
0
        /*
        ** try to find last instruction before 'lastpc' that modified register 'reg'
        */
        private static int findsetreg(Proto p, int lastpc, int reg)
        {
            int pc;
            int setreg = -1;        /* keep last instruction that changed 'reg' */

            for (pc = 0; pc < lastpc; pc++)
            {
                Instruction i  = p.code[pc];
                OpCode      op = GET_OPCODE(i);
                int         a  = GETARG_A(i);
                switch (op)
                {
                case OpCode.OP_LOADNIL: {
                    int b = GETARG_B(i);
                    if (a <= reg && reg <= a + b)      /* set registers from 'a' to 'a+b' */
                    {
                        setreg = pc;
                    }
                    break;
                }

                case OpCode.OP_TFORCALL: {
                    if (reg >= a + 2)
                    {
                        setreg = pc;                    /* affect all regs above its base */
                    }
                    break;
                }

                case OpCode.OP_CALL:
                case OpCode.OP_TAILCALL: {
                    if (reg >= a)
                    {
                        setreg = pc;                /* affect all registers above base */
                    }
                    break;
                }

                case OpCode.OP_JMP: {
                    int b    = GETARG_sBx(i);
                    int dest = pc + 1 + b;
                    /* jump is forward and do not skip `lastpc'? */
                    if (pc < dest && dest <= lastpc)
                    {
                        pc += b;    /* do the jump */
                    }
                    break;
                }

                case OpCode.OP_TEST: {
                    if (reg == a)
                    {
                        setreg = pc;                /* jumped code can change 'a' */
                    }
                    break;
                }

                default:
                    if (testAMode(op) != 0 && reg == a)    /* any instruction that set A */
                    {
                        setreg = pc;
                    }
                    break;
                }
            }
            return(setreg);
        }
예제 #14
0
        private static void PrintCode(Proto f)
        {
            Instruction[] code = f.code;
            int           pc, n = f.sizecode;

            for (pc = 0; pc < n; pc++)
            {
                Instruction i    = f.code[pc];
                OpCode      o    = GET_OPCODE(i);
                int         a    = GETARG_A(i);
                int         b    = GETARG_B(i);
                int         c    = GETARG_C(i);
                int         bx   = GETARG_Bx(i);
                int         sbx  = GETARG_sBx(i);
                int         line = getline(f, pc);
                printf("\t%d\t", pc + 1);
                if (line > 0)
                {
                    printf("[%d]\t", line);
                }
                else
                {
                    printf("[-]\t");
                }
                printf("%-9s\t", luaP_opnames[(int)o]);
                switch (getOpMode(o))
                {
                case OpMode.iABC:
                    printf("%d", a);
                    if (getBMode(o) != OpArgMask.OpArgN)
                    {
                        printf(" %d", (ISK(b) != 0) ? (-1 - INDEXK(b)) : b);
                    }
                    if (getCMode(o) != OpArgMask.OpArgN)
                    {
                        printf(" %d", (ISK(c) != 0) ? (-1 - INDEXK(c)) : c);
                    }
                    break;

                case OpMode.iABx:
                    if (getBMode(o) == OpArgMask.OpArgK)
                    {
                        printf("%d %d", a, -1 - bx);
                    }
                    else
                    {
                        printf("%d %d", a, bx);
                    }
                    break;

                case OpMode.iAsBx:
                    if (o == OpCode.OP_JMP)
                    {
                        printf("%d", sbx);
                    }
                    else
                    {
                        printf("%d %d", a, sbx);
                    }
                    break;
                }
                switch (o)
                {
                case OpCode.OP_LOADK:
                    printf("\t; "); PrintConstant(f, bx);
                    break;

                case OpCode.OP_GETUPVAL:
                case OpCode.OP_SETUPVAL:
                    printf("\t; %s", (f.sizeupvalues > 0) ? getstr(f.upvalues[b]) : "-");
                    break;

                case OpCode.OP_GETGLOBAL:
                case OpCode.OP_SETGLOBAL:
                    printf("\t; %s", svalue(f.k[bx]));
                    break;

                case OpCode.OP_GETTABLE:
                case OpCode.OP_SELF:
                    if (ISK(c) != 0)
                    {
                        printf("\t; "); PrintConstant(f, INDEXK(c));
                    }
                    break;

                case OpCode.OP_SETTABLE:
                case OpCode.OP_ADD:
                case OpCode.OP_SUB:
                case OpCode.OP_MUL:
                case OpCode.OP_DIV:
                case OpCode.OP_POW:
                case OpCode.OP_EQ:
                case OpCode.OP_LT:
                case OpCode.OP_LE:
                    if (ISK(b) != 0 || ISK(c) != 0)
                    {
                        printf("\t; ");
                        if (ISK(b) != 0)
                        {
                            PrintConstant(f, INDEXK(b));
                        }
                        else
                        {
                            printf("-");
                        }
                        printf(" ");
                        if (ISK(c) != 0)
                        {
                            PrintConstant(f, INDEXK(c));
                        }
                        else
                        {
                            printf("-");
                        }
                    }
                    break;

                case OpCode.OP_JMP:
                case OpCode.OP_FORLOOP:
                case OpCode.OP_FORPREP:
                    printf("\t; to %d", sbx + pc + 2);
                    break;

                case OpCode.OP_CLOSURE:
                    printf("\t; %p", VOID(f.p[bx]));
                    break;

                case OpCode.OP_SETLIST:
                    if (c == 0)
                    {
                        printf("\t; %d", (int)code[++pc]);
                    }
                    else
                    {
                        printf("\t; %d", c);
                    }
                    break;

                default:
                    break;
                }
                printf("\n");
            }
        }
예제 #15
0
 //#define setptvalue2s	setptvalue
 internal static void SetPTValue2S(LuaState L, TValue obj, Proto x)
 {
     SetPTValue(L, obj, x);
 }
예제 #16
0
        /*
        ** returns true if function has been executed (C function)
        */
        public static int luaD_precall(lua_State L, StkId func, int nresults)
        {
            LClosure  cl;
            ptrdiff_t funcr;

            if (!ttisfunction(func))       /* `func' is not a function? */
            {
                func = tryfuncTM(L, func); /* check the `function' tag method */
            }
            funcr         = savestack(L, func);
            cl            = clvalue(func).l;
            L.ci.nresults = (short)nresults; //FIXME:???
            if (cl.isC == 0)                 /* Lua function? prepare its call */
            {
                CallInfo ci;
                int      nparams, nargs;
                StkId    base_;
                Proto    p = cl.p;
                luaD_checkstack(L, p.maxstacksize);
                func    = restorestack(L, funcr);
                nargs   = cast_int(L.top - func) - 1; /* number of real arguments */
                nparams = p.numparams;                /* number of expected parameters */
                for (; nargs < nparams; nargs++)
                {
                    setnilvalue(lua_TValue.inc(ref L.top)); /* complete missing arguments */
                }
                if (p.is_vararg == 0)                       /* no varargs? */
                {
                    base_ = L.stack[func + 1];
                }
                else          /* vararg function */
                {
                    base_ = adjust_varargs(L, p, nargs);
                }
                ci           = next_ci(L); /* now `enter' new function */
                ci.func      = func;
                ci.u.l.base_ = base_;
                ci.top       = base_ + p.maxstacksize;
                lua_assert(ci.top <= L.stack_last);
                ci.u.l.savedpc   = new InstructionPtr(p.code, 0); /* starting point */        //FIXME:??? //FIXME:???
                ci.u.l.tailcalls = 0;
                ci.callstatus    = CIST_LUA;
                L.top            = ci.top;
                if ((L.hookmask & LUA_MASKCALL) != 0)
                {
                    InstructionPtr.inc(ref ci.u.l.savedpc);        /* hooks assume 'pc' is already incremented */
                    luaD_callhook(L, LUA_HOOKCALL, -1);
                    InstructionPtr.dec(ref ci.u.l.savedpc);        /* correct 'pc' */
                }
                return(0);
            }
            else          /* if is a C function, call it */
            {
                CallInfo ci;
                int      n;
                luaD_checkstack(L, LUA_MINSTACK); /* ensure minimum stack size */
                ci      = next_ci(L);             /* now `enter' new function */
                ci.func = restorestack(L, funcr);
                ci.top  = L.top + LUA_MINSTACK;
                lua_assert(ci.top <= L.stack_last);
                ci.callstatus = 0;
                if ((L.hookmask & LUA_MASKCALL) != 0)
                {
                    luaD_callhook(L, LUA_HOOKCALL, -1);
                }
                lua_unlock(L);
                n = curr_func(L).c.f(L);          /* do the actual call */
                lua_lock(L);
                luaD_poscall(L, L.top - n);
                return(1);
            }
        }
예제 #17
0
 private static void DumpCode(Proto f, DumpState D)
 {
     DumpVector(f.code, f.sizecode, D);
 }                                                                                                //FIXME:no sizeof(Instruction)
예제 #18
0
        //#undef check
        //#undef checkjump
        //#undef checkreg

        /* }====================================================== */


        public static int LuaGCheckCode(Proto pt)
        {
            return((SymbExec(pt, pt.sizecode, NO_REG) != 0) ? 1 : 0);
        }
예제 #19
0
        public static int luaD_precall(LuaState L, StkId func, int nresults)
        {
            LClosure  cl;
            ptrdiff_t funcr;

            if (!ttisfunction(func))       /* `func' is not a function? */
            {
                func = tryfuncTM(L, func); /* check the `function' tag method */
            }
            funcr        = savestack(L, func);
            cl           = clvalue(func).l;
            L.ci.savedpc = InstructionPtr.Assign(L.savedpc);
            if (cl.isC == 0)
            {  /* Lua function? prepare its call */
                CallInfo ci;
                StkId    st, base_;
                Proto    p = cl.p;
                luaD_checkstack(L, p.maxstacksize);
                func = restorestack(L, funcr);
                if (p.is_vararg == 0)
                {  /* no varargs? */
                    base_ = L.stack[func + 1];
                    if (L.top > base_ + p.numparams)
                    {
                        L.top = base_ + p.numparams;
                    }
                }
                else
                {  /* vararg function */
                    int nargs = L.top - func - 1;
                    base_ = adjust_varargs(L, p, nargs);
                    func  = restorestack(L, funcr); /* previous call may change the stack */
                }
                ci      = inc_ci(L);                /* now `enter' new function */
                ci.func = func;
                L.base_ = ci.base_ = base_;
                ci.top  = L.base_ + p.maxstacksize;
                lua_assert(ci.top <= L.stack_last);
                L.savedpc    = new InstructionPtr(p.code, 0); /* starting point */
                ci.tailcalls = 0;
                ci.nresults  = nresults;
                for (st = L.top; st < ci.top; StkId.inc(ref st))
                {
                    setnilvalue(st);
                }
                L.top = ci.top;
                if ((L.hookmask & LUA_MASKCALL) != 0)
                {
                    InstructionPtr.inc(ref L.savedpc);  /* hooks assume 'pc' is already incremented */
                    luaD_callhook(L, LUA_HOOKCALL, -1);
                    InstructionPtr.dec(ref L.savedpc);  /* correct 'pc' */
                }
                return(PCRLUA);
            }
            else
            {  /* if is a C function, call it */
                CallInfo ci;
                int      n;
                luaD_checkstack(L, LUA_MINSTACK); /* ensure minimum stack size */
                ci      = inc_ci(L);              /* now `enter' new function */
                ci.func = restorestack(L, funcr);
                L.base_ = ci.base_ = ci.func + 1;
                ci.top  = L.top + LUA_MINSTACK;
                lua_assert(ci.top <= L.stack_last);
                ci.nresults = nresults;
                if ((L.hookmask & LUA_MASKCALL) != 0)
                {
                    luaD_callhook(L, LUA_HOOKCALL, -1);
                }
                lua_unlock(L);
                n = curr_func(L).c.f(L); /* do the actual call */
                lua_lock(L);
                if (n < 0)               /* yielding? */
                {
                    return(PCRYIELD);
                }
                else
                {
                    luaD_poscall(L, L.top - n);
                    return(PCRC);
                }
            }
        }
예제 #20
0
        private static Instruction SymbExec(Proto pt, int lastpc, int reg)
        {
            int pc;
            int last;        /* stores position of last instruction that changed `reg' */
            int dest;

            last = pt.sizecode - 1;      /* points to final return (a `neutral' instruction) */
            if (PreCheck(pt) == 0)
            {
                return(0);
            }
            for (pc = 0; pc < lastpc; pc++)
            {
                Instruction i  = pt.code[pc];
                OpCode      op = GET_OPCODE(i);
                int         a  = GETARG_A(i);
                int         b  = 0;
                int         c  = 0;
                if (!((int)op < NUM_OPCODES))
                {
                    return(0);
                }
                CheckReg(pt, a);
                switch (getOpMode(op))
                {
                case OpMode.iABC: {
                    b = GETARG_B(i);
                    c = GETARG_C(i);
                    if (CheckArgMode(pt, b, getBMode(op)) == 0)
                    {
                        return(0);
                    }
                    if (CheckArgMode(pt, c, getCMode(op)) == 0)
                    {
                        return(0);
                    }
                    break;
                }

                case OpMode.iABx: {
                    b = GETARG_Bx(i);
                    if (getBMode(op) == OpArgMask.OpArgK)
                    {
                        if (!(b < pt.sizek))
                        {
                            return(0);
                        }
                    }
                    break;
                }

                case OpMode.iAsBx: {
                    b = GETARG_sBx(i);
                    if (getBMode(op) == OpArgMask.OpArgR)
                    {
                        dest = pc + 1 + b;
                        if (!((0 <= dest && dest < pt.sizecode)))
                        {
                            return(0);
                        }
                        if (dest > 0)
                        {
                            int j;

                            /* check that it does not jump to a setlist count; this
                             * is tricky, because the count from a previous setlist may
                             * have the same value of an invalid setlist; so, we must
                             * go all the way back to the first of them (if any) */
                            for (j = 0; j < dest; j++)
                            {
                                Instruction d = pt.code[dest - 1 - j];
                                if (!(GET_OPCODE(d) == OpCode.OP_SETLIST && GETARG_C(d) == 0))
                                {
                                    break;
                                }
                            }

                            /* if 'j' is even, previous value is not a setlist (even if
                             * it looks like one) */
                            if ((j & 1) != 0)
                            {
                                return(0);
                            }
                        }
                    }
                    break;
                }
                }
                if (testAMode(op) != 0)
                {
                    if (a == reg)
                    {
                        last = pc;                  /* change register `a' */
                    }
                }
                if (testTMode(op) != 0)
                {
                    if (!(pc + 2 < pt.sizecode))
                    {
                        return(0);                              /* check skip */
                    }
                    if (!(GET_OPCODE(pt.code[pc + 1]) == OpCode.OP_JMP))
                    {
                        return(0);
                    }
                }
                switch (op)
                {
                case OpCode.OP_LOADBOOL: {
                    if (c == 1)                /* does it jump? */
                    {
                        if (!(pc + 2 < pt.sizecode))
                        {
                            return(0);                                  /* check its jump */
                        }
                        if (!(GET_OPCODE(pt.code[pc + 1]) != OpCode.OP_SETLIST ||
                              GETARG_C(pt.code[pc + 1]) != 0))
                        {
                            return(0);
                        }
                    }
                    break;
                }

                case OpCode.OP_LOADNIL: {
                    if (a <= reg && reg <= b)
                    {
                        last = pc;            /* set registers from `a' to `b' */
                    }
                    break;
                }

                case OpCode.OP_GETUPVAL:
                case OpCode.OP_SETUPVAL: {
                    if (!(b < pt.nups))
                    {
                        return(0);
                    }
                    break;
                }

                case OpCode.OP_GETGLOBAL:
                case OpCode.OP_SETGLOBAL: {
                    if (!(TTIsString(pt.k[b])))
                    {
                        return(0);
                    }
                    break;
                }

                case OpCode.OP_SELF: {
                    CheckReg(pt, a + 1);
                    if (reg == a + 1)
                    {
                        last = pc;
                    }
                    break;
                }

                case OpCode.OP_CONCAT: {
                    if (!(b < c))
                    {
                        return(0);                       /* at least two operands */
                    }
                    break;
                }

                case OpCode.OP_TFORLOOP: {
                    if (!(c >= 1))
                    {
                        return(0);                    /* at least one result (control variable) */
                    }
                    CheckReg(pt, a + 2 + c);          /* space for results */
                    if (reg >= a + 2)
                    {
                        last = pc;                          /* affect all regs above its base */
                    }
                    break;
                }

                case OpCode.OP_FORLOOP:
                case OpCode.OP_FORPREP:
                    CheckReg(pt, a + 3);
                    /* go through ...no, on second thoughts don't, because this is C# */
                    dest = pc + 1 + b;
                    /* not full check and jump is forward and do not skip `lastpc'? */
                    if (reg != NO_REG && pc < dest && dest <= lastpc)
                    {
                        pc += b;                  /* do the jump */
                    }
                    break;

                case OpCode.OP_JMP: {
                    dest = pc + 1 + b;
                    /* not full check and jump is forward and do not skip `lastpc'? */
                    if (reg != NO_REG && pc < dest && dest <= lastpc)
                    {
                        pc += b;            /* do the jump */
                    }
                    break;
                }

                case OpCode.OP_CALL:
                case OpCode.OP_TAILCALL: {
                    if (b != 0)
                    {
                        CheckReg(pt, a + b - 1);
                    }
                    c--;              /* c = num. returns */
                    if (c == LUA_MULTRET)
                    {
                        if (CheckOpenOp(pt, pc) == 0)
                        {
                            return(0);
                        }
                    }
                    else if (c != 0)
                    {
                        CheckReg(pt, a + c - 1);
                    }
                    if (reg >= a)
                    {
                        last = pc;                        /* affect all registers above base */
                    }
                    break;
                }

                case OpCode.OP_RETURN: {
                    b--;              /* b = num. returns */
                    if (b > 0)
                    {
                        CheckReg(pt, a + b - 1);
                    }
                    break;
                }

                case OpCode.OP_SETLIST: {
                    if (b > 0)
                    {
                        CheckReg(pt, a + b);
                    }
                    if (c == 0)
                    {
                        pc++;
                        if (!(pc < pt.sizecode - 1))
                        {
                            return(0);
                        }
                    }
                    break;
                }

                case OpCode.OP_CLOSURE: {
                    int nup, j;
                    if (!(b < pt.sizep))
                    {
                        return(0);
                    }
                    nup = pt.p[b].nups;
                    if (!(pc + nup < pt.sizecode))
                    {
                        return(0);
                    }
                    for (j = 1; j <= nup; j++)
                    {
                        OpCode op1 = GET_OPCODE(pt.code[pc + j]);
                        if (!(op1 == OpCode.OP_GETUPVAL || op1 == OpCode.OP_MOVE))
                        {
                            return(0);
                        }
                    }
                    if (reg != NO_REG)        /* tracing? */
                    {
                        pc += nup;            /* do not 'execute' these pseudo-instructions */
                    }
                    break;
                }

                case OpCode.OP_VARARG: {
                    if (!((pt.is_vararg & VARARG_ISVARARG) != 0 &&
                          (pt.is_vararg & VARARG_NEEDSARG) == 0))
                    {
                        return(0);
                    }
                    b--;
                    if (b == LUA_MULTRET)
                    {
                        if (CheckOpenOp(pt, pc) == 0)
                        {
                            return(0);
                        }
                    }
                    CheckReg(pt, a + b - 1);
                    break;
                }

                default:
                    break;
                }
            }
            return(pt.code[last]);
        }
예제 #21
0
 public static int CheckOpenOp(Proto pt, int pc)
 {
     return(LuaGCheckOpenOp(pt.code[pc + 1]));
 }
예제 #22
0
 private static void DumpCode(Proto f, DumpState D)
 {
     DumpVector(f.code, f.sizecode, D);
 }
예제 #23
0
파일: lobject.cs 프로젝트: raymanyu/kopilua
 internal static void setptvalue(lua_State L, TValue obj, Proto x)
 {
     obj.value.gc = x;
     obj.tt = LUA_TPROTO;
     checkliveness(G(L), obj);
 }
        private void Spawn(Vector3 position, Quaternion rotation, Transform parent)
        {
            var   gameData = StaticReplayScript.gameData;
            Proto proto    = StaticReplayScript.proto;

            // Choose the Andy model for the Trackable that got hit.
            // Instantiate Andy model at the hit pose.
            fieldObject = Instantiate(this.field, position, rotation);

            // Compensate for the hitPose rotation facing away from the raycast (i.e. camera).
            fieldObject.transform.Rotate(0, k_ModelRotation, 0, Space.Self);

            // Create an anchor to allow ARCore to track the hitpoint as understanding of the physical
            // world evolves.

            rootObject = new GameObject("Field/Car Anchor");
            // Make Andy model a child of the anchor.
            rootObject.transform.parent         = parent;
            rootObject.transform.localPosition  = new Vector3(0f, 0f, 0f);
            rootObject.transform.localScale     = new Vector3(1 / scaleFactor, 1 / scaleFactor, 1 / scaleFactor);
            fieldObject.transform.parent        = rootObject.transform;
            fieldObject.transform.localPosition = new Vector3(0f, -10f, 0f);
            fieldObject.transform.localScale    = new Vector3(65 * 1000 / scaleFactor, 65 * 1000 / scaleFactor, 65 * 1000 / scaleFactor);
            fieldObject.transform.localRotation = Quaternion.Euler(0f, -90f, 0f);
            for (int i = 0; i < gameData.players.Count; i++)
            {
                float x   = (float)(double)gameData.players[i][0][0] / localScale;
                float y   = (float)(double)gameData.players[i][0][2] / localScale;
                float z   = (float)(double)gameData.players[i][0][1] / localScale;
                var   car = Instantiate(prefab, new Vector3(0f, 0f, 0f), Quaternion.identity);
                car.transform.parent        = rootObject.transform;
                car.transform.localPosition = new Vector3(x, y, z);
                //car.transform.localScale = new Vector3(120 * 1000 / scaleFactor, 120 * 1000 / scaleFactor, 120 * 1000 / scaleFactor);
                var renderer  = car.transform.Find("carrosserie").GetComponent <Renderer>();
                var materials = renderer.materials;
                materials[0]       = gameData.colors[i] == 0 ? blueCar : orangeCar;
                renderer.materials = materials;


                var animatable = car.transform.Find("Animatable");
                foreach (Transform child in animatable)
                {
                    var childRenderer  = child.GetComponent <Renderer>();
                    var childMaterials = childRenderer.materials;
                    childMaterials[0]       = gameData.colors[i] == 0 ? blueCar : orangeCar;
                    childRenderer.materials = childMaterials;
                }
                //car.GetComponent<Renderer>().material = gameData.colors[i] == 0 ? blueCar : orangeCar;
                car.name = gameData.names[i];
                cars.Add(car);

                var boostObj = Instantiate(this.boost, new Vector3(0f, 0f, 0f), Quaternion.identity);
                boostObj.transform.parent        = car.transform;
                boostObj.transform.localPosition = new Vector3(0f, 0f, 0f);
                boostObj.transform.localRotation = Quaternion.Euler(-180f, 0f, 0f);
                var boostScale = 50f;
                boostObj.transform.localScale = new Vector3(1 / boostScale, 1 / boostScale, 1 / boostScale);
                boostObj.GetComponent <ParticleSystem>().Stop();
                boosts.Add(boostObj);
                var name = Instantiate(namePrefab, new Vector3(0f, 0f, 0f), Quaternion.identity);
                name.GetComponent <TextMesh>().text = gameData.names[i];
                name.transform.parent        = rootObject.transform;
                name.transform.localPosition = new Vector3(x, y + 1.0f, z);
                names.Add(name); // needed so we can look at camera all the time
                Debug.Log("Count " + (proto == null));
                Debug.Log(proto.players[i]);
                Debug.Log(proto.players[i].isOrange);
                playerTeamMap[proto.players[i].id.id] = proto.players[i].isOrange;
            }
            ballObject = Instantiate(ball, new Vector3(0f, 0f, 0f), Quaternion.identity);
            ballObject.transform.parent        = rootObject.transform;
            ballObject.transform.localPosition = new Vector3(0f, 0f, 0f);
            ballObject.transform.localScale    = new Vector3(10 * 1000 / scaleFactor, 10 * 1000 / scaleFactor, 10 * 1000 / scaleFactor);

            goalExplosionObject = Instantiate(goalExplosion, new Vector3(0f, 0f, 0f), Quaternion.identity);
            goalExplosionObject.transform.parent     = rootObject.transform;
            goalExplosionObject.transform.localScale = new Vector3(4 / scaleFactor, 4 / scaleFactor, 4 / scaleFactor);
            goalExplosionObject.Stop();


            currentTime = (float)gameData.frames[0][2];
        }
예제 #25
0
 private static void DumpDebug(Proto f, DumpState D)
 {
     int i,n;
      n= (D.strip != 0) ? 0 : f.sizelineinfo;
      DumpVector(f.lineinfo, n, D);
      n= (D.strip != 0) ? 0 : f.sizelocvars;
      DumpInt(n,D);
      for (i=0; i<n; i++)
      {
       DumpString(f.locvars[i].varname,D);
       DumpInt(f.locvars[i].startpc,D);
       DumpInt(f.locvars[i].endpc,D);
      }
      n= (D.strip != 0) ? 0 : f.sizeupvalues;
      DumpInt(n,D);
      for (i=0; i<n; i++) DumpString(f.upvalues[i],D);
 }
예제 #26
0
 public async Task Clear()
 {
     (await Proto.SendReceive("Clear")).Should().Be(ProtocolMessages.TagListClearConfirmation);
 }
예제 #27
0
 private static void DumpConstants(Proto f, DumpState D)
 {
     int i,n=f.sizek;
      DumpInt(n,D);
      for (i=0; i<n; i++)
      {
       /*const*/ TValue o=f.k[i];
       DumpChar(TType(o),D);
       switch (TType(o))
       {
        case LUA_TNIL:
     break;
        case LUA_TBOOLEAN:
     DumpChar(BValue(o),D);
     break;
        case LUA_TNUMBER:
     DumpNumber(NValue(o),D);
     break;
        case LUA_TSTRING:
     DumpString(RawTSValue(o),D);
     break;
        default:
     LuaAssert(0);			/* cannot happen */
     break;
       }
      }
      n=f.sizep;
      DumpInt(n,D);
      for (i=0; i<n; i++) DumpFunction(f.p[i],f.source,D);
 }
예제 #28
0
        public void Register(int responseId, Proto proto, Action <DDNode> handler)
        {
            var nrcb = new NetRecivedCallBack(proto.s2cdt, handler);

            handlerDic.Add(responseId, nrcb);
        }
예제 #29
0
파일: lundump.cs 프로젝트: raymanyu/kopilua
 private static void LoadConstants(LoadState S, Proto f)
 {
     int i,n;
      n=LoadInt(S);
      f.k = luaM_newvector<TValue>(S.L, n);
      f.sizek=n;
      for (i=0; i<n; i++) setnilvalue(f.k[i]);
      for (i=0; i<n; i++)
      {
       TValue o=f.k[i];
       int t=LoadChar(S);
       switch (t)
       {
        case LUA_TNIL:
        			setnilvalue(o);
     break;
        case LUA_TBOOLEAN:
        			setbvalue(o, LoadChar(S));
     break;
        case LUA_TNUMBER:
     setnvalue(o, LoadNumber(S));
     break;
        case LUA_TSTRING:
     setsvalue2n(S.L, o, LoadString(S));
     break;
        default:
     error(S,"bad constant");
     break;
       }
      }
      n=LoadInt(S);
      f.p=luaM_newvector<Proto>(S.L,n);
      f.sizep=n;
      for (i=0; i<n; i++) f.p[i]=null;
      for (i=0; i<n; i++) f.p[i]=LoadFunction(S,f.source);
 }
예제 #30
0
 public static void luaU_print(Proto f, int full)
 {
     PrintFunction(f, full);
 }
예제 #31
0
 public async Task AutoModeReset()
 {
     (await Proto.SendReceive("AutoModeReset")).Should().Be(ProtocolMessages.AutoModeResetConfirmation);
 }
예제 #32
0
 private static void DumpCode(Proto f, DumpState D)
 {
     DumpInt(f.sizecode, D);
     DumpVector(f.code, (uint)f.sizecode, D);
 }
예제 #33
0
 internal void Update(Proto.Seto.OrderCancelled message)
 {
     State.Update(message);
     OnStateUpdated();
 }
예제 #34
0
파일: lgc.cs 프로젝트: raymanyu/kopilua
 /*
 ** All marks are conditional because a GC may happen while the
 ** prototype is still being created
 */
 private static void traverseproto(global_State g, Proto f)
 {
     int i;
       if (f.source != null) stringmark(f.source);
       for (i=0; i<f.sizek; i++)  /* mark literals */
     markvalue(g, f.k[i]);
       for (i=0; i<f.sizeupvalues; i++) {  /* mark upvalue names */
     if (f.upvalues[i] != null)
       stringmark(f.upvalues[i]);
       }
       for (i=0; i<f.sizep; i++) {  /* mark nested protos */
     if (f.p[i] != null)
       markobject(g, f.p[i]);
       }
       for (i=0; i<f.sizelocvars; i++) {  /* mark local-variable names */
     if (f.locvars[i].varname != null)
       stringmark(f.locvars[i].varname);
       }
 }
        public void OnGUI()
        {
            var width  = Screen.width;
            var height = Screen.height;



            // Scoreboard
            int      offset    = 100;
            Color    orange    = new Color(1F, 0.64F, 0F);
            var      halfway   = width / 2;
            GUIStyle timeStyle = new GUIStyle();

            timeStyle.fontSize  = 40;
            timeStyle.fontStyle = FontStyle.Bold;

            timeStyle.normal.textColor = Color.gray;
            timeStyle.alignment        = TextAnchor.MiddleCenter;



            int timeRemaining = 300;

            if (StaticReplayScript.gameData != null)
            {
                timeRemaining = (int)StaticReplayScript.gameData.frames[currentFrame][1];
            }
            //int timeRemaining = 175;
            int minRemaining = timeRemaining / 60;
            int secondsRemaining;

            if (minRemaining > 0)
            {
                secondsRemaining = timeRemaining % (minRemaining * 60);
            }
            else
            {
                secondsRemaining = timeRemaining;
            }
            GUI.Label(new Rect(halfway, 35, 50, 50), String.Format("{0}:{1:D2}", minRemaining, secondsRemaining), timeStyle);


            var team0Score = 0;
            var team1Score = 0;

            if (StaticReplayScript.proto != null)
            {
                foreach (Goal g in StaticReplayScript.proto.gameMetadata.goals)
                {
                    if (g.frameNumber < currentFrame)
                    {
                        int playerTeam = playerTeamMap[g.playerId.id];
                        if (playerTeam == 0)
                        {
                            team0Score += 1;
                        }
                        else
                        {
                            team1Score += 1;
                        }
                    }
                }
            }
            for (int i = 0; i < 2; i++)
            {
                Color teamColor = (i == 0) ? Color.blue : (orange);

                var  offsetX  = (float)width / 2 - offset + (i * offset * 2);
                Rect position = new Rect(offsetX, 35, 50, 50);
                DrawQuad(position, teamColor);


                GUIStyle style = new GUIStyle();
                ///style.font = new Font("Liberation Sans");
                style.fontSize  = 40;
                style.fontStyle = FontStyle.Bold;

                style.normal.textColor = Color.white;
                style.alignment        = TextAnchor.MiddleCenter;

                GUI.Label(position, (i == 0 ? team0Score : team1Score).ToString(), style);
                //Color oldColor = GUI.backgroundColor;
                //GUI.backgroundColor = (i == 0) ? Color.blue : Color.red*Color.yellow;
                //GUI.backgroundColor = oldColor;
            }
            RootObject gameData = StaticReplayScript.gameData;
            Proto      proto    = StaticReplayScript.proto;

            if (gameData != null && proto != null && fieldObject != null)
            {
                // Slider Styling
                GUIStyle thumbStyle  = new GUIStyle(GUI.skin.horizontalSliderThumb);
                GUIStyle sliderStyle = new GUIStyle(GUI.skin.horizontalSlider);
                sliderStyle.padding = new RectOffset(width / 10, width / 10, width / 10, width / 10);


                var logoWidth = width / 60;
                var nextFrame = (int)GUI.HorizontalSlider(new Rect(0, 19 / 20f * height, width, height / 20f), currentFrame, 0, gameData.frames.Count);
                if (nextFrame != currentFrame)
                {
                    currentFrame = nextFrame;
                    currentTime  = (float)gameData.frames[nextFrame][2];
                }
                for (int i = 0; i < proto.gameMetadata.goals.Count; i++)
                {
                    Goal g     = proto.gameMetadata.goals[i];
                    var  frame = g.frameNumber;
                    var  size  = new Rect((width * frame / (float)gameData.frames.Count) - logoWidth / 2, 18 / 20f * height, logoWidth, logoWidth);
                    if (playerTeamMap.ContainsKey(g.playerId.id))
                    {
                        Color teamColor = playerTeamMap[g.playerId.id] == 0 ? Color.blue : (orange);
                        DrawQuad(size, teamColor);
                    }
                    else
                    {
                        Debug.Log(string.Format("{0} is not in {1}", g.playerId.id, playerTeamMap.Keys.Count));
                    }

                    GUI.Box(size, goalIndicator);
                }
            }

            GUIStyle buttonStyle = new GUIStyle(GUI.skin.button);

            buttonStyle.fontSize = 30;
            // Button
            var back = GUI.Button(new Rect(25, 25, width / 10, width / 25), "Back to Menu", buttonStyle);

            if (back)
            {
                SceneManager.LoadScene("Menu");
            }

            var zoomOut = GUI.Button(new Rect(width * 2 / 10, 25, width / 25, width / 25), "-", buttonStyle);
            var zoomIn  = GUI.Button(new Rect(width * 3 / 10, 25, width / 25, width / 25), "+", buttonStyle);

            if (zoomOut)
            {
                scaleFactor += 100;
                rootObject.transform.localScale = new Vector3(1 / scaleFactor, 1 / scaleFactor, 1 / scaleFactor);
            }
            else if (zoomIn)
            {
                scaleFactor -= 100;
                rootObject.transform.localScale = new Vector3(1 / scaleFactor, 1 / scaleFactor, 1 / scaleFactor);
            }


            if (dataMsg != null)
            {
                var style = new GUIStyle();
                style.fontSize  = 20;
                style.fontStyle = FontStyle.Bold;
                GUI.Label(new Rect(0, width / 10, width / 5, width / 10), dataMsg, style);
            }
            if (protoMsg != null)
            {
                var style = new GUIStyle();
                style.fontSize  = 20;
                style.fontStyle = FontStyle.Bold;
                GUI.Label(new Rect(0, 0, width / 5, width / 10), protoMsg, style);
            }
        }
예제 #36
0
        //#undef check
        //#undef checkjump
        //#undef checkreg

        /* }====================================================== */


        public static int luaG_checkcode(Proto pt)
        {
            return((symbexec(pt, pt.sizecode, NO_REG) != 0) ? 1 : 0);
        }
예제 #37
0
 internal void Update(Proto.Seto.OrderExecuted message)
 {
     State.Update(message);
     OnStateUpdated();
 }
예제 #38
0
        private static CharPtr getobjname(lua_State L, CallInfo ci, int reg,
                                          ref CharPtr name)
        {
            Proto   p      = ci_func(ci).p;
            CharPtr what   = null;
            int     lastpc = currentpc(ci);
            int     pc;

            name = luaF_getlocalname(p, reg + 1, lastpc);
            if (name != null)        /* is a local? */
            {
                return("local");
            }
            /* else try symbolic execution */
            for (pc = 0; pc < lastpc; pc++)
            {
                Instruction i  = p.code[pc];
                OpCode      op = GET_OPCODE(i);
                int         a  = GETARG_A(i);
                switch (op)
                {
                case OpCode.OP_MOVE: {
                    if (reg == a)
                    {
                        int b = GETARG_B(i);    /* move from 'b' to 'a' */
                        if (b < a)
                        {
                            what = getobjname(L, ci, b, ref name);  /* get name for 'b' */
                        }
                        else
                        {
                            what = null;
                        }
                    }
                    break;
                }

                case OpCode.OP_GETTABUP:
                case OpCode.OP_GETTABLE: {
                    if (reg == a)
                    {
                        int     k  = GETARG_C(i);               /* key index */
                        int     t  = GETARG_B(i);
                        CharPtr vn = (op == OpCode.OP_GETTABLE) /* name of indexed variable */
                                           ? luaF_getlocalname(p, t + 1, pc)
                                           : getstr(p.upvalues[t].name);
                        kname(L, ci, k, a, what, ref name);
                        what = (vn != null && strcmp(vn, LUA_ENV) == 0) ? "global" : "field";
                    }
                    break;
                }

                case OpCode.OP_GETUPVAL: {
                    if (reg == a)
                    {
                        int     u  = GETARG_B(i); /* upvalue index */
                        TString tn = p.upvalues[u].name;
                        name = tn != null?getstr(tn) : "?";

                        what = "upvalue";
                    }
                    break;
                }

                case OpCode.OP_LOADK:
                case OpCode.OP_LOADKX: {
                    if (reg == a)
                    {
                        int b = (op == OpCode.OP_LOADK) ? GETARG_Bx(i)
                                           : GETARG_Ax(p.code[pc + 1]);
                        if (ttisstring(p.k[b]))
                        {
                            what = "constant";
                            name = svalue(p.k[b]);
                        }
                    }
                    break;
                }

                case OpCode.OP_LOADNIL: {
                    int b = GETARG_B(i);
                    if (a <= reg && reg <= a + b)      /* set registers from 'a' to 'a+b' */
                    {
                        what = null;
                    }
                    break;
                }

                case OpCode.OP_SELF: {
                    if (reg == a)
                    {
                        int k = GETARG_C(i);    /* key index */
                        kname(L, ci, k, a, what, ref name);
                        what = "method";
                    }
                    break;
                }

                case OpCode.OP_TFORCALL: {
                    if (reg >= a + 2)
                    {
                        what = null;                    /* affect all regs above its base */
                    }
                    break;
                }

                case OpCode.OP_CALL:
                case OpCode.OP_TAILCALL: {
                    if (reg >= a)
                    {
                        what = null;                /* affect all registers above base */
                    }
                    break;
                }

                case OpCode.OP_JMP: {
                    int b    = GETARG_sBx(i);
                    int dest = pc + 1 + b;
                    /* jump is forward and do not skip `lastpc'? */
                    if (pc < dest && dest <= lastpc)
                    {
                        pc += b;    /* do the jump */
                    }
                    break;
                }

                case OpCode.OP_TEST: {
                    if (reg == a)
                    {
                        what = null;                /* jumped code can change 'a' */
                    }
                    break;
                }

                default:
                    if (testAMode(op) != 0 && reg == a)
                    {
                        what = null;
                    }
                    break;
                }
            }
            return(what);
        }
예제 #39
0
 internal static Order FromSeto(
     Proto.Seto.OrderState state,
     Proto.Seto.PriceType priceType,
     uint price,
     Proto.Seto.Uuid128 market,
     Proto.Seto.Uuid128 contract,
     Proto.Seto.Side side)
 {
     return new Order(
         new Price(priceType, price),
         OrderState.FromSeto(state),
         Uid.FromUuid128(market),
         Uid.FromUuid128(contract),
         SetoMap.Sides.FromSeto(side));
 }
예제 #40
0
        /*
        ** Try to find a name for a function based on the code that called it.
        ** (Only works when function was called by a Lua function.)
        ** Returns what the name is (e.g., "for iterator", "method",
        ** "metamethod") and sets '*name' to point to the name.
        */
        private static CharPtr funcnamefromcode(lua_State L, CallInfo ci,
                                                ref CharPtr name)
        {
            TMS         tm = (TMS)0; /* (initial value avoids warnings) */ //FIXME:added, = 0
            Proto       p  = ci_func(ci).p;                                /* calling function */
            int         pc = currentpc(ci);                                /* calling instruction index */
            Instruction i  = p.code[pc];                                   /* calling instruction */

            if (0 != (ci.callstatus & CIST_HOOKED))                        /* was it called inside a hook? */
            {
                name = "?";
                return("hook");
            }
            switch (GET_OPCODE(i))
            {
            case OpCode.OP_CALL:
            case OpCode.OP_TAILCALL:
                return(getobjname(p, pc, GETARG_A(i), ref name)); /* get function name */

            case OpCode.OP_TFORCALL: {                            /* for iterator */
                name = "for iterator";
                return("for iterator");
            }

            /* other instructions can do calls through metamethods */
            case OpCode.OP_SELF:
            case OpCode.OP_GETTABUP:
            case OpCode.OP_GETTABLE:
                tm = TMS.TM_INDEX;
                break;

            case OpCode.OP_SETTABUP:
            case OpCode.OP_SETTABLE:
                tm = TMS.TM_NEWINDEX;
                break;

            case OpCode.OP_ADD:
            case OpCode.OP_SUB:
            case OpCode.OP_MUL:
            case OpCode.OP_MOD:
            case OpCode.OP_POW:
            case OpCode.OP_DIV:
            case OpCode.OP_IDIV:
            case OpCode.OP_BAND:
            case OpCode.OP_BOR:
            case OpCode.OP_BXOR:
            case OpCode.OP_SHL:
            case OpCode.OP_SHR: {
                int offset = cast_int(GET_OPCODE(i)) - cast_int(OpCode.OP_ADD); /* ORDER OP */
                tm = (TMS)(offset + cast_int(TMS.TM_ADD));                      /* ORDER TM */
                break;
            }

            case OpCode.OP_UNM: tm = TMS.TM_UNM; break;

            case OpCode.OP_BNOT: tm = TMS.TM_BNOT; break;

            case OpCode.OP_LEN: tm = TMS.TM_LEN; break;

            case OpCode.OP_CONCAT: tm = TMS.TM_CONCAT; break;

            case OpCode.OP_EQ: tm = TMS.TM_EQ; break;

            case OpCode.OP_LT: tm = TMS.TM_LT; break;

            case OpCode.OP_LE: tm = TMS.TM_LE; break;

            default:
                return(null);                    /* cannot find a reasonable name */
            }
            name = getstr(G(L).tmname[(int)tm]); //FIXME:(int)
            return("metamethod");
        }
        /// <summary>Read the given number of bytes from the stream and deserialze it into the instance.</summary>
        public static Proto.Test.Nullables.LongMessage DeserializeLength(Stream stream, int length, Proto.Test.Nullables.LongMessage instance)
        {
            long limit = stream.Position + length;
            while (true)
            {
                if (stream.Position >= limit)
                {
                    if (stream.Position == limit)
                        break;
                    else
                        throw new global::SilentOrbit.ProtocolBuffers.ProtocolBufferException("Read past max limit");
                }
                int keyByte = stream.ReadByte();
                if (keyByte == -1)
                    throw new System.IO.EndOfStreamException();
                var key = global::SilentOrbit.ProtocolBuffers.ProtocolParser.ReadKey((byte)keyByte, stream);

                // Reading field ID > 16 and unknown field ID/wire type combinations
                switch (key.Field)
                {
                    case 0:
                        throw new global::SilentOrbit.ProtocolBuffers.ProtocolBufferException("Invalid field id: 0, something went wrong in the stream");
                    case 32:
                        if(key.WireType != global::SilentOrbit.ProtocolBuffers.Wire.Varint)
                            break;
                        instance.FieldX1 = (int)global::SilentOrbit.ProtocolBuffers.ProtocolParser.ReadUInt64(stream);
                        continue;
                    case 64:
                        if(key.WireType != global::SilentOrbit.ProtocolBuffers.Wire.Varint)
                            break;
                        instance.FieldX2 = (int)global::SilentOrbit.ProtocolBuffers.ProtocolParser.ReadUInt64(stream);
                        continue;
                    case 96:
                        if(key.WireType != global::SilentOrbit.ProtocolBuffers.Wire.Varint)
                            break;
                        instance.FieldX3 = (int)global::SilentOrbit.ProtocolBuffers.ProtocolParser.ReadUInt64(stream);
                        continue;
                    case 100:
                        if(key.WireType != global::SilentOrbit.ProtocolBuffers.Wire.Varint)
                            break;
                        instance.FieldX4 = (int)global::SilentOrbit.ProtocolBuffers.ProtocolParser.ReadUInt64(stream);
                        continue;
                    default:
                        global::SilentOrbit.ProtocolBuffers.ProtocolParser.SkipKey(stream, key);
                        break;
                }
            }

            return instance;
        }
예제 #42
0
        }                                                                                              //FIXME:changed, ref->return

        //#if !defined(luai_verifycode)
        public static Proto luai_verifycode(lua_State L, Mbuffer b, Proto f)
        {
            return(f);
        }
        /// <summary>Takes the remaining content of the stream and deserialze it into the instance.</summary>
        public static Proto.Test.Nullables.Container Deserialize(Stream stream, Proto.Test.Nullables.Container instance)
        {
            while (true)
            {
                int keyByte = stream.ReadByte();
                if (keyByte == -1)
                    break;
                // Optimized reading of known fields with field ID < 16
                switch (keyByte)
                {
                    // Field 1 LengthDelimited
                    case 10:
                        if (instance.MyNestedMessage == null)
                            instance.MyNestedMessage = Proto.Test.Nullables.Container.Nested.DeserializeLengthDelimited(stream);
                        else
                            Proto.Test.Nullables.Container.Nested.DeserializeLengthDelimited(stream, instance.MyNestedMessage);
                        continue;
                    // Field 2 LengthDelimited
                    case 18:
                        if (instance.NestedField == null)
                            instance.NestedField = Proto.Test.Nullables.Container.Nested.DeserializeLengthDelimited(stream);
                        else
                            Proto.Test.Nullables.Container.Nested.DeserializeLengthDelimited(stream, instance.NestedField);
                        continue;
                }

                var key = global::SilentOrbit.ProtocolBuffers.ProtocolParser.ReadKey((byte)keyByte, stream);

                // Reading field ID > 16 and unknown field ID/wire type combinations
                switch (key.Field)
                {
                    case 0:
                        throw new global::SilentOrbit.ProtocolBuffers.ProtocolBufferException("Invalid field id: 0, something went wrong in the stream");
                    default:
                        global::SilentOrbit.ProtocolBuffers.ProtocolParser.SkipKey(stream, key);
                        break;
                }
            }

            return instance;
        }
예제 #44
0
        /*
        ** try to find last instruction before 'lastpc' that modified register 'reg'
        */
        private static int findsetreg(Proto p, int lastpc, int reg)
        {
            int pc;
            int setreg    = -1;     /* keep last instruction that changed 'reg' */
            int jmptarget = 0;      /* any code before this address is conditional */

            for (pc = 0; pc < lastpc; pc++)
            {
                Instruction i  = p.code[pc];
                OpCode      op = GET_OPCODE(i);
                int         a  = GETARG_A(i);
                switch (op)
                {
                case OpCode.OP_LOADNIL: {
                    int b = GETARG_B(i);
                    if (a <= reg && reg <= a + b)      /* set registers from 'a' to 'a+b' */
                    {
                        setreg = filterpc(pc, jmptarget);
                    }
                    break;
                }

                case OpCode.OP_TFORCALL: {
                    if (reg >= a + 2)      /* affect all regs above its base */
                    {
                        setreg = filterpc(pc, jmptarget);
                    }
                    break;
                }

                case OpCode.OP_CALL:
                case OpCode.OP_TAILCALL: {
                    if (reg >= a)
                    {
                        setreg = pc;                /* affect all registers above base */
                    }
                    break;
                }

                case OpCode.OP_JMP: {
                    int b    = GETARG_sBx(i);
                    int dest = pc + 1 + b;
                    /* jump is forward and do not skip `lastpc'? */
                    if (pc < dest && dest <= lastpc)
                    {
                        if (dest > jmptarget)
                        {
                            jmptarget = dest;  /* update 'jmptarget' */
                        }
                    }
                    break;
                }

                default:
                    if (testAMode(op) != 0 && reg == a)      /* any instruction that set A */
                    {
                        setreg = filterpc(pc, jmptarget);
                    }
                    break;
                }
            }
            return(setreg);
        }
            /// <summary>Read the VarInt length prefix and the given number of bytes from the stream and deserialze it into the instance.</summary>
            public static Proto.Test.Nullables.Container.Nested DeserializeLengthDelimited(Stream stream, Proto.Test.Nullables.Container.Nested instance)
            {
                long limit = global::SilentOrbit.ProtocolBuffers.ProtocolParser.ReadUInt32(stream);
                limit += stream.Position;
                while (true)
                {
                    if (stream.Position >= limit)
                    {
                        if (stream.Position == limit)
                            break;
                        else
                            throw new global::SilentOrbit.ProtocolBuffers.ProtocolBufferException("Read past max limit");
                    }
                    int keyByte = stream.ReadByte();
                    if (keyByte == -1)
                        throw new System.IO.EndOfStreamException();
                    // Optimized reading of known fields with field ID < 16
                    switch (keyByte)
                    {
                        // Field 1 LengthDelimited
                        case 10:
                            if (instance.NestedData == null)
                                instance.NestedData = Proto.Test.Nullables.Data.DeserializeLengthDelimited(stream);
                            else
                                Proto.Test.Nullables.Data.DeserializeLengthDelimited(stream, instance.NestedData);
                            continue;
                    }

                    var key = global::SilentOrbit.ProtocolBuffers.ProtocolParser.ReadKey((byte)keyByte, stream);

                    // Reading field ID > 16 and unknown field ID/wire type combinations
                    switch (key.Field)
                    {
                        case 0:
                            throw new global::SilentOrbit.ProtocolBuffers.ProtocolBufferException("Invalid field id: 0, something went wrong in the stream");
                        default:
                            global::SilentOrbit.ProtocolBuffers.ProtocolParser.SkipKey(stream, key);
                            break;
                    }
                }

                return instance;
            }
예제 #46
0
        private static CharPtr getobjname(Proto p, int lastpc, int reg,
                                          ref CharPtr name)
        {
            int pc;

            name = luaF_getlocalname(p, reg + 1, lastpc);
            if (name != null)      /* is a local? */
            {
                return("local");
            }
            /* else try symbolic execution */
            pc = findsetreg(p, lastpc, reg);
            if (pc != -1)          /* could find instruction? */
            {
                Instruction i  = p.code[pc];
                OpCode      op = GET_OPCODE(i);
                switch (op)
                {
                case OpCode.OP_MOVE: {
                    int b = GETARG_B(i);      /* move from 'b' to 'a' */
                    if (b < GETARG_A(i))
                    {
                        return(getobjname(p, pc, b, ref name));   /* get name for 'b' */
                    }
                    break;
                }

                case OpCode.OP_GETTABUP:
                case OpCode.OP_GETTABLE: {
                    int     k  = GETARG_C(i);               /* key index */
                    int     t  = GETARG_B(i);               /* table index */
                    CharPtr vn = (op == OpCode.OP_GETTABLE) /* name of indexed variable */
                                         ? luaF_getlocalname(p, t + 1, pc)
                                         : upvalname(p, t);
                    kname(p, pc, k, ref name);
                    return((vn != null && strcmp(vn, LUA_ENV) == 0) ? "global" : "field");
                }

                case OpCode.OP_GETUPVAL: {
                    name = upvalname(p, GETARG_B(i));
                    return("upvalue");
                }

                case OpCode.OP_LOADK:
                case OpCode.OP_LOADKX: {
                    int b = (op == OpCode.OP_LOADK) ? GETARG_Bx(i)
                                                 : GETARG_Ax(p.code[pc + 1]);
                    if (ttisstring(p.k[b]))
                    {
                        name = svalue(p.k[b]);
                        return("constant");
                    }
                    break;
                }

                case OpCode.OP_SELF: {
                    int k = GETARG_C(i);      /* key index */
                    kname(p, pc, k, ref name);
                    return("method");
                }

                default: break;        /* go through to return NULL */
                }
            }
            return(null);       /* could not find reasonable name */
        }
        /// <summary>Read the given number of bytes from the stream and deserialze it into the instance.</summary>
        public static Proto.Test.Nullables.MyMessage DeserializeLength(Stream stream, int length, Proto.Test.Nullables.MyMessage instance)
        {
            long limit = stream.Position + length;
            while (true)
            {
                if (stream.Position >= limit)
                {
                    if (stream.Position == limit)
                        break;
                    else
                        throw new global::SilentOrbit.ProtocolBuffers.ProtocolBufferException("Read past max limit");
                }
                int keyByte = stream.ReadByte();
                if (keyByte == -1)
                    throw new System.IO.EndOfStreamException();
                // Optimized reading of known fields with field ID < 16
                switch (keyByte)
                {
                    // Field 1 Varint
                    case 8:
                        instance.Foo = (int)global::SilentOrbit.ProtocolBuffers.ProtocolParser.ReadUInt64(stream);
                        continue;
                    // Field 2 LengthDelimited
                    case 18:
                        instance.Bar = global::SilentOrbit.ProtocolBuffers.ProtocolParser.ReadString(stream);
                        continue;
                }

                var key = global::SilentOrbit.ProtocolBuffers.ProtocolParser.ReadKey((byte)keyByte, stream);

                // Reading field ID > 16 and unknown field ID/wire type combinations
                switch (key.Field)
                {
                    case 0:
                        throw new global::SilentOrbit.ProtocolBuffers.ProtocolBufferException("Invalid field id: 0, something went wrong in the stream");
                    default:
                        global::SilentOrbit.ProtocolBuffers.ProtocolParser.SkipKey(stream, key);
                        break;
                }
            }

            return instance;
        }
예제 #48
0
        /*
        ** returns true if function has been executed (C function)
        */
        public static int luaD_precall(lua_State L, StkId func, int nresults)
        {
            lua_CFunction f;
            CallInfo      ci;
            int           n; /* number of arguments (Lua) or returns (C) */
            ptrdiff_t     funcr = savestack(L, func);

            switch (ttype(func))
            {
            case LUA_TLCF:          /* light C function */
                f = fvalue(func);
                //goto Cfunc; //FIXME:removed, see below
                luaC_checkGC(L);                  /* stack grow uses memory */
                luaD_checkstack(L, LUA_MINSTACK); /* ensure minimum stack size */
                ci          = next_ci(L);         /* now 'enter' new function */
                ci.nresults = (short)nresults;    //FIXME:added, (short)
                ci.func     = restorestack(L, funcr);
                ci.top      = L.top + LUA_MINSTACK;
                lua_assert(ci.top <= L.stack_last);
                ci.callstatus = 0;
                if ((L.hookmask & LUA_MASKCALL) != 0)
                {
                    luaD_hook(L, LUA_HOOKCALL, -1);
                }
                lua_unlock(L);
                n = f(L);        /* do the actual call */
                lua_lock(L);
                api_checknelems(L, n);
                luaD_poscall(L, L.top - n, n);
                return(1);

            case LUA_TCCL: {          /* C closure */
                f = clCvalue(func).f;
                //Cfunc: //FIXME:removed, see upper
                luaC_checkGC(L);                  /* stack grow uses memory */
                luaD_checkstack(L, LUA_MINSTACK); /* ensure minimum stack size */
                ci          = next_ci(L);         /* now 'enter' new function */
                ci.nresults = (short)nresults;    //FIXME:added, (short)
                ci.func     = restorestack(L, funcr);
                ci.top      = L.top + LUA_MINSTACK;
                lua_assert(ci.top <= L.stack_last);
                ci.callstatus = 0;
                if ((L.hookmask & LUA_MASKCALL) != 0)
                {
                    luaD_hook(L, LUA_HOOKCALL, -1);
                }
                lua_unlock(L);
                n = f(L);        /* do the actual call */
                lua_lock(L);
                api_checknelems(L, n);
                luaD_poscall(L, L.top - n, n);
                return(1);
            }

            case LUA_TLCL: {          /* Lua function: prepare its call */
                StkId base_;
                Proto p = clLvalue(func).p;
                n = cast_int(L.top - func) - 1; /* number of real arguments */
                luaC_checkGC(L);                /* stack grow uses memory */
                luaD_checkstack(L, p.maxstacksize);
                for (; n < p.numparams; n++)
                {
                    setnilvalue(lua_TValue.inc(ref L.top));      /* complete missing arguments */
                }
                if (0 == p.is_vararg)
                {
                    func  = restorestack(L, funcr);
                    base_ = func + 1;
                }
                else
                {
                    base_ = adjust_varargs(L, p, n);
                    func  = restorestack(L, funcr); /* previous call can change stack */
                }
                ci           = next_ci(L);          /* now `enter' new function */
                ci.nresults  = (short)nresults;     //FIXME:added, (short)
                ci.func      = func;
                ci.u.l.base_ = base_;
                ci.top       = base_ + p.maxstacksize;
                lua_assert(ci.top <= L.stack_last);
                ci.u.l.savedpc = new InstructionPtr(p.code, 0); /* starting point */            //FIXME:??? //FIXME:???
                ci.callstatus  = CIST_LUA;
                L.top          = ci.top;
                if ((L.hookmask & LUA_MASKCALL) != 0)
                {
                    callhook(L, ci);
                }
                return(0);
            }

            default: {                                   /* not a function */
                luaD_checkstack(L, 1);                   /* ensure space for metamethod */
                func = restorestack(L, funcr);           /* previous call may change stack */
                tryfuncTM(L, func);                      /* try to get '__call' metamethod */
                return(luaD_precall(L, func, nresults)); /* now it must be a function */
            }
            }
        }
예제 #49
0
파일: lobject.cs 프로젝트: raymanyu/kopilua
 //#define setptvalue2s	setptvalue
 internal static void setptvalue2s(lua_State L, TValue obj, Proto x)
 {
     setptvalue(L, obj, x);
 }
예제 #50
0
 internal static void setptvalue(lua_State L, TValue obj, Proto x)
 {
     obj.value.gc = x;
     obj.tt       = LUA_TPROTO;
     checkliveness(G(L), obj);
 }
예제 #51
0
 private static void DumpFunction(Proto f, TString p, DumpState D)
 {
     DumpString( ((f.source==p) || (D.strip!=0)) ? null : f.source, D);
      DumpInt(f.linedefined,D);
      DumpInt(f.lastlinedefined,D);
      DumpChar(f.nups,D);
      DumpChar(f.numparams,D);
      DumpChar(f.is_vararg,D);
      DumpChar(f.maxstacksize,D);
      DumpCode(f,D);
      DumpConstants(f,D);
      DumpDebug(f,D);
 }
예제 #52
0
 //#define setptvalue2s	setptvalue
 internal static void setptvalue2s(lua_State L, TValue obj, Proto x)
 {
     setptvalue(L, obj, x);
 }
예제 #53
0
 private static void DumpCode(Proto f,DumpState D)
 {
     DumpVector(f.code, f.sizecode, D);
 }
예제 #54
0
 public static int pcRel(InstructionPtr pc, Proto p)
 {
     Debug.Assert(pc.codes == p.code);
     return(pc.pc - 1);
 }
예제 #55
0
 internal static void SetPTValue(LuaState L, TValue obj, Proto x)
 {
     obj.value.gc = x;
     obj.tt = LUATPROTO;
     CheckLiveness(G(L), obj);
 }
예제 #56
0
 public static int getfuncline(Proto f, int pc)
 {
     return((f.lineinfo != null) ? f.lineinfo[pc] : 0);
 }
예제 #57
0
파일: lundump.cs 프로젝트: raymanyu/kopilua
 private static void LoadCode(LoadState S, Proto f)
 {
     int n=LoadInt(S);
      f.code = luaM_newvector<Instruction>(S.L, n);
      f.sizecode=n;
      f.code = (Instruction[])LoadVector(S, typeof(Instruction), n);
 }
예제 #58
0
 private void OnDestroy()
 {
     Proto.CallLeave();
     Net.Close();
 }
예제 #59
0
파일: lundump.cs 프로젝트: raymanyu/kopilua
 private static void LoadDebug(LoadState S, Proto f)
 {
     int i,n;
      n=LoadInt(S);
      f.lineinfo=luaM_newvector<int>(S.L,n);
      f.sizelineinfo=n;
      f.lineinfo = (int[])LoadVector(S, typeof(int), n);
      n=LoadInt(S);
      f.locvars=luaM_newvector<LocVar>(S.L,n);
      f.sizelocvars=n;
      for (i=0; i<n; i++) f.locvars[i].varname=null;
      for (i=0; i<n; i++)
      {
       f.locvars[i].varname=LoadString(S);
       f.locvars[i].startpc=LoadInt(S);
       f.locvars[i].endpc=LoadInt(S);
      }
      n=LoadInt(S);
      f.upvalues=luaM_newvector<TString>(S.L, n);
      f.sizeupvalues=n;
      for (i=0; i<n; i++) f.upvalues[i]=null;
      for (i=0; i<n; i++) f.upvalues[i]=LoadString(S);
 }
예제 #60
0
 public async Task RfModulation()
 {
     (await Proto.SendReceive("RFModulation = DRM")).Should().Be("RFModulation = DRM");
     (await Proto.SendReceive("RFModulation?")).Should().Be("RFModulation = DRM");
 }