自学教程：C++ ttistable函数代码示例

LUA_API int lua_rawgetp (lua_State *L, int idx, const void *p) {  StkId t;  TValue k;  lua_lock(L);  t = index2addr(L, idx);  api_check(L, ttistable(t), "table expected");  setpvalue(&k, cast(void *, p));  setobj2s(L, L->top, luaH_get(hvalue(t), &k));  api_incr_top(L);  lua_unlock(L);  return ttnov(L->top - 1);}

LUA_API void lua_rawset (lua_State *L, int idx) {  StkId t;  lua_lock(L);  api_checknelems(L, 2);  t = index2addr(L, idx);  api_check(L, ttistable(t), "table expected");  setobj2t(L, luaH_set(L, hvalue(t), L->top-2), L->top-1);  invalidateTMcache(hvalue(t));  luaC_barrierback(L, gcvalue(t), L->top-1);  L->top -= 2;  lua_unlock(L);}

/*** Function to index a table.** Receives the table at `t' and the key at `key'.** leaves the result at `res'.*/const TObject *luaV_gettable (lua_State *L, const TObject *t, TObject *key,                              int loop) {  if (loop > MAXTAGLOOP)    luaG_runerror(L, "loop in gettable");  if (ttistable(t)) {  /* `t' is a table? */    Table *h = hvalue(t);    const TObject *v = luaH_get(h, key);  /* do a primitive get */    if (!ttisnil(v)) return v;    else return luaV_index(L, t, key, loop+1);  }  else return luaV_getnotable(L, t, key, loop+1);}

void luaV_settable (lua_State *L, const TValue *t, TValue *key, StkId val) {  int loop;  TValue temp;  setnilvalue(L->top);  L->top++;  fixedstack(L);  for (loop = 0; loop < MAXTAGLOOP; loop++) {    const TValue *tm;    if (ttistable(t) || ttisrotable(t)) {  /* `t' is a table? */      void *h = ttistable(t) ? hvalue(t) : rvalue(t);      TValue *oldval = ttistable(t) ? luaH_set(L, (Table*)h, key) : NULL; /* do a primitive set */      if ((oldval && !ttisnil(oldval)) ||  /* result is no nil? */          (tm = fasttm(L, ttistable(t) ? ((Table*)h)->metatable : (Table*)luaR_getmeta(h), TM_NEWINDEX)) == NULL) { /* or no TM? */        if(oldval) {          L->top--;          unfixedstack(L);          setobj2t(L, oldval, val);          ((Table *)h)->flags = 0;          luaC_barriert(L, (Table*)h, val);        }        return;      }      /* else will try the tag method */    }    else if (ttisnil(tm = luaT_gettmbyobj(L, t, TM_NEWINDEX)))      luaG_typeerror(L, t, "index");    if (ttisfunction(tm) || ttislightfunction(tm)) {      L->top--;      unfixedstack(L);      callTM(L, tm, t, key, val);      return;    }    /* else repeat with `tm' */    setobj(L, &temp, tm);  /* avoid pointing inside table (may rehash) */    t = &temp;    setobj2s(L, L->top-1, t);  /* need to protect value from EGC. */  }  luaG_runerror(L, "loop in settable");}

LUA_API void lua_rawsetp (lua_State *L, int idx, const void *p) {  StkId t;  TValue k;  lua_lock(L);  api_checknelems(L, 1);  t = index2addr(L, idx);  api_check(L, ttistable(t), "table expected");  setpvalue(&k, cast(void *, p));  setobj2t(L, luaH_set(L, hvalue(t), &k), L->top - 1);  luaC_barrierback(L, gcvalue(t), L->top - 1);  L->top--;  lua_unlock(L);}

LUA_API void lua_rawseti (lua_State *L, int idx, lua_Integer n) {  StkId o;  Table *t;  lua_lock(L);  api_checknelems(L, 1);  o = index2addr(L, idx);  api_check(ttistable(o), "table expected");  t = hvalue(o);  luaH_setint(L, t, n, L->top - 1);  luaC_barrierback(L, t, L->top-1);  L->top--;  lua_unlock(L);}

