ct                266 lib_base.c           CType *ct = lj_ctype_rawref(cts, cdataV(o)->ctypeid);
ct                267 lib_base.c           if (ctype_isenum(ct->info)) ct = ctype_child(cts, ct);
ct                268 lib_base.c           if (ctype_isnum(ct->info) || ctype_iscomplex(ct->info)) {
ct                269 lib_base.c     	if (LJ_DUALNUM && ctype_isinteger_or_bool(ct->info) &&
ct                270 lib_base.c     	    ct->size <= 4 && !(ct->size == 4 && (ct->info & CTF_UNSIGNED))) {
ct                108 lib_ffi.c        CTypeID id = ctype_typeid(cts, ct);
ct                149 lib_ffi.c        CType *ct;
ct                154 lib_ffi.c        ct = lj_cdata_index(cts, cdataV(o), o+1, &p, &qual);
ct                156 lib_ffi.c          return ffi_index_meta(L, cts, ct, MM_index);
ct                157 lib_ffi.c        if (lj_cdata_get(cts, ct, L->top-1, p))
ct                166 lib_ffi.c        CType *ct;
ct                171 lib_ffi.c        ct = lj_cdata_index(cts, cdataV(o), o+1, &p, &qual);
ct                175 lib_ffi.c          return ffi_index_meta(L, cts, ct, MM_newindex);
ct                177 lib_ffi.c        lj_cdata_set(cts, ct, p, o+2, qual);
ct                222 lib_ffi.c        CType *ct;
ct                234 lib_ffi.c        ct = ctype_raw(cts, id);
ct                235 lib_ffi.c        if (ctype_isptr(ct->info)) id = ctype_cid(ct->info);
ct                291 lib_ffi.c          CType *ct = ctype_raw(cts, id);
ct                292 lib_ffi.c          if (ctype_isref(ct->info)) {
ct                294 lib_ffi.c            ct = ctype_rawchild(cts, ct);
ct                296 lib_ffi.c          if (ctype_iscomplex(ct->info)) {
ct                297 lib_ffi.c            setstrV(L, L->top-1, lj_ctype_repr_complex(L, cdataptr(cd), ct->size));
ct                299 lib_ffi.c          } else if (ct->size == 8 && ctype_isinteger(ct->info)) {
ct                301 lib_ffi.c      					       (ct->info & CTF_UNSIGNED)));
ct                303 lib_ffi.c          } else if (ctype_isfunc(ct->info)) {
ct                305 lib_ffi.c          } else if (ctype_isenum(ct->info)) {
ct                309 lib_ffi.c            if (ctype_isptr(ct->info)) {
ct                310 lib_ffi.c      	p = cdata_getptr(p, ct->size);
ct                311 lib_ffi.c      	ct = ctype_rawchild(cts, ct);
ct                313 lib_ffi.c            if (ctype_isstruct(ct->info) || ctype_isvector(ct->info)) {
ct                315 lib_ffi.c      	cTValue *tv = lj_ctype_meta(cts, ctype_typeid(cts, ct), MM_tostring);
ct                331 lib_ffi.c        CType *ct = ctype_raw(cts, id);
ct                333 lib_ffi.c        if (ctype_isptr(ct->info)) id = ctype_cid(ct->info);
ct                382 lib_ffi.c            CType *ct = ctype_raw(cts, sid);
ct                383 lib_ffi.c            if (lj_cconv_tv_ct(cts, ct, sid, L->top-1, sp))
ct                435 lib_ffi.c        CType *ct = ctype_raw(cts, cd->ctypeid);
ct                436 lib_ffi.c        if (ctype_isptr(ct->info) && (LJ_32 || ct->size == 8)) {
ct                496 lib_ffi.c        CType *ct = ctype_raw(cts, id);
ct                503 lib_ffi.c          sz = lj_ctype_vlsize(cts, ct, (CTSize)ffi_checkint(L, 2));
ct                512 lib_ffi.c        lj_cconv_ct_init(cts, ct, sz, cdataptr(cd),
ct                514 lib_ffi.c        if (ctype_isstruct(ct->info)) {
ct                599 lib_ffi.c          CType *ct = lj_ctype_rawref(cts, id);
ct                600 lib_ffi.c          if (ctype_isvltype(ct->info))
ct                601 lib_ffi.c            sz = lj_ctype_vlsize(cts, ct, (CTSize)ffi_checkint(L, 2));
ct                603 lib_ffi.c            sz = ctype_hassize(ct->info) ? ct->size : CTSIZE_INVALID;
ct                628 lib_ffi.c        CType *ct = lj_ctype_rawref(cts, id);
ct                630 lib_ffi.c        if (ctype_isstruct(ct->info) && ct->size != CTSIZE_INVALID) {
ct                631 lib_ffi.c          CType *fct = lj_ctype_getfield(cts, ct, name, &ofs);
ct                746 lib_ffi.c        CType *ct = ctype_get(cts, id);  /* Only allow raw types. */
ct                749 lib_ffi.c        if (!(ctype_isstruct(ct->info) || ctype_iscomplex(ct->info) ||
ct                750 lib_ffi.c      	ctype_isvector(ct->info)))
ct                772 lib_ffi.c        CType *ct = ctype_raw(cts, cd->ctypeid);
ct                773 lib_ffi.c        if (!(ctype_isptr(ct->info) || ctype_isstruct(ct->info) ||
ct                774 lib_ffi.c      	ctype_isrefarray(ct->info)))
ct                975 lj_asm.c           CType *ct = ctype_get(ctype_ctsG(J2G(as->J)), id);
ct                976 lj_asm.c           nargs |= ((ct->info & CTF_VARARG) ? CCI_VARARG : 0);
ct                978 lj_asm.c           nargs |= (ctype_cconv(ct->info) << CCI_CC_SHIFT);
ct                 24 lj_carith.c      CType *ct[2];
ct                 39 lj_carith.c          CType *ct = ctype_raw(cts, id);
ct                 41 lj_carith.c          if (ctype_isptr(ct->info)) {
ct                 42 lj_carith.c    	p = (uint8_t *)cdata_getptr(p, ct->size);
ct                 43 lj_carith.c    	if (ctype_isref(ct->info)) ct = ctype_rawchild(cts, ct);
ct                 44 lj_carith.c          } else if (ctype_isfunc(ct->info)) {
ct                 46 lj_carith.c    	ct = ctype_get(cts,
ct                 49 lj_carith.c          if (ctype_isenum(ct->info)) ct = ctype_child(cts, ct);
ct                 50 lj_carith.c          ca->ct[i] = ct;
ct                 53 lj_carith.c          ca->ct[i] = ctype_get(cts, CTID_INT32);
ct                 56 lj_carith.c          ca->ct[i] = ctype_get(cts, CTID_DOUBLE);
ct                 59 lj_carith.c          ca->ct[i] = ctype_get(cts, CTID_P_VOID);
ct                 63 lj_carith.c          CType *ct = ctype_raw(cts, cdataV(o2)->ctypeid);
ct                 64 lj_carith.c          ca->ct[i] = NULL;
ct                 67 lj_carith.c          if (ctype_isenum(ct->info)) {
ct                 69 lj_carith.c    	CType *cct = lj_ctype_getfield(cts, ct, strV(o), &ofs);
ct                 71 lj_carith.c    	  ca->ct[i] = ctype_child(cts, cct);
ct                 75 lj_carith.c    	  ca->ct[1-i] = ct;  /* Use enum to improve error message. */
ct                 81 lj_carith.c          ca->ct[i] = NULL;
ct                 92 lj_carith.c      CType *ctp = ca->ct[0];
ct                100 lj_carith.c    	(ctype_isptr(ca->ct[1]->info) || ctype_isrefarray(ca->ct[1]->info))) {
ct                106 lj_carith.c          if (!lj_cconv_compatptr(cts, ctp, ca->ct[1], CCF_IGNQUAL))
ct                128 lj_carith.c        if (!((mm == MM_add || mm == MM_sub) && ctype_isnum(ca->ct[1]->info)))
ct                130 lj_carith.c        lj_cconv_ct_ct(cts, ctype_get(cts, CTID_INT_PSZ), ca->ct[1],
ct                134 lj_carith.c          (ctype_isptr(ca->ct[1]->info) || ctype_isrefarray(ca->ct[1]->info))) {
ct                136 lj_carith.c        ctp = ca->ct[1]; pp = ca->p[1];
ct                137 lj_carith.c        lj_cconv_ct_ct(cts, ctype_get(cts, CTID_INT_PSZ), ca->ct[0],
ct                158 lj_carith.c      if (ctype_isnum(ca->ct[0]->info) && ca->ct[0]->size <= 8 &&
ct                159 lj_carith.c          ctype_isnum(ca->ct[1]->info) && ca->ct[1]->size <= 8) {
ct                160 lj_carith.c        CTypeID id = (((ca->ct[0]->info & CTF_UNSIGNED) && ca->ct[0]->size == 8) ||
ct                161 lj_carith.c    		  ((ca->ct[1]->info & CTF_UNSIGNED) && ca->ct[1]->size == 8)) ?
ct                163 lj_carith.c        CType *ct = ctype_get(cts, id);
ct                166 lj_carith.c        lj_cconv_ct_ct(cts, ct, ca->ct[0], (uint8_t *)&u0, ca->p[0], 0);
ct                168 lj_carith.c          lj_cconv_ct_ct(cts, ct, ca->ct[1], (uint8_t *)&u1, ca->p[1], 0);
ct                223 lj_carith.c        CType *ct = ctype_raw(cts, id);
ct                224 lj_carith.c        if (ctype_isptr(ct->info)) id = ctype_cid(ct->info);
ct                229 lj_carith.c        CType *ct = ctype_raw(cts, id);
ct                230 lj_carith.c        if (ctype_isptr(ct->info)) id = ctype_cid(ct->info);
ct                243 lj_carith.c          if (ca->ct[i] && tviscdata(L->base+i)) {
ct                244 lj_carith.c    	if (ctype_isenum(ca->ct[i]->info)) isenum = i;
ct                245 lj_carith.c    	repr[i] = strdata(lj_ctype_repr(L, ctype_typeid(cts, ca->ct[i]), NULL));
ct                220 lj_ccall.c       cc->retref = !ccall_classify_struct(cts, ctr, ct); \
ct                224 lj_ccall.c       if (ccall_classify_struct(cts, ctr, ct) > 1) sp = (uint8_t *)&cc->fpr[0]; \
ct                228 lj_ccall.c       if (!(ct->info & CTF_VARARG)) cc->retref = 0;  /* Return complex in FPRs. */
ct                231 lj_ccall.c       if (!(ct->info & CTF_VARARG)) memcpy(dp, &cc->fpr[0], ctr->size);
ct                234 lj_ccall.c       isfp = (ccall_classify_struct(cts, d, ct) > 1);
ct                241 lj_ccall.c       if (isfp && !(ct->info & CTF_VARARG)) { \
ct                292 lj_ccall.c       if ((ct->info & CTF_VARARG)) sp = (uint8_t *)&cc->gpr[0];
ct                405 lj_ccall.c       if (isfp && nfpr < CCALL_NARG_FPR && !(ct->info & CTF_VARARG)) { \
ct                447 lj_ccall.c       CTSize sz = ct->size;
ct                449 lj_ccall.c       if ((ct->info & CTF_UNION)) return 0;
ct                450 lj_ccall.c       while (ct->sib) {
ct                451 lj_ccall.c         ct = ctype_get(cts, ct->sib);
ct                452 lj_ccall.c         if (ctype_isfield(ct->info)) {
ct                453 lj_ccall.c           CType *sct = ctype_rawchild(cts, ct);
ct                463 lj_ccall.c         } else if (ctype_isbitfield(ct->info)) {
ct                465 lj_ccall.c         } else if (ctype_isxattrib(ct->info, CTA_SUBTYPE)) {
ct                466 lj_ccall.c           CType *sct = ctype_rawchild(cts, ct);
ct                491 lj_ccall.c       if (ctype_isarray(ct->info)) {
ct                492 lj_ccall.c         CType *cct = ctype_rawchild(cts, ct);
ct                493 lj_ccall.c         CTSize eofs, esz = cct->size, asz = ct->size;
ct                496 lj_ccall.c       } else if (ctype_isstruct(ct->info)) {
ct                497 lj_ccall.c         ccall_classify_struct(cts, ct, rcl, ofs);
ct                499 lj_ccall.c         int cl = ctype_isfp(ct->info) ? CCALL_RCL_SSE : CCALL_RCL_INT;
ct                500 lj_ccall.c         lua_assert(ctype_hassize(ct->info));
ct                501 lj_ccall.c         if ((ofs & (ct->size-1))) cl = CCALL_RCL_MEM;  /* Unaligned. */
ct                509 lj_ccall.c       if (ct->size > 16) return CCALL_RCL_MEM;  /* Too big, gets memory class. */
ct                510 lj_ccall.c       while (ct->sib) {
ct                512 lj_ccall.c         ct = ctype_get(cts, ct->sib);
ct                513 lj_ccall.c         fofs = ofs+ct->size;
ct                514 lj_ccall.c         if (ctype_isfield(ct->info))
ct                515 lj_ccall.c           ccall_classify_ct(cts, ctype_rawchild(cts, ct), rcl, fofs);
ct                516 lj_ccall.c         else if (ctype_isbitfield(ct->info))
ct                518 lj_ccall.c         else if (ctype_isxattrib(ct->info, CTA_SUBTYPE))
ct                519 lj_ccall.c           ccall_classify_struct(cts, ctype_rawchild(cts, ct), rcl, fofs);
ct                584 lj_ccall.c       CTSize sz = ct->size;
ct                585 lj_ccall.c       unsigned int r = 0, n = 0, isu = (ct->info & CTF_UNION);
ct                587 lj_ccall.c       while (ct->sib) {
ct                589 lj_ccall.c         ct = ctype_get(cts, ct->sib);
ct                590 lj_ccall.c         if (ctype_isfield(ct->info)) {
ct                591 lj_ccall.c           sct = ctype_rawchild(cts, ct);
ct                603 lj_ccall.c         } else if (ctype_isbitfield(ct->info)) {
ct                605 lj_ccall.c         } else if (ctype_isxattrib(ct->info, CTA_SUBTYPE)) {
ct                606 lj_ccall.c           sct = ctype_rawchild(cts, ct);
ct                679 lj_ccall.c       switch (ctype_cconv(ct->info)) {
ct                689 lj_ccall.c       ctr = ctype_rawchild(cts, ct);
ct                696 lj_ccall.c         GCcdata *cd = lj_cdata_new(cts, ctype_cid(ct->info), sz);
ct                711 lj_ccall.c       fid = ct->sib;
ct                732 lj_ccall.c           if (!(ct->info & CTF_VARARG))
ct                826 lj_ccall.c       CType *ctr = ctype_rawchild(cts, ct);
ct                865 lj_ccall.c       CType *ct = ctype_raw(cts, cd->ctypeid);
ct                867 lj_ccall.c       if (ctype_isptr(ct->info)) {
ct                868 lj_ccall.c         sz = ct->size;
ct                869 lj_ccall.c         ct = ctype_rawchild(cts, ct);
ct                871 lj_ccall.c       if (ctype_isfunc(ct->info)) {
ct                875 lj_ccall.c         gcsteps = ccall_set_args(L, cts, ct, &cc);
ct                876 lj_ccall.c         ct = (CType *)((intptr_t)ct-(intptr_t)cts->tab);
ct                884 lj_ccall.c         ct = (CType *)((intptr_t)ct+(intptr_t)cts->tab);  /* May be reallocated. */
ct                885 lj_ccall.c         gcsteps += ccall_get_results(L, cts, ct, &cc, &ret);
ct                888 lj_ccall.c         if (cc.spadj && ctype_cconv(ct->info) == CTCC_CDECL) {
ct                889 lj_ccall.c           CTF_INSERT(ct->info, CCONV, CTCC_STDCALL);
ct                412 lj_ccallback.c   CType *ct;
ct                423 lj_ccallback.c     ct = ctype_get(cts, id);
ct                424 lj_ccallback.c     rid = ctype_cid(ct->info);
ct                427 lj_ccallback.c     ct = NULL;
ct                437 lj_ccallback.c   if (!ct)
ct                446 lj_ccallback.c   switch (ctype_cconv(ct->info)) {
ct                453 lj_ccallback.c   fid = ct->sib;
ct                486 lj_ccallback.c   if (ctype_cconv(ct->info) != CTCC_CDECL)
ct                576 lj_ccallback.c   CTypeID id = ctype_typeid(cts, ct);
ct                601 lj_ccallback.c   if (!ctype_isptr(ct->info) || (LJ_64 && ct->size != CTSIZE_PTR))
ct                603 lj_ccallback.c   ct = ctype_rawchild(cts, ct);
ct                604 lj_ccallback.c   if (ctype_isfunc(ct->info)) {
ct                605 lj_ccallback.c     CType *ctr = ctype_rawchild(cts, ct);
ct                606 lj_ccallback.c     CTypeID fid = ct->sib;
ct                610 lj_ccallback.c     if ((ct->info & CTF_VARARG))
ct                625 lj_ccallback.c     return ct;
ct                633 lj_ccallback.c   ct = callback_checkfunc(cts, ct);
ct                634 lj_ccallback.c   if (ct) {
ct                635 lj_ccallback.c     MSize slot = callback_slot_new(cts, ct);
ct                 60 lj_cconv.c       ct = ctype_child(cts, ct);
ct                 62 lj_cconv.c         if (ctype_isattrib(ct->info)) {
ct                 63 lj_cconv.c           if (ctype_attrib(ct->info) == CTA_QUAL) *qual |= ct->size;
ct                 64 lj_cconv.c         } else if (!ctype_isenum(ct->info)) {
ct                 67 lj_cconv.c         ct = ctype_child(cts, ct);
ct                 69 lj_cconv.c       *qual |= (ct->info & CTF_QUAL);
ct                 70 lj_cconv.c       return ct;
ct                 69 lj_cdata.c         CType *ct = ctype_raw(ctype_ctsG(g), cd->ctypeid);
ct                 70 lj_cdata.c         CTSize sz = ctype_hassize(ct->info) ? ct->size : CTSIZE_PTR;
ct                 71 lj_cdata.c         lua_assert(ctype_hassize(ct->info) || ctype_isfunc(ct->info) ||
ct                 72 lj_cdata.c     	       ctype_isextern(ct->info));
ct                104 lj_cdata.c       CType *ct = ctype_get(cts, cd->ctypeid);
ct                108 lj_cdata.c       if (ctype_isref(ct->info)) {
ct                109 lj_cdata.c         lua_assert(ct->size == CTSIZE_PTR);
ct                111 lj_cdata.c         ct = ctype_child(cts, ct);
ct                116 lj_cdata.c       while (ctype_isattrib(ct->info)) {
ct                117 lj_cdata.c         if (ctype_attrib(ct->info) == CTA_QUAL) *qual |= ct->size;
ct                118 lj_cdata.c         ct = ctype_child(cts, ct);
ct                120 lj_cdata.c       lua_assert(!ctype_isref(ct->info));  /* Interning rejects refs to refs. */
ct                128 lj_cdata.c         if (ctype_ispointer(ct->info)) {
ct                129 lj_cdata.c           CTSize sz = lj_ctype_size(cts, ctype_cid(ct->info));  /* Element size. */
ct                132 lj_cdata.c           if (ctype_isptr(ct->info)) {
ct                133 lj_cdata.c     	p = (uint8_t *)cdata_getptr(p, ct->size);
ct                134 lj_cdata.c           } else if ((ct->info & (CTF_VECTOR|CTF_COMPLEX))) {
ct                135 lj_cdata.c     	if ((ct->info & CTF_COMPLEX)) idx &= 1;
ct                139 lj_cdata.c           return ct;
ct                152 lj_cdata.c         if (ctype_isstruct(ct->info)) {
ct                154 lj_cdata.c           CType *fct = lj_ctype_getfieldq(cts, ct, name, &ofs, qual);
ct                159 lj_cdata.c         } else if (ctype_iscomplex(ct->info)) {
ct                164 lj_cdata.c     	  return ct;
ct                166 lj_cdata.c     	  *pp = p + (ct->size >> 1);
ct                167 lj_cdata.c     	  return ct;
ct                181 lj_cdata.c           ct = sct;  /* Allow resolving metamethods for constructors, too. */
ct                184 lj_cdata.c       if (ctype_isptr(ct->info)) {  /* Automatically perform '->'. */
ct                185 lj_cdata.c         if (ctype_isstruct(ctype_rawchild(cts, ct)->info)) {
ct                186 lj_cdata.c           p = (uint8_t *)cdata_getptr(p, ct->size);
ct                187 lj_cdata.c           ct = ctype_child(cts, ct);
ct                192 lj_cdata.c       return ct;  /* But return the resolved raw type. */
ct                200 lj_cdata.c       CType *ctt = ctype_child(cts, ct);
ct                203 lj_cdata.c       if ((ctt->info & CTF_UNSIGNED) && (int32_t)ct->size < 0)
ct                204 lj_cdata.c         setnumV(o, (lua_Number)(uint32_t)ct->size);
ct                206 lj_cdata.c         setintV(o, (int32_t)ct->size);
ct                 42 lj_cdata.h       CType *ct = ctype_raw(cts, id);
ct                 43 lj_cdata.h       lua_assert((ctype_hassize(ct->info) ? ct->size : CTSIZE_PTR) == sz);
ct                296 lj_clib.c        while (ct->sib) {
ct                298 lj_clib.c          ct = ctype_get(cts, ct->sib);
ct                299 lj_clib.c          if (ctype_isfield(ct->info)) {
ct                300 lj_clib.c            d = ctype_rawchild(cts, ct);
ct                311 lj_clib.c        if (ct->sib) {
ct                312 lj_clib.c          CType *ctf = ctype_get(cts, ct->sib);
ct                325 lj_clib.c          CType *ct;
ct                326 lj_clib.c          CTypeID id = lj_ctype_getname(cts, &ct, name, CLNS_INDEX);
ct                329 lj_clib.c          if (ctype_isconstval(ct->info)) {
ct                330 lj_clib.c            CType *ctt = ctype_child(cts, ct);
ct                332 lj_clib.c            if ((ctt->info & CTF_UNSIGNED) && (int32_t)ct->size < 0)
ct                333 lj_clib.c      	setnumV(tv, (lua_Number)(uint32_t)ct->size);
ct                335 lj_clib.c      	setintV(tv, (int32_t)ct->size);
ct                337 lj_clib.c            const char *sym = clib_extsym(cts, ct, name);
ct                343 lj_clib.c            lua_assert(ctype_isfunc(ct->info) || ctype_isextern(ct->info));
ct                346 lj_clib.c            if (!p && ctype_isfunc(ct->info)) {
ct                347 lj_clib.c      	CTInfo cconv = ctype_cconv(ct->info);
ct                349 lj_clib.c      	  CTSize sz = clib_func_argsize(cts, ct);
ct                149 lj_cparse.c      GCstr *s = lj_ctype_repr(cp->cts->L, ctype_typeid(cp->cts, ct), NULL);
ct                181 lj_cparse.c      cp->val.id = lj_ctype_getname(cp->cts, &cp->ct, cp->str, cp->tmask);
ct                182 lj_cparse.c      if (ctype_type(cp->ct->info) == CT_KW)
ct                183 lj_cparse.c        return ctype_cid(cp->ct->info);
ct                200 lj_cparse.c        cp->ct = &cp->cts->tab[0];
ct                422 lj_cparse.c      if (cp->tok == CTOK_IDENT && ctype_istypedef(cp->ct->info)) return 1;
ct                496 lj_cparse.c        CType *ct;
ct                498 lj_cparse.c        ct = lj_ctype_rawref(cp->cts, k->id);
ct                499 lj_cparse.c        if (!ctype_ispointer(ct->info))
ct                500 lj_cparse.c          cp_err_badidx(cp, ct);
ct                501 lj_cparse.c        k->u32 = 0; k->id = ctype_cid(ct->info);
ct                511 lj_cparse.c        if (ctype_type(cp->ct->info) == CT_CONSTVAL) {
ct                512 lj_cparse.c          k->u32 = cp->ct->size; k->id = ctype_cid(cp->ct->info);
ct                513 lj_cparse.c        } else if (ctype_type(cp->ct->info) == CT_EXTERN) {
ct                514 lj_cparse.c          k->u32 = cp->val.id; k->id = ctype_cid(cp->ct->info);
ct                515 lj_cparse.c        } else if (ctype_type(cp->ct->info) == CT_FUNC) {
ct                537 lj_cparse.c        CType *ct;
ct                541 lj_cparse.c          ct = lj_ctype_rawref(cp->cts, k->id);
ct                542 lj_cparse.c          if (!ctype_ispointer(ct->info)) {
ct                543 lj_cparse.c    	ct = lj_ctype_rawref(cp->cts, k2.id);
ct                544 lj_cparse.c    	if (!ctype_ispointer(ct->info))
ct                545 lj_cparse.c    	  cp_err_badidx(cp, ct);
ct                552 lj_cparse.c          ct = lj_ctype_rawref(cp->cts, k->id);
ct                554 lj_cparse.c    	if (!ctype_ispointer(ct->info))
ct                555 lj_cparse.c    	  cp_err_badidx(cp, ct);
ct                556 lj_cparse.c    	ct = lj_ctype_rawref(cp->cts, ctype_cid(ct->info));
ct                560 lj_cparse.c          if (!ctype_isstruct(ct->info) || ct->size == CTSIZE_INVALID ||
ct                561 lj_cparse.c    	  !(fct = lj_ctype_getfield(cp->cts, ct, cp->str, &ofs)) ||
ct                563 lj_cparse.c    	GCstr *s = lj_ctype_repr(cp->cts->L, ctype_typeid(cp->cts, ct), NULL);
ct                566 lj_cparse.c          ct = fct;
ct                567 lj_cparse.c          k->u32 = ctype_isconstval(ct->info) ? ct->size : 0;
ct                572 lj_cparse.c        k->id = ctype_cid(ct->info);
ct                729 lj_cparse.c      CType *ct;
ct                731 lj_cparse.c      ct = ctype_raw(cp->cts, k->id);
ct                732 lj_cparse.c      if (!ctype_isinteger(ct->info)) cp_err(cp, LJ_ERR_BADVAL);
ct                770 lj_cparse.c      CType *ct = &decl->stack[decl->pos];
ct                771 lj_cparse.c      if (ctype_isfunc(ct->info)) {  /* Ok to modify in-place. */
ct                774 lj_cparse.c          ct->info = (ct->info & (CTMASK_NUM|CTF_VARARG|CTMASK_CID)) +
ct                787 lj_cparse.c      CType *ct = ctype_get(decl->cp->cts, id);
ct                788 lj_cparse.c      CTInfo info = ct->info;
ct                789 lj_cparse.c      CTSize size = ct->size;
ct                806 lj_cparse.c        if ((ct->info & (CTF_VECTOR|CTF_COMPLEX))) {
ct                817 lj_cparse.c        decl->stack[cp_push(decl, info, size)].sib = ct->sib;
ct                835 lj_cparse.c        CType *ct = &decl->stack[idx];
ct                836 lj_cparse.c        CTInfo info = ct->info;
ct                837 lj_cparse.c        CTInfo size = ct->size;
ct                839 lj_cparse.c        idx = ct->next;
ct                863 lj_cparse.c          sib = ct->sib;  /* Next line may reallocate the C type table. */
ct                917 lj_cparse.c    	if (ct->sib == 0) {  /* Only check/size arrays not copied by unroll. */
ct               1174 lj_cparse.c          CTF_INSERT(decl->fattr, CCONV, cp->ct->size);
ct               1180 lj_cparse.c          CTF_INSERT(decl->attr, MSIZEP, cp->ct->size);
ct               1193 lj_cparse.c      CType *ct;
ct               1202 lj_cparse.c          ct = cp->ct;
ct               1203 lj_cparse.c          if ((ct->info ^ info) & (CTMASK_NUM|CTF_UNION))  /* Wrong type. */
ct               1204 lj_cparse.c    	cp_errmsg(cp, 0, LJ_ERR_FFI_REDEF, strdata(gco2str(gcref(ct->name))));
ct               1208 lj_cparse.c          sid = lj_ctype_new(cp->cts, &ct);
ct               1209 lj_cparse.c          ct->info = info;
ct               1210 lj_cparse.c          ct->size = CTSIZE_INVALID;
ct               1211 lj_cparse.c          ctype_setname(ct, cp->str);
ct               1212 lj_cparse.c          lj_ctype_addname(cp->cts, ct, sid);
ct               1216 lj_cparse.c        sid = lj_ctype_new(cp->cts, &ct);
ct               1217 lj_cparse.c        ct->info = info;
ct               1218 lj_cparse.c        ct->size = CTSIZE_INVALID;
ct               1221 lj_cparse.c        if (ct->size != CTSIZE_INVALID || ct->sib)
ct               1222 lj_cparse.c          cp_errmsg(cp, 0, LJ_ERR_FFI_REDEF, strdata(gco2str(gcref(ct->name))));
ct               1223 lj_cparse.c        ct->sib = 1;  /* Indicate the type is currently being defined. */
ct               1232 lj_cparse.c      UNUSED(cp); UNUSED(ct);
ct               1238 lj_cparse.c    	ct = ctype_rawchild(cp->cts, ct);
ct               1239 lj_cparse.c    	info = ct->info;
ct               1258 lj_cparse.c        CType *ct = ctype_get(cp->cts, fieldid);
ct               1259 lj_cparse.c        CTInfo attr = ct->size;  /* Field declaration attributes (temp.). */
ct               1261 lj_cparse.c        if (ctype_isfield(ct->info) ||
ct               1262 lj_cparse.c    	(ctype_isxattrib(ct->info, CTA_SUBTYPE) && attr)) {
ct               1265 lj_cparse.c          CTInfo info = lj_ctype_info(cp->cts, ctype_cid(ct->info), &sz);
ct               1276 lj_cparse.c          align = cp_field_align(cp, ct, info);
ct               1285 lj_cparse.c          bsz = ctype_bitcsz(ct->info);  /* Bitfield size (temp.). */
ct               1286 lj_cparse.c          if (bsz == CTBSZ_FIELD || !ctype_isfield(ct->info)) {
ct               1289 lj_cparse.c    	ct->size = (bofs >> 3);  /* Store field offset. */
ct               1297 lj_cparse.c    	  ct->info = CTINFO(CT_FIELD, ctype_cid(ct->info));
ct               1298 lj_cparse.c    	  ct->size = (bofs >> 3);  /* Store field offset. */
ct               1300 lj_cparse.c    	  ct->info = CTINFO(CT_BITFIELD,
ct               1304 lj_cparse.c    	  ct->info += ((csz - (bofs & (csz-1)) - bsz) << CTSHIFT_BITPOS);
ct               1306 lj_cparse.c    	  ct->info += ((bofs & (csz-1)) << CTSHIFT_BITPOS);
ct               1308 lj_cparse.c    	  ct->size = ((bofs & ~(csz-1)) >> 3);  /* Store container offset. */
ct               1320 lj_cparse.c        fieldid = ct->sib;
ct               1354 lj_cparse.c    	  CType *ct;
ct               1355 lj_cparse.c    	  CTypeID fieldid = cp_decl_constinit(cp, &ct, ctypeid);
ct               1358 lj_cparse.c    	  ctype_setname(ct, decl.name);
ct               1361 lj_cparse.c    	  CType *ct;
ct               1362 lj_cparse.c    	  CTypeID fieldid = lj_ctype_new(cp->cts, &ct);  /* Do this first. */
ct               1374 lj_cparse.c    	      ct->info = CTINFO(CT_ATTRIB, CTATTRIB(CTA_SUBTYPE) + ctypeid);
ct               1375 lj_cparse.c    	      ct->size = ctype_isstruct(tct->info) ?
ct               1388 lj_cparse.c    	  ct->info = CTINFO(CT_FIELD, ctypeid + (bsz << CTSHIFT_BITCSZ));
ct               1389 lj_cparse.c    	  ct->size = decl.attr;
ct               1390 lj_cparse.c    	  if (decl.name) ctype_setname(ct, decl.name);
ct               1444 lj_cparse.c    	CType *ct;
ct               1445 lj_cparse.c    	CTypeID constid = lj_ctype_new(cp->cts, &ct);
ct               1448 lj_cparse.c    	ctype_setname(ct, name);
ct               1449 lj_cparse.c    	ct->info = CTINFO(CT_CONSTVAL, CTF_CONST|k.id);
ct               1450 lj_cparse.c    	ct->size = k.u32++;
ct               1452 lj_cparse.c    	lj_ctype_addname(cp->cts, ct, constid);
ct               1483 lj_cparse.c          if (cp->ct->size) {
ct               1485 lj_cparse.c    	sz = cp->ct->size;
ct               1511 lj_cparse.c          if (ctype_istypedef(cp->ct->info)) {
ct               1512 lj_cparse.c    	tdef = ctype_cid(cp->ct->info);  /* Get typedef. */
ct               1601 lj_cparse.c          CType *ct;
ct               1612 lj_cparse.c          ct = ctype_raw(cp->cts, ctypeid);
ct               1613 lj_cparse.c          if (ctype_isvoid(ct->info))
ct               1615 lj_cparse.c          else if (ctype_isrefarray(ct->info))
ct               1617 lj_cparse.c    	  CTINFO(CT_PTR, CTALIGN_PTR|ctype_cid(ct->info)), CTSIZE_PTR);
ct               1618 lj_cparse.c          else if (ctype_isfunc(ct->info))
ct               1622 lj_cparse.c          fieldid = lj_ctype_new(cp->cts, &ct);
ct               1628 lj_cparse.c          if (decl.name) ctype_setname(ct, decl.name);
ct               1629 lj_cparse.c          ct->info = CTINFO(CT_FIELD, ctypeid);
ct               1630 lj_cparse.c          ct->size = nargs++;
ct               1797 lj_cparse.c    	CType *ct;
ct               1800 lj_cparse.c    	  id = lj_ctype_new(cp->cts, &ct);
ct               1801 lj_cparse.c    	  ct->info = CTINFO(CT_TYPEDEF, ctypeid);
ct               1805 lj_cparse.c    	  ct = ctype_get(cp->cts, ctypeid);
ct               1807 lj_cparse.c    	  lua_assert(gcref(ct->name) == NULL);
ct               1810 lj_cparse.c    	  id = cp_decl_constinit(cp, &ct, ctypeid);
ct               1813 lj_cparse.c    	  id = lj_ctype_new(cp->cts, &ct);
ct               1814 lj_cparse.c    	  ct->info = CTINFO(CT_EXTERN, ctypeid);
ct               1819 lj_cparse.c    	  ct = ctype_get(cp->cts, id);  /* Table may have been reallocated. */
ct               1821 lj_cparse.c    	  cta->sib = ct->sib;
ct               1822 lj_cparse.c    	  ct->sib = aid;
ct               1826 lj_cparse.c    	ctype_setname(ct, decl.name);
ct               1827 lj_cparse.c    	lj_ctype_addname(cp->cts, ct, id);
ct                 46 lj_cparse.h      CType *ct;		/* C type table entry. */
ct                 98 lj_crecord.c     if (ctype_isenum(ct->info)) ct = ctype_child(cts, ct);
ct                 99 lj_crecord.c     if (LJ_LIKELY(ctype_isnum(ct->info))) {
ct                100 lj_crecord.c       if ((ct->info & CTF_FP)) {
ct                101 lj_crecord.c         if (ct->size == sizeof(double))
ct                103 lj_crecord.c         else if (ct->size == sizeof(float))
ct                106 lj_crecord.c         uint32_t b = lj_fls(ct->size);
ct                108 lj_crecord.c   	return IRT_I8 + 2*b + ((ct->info & CTF_UNSIGNED) ? 1 : 0);
ct                110 lj_crecord.c     } else if (ctype_isptr(ct->info)) {
ct                111 lj_crecord.c       return (LJ_64 && ct->size == 8) ? IRT_P64 : IRT_P32;
ct                112 lj_crecord.c     } else if (ctype_iscomplex(ct->info)) {
ct                113 lj_crecord.c       if (ct->size == 2*sizeof(double))
ct                115 lj_crecord.c       else if (ct->size == 2*sizeof(float))
ct                149 lj_crecord.c     CTypeID fid = ct->sib;
ct                237 lj_crecord.c       if (ct) {
ct                239 lj_crecord.c         lua_assert(ctype_isarray(ct->info) || ctype_isstruct(ct->info));
ct                240 lj_crecord.c         if (ctype_isarray(ct->info)) {
ct                241 lj_crecord.c   	CType *cct = ctype_rawchild(cts, ct);
ct                246 lj_crecord.c         } else if ((ct->info & CTF_UNION)) {
ct                247 lj_crecord.c   	step = (1u << ctype_align(ct->info));
ct                250 lj_crecord.c   	mlp = crec_copy_struct(ml, cts, ct);
ct                707 lj_crecord.c     CTypeID id = ctype_typeid(cts, ct);
ct                736 lj_crecord.c     CType *ct = ctype_raw(cts, cd->ctypeid);
ct                740 lj_crecord.c     if (ctype_isptr(ct->info)) {
ct                741 lj_crecord.c       IRType t = (LJ_64 && ct->size == 8) ? IRT_P64 : IRT_P32;
ct                742 lj_crecord.c       if (ctype_isref(ct->info)) ct = ctype_rawchild(cts, ct);
ct                752 lj_crecord.c       if (ctype_ispointer(ct->info)) {
ct                755 lj_crecord.c         if ((ct->info & CTF_COMPLEX))
ct                757 lj_crecord.c         sz = lj_ctype_size(cts, (sid = ctype_cid(ct->info)));
ct                777 lj_crecord.c       if (ctype_ispointer(ct->info) && t >= IRT_I8 && t <= IRT_U64) {
ct                798 lj_crecord.c         ct = ctype_raw(cts, crec_constructor(J, cd, ptr));
ct                799 lj_crecord.c       if (ctype_isstruct(ct->info)) {
ct                802 lj_crecord.c         fct = lj_ctype_getfield(cts, ct, name, &fofs);
ct                822 lj_crecord.c       } else if (ctype_iscomplex(ct->info)) {
ct                828 lj_crecord.c   	if (strdata(name)[0] == 'i') ofs += (ct->size >> 1);
ct                829 lj_crecord.c   	sid = ctype_cid(ct->info);
ct                834 lj_crecord.c       if (ctype_isptr(ct->info)) {  /* Automatically perform '->'. */
ct                835 lj_crecord.c         CType *cct = ctype_rawchild(cts, ct);
ct                837 lj_crecord.c   	ct = cct;
ct                842 lj_crecord.c       crec_index_meta(J, cts, ct, rd);
ct                850 lj_crecord.c     ct = ctype_get(cts, sid);
ct                851 lj_crecord.c     if (ctype_isref(ct->info)) {
ct                853 lj_crecord.c       sid = ctype_cid(ct->info);
ct                854 lj_crecord.c       ct = ctype_get(cts, sid);
ct                857 lj_crecord.c     while (ctype_isattrib(ct->info))
ct                858 lj_crecord.c       ct = ctype_child(cts, ct);  /* Skip attributes. */
ct                861 lj_crecord.c       J->base[0] = crec_tv_ct(J, ct, sid, ptr);
ct                865 lj_crecord.c       crec_ct_tv(J, ct, ptr, J->base[2], &rd->argv[2]);
ct               1000 lj_crecord.c     if (ctype_cconv(ct->info) == CTCC_THISCALL)
ct               1002 lj_crecord.c     else if (ctype_cconv(ct->info) == CTCC_FASTCALL)
ct               1007 lj_crecord.c     fid = ct->sib;
ct               1027 lj_crecord.c         if (!(ct->info & CTF_VARARG))
ct               1109 lj_crecord.c     CType *ct = ctype_raw(cts, cd->ctypeid);
ct               1111 lj_crecord.c     if (ctype_isptr(ct->info)) {
ct               1112 lj_crecord.c       tp = (LJ_64 && ct->size == 8) ? IRT_P64 : IRT_P32;
ct               1113 lj_crecord.c       ct = ctype_rawchild(cts, ct);
ct               1115 lj_crecord.c     if (ctype_isfunc(ct->info)) {
ct               1117 lj_crecord.c       CType *ctr = ctype_rawchild(cts, ct);
ct               1133 lj_crecord.c       if ((ct->info & CTF_VARARG)
ct               1135 lj_crecord.c   	|| ctype_cconv(ct->info) != CTCC_CDECL
ct               1139 lj_crecord.c   		    lj_ir_kint(J, ctype_typeid(cts, ct)));
ct               1140 lj_crecord.c       tr = emitir(IRT(IR_CALLXS, t), crec_call_args(J, rd, cts, ct), func);
ct               1158 lj_crecord.c         TRef trid = lj_ir_kint(J, ctype_cid(ct->info));
ct               1180 lj_crecord.c     CType *ct;
ct               1190 lj_crecord.c     ct = ctype_raw(cts, id);
ct               1191 lj_crecord.c     tv = lj_ctype_meta(cts, ctype_isptr(ct->info) ? ctype_cid(ct->info) : id, mm);
ct               1332 lj_crecord.c         CType *ct = ctype_raw(cts, id);
ct               1333 lj_crecord.c         if (ctype_isptr(ct->info)) id = ctype_cid(ct->info);
ct               1338 lj_crecord.c         CType *ct = ctype_raw(cts, id);
ct               1339 lj_crecord.c         if (ctype_isptr(ct->info)) id = ctype_cid(ct->info);
ct               1371 lj_crecord.c       CType *ct = ctype_get(cts, CTID_DOUBLE);
ct               1377 lj_crecord.c         ct = ctype_raw(cts, id);
ct               1378 lj_crecord.c         t = crec_ct2irt(cts, ct);
ct               1379 lj_crecord.c         if (ctype_isptr(ct->info)) {  /* Resolve pointer or reference. */
ct               1381 lj_crecord.c   	if (ctype_isref(ct->info)) {
ct               1382 lj_crecord.c   	  ct = ctype_rawchild(cts, ct);
ct               1383 lj_crecord.c   	  t = crec_ct2irt(cts, ct);
ct               1391 lj_crecord.c   	if (ctype_isenum(ct->info)) ct = ctype_child(cts, ct);
ct               1393 lj_crecord.c         } else if (ctype_isfunc(ct->info)) {
ct               1395 lj_crecord.c   	ct = ctype_get(cts,
ct               1401 lj_crecord.c         if (ctype_isenum(ct->info)) ct = ctype_child(cts, ct);
ct               1402 lj_crecord.c         if (ctype_isnum(ct->info)) {
ct               1412 lj_crecord.c         ct = ctype_get(cts, CTID_P_VOID);
ct               1414 lj_crecord.c         ct = ctype_get(cts, CTID_INT32);
ct               1418 lj_crecord.c         ct = ctype_raw(cts, id);
ct               1419 lj_crecord.c         if (ctype_isenum(ct->info)) {  /* Match string against enum constant. */
ct               1422 lj_crecord.c   	CType *cct = lj_ctype_getfield(cts, ct, str, &ofs);
ct               1426 lj_crecord.c   	  ct = ctype_child(cts, cct);
ct               1429 lj_crecord.c   	  ct = ctype_get(cts, CTID_P_VOID);
ct               1431 lj_crecord.c         } else if (ctype_isptr(ct->info)) {
ct               1434 lj_crecord.c   	ct = ctype_get(cts, CTID_P_VOID);
ct               1438 lj_crecord.c         ct = ctype_get(cts, CTID_P_VOID);
ct               1441 lj_crecord.c       s[i] = ct;
ct               1473 lj_crecord.c       CType *ct;
ct               1474 lj_crecord.c       CTypeID id = lj_ctype_getname(cts, &ct, name, CLNS_INDEX);
ct               1480 lj_crecord.c         if (ctype_isconstval(ct->info)) {
ct               1481 lj_crecord.c   	if (ct->size >= 0x80000000u &&
ct               1482 lj_crecord.c   	    (ctype_child(cts, ct)->info & CTF_UNSIGNED))
ct               1483 lj_crecord.c   	  J->base[0] = lj_ir_knum(J, (lua_Number)(uint32_t)ct->size);
ct               1485 lj_crecord.c   	  J->base[0] = lj_ir_kint(J, (int32_t)ct->size);
ct               1486 lj_crecord.c         } else if (ctype_isextern(ct->info)) {
ct               1487 lj_crecord.c   	CTypeID sid = ctype_cid(ct->info);
ct               1490 lj_crecord.c   	ct = ctype_raw(cts, sid);
ct               1496 lj_crecord.c   	  J->base[0] = crec_tv_ct(J, ct, sid, ptr);
ct               1499 lj_crecord.c   	  crec_ct_tv(J, ct, ptr, J->base[2], &rd->argv[2]);
ct               1573 lj_crecord.c         CType *ct = ctype_raw(cts, cdataV(&rd->argv[0])->ctypeid);
ct               1574 lj_crecord.c         if (ctype_isptr(ct->info))
ct               1575 lj_crecord.c   	ct = ctype_rawchild(cts, ct);
ct               1576 lj_crecord.c         step = (1u<<ctype_align(lj_ctype_info(cts, ctype_typeid(cts, ct), &sz)));
ct               1630 lj_crecord.c       CType *ct = lj_ctype_rawref(ctype_ctsG(J2G(J)), id);
ct               1631 lj_crecord.c       if (ctype_isvltype(ct->info))
ct               1654 lj_crecord.c     CType *d, *ct = lj_ctype_rawref(cts, cdataV(&rd->argv[0])->ctypeid);
ct               1655 lj_crecord.c     if (ctype_isenum(ct->info)) ct = ctype_child(cts, ct);
ct               1656 lj_crecord.c     if (ctype_isnum(ct->info) || ctype_iscomplex(ct->info)) {
ct               1657 lj_crecord.c       if (ctype_isinteger_or_bool(ct->info) && ct->size <= 4 &&
ct               1658 lj_crecord.c   	!(ct->size == 4 && (ct->info & CTF_UNSIGNED)))
ct                112 lj_ctype.c     #define CTTYINFODEF(id, sz, ct, info)	CTINFO((ct),(((sz)&0x3fu)<<10)+(info)),
ct                151 lj_ctype.c       CType *ct;
ct                156 lj_ctype.c         ct = lj_mem_newvec(cts->L, id+1, CType);
ct                157 lj_ctype.c         memcpy(ct, cts->tab, id*sizeof(CType));
ct                160 lj_ctype.c         cts->tab = ct;
ct                167 lj_ctype.c       *ctp = ct = &cts->tab[id];
ct                168 lj_ctype.c       ct->info = 0;
ct                169 lj_ctype.c       ct->size = 0;
ct                170 lj_ctype.c       ct->sib = 0;
ct                171 lj_ctype.c       ct->next = 0;
ct                172 lj_ctype.c       setgcrefnull(ct->name);
ct                183 lj_ctype.c         CType *ct = ctype_get(cts, id);
ct                184 lj_ctype.c         if (ct->info == info && ct->size == size)
ct                186 lj_ctype.c         id = ct->next;
ct                206 lj_ctype.c       uint32_t h = ct_hashtype(ct->info, ct->size);
ct                207 lj_ctype.c       ct->next = cts->hash[h];
ct                214 lj_ctype.c       uint32_t h = ct_hashname(gcref(ct->name));
ct                215 lj_ctype.c       ct->next = cts->hash[h];
ct                224 lj_ctype.c         CType *ct = ctype_get(cts, id);
ct                225 lj_ctype.c         if (gcref(ct->name) == obj2gco(name) &&
ct                226 lj_ctype.c     	((tmask >> ctype_type(ct->info)) & 1)) {
ct                227 lj_ctype.c           *ctp = ct;
ct                230 lj_ctype.c         id = ct->next;
ct                240 lj_ctype.c       while (ct->sib) {
ct                241 lj_ctype.c         ct = ctype_get(cts, ct->sib);
ct                242 lj_ctype.c         if (gcref(ct->name) == obj2gco(name)) {
ct                243 lj_ctype.c           *ofs = ct->size;
ct                244 lj_ctype.c           return ct;
ct                246 lj_ctype.c         if (ctype_isxattrib(ct->info, CTA_SUBTYPE)) {
ct                247 lj_ctype.c           CType *fct, *cct = ctype_child(cts, ct);
ct                256 lj_ctype.c     	*ofs += ct->size;
ct                269 lj_ctype.c       CType *ct = ctype_get(cts, id);
ct                270 lj_ctype.c       while (ctype_isattrib(ct->info) || ctype_isref(ct->info))
ct                271 lj_ctype.c         ct = ctype_child(cts, ct);
ct                272 lj_ctype.c       return ct;
ct                278 lj_ctype.c       CType *ct = ctype_raw(cts, id);
ct                279 lj_ctype.c       return ctype_hassize(ct->info) ? ct->size : CTSIZE_INVALID;
ct                286 lj_ctype.c       if (ctype_isstruct(ct->info)) {
ct                287 lj_ctype.c         CTypeID arrid = 0, fid = ct->sib;
ct                288 lj_ctype.c         xsz = ct->size;  /* Add the struct size. */
ct                295 lj_ctype.c         ct = ctype_raw(cts, arrid);
ct                297 lj_ctype.c       lua_assert(ctype_isvlarray(ct->info));  /* Must be a VLA. */
ct                298 lj_ctype.c       ct = ctype_rawchild(cts, ct);  /* Get array element. */
ct                299 lj_ctype.c       lua_assert(ctype_hassize(ct->info));
ct                301 lj_ctype.c       xsz += (uint64_t)ct->size * nelem;
ct                309 lj_ctype.c       CType *ct = ctype_get(cts, id);
ct                311 lj_ctype.c         CTInfo info = ct->info;
ct                316 lj_ctype.c     	qual |= ct->size;
ct                318 lj_ctype.c     	qual |= CTFP_ALIGNED + CTALIGN(ct->size);
ct                323 lj_ctype.c           *szp = ctype_isfunc(info) ? CTSIZE_INVALID : ct->size;
ct                326 lj_ctype.c         ct = ctype_get(cts, ctype_cid(info));
ct                334 lj_ctype.c       CType *ct = ctype_get(cts, id);
ct                336 lj_ctype.c       while (ctype_isattrib(ct->info) || ctype_isref(ct->info)) {
ct                337 lj_ctype.c         id = ctype_cid(ct->info);
ct                338 lj_ctype.c         ct = ctype_get(cts, id);
ct                340 lj_ctype.c       if (ctype_isptr(ct->info) &&
ct                341 lj_ctype.c           ctype_isfunc(ctype_get(cts, ctype_cid(ct->info))->info))
ct                425 lj_ctype.c       if (gcref(ct->name)) {
ct                426 lj_ctype.c         GCstr *str = gco2str(gcref(ct->name));
ct                430 lj_ctype.c         ctype_prepnum(ctr, ctype_typeid(ctr->cts, ct));
ct                439 lj_ctype.c       CType *ct = ctype_get(ctr->cts, id);
ct                443 lj_ctype.c         CTInfo info = ct->info;
ct                444 lj_ctype.c         CTSize size = ct->size;
ct                474 lj_ctype.c           ctype_preptype(ctr, ct, qual, (info & CTF_UNION) ? "union" : "struct");
ct                481 lj_ctype.c           ctype_preptype(ctr, ct, qual, "enum");
ct                504 lj_ctype.c     	  CTSize csize = ctype_child(ctr->cts, ct)->size;
ct                530 lj_ctype.c         ct = ctype_get(ctr->cts, ctype_cid(info));
ct                592 lj_ctype.c       CType *ct = lj_mem_newvec(L, CTTYPETAB_MIN, CType);
ct                596 lj_ctype.c       cts->tab = ct;
ct                601 lj_ctype.c       for (id = 0; id < CTTYPEINFO_NUM; id++, ct++) {
ct                603 lj_ctype.c         ct->size = (CTSize)((int32_t)(info << 16) >> 26);
ct                604 lj_ctype.c         ct->info = info & 0xffff03ffu;
ct                605 lj_ctype.c         ct->sib = 0;
ct                609 lj_ctype.c           ctype_setname(ct, str);
ct                611 lj_ctype.c           lj_ctype_addname(cts, ct, id);
ct                613 lj_ctype.c           setgcrefnull(ct->name);
ct                614 lj_ctype.c           ct->next = 0;
ct                615 lj_ctype.c           if (!ctype_isenum(info)) ctype_addtype(cts, ct, id);
ct                186 lj_ctype.h     #define CTINFO(ct, flags)	(((CTInfo)(ct) << CTSHIFT_NUM) + (flags))
ct                406 lj_ctype.h     #define ctype_typeid(cts, ct)	((CTypeID)((ct) - (cts)->tab))
ct                411 lj_ctype.h       lua_assert(!(ctype_isvoid(ct->info) || ctype_isstruct(ct->info) ||
ct                412 lj_ctype.h     	     ctype_isbitfield(ct->info)));  /* These don't have children. */
ct                413 lj_ctype.h       return ctype_get(cts, ctype_cid(ct->info));
ct                419 lj_ctype.h       CType *ct = ctype_get(cts, id);
ct                420 lj_ctype.h       while (ctype_isattrib(ct->info)) ct = ctype_child(cts, ct);
ct                421 lj_ctype.h       return ct;
ct                427 lj_ctype.h       do { ct = ctype_child(cts, ct); } while (ctype_isattrib(ct->info));
ct                428 lj_ctype.h       return ct;
ct                436 lj_ctype.h       setgcref(ct->name, obj2gco(s));
ct                447 lj_ctype.h       lj_ctype_getfieldq((cts), (ct), (name), (ofs), NULL)
ct                545 lj_opt_fold.c      CType *ct = ctype_raw(ctype_ctsG(J2G(J)), gco2cd(o)->ctypeid);
ct                546 lj_opt_fold.c      if (ctype_isnum(ct->info) || ctype_isenum(ct->info) ||
ct                547 lj_opt_fold.c  	ctype_isptr(ct->info) || ctype_isfunc(ct->info) ||
ct                548 lj_opt_fold.c  	ctype_iscomplex(ct->info) || ctype_isvector(ct->info))
ct               1307 lj_record.c    	CType *ct = ctype_raw(ctype_ctsG(J2G(J)), cd->ctypeid);
ct               1308 lj_record.c    	if (!ctype_hassize(ct->info) || ct->size <= 16)