check(precheck(pt));  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;    check(op < NUM_OPCODES);    checkreg(pt, a);    switch (getOpMode(op)) {      case iABC: {        b = GETARG_B(i);        c = GETARG_C(i);        check(checkArgMode(pt, b, getBMode(op)));        check(checkArgMode(pt, c, getCMode(op)));        break;      }      case iABx: {        b = GETARG_Bx(i);        if (getBMode(op) == OpArgK) check(b < pt->sizek);        break;      }      case iAsBx: {        b = GETARG_sBx(i);        if (getBMode(op) == OpArgR) {          int dest = pc+1+b;          check(0 <= dest && dest < pt->sizecode);          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) == OP_SETLIST && GETARG_C(d) == 0)) break;            }            /* if 'j' is even, previous value is not a setlist (even if               it looks like one) */            check((j&1) == 0);          }        }        break;      }    }    if (testAMode(op)) {      if (a == reg) last = pc;  /* change register `a' */    }    if (testTMode(op)) {      check(pc+2 < pt->sizecode);  /* check skip */      check(GET_OPCODE(pt->code[pc+1]) == OP_JMP);    }    switch (op) {      case OP_LOADBOOL: {        if (c == 1) {  /* does it jump? */          check(pc+2 < pt->sizecode);  /* check its jump */          check(GET_OPCODE(pt->code[pc+1]) != OP_SETLIST ||                GETARG_C(pt->code[pc+1]) != 0);        }        break;      }      case OP_LOADNIL: {        if (a <= reg && reg <= b)          last = pc;  /* set registers from `a' to `b' */        break;      }      case OP_GETUPVAL:      case OP_SETUPVAL: {        check(b < pt->nups);        break;      }      case OP_GETGLOBAL:      case OP_SETGLOBAL: {        check(ttisstring(&pt->k[b]));        break;      }      case OP_SELF: {        checkreg(pt, a+1);        if (reg == a+1) last = pc;        break;      }      case OP_CONCAT: {        check(b < c);  /* at least two operands */        break;      }      case OP_TFORLOOP: {        check(c >= 1);  /* 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 OP_FORLOOP:      case OP_FORPREP:        checkreg(pt, a+3);        /* go through */      case OP_JMP: {        int 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 OP_CALL:      case OP_TAILCALL: {        if (b != 0) {          checkreg(pt, a+b-1);        }        c--;  /* c = num. returns */        if (c == LUA_MULTRET) {          check(checkopenop(pt, pc));        }        else if (c != 0)          checkreg(pt, a+c-1);        if (reg >= a) last = pc;  /* affect all registers above base */        break;      }      case OP_RETURN: {        b--;  /* b = num. returns */        if (b > 0) checkreg(pt, a+b-1);        break;      }      case OP_SETLIST: {        if (b > 0) checkreg(pt, a + b);        if (c == 0) {          pc++;          check(pc < pt->sizecode - 1);        }        break;      }      case OP_CLOSURE: {        int nup, j;        check(b < pt->sizep);        nup = pt->p[b]->nups;        check(pc + nup < pt->sizecode);        for (j = 1; j <= nup; j++) {          OpCode op1 = GET_OPCODE(pt->code[pc + j]);          check(op1 == OP_GETUPVAL || op1 == OP_MOVE);        }        if (reg != NO_REG)  /* tracing? */          pc += nup;  /* do not 'execute' these pseudo-instructions */        break;      }      case OP_VARARG: {        check((pt->is_vararg & VARARG_ISVARARG) &&             !(pt->is_vararg & VARARG_NEEDSARG));        b--;        if (b == LUA_MULTRET) check(checkopenop(pt, pc));        checkreg(pt, a+b-1);        break;      }      default: break;    }  }  return pt->code[last];}#undef check#undef checkjump#undef checkreg/* }====================================================== */int luaG_checkcode (const Proto *pt) {  return (symbexec(pt, pt->sizecode, NO_REG) != 0);}static const char *kname (Proto *p, int c) {  if (ISK(c) && ttisstring(&p->k[INDEXK(c)]))    return svalue(&p->k[INDEXK(c)]);  else    return "?";}static const char *getobjname (lua_State *L, CallInfo *ci, int stackpos,                               const char **name) {  if (isLua(ci)) {  /* a Lua function? */    Proto *p = ci_func(ci)->l.p;    int pc = currentpc(L, ci);    Instruction i;    *name = luaF_getlocalname(p, stackpos+1, pc);    if (*name)  /* is a local? */      return "local";    i = symbexec(p, pc, stackpos);  /* try symbolic execution */    lua_assert(pc != -1);    switch (GET_OPCODE(i)) {      case OP_GETGLOBAL: {        int g = GETARG_Bx(i);  /* global index */        lua_assert(ttisstring(&p->k[g]));        *name = svalue(&p->k[g]);        return "global";      }      case OP_MOVE: {        int a = GETARG_A(i);        int b = GETARG_B(i);  /* move from `b' to `a' */        if (b < a)          return getobjname(L, ci, b, name);  /* get name for `b' */        break;      }      case OP_GETTABLE: {        int k = GETARG_C(i);  /* key index */        *name = kname(p, k);        return "field";      }      case OP_GETUPVAL: {        int u = GETARG_B(i);  /* upvalue index */        *name = p->upvalues ? getstr(p->upvalues[u]) : "?";        return "upvalue";      }      case OP_SELF: {        int k = GETARG_C(i);  /* key index */        *name = kname(p, k);        return "method";      }      default: break;    }  }  return NULL;  /* no useful name found */}static const char *getfuncname (lua_State *L, CallInfo *ci, const char **name) {  Instruction i;  if ((isLua(ci) && ci->tailcalls > 0) || !isLua(ci - 1))    return NULL;  /* calling function is not Lua (or is unknown) */  ci--;  /* calling function */  i = ci_func(ci)->l.p->code[currentpc(L, ci)];  if (GET_OPCODE(i) == OP_CALL || GET_OPCODE(i) == OP_TAILCALL ||      GET_OPCODE(i) == OP_TFORLOOP)    return getobjname(L, ci, GETARG_A(i), name);  else    return NULL;  /* no useful name can be found */}/* only ANSI way to check whether a pointer points to an array */static int isinstack (CallInfo *ci, const TValue *o) {  StkId p;  for (p = ci->base; p < ci->top; p++)    if (o == p) return 1;  return 0;}void luaG_typeerror (lua_State *L, const TValue *o, const char *op) {  const char *name = NULL;  const char *t = luaT_typenames[ttype(o)];  const char *kind = (isinstack(L->ci, o)) ?                         getobjname(L, L->ci, cast_int(o - L->base), &name) :                         NULL;  if (kind)    luaG_runerror(L, "attempt to %s %s " LUA_QS " (a %s value)",                op, kind, name, t);  else    luaG_runerror(L, "attempt to %s a %s value", op, t);}void luaG_concaterror (lua_State *L, StkId p1, StkId p2) {  if (ttisstring(p1) || ttisnumber(p1)) p1 = p2;  lua_assert(!ttisstring(p1) && !ttisnumber(p1));  luaG_typeerror(L, p1, "concatenate");}void luaG_aritherror (lua_State *L, const TValue *p1, const TValue *p2) {  TValue temp;  if (luaV_tonumber(p1, &temp) == NULL)    p2 = p1;  /* first operand is wrong */  luaG_typeerror(L, p2, "perform arithmetic on");}int luaG_ordererror (lua_State *L, const TValue *p1, const TValue *p2) {  const char *t1 = luaT_typenames[ttype(p1)];  const char *t2 = luaT_typenames[ttype(p2)];  if (t1[2] == t2[2])    luaG_runerror(L, "attempt to compare two %s values", t1);  else    luaG_runerror(L, "attempt to compare %s with %s", t1, t2);  return 0;}static void addinfo (lua_State *L, const char *msg) {  CallInfo *ci = L->ci;  if (isLua(ci)) {  /* is Lua code? */    char buff[LUA_IDSIZE];  /* add file:line information */    int line = currentline(L, ci);    luaO_chunkid(buff, getstr(getluaproto(ci)->source), LUA_IDSIZE);    luaO_pushfstring(L, "%s:%d: %s", buff, line, msg);  }}void luaG_errormsg (lua_State *L) {  if (L->errfunc != 0) {  /* is there an error handling function? */    StkId errfunc = restorestack(L, L->errfunc);    if (!ttisfunction(errfunc)) luaD_throw(L, LUA_ERRERR);    setobjs2s(L, L->top, L->top - 1);  /* move argument */    setobjs2s(L, L->top - 1, errfunc);  /* push function */    incr_top(L);    luaD_call(L, L->top - 2, 1);  /* call it */  }  luaD_throw(L, LUA_ERRRUN);}void luaG_runerror (lua_State *L, const char *fmt, ...) {  va_list argp;  va_start(argp, fmt);  addinfo(L, luaO_pushvfstring(L, fmt, argp));  va_end(argp);  luaG_errormsg(L);}