LUA_API void lua_rawseti (lua_State *L, int idx, int n) {  StkId o;  lua_lock(L);  api_checknelems(L, 1);  o = luaA_index(L, idx);  api_check(L, ttistable(o));  setobj2t(luaH_setnum(L, hvalue(o), n), L->top-1);  /* write barrier */#if LUA_REFCOUNT  setnilvalue(--L->top);#else !LUA_REFCOUNT  L->top--;#endif LUA_REFCOUNT  lua_unlock(L);}

LUA_API int lua_setfenv (lua_State *L, int idx) {  StkId o;  int res = 0;  lua_lock(L);  api_checknelems(L, 1);  o = luaA_index(L, idx);  L->top--;  api_check(L, ttistable(L->top));  if (isLfunction(o)) {    res = 1;    clvalue(o)->l.g = *(L->top);  }  lua_unlock(L);  return res;}

void luaV_gettable (lua_State *L, const TValue *t, TValue *key, StkId val) {  int loop;  for (loop = 0; loop < MAXTAGLOOP; loop++) {    const TValue *tm;    if (ttistable(t) || ttisrotable(t)) {  /* `t' is a table? */      void *h = ttistable(t) ? hvalue(t) : rvalue(t);      const TValue *res = ttistable(t) ? luaH_get((Table*)h, key) : luaH_get_ro(h, key); /* do a primitive get */      if (!ttisnil(res) ||  /* result is no nil? */          (tm = fasttm(L, ttistable(t) ? ((Table*)h)->metatable : (Table*)luaR_getmeta(h), TM_INDEX)) == NULL) { /* or no TM? */        setobj2s(L, val, res);        return;      }            /* else will try the tag method */    }    else if (ttisnil(tm = luaT_gettmbyobj(L, t, TM_INDEX)))        luaG_typeerror(L, t, "index");    if (ttisfunction(tm) || ttislightfunction(tm)) {      callTMres(L, val, tm, t, key);      return;    }    t = tm;  /* else repeat with `tm' */   }  luaG_runerror(L, "loop in gettable");}

LUA_API void lua_setuservalue (lua_State *L, int idx) {	StkId o;	lua_lock(L);	api_checknelems(L, 1);	o = index2addr(L, idx);	api_check(L, ttisuserdata(o), "userdata expected");	if (ttisnil(L->top - 1))	uvalue(o)->env = NULL;	else {	api_check(L, ttistable(L->top - 1), "table expected");	uvalue(o)->env = hvalue(L->top - 1);	luaC_objbarrier(L, gcvalue(o), hvalue(L->top - 1));	}	L->top--;	lua_unlock(L);}

LUA_API void lua_rawset (lua_State *L, int idx) {  StkId t;  lua_lock(L);  api_checknelems(L, 2);  t = luaA_index(L, idx);  api_check(L, ttistable(t));  setobj2t(luaH_set(L, hvalue(t), L->top-2), L->top-1);  /* write barrier */#if LUA_REFCOUNT  setnilvalue(--L->top);  setnilvalue(--L->top);#else !LUA_REFCOUNT  L->top -= 2;#endif LUA_REFCOUNT  lua_unlock(L);}

static int ktap_lib_histogram(ktap_state *ks){	ktap_value *v = kp_arg(ks, 1);	if (G(ks)->mainthread != ks) {		kp_error(ks, "only mainthread can call table historgram/n");		return -1;	}	if (ttistable(v))		kp_table_histogram(ks, hvalue(v));	else if (ttisaggrtable(v))		kp_aggrtable_histogram(ks, ahvalue(v));	return 0;}

void vm_OP_SETLIST(lua_State *L, int a, int b, int c) {  TValue *base = L->base;  TValue *ra = base + a;  int last;  Table *h;  fixedstack(L);  if (b == 0) {    b = cast_int(L->top - ra) - 1;    L->top = L->ci->top;  }  runtime_check(L, ttistable(ra));  h = hvalue(ra);  last = ((c-1)*LFIELDS_PER_FLUSH) + b;  if (last > h->sizearray)  /* needs more space? */    luaH_resizearray(L, h, last);  /* pre-alloc it at once */  for (; b > 0; b--) {    TValue *val = ra+b;    setobj2t(L, luaH_setnum(L, h, last--), val);    luaC_barriert(L, h, val);  }  unfixedstack(L);}

/*** Complete a table access: if 't' is a table, 'tm' has its metamethod;** otherwise, 'tm' is NULL.*/void luaV_finishget (lua_State *L, const TValue *t, TValue *key, StkId val,                      const TValue *tm) {  int loop;  /* counter to avoid infinite loops */  lua_assert(tm != NULL || !ttistable(t));  for (loop = 0; loop < MAXTAGLOOP; loop++) {    if (tm == NULL) {  /* no metamethod (from a table)? */      if (ttisnil(tm = luaT_gettmbyobj(L, t, TM_INDEX)))        luaG_typeerror(L, t, "index");  /* no metamethod */    }    if (ttisfunction(tm)) {  /* metamethod is a function */      luaT_callTM(L, tm, t, key, val, 1);  /* call it */      return;    }    t = tm;  /* else repeat access over 'tm' */    if (luaV_fastget(L,t,key,tm,luaH_get)) {  /* try fast track */      setobj2s(L, val, tm);  /* done */      return;    }    /* else repeat */  }  luaG_runerror(L, "gettable chain too long; possible loop");}

/*** Main function for table assignment (invoking metamethods if needed).** Compute 't[key] = val'*/void luaV_finishset (lua_State *L, const TValue *t, TValue *key,                     StkId val, const TValue *oldval) {  int loop;  /* counter to avoid infinite loops */  for (loop = 0; loop < MAXTAGLOOP; loop++) {    const TValue *tm;    if (oldval != NULL) {      lua_assert(ttistable(t) && ttisnil(oldval));      /* must check the metamethod */      if ((tm = fasttm(L, hvalue(t)->metatable, TM_NEWINDEX)) == NULL &&         /* no metamethod; is there a previous entry in the table? */         (oldval != luaO_nilobject ||         /* no previous entry; must create one. (The next test is            always true; we only need the assignment.) */         (oldval = luaH_newkey(L, hvalue(t), key), 1))) {        /* no metamethod and (now) there is an entry with given key */        setobj2t(L, cast(TValue *, oldval), val);        invalidateTMcache(hvalue(t));        luaC_barrierback(L, hvalue(t), val);        return;      }      /* else will try the metamethod */    }    else {  /* not a table; check metamethod */      if (ttisnil(tm = luaT_gettmbyobj(L, t, TM_NEWINDEX)))        luaG_typeerror(L, t, "index");    }    /* try the metamethod */    if (ttisfunction(tm)) {      luaT_callTM(L, tm, t, key, val, 0);      return;    }    t = tm;  /* else repeat assignment over 'tm' */    if (luaV_fastset(L, t, key, oldval, luaH_get, val))      return;  /* done */    /* else loop */  }  luaG_runerror(L, "settable chain too long; possible loop");}

LUA_API int lua_setmetatable (lua_State *L, int objindex) {  TObject *obj, *mt;  int res = 1;  lua_lock(L);  api_checknelems(L, 1);  obj = luaA_index(L, objindex);  mt = (!ttisnil(L->top - 1)) ? L->top - 1 : defaultmeta(L);  api_check(L, ttistable(mt));  switch (ttype(obj)) {    case LUA_TTABLE: {#if LUA_REFCOUNT      __AddRefDirect(hvalue(mt));      __ReleaseDirect(L, hvalue(obj)->metatable);#endif LUA_REFCOUNT	  hvalue(obj)->metatable = hvalue(mt);  /* write barrier */      break;    }    case LUA_TUSERDATA: {#if LUA_REFCOUNT      __AddRefDirect(hvalue(mt));	  __ReleaseDirect(L, &uvalue(obj)->uv.metatable);#endif LUA_REFCOUNT      uvalue(obj)->uv.metatable = hvalue(mt);  /* write barrier */      break;    }    default: {      res = 0;  /* cannot set */      break;    }  }#if LUA_REFCOUNT  setnilvalue(--L->top);#else !LUA_REFCOUNT  L->top--;#endif LUA_REFCOUNT  lua_unlock(L);  return res;}

LUA_API int lua_setmetatable (lua_State *L, int objindex) {  TValue *obj;  Table *mt;  lua_lock(L);  api_checknelems(L, 1);  obj = index2addr(L, objindex);  api_checkvalidindex(L, obj);  if (ttisnil(L->top - 1))    mt = NULL;  else {    api_check(L, ttistable(L->top - 1), "table expected");    mt = hvalue(L->top - 1);  }  switch (ttypenv(obj)) {    case LUA_TTABLE: {      hvalue(obj)->metatable = mt;      if (mt)        luaC_objbarrierback(L, gcvalue(obj), mt);        luaC_checkfinalizer(L, gcvalue(obj), mt);      break;    }    case LUA_TUSERDATA: {      uvalue(obj)->metatable = mt;      if (mt) {        luaC_objbarrier(L, rawuvalue(obj), mt);        luaC_checkfinalizer(L, gcvalue(obj), mt);      }      break;    }    default: {      G(L)->mt[ttypenv(obj)] = mt;      break;    }  }  L->top--;  lua_unlock(L);  return 1;}

/*** Receives table at `t', key at `key' and value at `val'.*/void luaV_settable (lua_State *L, const TObject *t, TObject *key, StkId val) {  const TObject *tm;  int loop = 0;  do {    if (ttistable(t)) {  /* `t' is a table? */      Table *h = hvalue(t);      TObject *oldval = luaH_set(L, h, key); /* do a primitive set */      if (!ttisnil(oldval) ||  /* result is no nil? */          (tm = fasttm(L, h->metatable, TM_NEWINDEX)) == NULL) { /* or no TM? */        setobj2t(oldval, val);  /* write barrier */        return;      }      /* else will try the tag method */    }    else if (ttisnil(tm = luaT_gettmbyobj(L, t, TM_NEWINDEX)))      luaG_typeerror(L, t, "index");    if (ttisfunction(tm)) {      callTM(L, tm, t, key, val);      return;    }    t = tm;  /* else repeat with `tm' */   } while (++loop <= MAXTAGLOOP);  luaG_runerror(L, "loop in settable");}

/*** Main function for table access (invoking metamethods if needed).** Compute 'val = t[key]'*/void luaV_gettable (lua_State *L, const TValue *t, TValue *key, StkId val) {    int loop;    /* counter to avoid infinite loops */    for (loop = 0; loop < MAXTAGLOOP; loop++) {        const TValue *tm;        if (ttistable(t)) {    /* 't' is a table? */            Table *h = hvalue(t);            const TValue *res = luaH_get(h, key); /* do a primitive get */            if (!ttisnil(res) ||    /* result is not nil? */                    (tm = fasttm(L, h->metatable, TM_INDEX)) == NULL) { /* or no TM? */                setobj2s(L, val, res);    /* result is the raw get */                return;            }            /* else will try metamethod */        }        else if (ttisnil(tm = luaT_gettmbyobj(L, t, TM_INDEX)))            luaG_typeerror(L, t, "index");    /* no metamethod */        if (ttisfunction(tm)) {    /* metamethod is a function */            luaT_callTM(L, tm, t, key, val, 1);            return;        }        t = tm;    /* else repeat access over 'tm' */    }    luaG_runerror(L, "gettable chain too long; possible loop");}

void luaV_gettable (lua_State *L, const TValue *t, TValue *key, StkId val) {  int loop;  for (loop = 0; loop < MAXTAGLOOP; loop++) {    const TValue *tm;    if (ttistable(t)) {  /* `t' is a table? */      Table *h = hvalue(t);      const TValue *res = luaH_get(h, key); /* do a primitive get */      if (!ttisnil(res) ||  /* result is not nil? */          (tm = fasttm(L, h->metatable, TM_INDEX)) == NULL) { /* or no TM? */        setobj2s(L, val, res);        return;      }      /* else will try the tag method */    }    else if (ttisnil(tm = luaT_gettmbyobj(L, t, TM_INDEX)))      luaG_typeerror(L, t, "index");    if (ttisfunction(tm)) {      callTM(L, tm, t, key, val, 1);      return;    }    t = tm;  /* else repeat with 'tm' */  }  luaG_runerror(L, "loop in gettable");}

void luaV_gettable (lua_State *L, const TValue *t, TValue *key, StkId val) {  int loop;  for (loop = 0; loop < MAXTAGLOOP; loop++) {    const TValue *tm = 0; /* LUA-VEC -- compiler gives a warning of uninitialized value on this so we set it to 0 */    if (ttistable(t)) {  /* `t' is a table? */      Table *h = hvalue(t);      const TValue *res = luaH_get(h, key); /* do a primitive get */      if (!ttisnil(res) ||  /* result is no nil? */          (tm = fasttm(L, h->metatable, TM_INDEX)) == NULL) { /* or no TM? */        setobj2s(L, val, res);        return;      }      /* else will try the tag method */    }    else if (ttisvec(t)) { /* LUA-VEC -- vec[idx] operator */      /* issue: "index" may not be the correct arg for luaG_typeerror in here */      if (ttisnumber(key) &&   /* acessing vec by a number? */          (nvalue(key) >= 1 && nvalue(key) <= 4)) {  /* index is between 1-4? */        TValue res;        setnvalue(&res, vecvalue(t)[(int)nvalue(key)-1]);        setobj2s(L, val, &res);        return;      }      else if (ttisstring(key)) {  /* acessing vec by a string? */        if (tsvalue(key)->len == 1) {          /* accessing by a single component, such as vec.x */          TValue res;          switch (*getstr(tsvalue(key))) {            case 'x':  setnvalue(&res, vecvalue(t)[0]); break;            case 'y':  setnvalue(&res, vecvalue(t)[1]); break;            case 'z':  setnvalue(&res, vecvalue(t)[2]); break;            case 'w':  setnvalue(&res, vecvalue(t)[3]); break;            default:   luaG_typeerror(L, t, "index");          }          setobj2s(L, val, &res);          return;        }        else if (tsvalue(key)->len <= 4) {          /* accessing by swizzling, such as vec.xy, vec.xxyz etc. */          TValue res;          float v[4] = {0.0f,0.0f,0.0f,0.0f};          int i;          for (i = 0; i < (int)tsvalue(key)->len; ++i) {            switch (getstr(tsvalue(key))[i]) {              case 'x':  v[i] = vecvalue(t)[0]; break;              case 'y':  v[i] = vecvalue(t)[1]; break;              case 'z':  v[i] = vecvalue(t)[2]; break;              case 'w':  v[i] = vecvalue(t)[3]; break;              default:   luaG_typeerror(L, t, "index");            }          }          setvecvalue(&res, v[0], v[1], v[2], v[3]);          setobj2s(L, val, &res);          return;        }      }      luaG_typeerror(L, t, "index");    }    else if (ttisnil(tm = luaT_gettmbyobj(L, t, TM_INDEX)))      luaG_typeerror(L, t, "index");    if (ttisfunction(tm)) {      callTMres(L, val, tm, t, key);      return;    }    t = tm;  /* else repeat with `tm' */   }  luaG_runerror(L, "loop in gettable");}

//.........这里部分代码省略.........        continue;      }      case OP_ADD: {        arith_op(luai_numadd, TM_ADD);        continue;      }      case OP_SUB: {        arith_op(luai_numsub, TM_SUB);        continue;      }      case OP_MUL: {        arith_op(luai_nummul, TM_MUL);        continue;      }      case OP_DIV: {        arith_op(luai_lnumdiv, TM_DIV);        continue;      }      case OP_MOD: {        arith_op(luai_lnummod, TM_MOD);        continue;      }      case OP_POW: {        arith_op(luai_numpow, TM_POW);        continue;      }      case OP_UNM: {        TValue *rb = RB(i);        if (ttisnumber(rb)) {          lua_Number nb = nvalue(rb);          setnvalue(ra, luai_numunm(nb));        }        else {          Protect(Arith(L, ra, rb, rb, TM_UNM));        }        continue;      }      case OP_NOT: {        int res = l_isfalse(RB(i));  /* next assignment may change this value */        setbvalue(ra, res);        continue;      }      case OP_LEN: {        const TValue *rb = RB(i);        switch (ttype(rb)) {          case LUA_TTABLE:           case LUA_TROTABLE: {            setnvalue(ra, ttistable(rb) ? cast_num(luaH_getn(hvalue(rb))) : cast_num(luaH_getn_ro(rvalue(rb))));            break;          }          case LUA_TSTRING: {            setnvalue(ra, cast_num(tsvalue(rb)->len));            break;          }          default: {  /* try metamethod */            Protect(              if (!call_binTM(L, rb, luaO_nilobject, ra, TM_LEN))                luaG_typeerror(L, rb, "get length of");            )          }        }        continue;      }      case OP_CONCAT: {        int b = GETARG_B(i);        int c = GETARG_C(i);        Protect(luaV_concat(L, c-b+1, c); luaC_checkGC(L));        setobjs2s(L, RA(i), base+b);        continue;      }      case OP_JMP: {        dojump(L, pc, GETARG_sBx(i));        continue;      }      case OP_EQ: {        TValue *rb = RKB(i);        TValue *rc = RKC(i);        Protect(          if (equalobj(L, rb, rc) == GETARG_A(i))            dojump(L, pc, GETARG_sBx(*pc));        )        pc++;        continue;      }      case OP_LT: {        Protect(          if (luaV_lessthan(L, RKB(i), RKC(i)) == GETARG_A(i))            dojump(L, pc, GETARG_sBx(*pc));        )        pc++;        continue;      }      case OP_LE: {        Protect(          if (lessequal(L, RKB(i), RKC(i)) == GETARG_A(i))            dojump(L, pc, GETARG_sBx(*pc));        )        pc++;        continue;      }

StkId luaV_execute (lua_State *L) {  LClosure *cl;  TObject *k;  const Instruction *pc; callentry:  /* entry point when calling new functions */  L->ci->u.l.pc = &pc;  if (L->hookmask & LUA_MASKCALL)    luaD_callhook(L, LUA_HOOKCALL, -1); retentry:  /* entry point when returning to old functions */  lua_assert(L->ci->state == CI_SAVEDPC ||             L->ci->state == (CI_SAVEDPC | CI_CALLING));  L->ci->state = CI_HASFRAME;  /* activate frame */  pc = L->ci->u.l.savedpc;  cl = &clvalue(L->base - 1)->l;  k = cl->p->k;  /* main loop of interpreter */  for (;;) {    const Instruction i = *pc++;    StkId base, ra;    if ((L->hookmask & (LUA_MASKLINE | LUA_MASKCOUNT)) &&        (--L->hookcount == 0 || L->hookmask & LUA_MASKLINE)) {      traceexec(L);      if (L->ci->state & CI_YIELD) {  /* did hook yield? */        L->ci->u.l.savedpc = pc - 1;        L->ci->state = CI_YIELD | CI_SAVEDPC;        return NULL;      }    }    /* warning!! several calls may realloc the stack and invalidate `ra' */    base = L->base;    ra = RA(i);    lua_assert(L->ci->state & CI_HASFRAME);    lua_assert(base == L->ci->base);    lua_assert(L->top <= L->stack + L->stacksize && L->top >= base);    lua_assert(L->top == L->ci->top ||         GET_OPCODE(i) == OP_CALL ||   GET_OPCODE(i) == OP_TAILCALL ||         GET_OPCODE(i) == OP_RETURN || GET_OPCODE(i) == OP_SETLISTO);    switch (GET_OPCODE(i)) {      case OP_MOVE: {        setobjs2s(ra, RB(i));        break;      }      case OP_LOADK: {        setobj2s(ra, KBx(i));        break;      }      case OP_LOADBOOL: {        setbvalue(ra, GETARG_B(i));        if (GETARG_C(i)) pc++;  /* skip next instruction (if C) */        break;      }      case OP_LOADNIL: {        TObject *rb = RB(i);        do {          setnilvalue(rb--);        } while (rb >= ra);        break;      }      case OP_GETUPVAL: {        int b = GETARG_B(i);        setobj2s(ra, cl->upvals[b]->v);        break;      }      case OP_GETGLOBAL: {        TObject *rb = KBx(i);        const TObject *v;        lua_assert(ttisstring(rb) && ttistable(&cl->g));        v = luaH_getstr(hvalue(&cl->g), tsvalue(rb));        if (!ttisnil(v)) { setobj2s(ra, v); }        else          setobj2s(XRA(i), luaV_index(L, &cl->g, rb, 0));        break;      }      case OP_GETTABLE: {        StkId rb = RB(i);        TObject *rc = RKC(i);        if (ttistable(rb)) {          const TObject *v = luaH_get(hvalue(rb), rc);          if (!ttisnil(v)) { setobj2s(ra, v); }          else            setobj2s(XRA(i), luaV_index(L, rb, rc, 0));        }        else          setobj2s(XRA(i), luaV_getnotable(L, rb, rc, 0));        break;      }      case OP_SETGLOBAL: {        lua_assert(ttisstring(KBx(i)) && ttistable(&cl->g));        luaV_settable(L, &cl->g, KBx(i), ra);        break;      }      case OP_SETUPVAL: {        int b = GETARG_B(i);        setobj(cl->upvals[b]->v, ra);  /* write barrier */        break;      }      case OP_SETTABLE: {        luaV_settable(L, ra, RKB(i), RKC(i));        break;      }//.........这里部分代码省略.........