Avoid pesky compiler warnings about C++ keywords (eh?).

src/lib_base.c

@@ -198,7 +198,7 @@ LJLIB_ASM(tonumber)		LJLIB_REC(.)
 #if LJ_HASFFI
     if (tviscdata(o)) {
       CTState *cts = ctype_cts(L);
-      CType *ct = lj_ctype_rawref(cts, cdataV(o)->typeid);
+      CType *ct = lj_ctype_rawref(cts, cdataV(o)->ctypeid);
       if (ctype_isenum(ct->info)) ct = ctype_child(cts, ct);
       if (ctype_isnum(ct->info) || ctype_iscomplex(ct->info)) {
 	if (LJ_DUALNUM && ctype_isinteger_or_bool(ct->info) &&

src/lib_ffi.c

@@ -60,7 +60,7 @@ static CTypeID ffi_checkctype(lua_State *L, CTState *cts, TValue *param)
     if (!tviscdata(o)) goto err_argtype;
     if (param && param < L->top) lj_err_arg(L, 1, LJ_ERR_FFI_NUMPARAM);
     cd = cdataV(o);
-    return cd->typeid == CTID_CTYPEID ? *(CTypeID *)cdataptr(cd) : cd->typeid;
+    return cd->ctypeid == CTID_CTYPEID ? *(CTypeID *)cdataptr(cd) : cd->ctypeid;
   }
 }
 
@@ -213,11 +213,11 @@ LJLIB_CF(ffi_meta___call)	LJLIB_REC(cdata_call)
 {
   CTState *cts = ctype_cts(L);
   GCcdata *cd = ffi_checkcdata(L, 1);
-  CTypeID id = cd->typeid;
+  CTypeID id = cd->ctypeid;
   CType *ct;
   cTValue *tv;
   MMS mm = MM_call;
-  if (cd->typeid == CTID_CTYPEID) {
+  if (cd->ctypeid == CTID_CTYPEID) {
     id = *(CTypeID *)cdataptr(cd);
     mm = MM_new;
   } else {
@@ -276,7 +276,7 @@ LJLIB_CF(ffi_meta___tostring)
 {
   GCcdata *cd = ffi_checkcdata(L, 1);
   const char *msg = "cdata<%s>: %p";
-  CTypeID id = cd->typeid;
+  CTypeID id = cd->ctypeid;
   void *p = cdataptr(cd);
   if (id == CTID_CTYPEID) {
     msg = "ctype<%s>";
@@ -340,7 +340,7 @@ LJLIB_CF(ffi_clib___index)	LJLIB_REC(clib_index 1)
   if (tviscdata(tv)) {
     CTState *cts = ctype_cts(L);
     GCcdata *cd = cdataV(tv);
-    CType *s = ctype_get(cts, cd->typeid);
+    CType *s = ctype_get(cts, cd->ctypeid);
     if (ctype_isextern(s->info)) {
       CTypeID sid = ctype_cid(s->info);
       void *sp = *(void **)cdataptr(cd);
@@ -362,7 +362,7 @@ LJLIB_CF(ffi_clib___newindex)	LJLIB_REC(clib_index 0)
   if (o < L->top && tviscdata(tv)) {
     CTState *cts = ctype_cts(L);
     GCcdata *cd = cdataV(tv);
-    CType *d = ctype_get(cts, cd->typeid);
+    CType *d = ctype_get(cts, cd->ctypeid);
     if (ctype_isextern(d->info)) {
       CTInfo qual = 0;
       for (;;) {  /* Skip attributes and collect qualifiers. */
@@ -398,7 +398,7 @@ static int ffi_callback_set(lua_State *L, GCfunc *fn)
 {
   GCcdata *cd = ffi_checkcdata(L, 1);
   CTState *cts = ctype_cts(L);
-  CType *ct = ctype_raw(cts, cd->typeid);
+  CType *ct = ctype_raw(cts, cd->ctypeid);
   if (ctype_isptr(ct->info) && (LJ_32 || ct->size == 8)) {
     MSize slot = lj_ccallback_ptr2slot(cts, *(void **)cdataptr(cd));
     if (slot < cts->cb.sizeid && cts->cb.cbid[slot] != 0) {
@@ -504,7 +504,7 @@ LJLIB_CF(ffi_cast)	LJLIB_REC(ffi_new)
   L->top = o+1;  /* Make sure this is the last item on the stack. */
   if (!(ctype_isnum(d->info) || ctype_isptr(d->info) || ctype_isenum(d->info)))
     lj_err_arg(L, 1, LJ_ERR_FFI_INVTYPE);
-  if (!(tviscdata(o) && cdataV(o)->typeid == id)) {
+  if (!(tviscdata(o) && cdataV(o)->ctypeid == id)) {
     GCcdata *cd = lj_cdata_new(cts, id, d->size);
     lj_cconv_ct_tv(cts, d, cdataptr(cd), o, CCF_CAST);
     setcdataV(L, o, cd);
@@ -532,8 +532,8 @@ LJLIB_CF(ffi_istype)	LJLIB_REC(ffi_istype)
   int b = 0;
   if (tviscdata(o)) {
     GCcdata *cd = cdataV(o);
-    CTypeID id2 = cd->typeid == CTID_CTYPEID ? *(CTypeID *)cdataptr(cd) :
-					       cd->typeid;
+    CTypeID id2 = cd->ctypeid == CTID_CTYPEID ? *(CTypeID *)cdataptr(cd) :
+						cd->ctypeid;
     CType *ct1 = lj_ctype_rawref(cts, id1);
     CType *ct2 = lj_ctype_rawref(cts, id2);
     if (ct1 == ct2) {
@@ -735,7 +735,7 @@ LJLIB_CF(ffi_gc)
   TValue *fin = lj_lib_checkany(L, 2);
   CTState *cts = ctype_cts(L);
   GCtab *t = cts->finalizer;
-  CType *ct = ctype_raw(cts, cd->typeid);
+  CType *ct = ctype_raw(cts, cd->ctypeid);
   if (!(ctype_isptr(ct->info) || ctype_isstruct(ct->info) ||
 	ctype_isrefarray(ct->info)))
     lj_err_arg(L, 1, LJ_ERR_FFI_INVTYPE);

src/lj_asm_arm.h

@@ -947,9 +947,9 @@ static void asm_sload(ASMState *as, IRIns *ir)
 static void asm_cnew(ASMState *as, IRIns *ir)
 {
   CTState *cts = ctype_ctsG(J2G(as->J));
-  CTypeID typeid = (CTypeID)IR(ir->op1)->i;
+  CTypeID ctypeid = (CTypeID)IR(ir->op1)->i;
   CTSize sz = (ir->o == IR_CNEWI || ir->op2 == REF_NIL) ?
-	      lj_ctype_size(cts, typeid) : (CTSize)IR(ir->op2)->i;
+	      lj_ctype_size(cts, ctypeid) : (CTSize)IR(ir->op2)->i;
   const CCallInfo *ci = &lj_ir_callinfo[IRCALL_lj_mem_newgco];
   IRRef args[2];
   RegSet allow = (RSET_GPR & ~RSET_SCRATCH);
@@ -982,12 +982,12 @@ static void asm_cnew(ASMState *as, IRIns *ir)
       ofs -= 4; ir--;
     }
   }
-  /* Initialize gct and typeid. lj_mem_newgco() already sets marked. */
+  /* Initialize gct and ctypeid. lj_mem_newgco() already sets marked. */
   {
-    uint32_t k = emit_isk12(ARMI_MOV, typeid);
-    Reg r = k ? RID_R1 : ra_allock(as, typeid, allow);
+    uint32_t k = emit_isk12(ARMI_MOV, ctypeid);
+    Reg r = k ? RID_R1 : ra_allock(as, ctypeid, allow);
     emit_lso(as, ARMI_STRB, RID_TMP, RID_RET, offsetof(GCcdata, gct));
-    emit_lsox(as, ARMI_STRH, r, RID_RET, offsetof(GCcdata, typeid));
+    emit_lsox(as, ARMI_STRH, r, RID_RET, offsetof(GCcdata, ctypeid));
     emit_d(as, ARMI_MOV|ARMI_K12|~LJ_TCDATA, RID_TMP);
     if (k) emit_d(as, ARMI_MOV^k, RID_R1);
   }

src/lj_asm_mips.h

@@ -1043,9 +1043,9 @@ dotypecheck:
 static void asm_cnew(ASMState *as, IRIns *ir)
 {
   CTState *cts = ctype_ctsG(J2G(as->J));
-  CTypeID typeid = (CTypeID)IR(ir->op1)->i;
+  CTypeID ctypeid = (CTypeID)IR(ir->op1)->i;
   CTSize sz = (ir->o == IR_CNEWI || ir->op2 == REF_NIL) ?
-	      lj_ctype_size(cts, typeid) : (CTSize)IR(ir->op2)->i;
+	      lj_ctype_size(cts, ctypeid) : (CTSize)IR(ir->op2)->i;
   const CCallInfo *ci = &lj_ir_callinfo[IRCALL_lj_mem_newgco];
   IRRef args[2];
   RegSet allow = (RSET_GPR & ~RSET_SCRATCH);
@@ -1079,11 +1079,11 @@ static void asm_cnew(ASMState *as, IRIns *ir)
       ofs -= 4; if (LJ_BE) ir++; else ir--;
     }
   }
-  /* Initialize gct and typeid. lj_mem_newgco() already sets marked. */
+  /* Initialize gct and ctypeid. lj_mem_newgco() already sets marked. */
   emit_tsi(as, MIPSI_SB, RID_RET+1, RID_RET, offsetof(GCcdata, gct));
-  emit_tsi(as, MIPSI_SH, RID_TMP, RID_RET, offsetof(GCcdata, typeid));
+  emit_tsi(as, MIPSI_SH, RID_TMP, RID_RET, offsetof(GCcdata, ctypeid));
   emit_ti(as, MIPSI_LI, RID_RET+1, ~LJ_TCDATA);
-  emit_ti(as, MIPSI_LI, RID_TMP, typeid);  /* Lower 16 bit used. Sign-ext ok. */
+  emit_ti(as, MIPSI_LI, RID_TMP, ctypeid); /* Lower 16 bit used. Sign-ext ok. */
   asm_gencall(as, ci, args);
   ra_allockreg(as, (int32_t)(sz+sizeof(GCcdata)),
 	       ra_releasetmp(as, ASMREF_TMP1));

src/lj_asm_ppc.h

@@ -1086,9 +1086,9 @@ dotypecheck:
 static void asm_cnew(ASMState *as, IRIns *ir)
 {
   CTState *cts = ctype_ctsG(J2G(as->J));
-  CTypeID typeid = (CTypeID)IR(ir->op1)->i;
+  CTypeID ctypeid = (CTypeID)IR(ir->op1)->i;
   CTSize sz = (ir->o == IR_CNEWI || ir->op2 == REF_NIL) ?
-	      lj_ctype_size(cts, typeid) : (CTSize)IR(ir->op2)->i;
+	      lj_ctype_size(cts, ctypeid) : (CTSize)IR(ir->op2)->i;
   const CCallInfo *ci = &lj_ir_callinfo[IRCALL_lj_mem_newgco];
   IRRef args[2];
   RegSet allow = (RSET_GPR & ~RSET_SCRATCH);
@@ -1121,11 +1121,11 @@ static void asm_cnew(ASMState *as, IRIns *ir)
       ofs -= 4; ir++;
     }
   }
-  /* Initialize gct and typeid. lj_mem_newgco() already sets marked. */
+  /* Initialize gct and ctypeid. lj_mem_newgco() already sets marked. */
   emit_tai(as, PPCI_STB, RID_RET+1, RID_RET, offsetof(GCcdata, gct));
-  emit_tai(as, PPCI_STH, RID_TMP, RID_RET, offsetof(GCcdata, typeid));
+  emit_tai(as, PPCI_STH, RID_TMP, RID_RET, offsetof(GCcdata, ctypeid));
   emit_ti(as, PPCI_LI, RID_RET+1, ~LJ_TCDATA);
-  emit_ti(as, PPCI_LI, RID_TMP, typeid);  /* Lower 16 bit used. Sign-ext ok. */
+  emit_ti(as, PPCI_LI, RID_TMP, ctypeid);  /* Lower 16 bit used. Sign-ext ok. */
   asm_gencall(as, ci, args);
   ra_allockreg(as, (int32_t)(sz+sizeof(GCcdata)),
 	       ra_releasetmp(as, ASMREF_TMP1));

src/lj_asm_x86.h

@@ -1476,9 +1476,9 @@ static void asm_sload(ASMState *as, IRIns *ir)
 static void asm_cnew(ASMState *as, IRIns *ir)
 {
   CTState *cts = ctype_ctsG(J2G(as->J));
-  CTypeID typeid = (CTypeID)IR(ir->op1)->i;
+  CTypeID ctypeid = (CTypeID)IR(ir->op1)->i;
   CTSize sz = (ir->o == IR_CNEWI || ir->op2 == REF_NIL) ?
-	      lj_ctype_size(cts, typeid) : (CTSize)IR(ir->op2)->i;
+	      lj_ctype_size(cts, ctypeid) : (CTSize)IR(ir->op2)->i;
   const CCallInfo *ci = &lj_ir_callinfo[IRCALL_lj_mem_newgco];
   IRRef args[2];
   lua_assert(sz != CTSIZE_INVALID);
@@ -1529,10 +1529,10 @@ static void asm_cnew(ASMState *as, IRIns *ir)
     lua_assert(sz == 4 || sz == 8);
   }
 
-  /* Combine initialization of marked, gct and typeid. */
+  /* Combine initialization of marked, gct and ctypeid. */
   emit_movtomro(as, RID_ECX, RID_RET, offsetof(GCcdata, marked));
   emit_gri(as, XG_ARITHi(XOg_OR), RID_ECX,
-	   (int32_t)((~LJ_TCDATA<<8)+(typeid<<16)));
+	   (int32_t)((~LJ_TCDATA<<8)+(ctypeid<<16)));
   emit_gri(as, XG_ARITHi(XOg_AND), RID_ECX, LJ_GC_WHITES);
   emit_opgl(as, XO_MOVZXb, RID_ECX, gc.currentwhite);
 

src/lj_bcwrite.c

@@ -164,7 +164,7 @@ static void bcwrite_kgc(BCWriteCtx *ctx, GCproto *pt)
       tp = BCDUMP_KGC_CHILD;
 #if LJ_HASFFI
     } else if (o->gch.gct == ~LJ_TCDATA) {
-      CTypeID id = gco2cd(o)->typeid;
+      CTypeID id = gco2cd(o)->ctypeid;
       need = 1+4*5;
       if (id == CTID_INT64) {
 	tp = BCDUMP_KGC_I64;

src/lj_carith.c

@@ -35,7 +35,7 @@ static int carith_checkarg(lua_State *L, CTState *cts, CDArith *ca)
   for (i = 0; i < 2; i++, o++) {
     if (tviscdata(o)) {
       GCcdata *cd = cdataV(o);
-      CTypeID id = (CTypeID)cd->typeid;
+      CTypeID id = (CTypeID)cd->ctypeid;
       CType *ct = ctype_raw(cts, id);
       uint8_t *p = (uint8_t *)cdataptr(cd);
       if (ctype_isptr(ct->info)) {
@@ -199,9 +199,9 @@ static int lj_carith_meta(lua_State *L, CTState *cts, CDArith *ca, MMS mm)
 {
   cTValue *tv = NULL;
   if (tviscdata(L->base))
-    tv = lj_ctype_meta(cts, cdataV(L->base)->typeid, mm);
+    tv = lj_ctype_meta(cts, cdataV(L->base)->ctypeid, mm);
   if (!tv && L->base+1 < L->top && tviscdata(L->base+1))
-    tv = lj_ctype_meta(cts, cdataV(L->base+1)->typeid, mm);
+    tv = lj_ctype_meta(cts, cdataV(L->base+1)->ctypeid, mm);
   if (!tv) {
     const char *repr[2];
     int i;

src/lj_ccall.c

@@ -461,7 +461,7 @@ CTypeID lj_ccall_ctid_vararg(CTState *cts, cTValue *o)
   if (tvisnumber(o)) {
     return CTID_DOUBLE;
   } else if (tviscdata(o)) {
-    CTypeID id = cdataV(o)->typeid;
+    CTypeID id = cdataV(o)->ctypeid;
     CType *s = ctype_get(cts, id);
     if (ctype_isrefarray(s->info)) {
       return lj_ctype_intern(cts,
@@ -692,7 +692,7 @@ static int ccall_get_results(lua_State *L, CTState *cts, CType *ct,
 int lj_ccall_func(lua_State *L, GCcdata *cd)
 {
   CTState *cts = ctype_cts(L);
-  CType *ct = ctype_raw(cts, cd->typeid);
+  CType *ct = ctype_raw(cts, cd->ctypeid);
   CTSize sz = CTSIZE_PTR;
   if (ctype_isptr(ct->info)) {
     sz = ct->size;

src/lj_cconv.c

@@ -547,7 +547,7 @@ void lj_cconv_ct_tv(CTState *cts, CType *d,
     flags |= CCF_FROMTV;
   } else if (tviscdata(o)) {
     sp = cdataptr(cdataV(o));
-    sid = cdataV(o)->typeid;
+    sid = cdataV(o)->ctypeid;
     s = ctype_get(cts, sid);
     if (ctype_isref(s->info)) {  /* Resolve reference for value. */
       lua_assert(s->size == CTSIZE_PTR);

src/lj_cdata.c

@@ -46,7 +46,7 @@ GCcdata *lj_cdata_newv(CTState *cts, CTypeID id, CTSize sz, CTSize align)
   newwhite(g, obj2gco(cd));
   cd->marked |= 0x80;
   cd->gct = ~LJ_TCDATA;
-  cd->typeid = id;
+  cd->ctypeid = id;
   return cd;
 }
 
@@ -66,7 +66,7 @@ void LJ_FASTCALL lj_cdata_free(global_State *g, GCcdata *cd)
       setgcref(g->gc.mmudata, obj2gco(cd));
     }
   } else if (LJ_LIKELY(!cdataisv(cd))) {
-    CType *ct = ctype_raw(ctype_ctsG(g), cd->typeid);
+    CType *ct = ctype_raw(ctype_ctsG(g), cd->ctypeid);
     CTSize sz = ctype_hassize(ct->info) ? ct->size : CTSIZE_PTR;
     lua_assert(ctype_hassize(ct->info) || ctype_isfunc(ct->info) ||
 	       ctype_isextern(ct->info));
@@ -101,7 +101,7 @@ CType *lj_cdata_index(CTState *cts, GCcdata *cd, cTValue *key, uint8_t **pp,
 		      CTInfo *qual)
 {
   uint8_t *p = (uint8_t *)cdataptr(cd);
-  CType *ct = ctype_get(cts, cd->typeid);
+  CType *ct = ctype_get(cts, cd->ctypeid);
   ptrdiff_t idx;
 
   /* Resolve reference for cdata object. */
@@ -140,7 +140,7 @@ collect_attrib:
     }
   } else if (tviscdata(key)) {  /* Integer cdata key. */
     GCcdata *cdk = cdataV(key);
-    CType *ctk = ctype_raw(cts, cdk->typeid);
+    CType *ctk = ctype_raw(cts, cdk->ctypeid);
     if (ctype_isenum(ctk->info)) ctk = ctype_child(cts, ctk);
     if (ctype_isinteger(ctk->info)) {
       lj_cconv_ct_ct(cts, ctype_get(cts, CTID_INT_PSZ), ctk,
@@ -167,7 +167,7 @@ collect_attrib:
 	  return ct;
 	}
       }
-    } else if (cd->typeid == CTID_CTYPEID) {
+    } else if (cd->ctypeid == CTID_CTYPEID) {
       /* Allow indexing a (pointer to) struct constructor to get constants. */
       CType *sct = ctype_raw(cts, *(CTypeID *)p);
       if (ctype_isptr(sct->info))

src/lj_cdata.h

@@ -44,7 +44,7 @@ static LJ_AINLINE GCcdata *lj_cdata_new(CTState *cts, CTypeID id, CTSize sz)
 #endif
   cd = (GCcdata *)lj_mem_newgco(cts->L, sizeof(GCcdata) + sz);
   cd->gct = ~LJ_TCDATA;
-  cd->typeid = ctype_check(cts, id);
+  cd->ctypeid = ctype_check(cts, id);
   return cd;
 }
 
@@ -53,7 +53,7 @@ static LJ_AINLINE GCcdata *lj_cdata_new_(lua_State *L, CTypeID id, CTSize sz)
 {
   GCcdata *cd = (GCcdata *)lj_mem_newgco(L, sizeof(GCcdata) + sz);
   cd->gct = ~LJ_TCDATA;
-  cd->typeid = id;
+  cd->ctypeid = id;
   return cd;
 }
 

src/lj_cparse.c

@@ -227,10 +227,10 @@ static CPToken cp_param(CPState *cp)
     GCcdata *cd;
     if (!tviscdata(o)) lj_err_argtype(cp->L, o-cp->L->base+1, "type parameter");
     cd = cdataV(o);
-    if (cd->typeid == CTID_CTYPEID)
+    if (cd->ctypeid == CTID_CTYPEID)
       cp->val.id = *(CTypeID *)cdataptr(cd);
     else
-      cp->val.id = cd->typeid;
+      cp->val.id = cd->ctypeid;
     return '$';
   }
 }
@@ -970,16 +970,16 @@ static void cp_decl_reset(CPDecl *decl)
 
 /* Parse constant initializer. */
 /* NYI: FP constants and strings as initializers. */
-static CTypeID cp_decl_constinit(CPState *cp, CType **ctp, CTypeID typeid)
+static CTypeID cp_decl_constinit(CPState *cp, CType **ctp, CTypeID ctypeid)
 {
-  CType *ctt = ctype_get(cp->cts, typeid);
+  CType *ctt = ctype_get(cp->cts, ctypeid);
   CTInfo info;
   CTSize size;
   CPValue k;
   CTypeID constid;
   while (ctype_isattrib(ctt->info)) {  /* Skip attributes. */
-    typeid = ctype_cid(ctt->info);  /* Update ID, too. */
-    ctt = ctype_get(cp->cts, typeid);
+    ctypeid = ctype_cid(ctt->info);  /* Update ID, too. */
+    ctt = ctype_get(cp->cts, ctypeid);
   }
   info = ctt->info;
   size = ctt->size;
@@ -988,7 +988,7 @@ static CTypeID cp_decl_constinit(CPState *cp, CType **ctp, CTypeID typeid)
   cp_check(cp, '=');
   cp_expr_sub(cp, &k, 0);
   constid = lj_ctype_new(cp->cts, ctp);
-  (*ctp)->info = CTINFO(CT_CONSTVAL, CTF_CONST|typeid);
+  (*ctp)->info = CTINFO(CT_CONSTVAL, CTF_CONST|ctypeid);
   k.u32 <<= 8*(4-size);
   if ((info & CTF_UNSIGNED))
     k.u32 >>= 8*(4-size);
@@ -1352,18 +1352,18 @@ static CTypeID cp_decl_struct(CPState *cp, CPDecl *sdecl, CTInfo sinfo)
 	CPARSE_MODE_DIRECT|CPARSE_MODE_ABSTRACT|CPARSE_MODE_FIELD;
 
       for (;;) {
-	CTypeID typeid;
+	CTypeID ctypeid;
 
 	if (lastdecl) cp_err_token(cp, '}');
 
 	/* Parse field declarator. */
 	decl.bits = CTSIZE_INVALID;
 	cp_declarator(cp, &decl);
-	typeid = cp_decl_intern(cp, &decl);
+	ctypeid = cp_decl_intern(cp, &decl);
 
 	if ((scl & CDF_STATIC)) {  /* Static constant in struct namespace. */
 	  CType *ct;
-	  CTypeID fieldid = cp_decl_constinit(cp, &ct, typeid);
+	  CTypeID fieldid = cp_decl_constinit(cp, &ct, ctypeid);
 	  ctype_get(cp->cts, lastid)->sib = fieldid;
 	  lastid = fieldid;
 	  ctype_setname(ct, decl.name);
@@ -1371,7 +1371,7 @@ static CTypeID cp_decl_struct(CPState *cp, CPDecl *sdecl, CTInfo sinfo)
 	  CTSize bsz = CTBSZ_FIELD;  /* Temp. for layout phase. */
 	  CType *ct;
 	  CTypeID fieldid = lj_ctype_new(cp->cts, &ct);  /* Do this first. */
-	  CType *tct = ctype_raw(cp->cts, typeid);
+	  CType *tct = ctype_raw(cp->cts, ctypeid);
 
 	  if (decl.bits == CTSIZE_INVALID) {  /* Regular field. */
 	    if (ctype_isarray(tct->info) && tct->size == CTSIZE_INVALID)
@@ -1382,7 +1382,7 @@ static CTypeID cp_decl_struct(CPState *cp, CPDecl *sdecl, CTInfo sinfo)
 	      if (!((ctype_isstruct(tct->info) && !(tct->info & CTF_VLA)) ||
 		    ctype_isenum(tct->info)))
 		cp_err_token(cp, CTOK_IDENT);
-	      ct->info = CTINFO(CT_ATTRIB, CTATTRIB(CTA_SUBTYPE) + typeid);
+	      ct->info = CTINFO(CT_ATTRIB, CTATTRIB(CTA_SUBTYPE) + ctypeid);
 	      ct->size = ctype_isstruct(tct->info) ?
 			 (decl.attr|0x80000000u) : 0;  /* For layout phase. */
 	      goto add_field;
@@ -1396,7 +1396,7 @@ static CTypeID cp_decl_struct(CPState *cp, CPDecl *sdecl, CTInfo sinfo)
 	  }
 
 	  /* Create temporary field for layout phase. */
-	  ct->info = CTINFO(CT_FIELD, typeid + (bsz << CTSHIFT_BITCSZ));
+	  ct->info = CTINFO(CT_FIELD, ctypeid + (bsz << CTSHIFT_BITCSZ));
 	  ct->size = decl.attr;
 	  if (decl.name) ctype_setname(ct, decl.name);
 
@@ -1601,7 +1601,7 @@ static void cp_decl_func(CPState *cp, CPDecl *fdecl)
   if (cp->tok != ')') {
     do {
       CPDecl decl;
-      CTypeID typeid, fieldid;
+      CTypeID ctypeid, fieldid;
       CType *ct;
       if (cp_opt(cp, '.')) {  /* Vararg function. */
 	cp_check(cp, '.');  /* Workaround for the minimalistic lexer. */
@@ -1612,16 +1612,16 @@ static void cp_decl_func(CPState *cp, CPDecl *fdecl)
       cp_decl_spec(cp, &decl, CDF_REGISTER);
       decl.mode = CPARSE_MODE_DIRECT|CPARSE_MODE_ABSTRACT;
       cp_declarator(cp, &decl);
-      typeid = cp_decl_intern(cp, &decl);
-      ct = ctype_raw(cp->cts, typeid);
+      ctypeid = cp_decl_intern(cp, &decl);
+      ct = ctype_raw(cp->cts, ctypeid);
       if (ctype_isvoid(ct->info))
 	break;
       else if (ctype_isrefarray(ct->info))
-	typeid = lj_ctype_intern(cp->cts,
+	ctypeid = lj_ctype_intern(cp->cts,
 	  CTINFO(CT_PTR, CTALIGN_PTR|ctype_cid(ct->info)), CTSIZE_PTR);
       else if (ctype_isfunc(ct->info))
-	typeid = lj_ctype_intern(cp->cts,
-	  CTINFO(CT_PTR, CTALIGN_PTR|typeid), CTSIZE_PTR);
+	ctypeid = lj_ctype_intern(cp->cts,
+	  CTINFO(CT_PTR, CTALIGN_PTR|ctypeid), CTSIZE_PTR);
       /* Add new parameter. */
       fieldid = lj_ctype_new(cp->cts, &ct);
       if (anchor)
@@ -1630,7 +1630,7 @@ static void cp_decl_func(CPState *cp, CPDecl *fdecl)
 	anchor = fieldid;
       lastid = fieldid;
       if (decl.name) ctype_setname(ct, decl.name);
-      ct->info = CTINFO(CT_FIELD, typeid);
+      ct->info = CTINFO(CT_FIELD, ctypeid);
       ct->size = nargs++;
     } while (cp_opt(cp, ','));
   }
@@ -1794,28 +1794,28 @@ static void cp_decl_multi(CPState *cp)
 	goto decl_end;  /* Accept empty declaration of struct/union/enum. */
     }
     for (;;) {
-      CTypeID typeid;
+      CTypeID ctypeid;
       cp_declarator(cp, &decl);
-      typeid = cp_decl_intern(cp, &decl);
+      ctypeid = cp_decl_intern(cp, &decl);
       if (decl.name && !decl.nameid) {  /* NYI: redeclarations are ignored. */
 	CType *ct;
 	CTypeID id;
 	if ((scl & CDF_TYPEDEF)) {  /* Create new typedef. */
 	  id = lj_ctype_new(cp->cts, &ct);
-	  ct->info = CTINFO(CT_TYPEDEF, typeid);
+	  ct->info = CTINFO(CT_TYPEDEF, ctypeid);
 	  goto noredir;
-	} else if (ctype_isfunc(ctype_get(cp->cts, typeid)->info)) {
+	} else if (ctype_isfunc(ctype_get(cp->cts, ctypeid)->info)) {
 	  /* Treat both static and extern function declarations as extern. */
-	  ct = ctype_get(cp->cts, typeid);
+	  ct = ctype_get(cp->cts, ctypeid);
 	  /* We always get new anonymous functions (typedefs are copied). */
 	  lua_assert(gcref(ct->name) == NULL);
-	  id = typeid;  /* Just name it. */
+	  id = ctypeid;  /* Just name it. */
 	} else if ((scl & CDF_STATIC)) {  /* Accept static constants. */
-	  id = cp_decl_constinit(cp, &ct, typeid);
+	  id = cp_decl_constinit(cp, &ct, ctypeid);
 	  goto noredir;
 	} else {  /* External references have extern or no storage class. */
 	  id = lj_ctype_new(cp->cts, &ct);
-	  ct->info = CTINFO(CT_EXTERN, typeid);
+	  ct->info = CTINFO(CT_EXTERN, ctypeid);
 	}
 	if (decl.redir) {  /* Add attribute for redirected symbol name. */
 	  CType *cta;

src/lj_crecord.c

@@ -50,8 +50,8 @@ static GCcdata *argv2cdata(jit_State *J, TRef tr, cTValue *o)
     lj_trace_err(J, LJ_TRERR_BADTYPE);
   cd = cdataV(o);
   /* Specialize to the CTypeID. */
-  trtypeid = emitir(IRT(IR_FLOAD, IRT_U16), tr, IRFL_CDATA_TYPEID);
-  emitir(IRTG(IR_EQ, IRT_INT), trtypeid, lj_ir_kint(J, (int32_t)cd->typeid));
+  trtypeid = emitir(IRT(IR_FLOAD, IRT_U16), tr, IRFL_CDATA_CTYPEID);
+  emitir(IRTG(IR_EQ, IRT_INT), trtypeid, lj_ir_kint(J, (int32_t)cd->ctypeid));
   return cd;
 }
 
@@ -59,7 +59,7 @@ static GCcdata *argv2cdata(jit_State *J, TRef tr, cTValue *o)
 static CTypeID crec_constructor(jit_State *J, GCcdata *cd, TRef tr)
 {
   CTypeID id;
-  lua_assert(tref_iscdata(tr) && cd->typeid == CTID_CTYPEID);
+  lua_assert(tref_iscdata(tr) && cd->ctypeid == CTID_CTYPEID);
   id = *(CTypeID *)cdataptr(cd);
   tr = emitir(IRT(IR_ADD, IRT_PTR), tr, lj_ir_kintp(J, sizeof(GCcdata)));
   tr = emitir(IRT(IR_XLOAD, IRT_INT), tr, 0);
@@ -87,8 +87,8 @@ static CTypeID argv2ctype(jit_State *J, TRef tr, cTValue *o)
     return cp.val.id;
   } else {
     GCcdata *cd = argv2cdata(J, tr, o);
-    return cd->typeid == CTID_CTYPEID ? crec_constructor(J, cd, tr) :
-					cd->typeid;
+    return cd->ctypeid == CTID_CTYPEID ? crec_constructor(J, cd, tr) :
+					cd->ctypeid;
   }
 }
 
@@ -415,7 +415,7 @@ static TRef crec_ct_tv(jit_State *J, CType *d, TRef dp, TRef sp, cTValue *sval)
     }
   } else {  /* NYI: tref_istab(sp), tref_islightud(sp). */
     IRType t;
-    sid = argv2cdata(J, sp, sval)->typeid;
+    sid = argv2cdata(J, sp, sval)->ctypeid;
     s = ctype_raw(cts, sid);
     svisnz = cdataptr(cdataV(sval));
     if (ctype_isenum(s->info)) s = ctype_child(cts, s);
@@ -514,7 +514,7 @@ void LJ_FASTCALL recff_cdata_index(jit_State *J, RecordFFData *rd)
   ptrdiff_t ofs = sizeof(GCcdata);
   GCcdata *cd = argv2cdata(J, ptr, &rd->argv[0]);
   CTState *cts = ctype_ctsG(J2G(J));
-  CType *ct = ctype_raw(cts, cd->typeid);
+  CType *ct = ctype_raw(cts, cd->ctypeid);
   CTypeID sid = 0;
 
   /* Resolve pointer or reference for cdata object. */
@@ -553,7 +553,7 @@ again:
     }
   } else if (tref_iscdata(idx)) {
     GCcdata *cdk = cdataV(&rd->argv[1]);
-    CType *ctk = ctype_raw(cts, cdk->typeid);
+    CType *ctk = ctype_raw(cts, cdk->ctypeid);
     IRType t;
     if (ctype_isenum(ctk->info)) ctk = ctype_child(cts, ctk);
     if (ctype_ispointer(ct->info) &&
@@ -577,7 +577,7 @@ again:
     }
   } else if (tref_isstr(idx)) {
     GCstr *name = strV(&rd->argv[1]);
-    if (cd->typeid == CTID_CTYPEID)
+    if (cd->ctypeid == CTID_CTYPEID)
       ct = ctype_raw(cts, crec_constructor(J, cd, ptr));
     if (ctype_isstruct(ct->info)) {
       CTSize fofs;
@@ -879,7 +879,7 @@ static void crec_snap_caller(jit_State *J)
 static int crec_call(jit_State *J, RecordFFData *rd, GCcdata *cd)
 {
   CTState *cts = ctype_ctsG(J2G(J));
-  CType *ct = ctype_raw(cts, cd->typeid);
+  CType *ct = ctype_raw(cts, cd->ctypeid);
   IRType tp = IRT_PTR;
   if (ctype_isptr(ct->info)) {
     tp = (LJ_64 && ct->size == 8) ? IRT_P64 : IRT_P32;
@@ -946,7 +946,7 @@ void LJ_FASTCALL recff_cdata_call(jit_State *J, RecordFFData *rd)
 {
   CTState *cts = ctype_ctsG(J2G(J));
   GCcdata *cd = argv2cdata(J, J->base[0], &rd->argv[0]);
-  CTypeID id = cd->typeid;
+  CTypeID id = cd->ctypeid;
   CType *ct;
   cTValue *tv;
   MMS mm = MM_call;
@@ -1084,10 +1084,10 @@ static void crec_arith_meta(jit_State *J, CTState *cts, RecordFFData *rd)
   cTValue *tv = NULL;
   if (J->base[0]) {
     if (tviscdata(&rd->argv[0]))
-      tv = lj_ctype_meta(cts, argv2cdata(J, J->base[0], &rd->argv[0])->typeid,
+      tv = lj_ctype_meta(cts, argv2cdata(J, J->base[0], &rd->argv[0])->ctypeid,
 			 (MMS)rd->data);
     if (!tv && J->base[1] && tviscdata(&rd->argv[1]))
-      tv = lj_ctype_meta(cts, argv2cdata(J, J->base[1], &rd->argv[1])->typeid,
+      tv = lj_ctype_meta(cts, argv2cdata(J, J->base[1], &rd->argv[1])->ctypeid,
 			 (MMS)rd->data);
   }
   if (tv) {
@@ -1115,7 +1115,7 @@ void LJ_FASTCALL recff_cdata_arith(jit_State *J, RecordFFData *rd)
     if (!tr) {
       goto trymeta;
     } else if (tref_iscdata(tr)) {
-      CTypeID id = argv2cdata(J, tr, &rd->argv[i])->typeid;
+      CTypeID id = argv2cdata(J, tr, &rd->argv[i])->ctypeid;
       ct = ctype_raw(cts, id);
       if (ctype_isptr(ct->info)) {  /* Resolve pointer or reference. */
 	IRType t = (LJ_64 && ct->size == 8) ? IRT_P64 : IRT_P32;
@@ -1323,7 +1323,7 @@ void LJ_FASTCALL recff_ffi_abi(jit_State *J, RecordFFData *rd)
 void LJ_FASTCALL lj_crecord_tonumber(jit_State *J, RecordFFData *rd)
 {
   CTState *cts = ctype_ctsG(J2G(J));
-  CType *d, *ct = lj_ctype_rawref(cts, cdataV(&rd->argv[0])->typeid);
+  CType *d, *ct = lj_ctype_rawref(cts, cdataV(&rd->argv[0])->ctypeid);
   if (ctype_isenum(ct->info)) ct = ctype_child(cts, ct);
   if (ctype_isnum(ct->info) || ctype_iscomplex(ct->info)) {
     if (ctype_isinteger_or_bool(ct->info) && ct->size <= 4 &&

src/lj_ir.h

@@ -195,7 +195,7 @@ IRFPMDEF(FPMENUM)
   _(UDATA_META,	offsetof(GCudata, metatable)) \
   _(UDATA_UDTYPE, offsetof(GCudata, udtype)) \
   _(UDATA_FILE,	sizeof(GCudata)) \
-  _(CDATA_TYPEID, offsetof(GCcdata, typeid)) \
+  _(CDATA_CTYPEID, offsetof(GCcdata, ctypeid)) \
   _(CDATA_PTR,	sizeof(GCcdata)) \
   _(CDATA_INT, sizeof(GCcdata)) \
   _(CDATA_INT64, sizeof(GCcdata)) \

src/lj_obj.h

@@ -264,7 +264,7 @@ enum {
 /* C data object. Payload follows. */
 typedef struct GCcdata {
   GCHeader;
-  uint16_t typeid;	/* C type ID. */
+  uint16_t ctypeid;	/* C type ID. */
 } GCcdata;
 
 /* Prepended to variable-sized or realigned C data objects. */

src/lj_opt_fold.c

@@ -1939,11 +1939,11 @@ LJFOLDF(fload_str_len_snew)
 }
 
 /* The C type ID of cdata objects is immutable. */
-LJFOLD(FLOAD KGC IRFL_CDATA_TYPEID)
+LJFOLD(FLOAD KGC IRFL_CDATA_CTYPEID)
 LJFOLDF(fload_cdata_typeid_kgc)
 {
   if (LJ_LIKELY(J->flags & JIT_F_OPT_FOLD))
-    return INTFOLD((int32_t)ir_kcdata(fleft)->typeid);
+    return INTFOLD((int32_t)ir_kcdata(fleft)->ctypeid);
   return NEXTFOLD;
 }
 
@@ -1962,8 +1962,8 @@ LJFOLDF(fload_cdata_int64_kgc)
   return NEXTFOLD;
 }
 
-LJFOLD(FLOAD CNEW IRFL_CDATA_TYPEID)
-LJFOLD(FLOAD CNEWI IRFL_CDATA_TYPEID)
+LJFOLD(FLOAD CNEW IRFL_CDATA_CTYPEID)
+LJFOLD(FLOAD CNEWI IRFL_CDATA_CTYPEID)
 LJFOLDF(fload_cdata_typeid_cnew)
 {
   if (LJ_LIKELY(J->flags & JIT_F_OPT_FOLD))
@@ -1983,7 +1983,7 @@ LJFOLDF(fload_cdata_ptr_int64_cnew)
 }
 
 LJFOLD(FLOAD any IRFL_STR_LEN)
-LJFOLD(FLOAD any IRFL_CDATA_TYPEID)
+LJFOLD(FLOAD any IRFL_CDATA_CTYPEID)
 LJFOLD(FLOAD any IRFL_CDATA_PTR)
 LJFOLD(FLOAD any IRFL_CDATA_INT)
 LJFOLD(FLOAD any IRFL_CDATA_INT64)

src/lj_parse.c

@@ -938,7 +938,7 @@ static void bcemit_unop(FuncState *fs, BCOp op, ExpDesc *e)
       if (e->k == VKCDATA) {  /* Fold in-place since cdata is not interned. */
 	GCcdata *cd = cdataV(&e->u.nval);
 	int64_t *p = (int64_t *)cdataptr(cd);
-	if (cd->typeid == CTID_COMPLEX_DOUBLE)
+	if (cd->ctypeid == CTID_COMPLEX_DOUBLE)
 	  p[1] ^= (int64_t)U64x(80000000,00000000);
 	else
 	  *p = -*p;