ct                271 lib_base.c           CType *ct = lj_ctype_rawref(cts, cdataV(o)->ctypeid);
ct                272 lib_base.c           if (ctype_isenum(ct->info)) ct = ctype_child(cts, ct);
ct                273 lib_base.c           if (ctype_isnum(ct->info) || ctype_iscomplex(ct->info)) {
ct                274 lib_base.c     	if (LJ_DUALNUM && ctype_isinteger_or_bool(ct->info) &&
ct                275 lib_base.c     	    ct->size <= 4 && !(ct->size == 4 && (ct->info & CTF_UNSIGNED))) {
ct                123 lib_bit.c          CType *ct = ctype_get(cts, id);
ct                128 lib_bit.c            lj_cconv_ct_tv(cts, ct, (uint8_t *)&x, o, 0);
ct                109 lib_ffi.c        CTypeID id = ctype_typeid(cts, ct);
ct                150 lib_ffi.c        CType *ct;
ct                155 lib_ffi.c        ct = lj_cdata_index(cts, cdataV(o), o+1, &p, &qual);
ct                157 lib_ffi.c          return ffi_index_meta(L, cts, ct, MM_index);
ct                158 lib_ffi.c        if (lj_cdata_get(cts, ct, L->top-1, p))
ct                167 lib_ffi.c        CType *ct;
ct                172 lib_ffi.c        ct = lj_cdata_index(cts, cdataV(o), o+1, &p, &qual);
ct                176 lib_ffi.c          return ffi_index_meta(L, cts, ct, MM_newindex);
ct                178 lib_ffi.c        lj_cdata_set(cts, ct, p, o+2, qual);
ct                223 lib_ffi.c        CType *ct;
ct                235 lib_ffi.c        ct = ctype_raw(cts, id);
ct                236 lib_ffi.c        if (ctype_isptr(ct->info)) id = ctype_cid(ct->info);
ct                292 lib_ffi.c          CType *ct = ctype_raw(cts, id);
ct                293 lib_ffi.c          if (ctype_isref(ct->info)) {
ct                295 lib_ffi.c            ct = ctype_rawchild(cts, ct);
ct                297 lib_ffi.c          if (ctype_iscomplex(ct->info)) {
ct                298 lib_ffi.c            setstrV(L, L->top-1, lj_ctype_repr_complex(L, cdataptr(cd), ct->size));
ct                300 lib_ffi.c          } else if (ct->size == 8 && ctype_isinteger(ct->info)) {
ct                302 lib_ffi.c      					       (ct->info & CTF_UNSIGNED)));
ct                304 lib_ffi.c          } else if (ctype_isfunc(ct->info)) {
ct                306 lib_ffi.c          } else if (ctype_isenum(ct->info)) {
ct                310 lib_ffi.c            if (ctype_isptr(ct->info)) {
ct                311 lib_ffi.c      	p = cdata_getptr(p, ct->size);
ct                312 lib_ffi.c      	ct = ctype_rawchild(cts, ct);
ct                314 lib_ffi.c            if (ctype_isstruct(ct->info) || ctype_isvector(ct->info)) {
ct                316 lib_ffi.c      	cTValue *tv = lj_ctype_meta(cts, ctype_typeid(cts, ct), MM_tostring);
ct                332 lib_ffi.c        CType *ct = ctype_raw(cts, id);
ct                334 lib_ffi.c        if (ctype_isptr(ct->info)) id = ctype_cid(ct->info);
ct                383 lib_ffi.c            CType *ct = ctype_raw(cts, sid);
ct                384 lib_ffi.c            if (lj_cconv_tv_ct(cts, ct, sid, L->top-1, sp))
ct                436 lib_ffi.c        CType *ct = ctype_raw(cts, cd->ctypeid);
ct                437 lib_ffi.c        if (ctype_isptr(ct->info) && (LJ_32 || ct->size == 8)) {
ct                497 lib_ffi.c        CType *ct = ctype_raw(cts, id);
ct                504 lib_ffi.c          sz = lj_ctype_vlsize(cts, ct, (CTSize)ffi_checkint(L, 2));
ct                510 lib_ffi.c        lj_cconv_ct_init(cts, ct, sz, cdataptr(cd),
ct                512 lib_ffi.c        if (ctype_isstruct(ct->info)) {
ct                565 lib_ffi.c          CType *ct = ctype_get(cts, id);
ct                569 lib_ffi.c          setintV(lj_tab_setstr(L, t, lj_str_newlit(L, "info")), (int32_t)ct->info);
ct                570 lib_ffi.c          if (ct->size != CTSIZE_INVALID)
ct                571 lib_ffi.c            setintV(lj_tab_setstr(L, t, lj_str_newlit(L, "size")), (int32_t)ct->size);
ct                572 lib_ffi.c          if (ct->sib)
ct                573 lib_ffi.c            setintV(lj_tab_setstr(L, t, lj_str_newlit(L, "sib")), (int32_t)ct->sib);
ct                574 lib_ffi.c          if (gcref(ct->name)) {
ct                575 lib_ffi.c            GCstr *s = gco2str(gcref(ct->name));
ct                622 lib_ffi.c          CType *ct = lj_ctype_rawref(cts, id);
ct                623 lib_ffi.c          if (ctype_isvltype(ct->info))
ct                624 lib_ffi.c            sz = lj_ctype_vlsize(cts, ct, (CTSize)ffi_checkint(L, 2));
ct                626 lib_ffi.c            sz = ctype_hassize(ct->info) ? ct->size : CTSIZE_INVALID;
ct                651 lib_ffi.c        CType *ct = lj_ctype_rawref(cts, id);
ct                653 lib_ffi.c        if (ctype_isstruct(ct->info) && ct->size != CTSIZE_INVALID) {
ct                654 lib_ffi.c          CType *fct = lj_ctype_getfield(cts, ct, name, &ofs);
ct                772 lib_ffi.c        CType *ct = ctype_get(cts, id);  /* Only allow raw types. */
ct                775 lib_ffi.c        if (!(ctype_isstruct(ct->info) || ctype_iscomplex(ct->info) ||
ct                776 lib_ffi.c      	ctype_isvector(ct->info)))
ct                797 lib_ffi.c        CType *ct = ctype_raw(cts, cd->ctypeid);
ct                798 lib_ffi.c        if (!(ctype_isptr(ct->info) || ctype_isstruct(ct->info) ||
ct                799 lib_ffi.c      	ctype_isrefarray(ct->info)))
ct               1283 lj_asm.c           CType *ct = ctype_get(ctype_ctsG(J2G(as->J)), id);
ct               1284 lj_asm.c           nargs |= ((ct->info & CTF_VARARG) ? CCI_VARARG : 0);
ct               1286 lj_asm.c           nargs |= (ctype_cconv(ct->info) << CCI_CC_SHIFT);
ct                 26 lj_carith.c      CType *ct[2];
ct                 41 lj_carith.c          CType *ct = ctype_raw(cts, id);
ct                 43 lj_carith.c          if (ctype_isptr(ct->info)) {
ct                 44 lj_carith.c    	p = (uint8_t *)cdata_getptr(p, ct->size);
ct                 45 lj_carith.c    	if (ctype_isref(ct->info)) ct = ctype_rawchild(cts, ct);
ct                 46 lj_carith.c          } else if (ctype_isfunc(ct->info)) {
ct                 48 lj_carith.c    	ct = ctype_get(cts,
ct                 51 lj_carith.c          if (ctype_isenum(ct->info)) ct = ctype_child(cts, ct);
ct                 52 lj_carith.c          ca->ct[i] = ct;
ct                 55 lj_carith.c          ca->ct[i] = ctype_get(cts, CTID_INT32);
ct                 58 lj_carith.c          ca->ct[i] = ctype_get(cts, CTID_DOUBLE);
ct                 61 lj_carith.c          ca->ct[i] = ctype_get(cts, CTID_P_VOID);
ct                 65 lj_carith.c          CType *ct = ctype_raw(cts, cdataV(o2)->ctypeid);
ct                 66 lj_carith.c          ca->ct[i] = NULL;
ct                 69 lj_carith.c          if (ctype_isenum(ct->info)) {
ct                 71 lj_carith.c    	CType *cct = lj_ctype_getfield(cts, ct, strV(o), &ofs);
ct                 73 lj_carith.c    	  ca->ct[i] = ctype_child(cts, cct);
ct                 77 lj_carith.c    	  ca->ct[1-i] = ct;  /* Use enum to improve error message. */
ct                 83 lj_carith.c          ca->ct[i] = NULL;
ct                 94 lj_carith.c      CType *ctp = ca->ct[0];
ct                102 lj_carith.c    	(ctype_isptr(ca->ct[1]->info) || ctype_isrefarray(ca->ct[1]->info))) {
ct                108 lj_carith.c          if (!lj_cconv_compatptr(cts, ctp, ca->ct[1], CCF_IGNQUAL))
ct                130 lj_carith.c        if (!((mm == MM_add || mm == MM_sub) && ctype_isnum(ca->ct[1]->info)))
ct                132 lj_carith.c        lj_cconv_ct_ct(cts, ctype_get(cts, CTID_INT_PSZ), ca->ct[1],
ct                136 lj_carith.c          (ctype_isptr(ca->ct[1]->info) || ctype_isrefarray(ca->ct[1]->info))) {
ct                138 lj_carith.c        ctp = ca->ct[1]; pp = ca->p[1];
ct                139 lj_carith.c        lj_cconv_ct_ct(cts, ctype_get(cts, CTID_INT_PSZ), ca->ct[0],
ct                160 lj_carith.c      if (ctype_isnum(ca->ct[0]->info) && ca->ct[0]->size <= 8 &&
ct                161 lj_carith.c          ctype_isnum(ca->ct[1]->info) && ca->ct[1]->size <= 8) {
ct                162 lj_carith.c        CTypeID id = (((ca->ct[0]->info & CTF_UNSIGNED) && ca->ct[0]->size == 8) ||
ct                163 lj_carith.c    		  ((ca->ct[1]->info & CTF_UNSIGNED) && ca->ct[1]->size == 8)) ?
ct                165 lj_carith.c        CType *ct = ctype_get(cts, id);
ct                168 lj_carith.c        lj_cconv_ct_ct(cts, ct, ca->ct[0], (uint8_t *)&u0, ca->p[0], 0);
ct                170 lj_carith.c          lj_cconv_ct_ct(cts, ct, ca->ct[1], (uint8_t *)&u1, ca->p[1], 0);
ct                225 lj_carith.c        CType *ct = ctype_raw(cts, id);
ct                226 lj_carith.c        if (ctype_isptr(ct->info)) id = ctype_cid(ct->info);
ct                231 lj_carith.c        CType *ct = ctype_raw(cts, id);
ct                232 lj_carith.c        if (ctype_isptr(ct->info)) id = ctype_cid(ct->info);
ct                245 lj_carith.c          if (ca->ct[i] && tviscdata(L->base+i)) {
ct                246 lj_carith.c    	if (ctype_isenum(ca->ct[i]->info)) isenum = i;
ct                247 lj_carith.c    	repr[i] = strdata(lj_ctype_repr(L, ctype_typeid(cts, ca->ct[i]), NULL));
ct                219 lj_ccall.c       cc->retref = !ccall_classify_struct(cts, ctr, ct); \
ct                223 lj_ccall.c       if (ccall_classify_struct(cts, ctr, ct) > 1) sp = (uint8_t *)&cc->fpr[0]; \
ct                227 lj_ccall.c       if (!(ct->info & CTF_VARARG)) cc->retref = 0;  /* Return complex in FPRs. */
ct                230 lj_ccall.c       if (!(ct->info & CTF_VARARG)) memcpy(dp, &cc->fpr[0], ctr->size);
ct                233 lj_ccall.c       isfp = (ccall_classify_struct(cts, d, ct) > 1);
ct                240 lj_ccall.c       if (isfp && !(ct->info & CTF_VARARG)) { \
ct                291 lj_ccall.c       if ((ct->info & CTF_VARARG)) sp = (uint8_t *)&cc->gpr[0];
ct                483 lj_ccall.c       if (isfp && nfpr < CCALL_NARG_FPR && !(ct->info & CTF_VARARG)) { \
ct                511 lj_ccall.c       ccall_copy_struct(cc, ctr, dp, sp, ccall_classify_struct(cts, ctr, ct));
ct                591 lj_ccall.c       CTSize sz = ct->size;
ct                593 lj_ccall.c       if ((ct->info & CTF_UNION)) return 0;
ct                594 lj_ccall.c       while (ct->sib) {
ct                595 lj_ccall.c         ct = ctype_get(cts, ct->sib);
ct                596 lj_ccall.c         if (ctype_isfield(ct->info)) {
ct                597 lj_ccall.c           CType *sct = ctype_rawchild(cts, ct);
ct                607 lj_ccall.c         } else if (ctype_isbitfield(ct->info)) {
ct                609 lj_ccall.c         } else if (ctype_isxattrib(ct->info, CTA_SUBTYPE)) {
ct                610 lj_ccall.c           CType *sct = ctype_rawchild(cts, ct);
ct                635 lj_ccall.c       if (ctype_isarray(ct->info)) {
ct                636 lj_ccall.c         CType *cct = ctype_rawchild(cts, ct);
ct                637 lj_ccall.c         CTSize eofs, esz = cct->size, asz = ct->size;
ct                640 lj_ccall.c       } else if (ctype_isstruct(ct->info)) {
ct                641 lj_ccall.c         ccall_classify_struct(cts, ct, rcl, ofs);
ct                643 lj_ccall.c         int cl = ctype_isfp(ct->info) ? CCALL_RCL_SSE : CCALL_RCL_INT;
ct                644 lj_ccall.c         lua_assert(ctype_hassize(ct->info));
ct                645 lj_ccall.c         if ((ofs & (ct->size-1))) cl = CCALL_RCL_MEM;  /* Unaligned. */
ct                653 lj_ccall.c       if (ct->size > 16) return CCALL_RCL_MEM;  /* Too big, gets memory class. */
ct                654 lj_ccall.c       while (ct->sib) {
ct                656 lj_ccall.c         ct = ctype_get(cts, ct->sib);
ct                657 lj_ccall.c         fofs = ofs+ct->size;
ct                658 lj_ccall.c         if (ctype_isfield(ct->info))
ct                659 lj_ccall.c           ccall_classify_ct(cts, ctype_rawchild(cts, ct), rcl, fofs);
ct                660 lj_ccall.c         else if (ctype_isbitfield(ct->info))
ct                662 lj_ccall.c         else if (ctype_isxattrib(ct->info, CTA_SUBTYPE))
ct                663 lj_ccall.c           ccall_classify_struct(cts, ctype_rawchild(cts, ct), rcl, fofs);
ct                728 lj_ccall.c       CTSize sz = ct->size;
ct                729 lj_ccall.c       unsigned int r = 0, n = 0, isu = (ct->info & CTF_UNION);
ct                731 lj_ccall.c       while (ct->sib) {
ct                733 lj_ccall.c         ct = ctype_get(cts, ct->sib);
ct                734 lj_ccall.c         if (ctype_isfield(ct->info)) {
ct                735 lj_ccall.c           sct = ctype_rawchild(cts, ct);
ct                747 lj_ccall.c         } else if (ctype_isbitfield(ct->info)) {
ct                749 lj_ccall.c         } else if (ctype_isxattrib(ct->info, CTA_SUBTYPE)) {
ct                750 lj_ccall.c           sct = ctype_rawchild(cts, ct);
ct                775 lj_ccall.c       CTSize sz = ct->size;
ct                776 lj_ccall.c       unsigned int r = 0, n = 0, isu = (ct->info & CTF_UNION);
ct                777 lj_ccall.c       while (ct->sib) {
ct                779 lj_ccall.c         ct = ctype_get(cts, ct->sib);
ct                780 lj_ccall.c         if (ctype_isfield(ct->info)) {
ct                781 lj_ccall.c           sct = ctype_rawchild(cts, ct);
ct                793 lj_ccall.c         } else if (ctype_isbitfield(ct->info)) {
ct                795 lj_ccall.c         } else if (ctype_isxattrib(ct->info, CTA_SUBTYPE)) {
ct                796 lj_ccall.c           sct = ctype_rawchild(cts, ct);
ct                825 lj_ccall.c       if ((ctf->info & CTF_VARARG) || (ct->info & CTF_UNION))
ct                827 lj_ccall.c       while (ct->sib) {
ct                829 lj_ccall.c         ct = ctype_get(cts, ct->sib);
ct                832 lj_ccall.c         } else if (ctype_isfield(ct->info)) {
ct                833 lj_ccall.c           sct = ctype_rawchild(cts, ct);
ct                840 lj_ccall.c         } else if (ctype_isbitfield(ct->info) ||
ct                841 lj_ccall.c     	       ctype_isxattrib(ct->info, CTA_SUBTYPE)) {
ct                942 lj_ccall.c       switch (ctype_cconv(ct->info)) {
ct                952 lj_ccall.c       ctr = ctype_rawchild(cts, ct);
ct                959 lj_ccall.c         GCcdata *cd = lj_cdata_new(cts, ctype_cid(ct->info), sz);
ct                974 lj_ccall.c       fid = ct->sib;
ct                995 lj_ccall.c           if (!(ct->info & CTF_VARARG))
ct               1108 lj_ccall.c       CType *ctr = ctype_rawchild(cts, ct);
ct               1148 lj_ccall.c       CType *ct = ctype_raw(cts, cd->ctypeid);
ct               1150 lj_ccall.c       if (ctype_isptr(ct->info)) {
ct               1151 lj_ccall.c         sz = ct->size;
ct               1152 lj_ccall.c         ct = ctype_rawchild(cts, ct);
ct               1154 lj_ccall.c       if (ctype_isfunc(ct->info)) {
ct               1158 lj_ccall.c         gcsteps = ccall_set_args(L, cts, ct, &cc);
ct               1159 lj_ccall.c         ct = (CType *)((intptr_t)ct-(intptr_t)cts->tab);
ct               1167 lj_ccall.c         ct = (CType *)((intptr_t)ct+(intptr_t)cts->tab);  /* May be reallocated. */
ct               1168 lj_ccall.c         gcsteps += ccall_get_results(L, cts, ct, &cc, &ret);
ct               1171 lj_ccall.c         if (cc.spadj && ctype_cconv(ct->info) == CTCC_CDECL) {
ct               1172 lj_ccall.c           CTF_INSERT(ct->info, CCONV, CTCC_STDCALL);
ct                522 lj_ccallback.c   CType *ct;
ct                534 lj_ccallback.c     ct = ctype_get(cts, id);
ct                535 lj_ccallback.c     rid = ctype_cid(ct->info);  /* Return type. x86: +(spadj<<16). */
ct                539 lj_ccallback.c     ct = NULL;
ct                557 lj_ccallback.c   if (!ct)
ct                566 lj_ccallback.c   switch (ctype_cconv(ct->info)) {
ct                573 lj_ccallback.c   fid = ct->sib;
ct                610 lj_ccallback.c   if (ctype_cconv(ct->info) != CTCC_CDECL) {
ct                719 lj_ccallback.c   CTypeID id = ctype_typeid(cts, ct);
ct                744 lj_ccallback.c   if (!ctype_isptr(ct->info) || (LJ_64 && ct->size != CTSIZE_PTR))
ct                746 lj_ccallback.c   ct = ctype_rawchild(cts, ct);
ct                747 lj_ccallback.c   if (ctype_isfunc(ct->info)) {
ct                748 lj_ccallback.c     CType *ctr = ctype_rawchild(cts, ct);
ct                749 lj_ccallback.c     CTypeID fid = ct->sib;
ct                753 lj_ccallback.c     if ((ct->info & CTF_VARARG))
ct                768 lj_ccallback.c     return ct;
ct                776 lj_ccallback.c   ct = callback_checkfunc(cts, ct);
ct                777 lj_ccallback.c   if (ct) {
ct                778 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                 77 lj_cdata.c         CType *ct = ctype_raw(ctype_ctsG(g), cd->ctypeid);
ct                 78 lj_cdata.c         CTSize sz = ctype_hassize(ct->info) ? ct->size : CTSIZE_PTR;
ct                 79 lj_cdata.c         lua_assert(ctype_hassize(ct->info) || ctype_isfunc(ct->info) ||
ct                 80 lj_cdata.c     	       ctype_isextern(ct->info));
ct                113 lj_cdata.c       CType *ct = ctype_get(cts, cd->ctypeid);
ct                117 lj_cdata.c       if (ctype_isref(ct->info)) {
ct                118 lj_cdata.c         lua_assert(ct->size == CTSIZE_PTR);
ct                120 lj_cdata.c         ct = ctype_child(cts, ct);
ct                125 lj_cdata.c       while (ctype_isattrib(ct->info)) {
ct                126 lj_cdata.c         if (ctype_attrib(ct->info) == CTA_QUAL) *qual |= ct->size;
ct                127 lj_cdata.c         ct = ctype_child(cts, ct);
ct                129 lj_cdata.c       lua_assert(!ctype_isref(ct->info));  /* Interning rejects refs to refs. */
ct                142 lj_cdata.c         if (ctype_ispointer(ct->info)) {
ct                143 lj_cdata.c           CTSize sz = lj_ctype_size(cts, ctype_cid(ct->info));  /* Element size. */
ct                146 lj_cdata.c           if (ctype_isptr(ct->info)) {
ct                147 lj_cdata.c     	p = (uint8_t *)cdata_getptr(p, ct->size);
ct                148 lj_cdata.c           } else if ((ct->info & (CTF_VECTOR|CTF_COMPLEX))) {
ct                149 lj_cdata.c     	if ((ct->info & CTF_COMPLEX)) idx &= 1;
ct                153 lj_cdata.c           return ct;
ct                166 lj_cdata.c         if (ctype_isstruct(ct->info)) {
ct                168 lj_cdata.c           CType *fct = lj_ctype_getfieldq(cts, ct, name, &ofs, qual);
ct                173 lj_cdata.c         } else if (ctype_iscomplex(ct->info)) {
ct                178 lj_cdata.c     	  return ct;
ct                180 lj_cdata.c     	  *pp = p + (ct->size >> 1);
ct                181 lj_cdata.c     	  return ct;
ct                195 lj_cdata.c           ct = sct;  /* Allow resolving metamethods for constructors, too. */
ct                198 lj_cdata.c       if (ctype_isptr(ct->info)) {  /* Automatically perform '->'. */
ct                199 lj_cdata.c         if (ctype_isstruct(ctype_rawchild(cts, ct)->info)) {
ct                200 lj_cdata.c           p = (uint8_t *)cdata_getptr(p, ct->size);
ct                201 lj_cdata.c           ct = ctype_child(cts, ct);
ct                206 lj_cdata.c       return ct;  /* But return the resolved raw type. */
ct                214 lj_cdata.c       CType *ctt = ctype_child(cts, ct);
ct                217 lj_cdata.c       if ((ctt->info & CTF_UNSIGNED) && (int32_t)ct->size < 0)
ct                218 lj_cdata.c         setnumV(o, (lua_Number)(uint32_t)ct->size);
ct                220 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                305 lj_clib.c        while (ct->sib) {
ct                307 lj_clib.c          ct = ctype_get(cts, ct->sib);
ct                308 lj_clib.c          if (ctype_isfield(ct->info)) {
ct                309 lj_clib.c            d = ctype_rawchild(cts, ct);
ct                320 lj_clib.c        if (ct->sib) {
ct                321 lj_clib.c          CType *ctf = ctype_get(cts, ct->sib);
ct                334 lj_clib.c          CType *ct;
ct                335 lj_clib.c          CTypeID id = lj_ctype_getname(cts, &ct, name, CLNS_INDEX);
ct                338 lj_clib.c          if (ctype_isconstval(ct->info)) {
ct                339 lj_clib.c            CType *ctt = ctype_child(cts, ct);
ct                341 lj_clib.c            if ((ctt->info & CTF_UNSIGNED) && (int32_t)ct->size < 0)
ct                342 lj_clib.c      	setnumV(tv, (lua_Number)(uint32_t)ct->size);
ct                344 lj_clib.c      	setintV(tv, (int32_t)ct->size);
ct                346 lj_clib.c            const char *sym = clib_extsym(cts, ct, name);
ct                352 lj_clib.c            lua_assert(ctype_isfunc(ct->info) || ctype_isextern(ct->info));
ct                355 lj_clib.c            if (!p && ctype_isfunc(ct->info)) {
ct                356 lj_clib.c      	CTInfo cconv = ctype_cconv(ct->info);
ct                358 lj_clib.c      	  CTSize sz = clib_func_argsize(cts, ct);
ct                136 lj_cparse.c      GCstr *s = lj_ctype_repr(cp->cts->L, ctype_typeid(cp->cts, ct), NULL);
ct                168 lj_cparse.c      cp->val.id = lj_ctype_getname(cp->cts, &cp->ct, cp->str, cp->tmask);
ct                169 lj_cparse.c      if (ctype_type(cp->ct->info) == CT_KW)
ct                170 lj_cparse.c        return ctype_cid(cp->ct->info);
ct                187 lj_cparse.c        cp->ct = &cp->cts->tab[0];
ct                408 lj_cparse.c      if (cp->tok == CTOK_IDENT && ctype_istypedef(cp->ct->info)) return 1;
ct                482 lj_cparse.c        CType *ct;
ct                484 lj_cparse.c        ct = lj_ctype_rawref(cp->cts, k->id);
ct                485 lj_cparse.c        if (!ctype_ispointer(ct->info))
ct                486 lj_cparse.c          cp_err_badidx(cp, ct);
ct                487 lj_cparse.c        k->u32 = 0; k->id = ctype_cid(ct->info);
ct                497 lj_cparse.c        if (ctype_type(cp->ct->info) == CT_CONSTVAL) {
ct                498 lj_cparse.c          k->u32 = cp->ct->size; k->id = ctype_cid(cp->ct->info);
ct                499 lj_cparse.c        } else if (ctype_type(cp->ct->info) == CT_EXTERN) {
ct                500 lj_cparse.c          k->u32 = cp->val.id; k->id = ctype_cid(cp->ct->info);
ct                501 lj_cparse.c        } else if (ctype_type(cp->ct->info) == CT_FUNC) {
ct                523 lj_cparse.c        CType *ct;
ct                527 lj_cparse.c          ct = lj_ctype_rawref(cp->cts, k->id);
ct                528 lj_cparse.c          if (!ctype_ispointer(ct->info)) {
ct                529 lj_cparse.c    	ct = lj_ctype_rawref(cp->cts, k2.id);
ct                530 lj_cparse.c    	if (!ctype_ispointer(ct->info))
ct                531 lj_cparse.c    	  cp_err_badidx(cp, ct);
ct                538 lj_cparse.c          ct = lj_ctype_rawref(cp->cts, k->id);
ct                540 lj_cparse.c    	if (!ctype_ispointer(ct->info))
ct                541 lj_cparse.c    	  cp_err_badidx(cp, ct);
ct                542 lj_cparse.c    	ct = lj_ctype_rawref(cp->cts, ctype_cid(ct->info));
ct                546 lj_cparse.c          if (!ctype_isstruct(ct->info) || ct->size == CTSIZE_INVALID ||
ct                547 lj_cparse.c    	  !(fct = lj_ctype_getfield(cp->cts, ct, cp->str, &ofs)) ||
ct                549 lj_cparse.c    	GCstr *s = lj_ctype_repr(cp->cts->L, ctype_typeid(cp->cts, ct), NULL);
ct                552 lj_cparse.c          ct = fct;
ct                553 lj_cparse.c          k->u32 = ctype_isconstval(ct->info) ? ct->size : 0;
ct                558 lj_cparse.c        k->id = ctype_cid(ct->info);
ct                715 lj_cparse.c      CType *ct;
ct                717 lj_cparse.c      ct = ctype_raw(cp->cts, k->id);
ct                718 lj_cparse.c      if (!ctype_isinteger(ct->info)) cp_err(cp, LJ_ERR_BADVAL);
ct                756 lj_cparse.c      CType *ct = &decl->stack[decl->pos];
ct                757 lj_cparse.c      if (ctype_isfunc(ct->info)) {  /* Ok to modify in-place. */
ct                760 lj_cparse.c          ct->info = (ct->info & (CTMASK_NUM|CTF_VARARG|CTMASK_CID)) +
ct                773 lj_cparse.c      CType *ct = ctype_get(decl->cp->cts, id);
ct                774 lj_cparse.c      CTInfo info = ct->info;
ct                775 lj_cparse.c      CTSize size = ct->size;
ct                792 lj_cparse.c        if ((ct->info & (CTF_VECTOR|CTF_COMPLEX))) {
ct                803 lj_cparse.c        decl->stack[cp_push(decl, info, size)].sib = ct->sib;
ct                821 lj_cparse.c        CType *ct = &decl->stack[idx];
ct                822 lj_cparse.c        CTInfo info = ct->info;
ct                823 lj_cparse.c        CTInfo size = ct->size;
ct                825 lj_cparse.c        idx = ct->next;
ct                849 lj_cparse.c          sib = ct->sib;  /* Next line may reallocate the C type table. */
ct                903 lj_cparse.c    	if (ct->sib == 0) {  /* Only check/size arrays not copied by unroll. */
ct               1160 lj_cparse.c          CTF_INSERT(decl->fattr, CCONV, cp->ct->size);
ct               1166 lj_cparse.c          CTF_INSERT(decl->attr, MSIZEP, cp->ct->size);
ct               1179 lj_cparse.c      CType *ct;
ct               1188 lj_cparse.c          ct = cp->ct;
ct               1189 lj_cparse.c          if ((ct->info ^ info) & (CTMASK_NUM|CTF_UNION))  /* Wrong type. */
ct               1190 lj_cparse.c    	cp_errmsg(cp, 0, LJ_ERR_FFI_REDEF, strdata(gco2str(gcref(ct->name))));
ct               1194 lj_cparse.c          sid = lj_ctype_new(cp->cts, &ct);
ct               1195 lj_cparse.c          ct->info = info;
ct               1196 lj_cparse.c          ct->size = CTSIZE_INVALID;
ct               1197 lj_cparse.c          ctype_setname(ct, cp->str);
ct               1198 lj_cparse.c          lj_ctype_addname(cp->cts, ct, sid);
ct               1202 lj_cparse.c        sid = lj_ctype_new(cp->cts, &ct);
ct               1203 lj_cparse.c        ct->info = info;
ct               1204 lj_cparse.c        ct->size = CTSIZE_INVALID;
ct               1207 lj_cparse.c        if (ct->size != CTSIZE_INVALID || ct->sib)
ct               1208 lj_cparse.c          cp_errmsg(cp, 0, LJ_ERR_FFI_REDEF, strdata(gco2str(gcref(ct->name))));
ct               1209 lj_cparse.c        ct->sib = 1;  /* Indicate the type is currently being defined. */
ct               1218 lj_cparse.c      UNUSED(cp); UNUSED(ct);
ct               1224 lj_cparse.c    	ct = ctype_rawchild(cp->cts, ct);
ct               1225 lj_cparse.c    	info = ct->info;
ct               1244 lj_cparse.c        CType *ct = ctype_get(cp->cts, fieldid);
ct               1245 lj_cparse.c        CTInfo attr = ct->size;  /* Field declaration attributes (temp.). */
ct               1247 lj_cparse.c        if (ctype_isfield(ct->info) ||
ct               1248 lj_cparse.c    	(ctype_isxattrib(ct->info, CTA_SUBTYPE) && attr)) {
ct               1251 lj_cparse.c          CTInfo info = lj_ctype_info(cp->cts, ctype_cid(ct->info), &sz);
ct               1262 lj_cparse.c          align = cp_field_align(cp, ct, info);
ct               1271 lj_cparse.c          bsz = ctype_bitcsz(ct->info);  /* Bitfield size (temp.). */
ct               1272 lj_cparse.c          if (bsz == CTBSZ_FIELD || !ctype_isfield(ct->info)) {
ct               1275 lj_cparse.c    	ct->size = (bofs >> 3);  /* Store field offset. */
ct               1283 lj_cparse.c    	  ct->info = CTINFO(CT_FIELD, ctype_cid(ct->info));
ct               1284 lj_cparse.c    	  ct->size = (bofs >> 3);  /* Store field offset. */
ct               1286 lj_cparse.c    	  ct->info = CTINFO(CT_BITFIELD,
ct               1290 lj_cparse.c    	  ct->info += ((csz - (bofs & (csz-1)) - bsz) << CTSHIFT_BITPOS);
ct               1292 lj_cparse.c    	  ct->info += ((bofs & (csz-1)) << CTSHIFT_BITPOS);
ct               1294 lj_cparse.c    	  ct->size = ((bofs & ~(csz-1)) >> 3);  /* Store container offset. */
ct               1306 lj_cparse.c        fieldid = ct->sib;
ct               1340 lj_cparse.c    	  CType *ct;
ct               1341 lj_cparse.c    	  CTypeID fieldid = cp_decl_constinit(cp, &ct, ctypeid);
ct               1344 lj_cparse.c    	  ctype_setname(ct, decl.name);
ct               1347 lj_cparse.c    	  CType *ct;
ct               1348 lj_cparse.c    	  CTypeID fieldid = lj_ctype_new(cp->cts, &ct);  /* Do this first. */
ct               1360 lj_cparse.c    	      ct->info = CTINFO(CT_ATTRIB, CTATTRIB(CTA_SUBTYPE) + ctypeid);
ct               1361 lj_cparse.c    	      ct->size = ctype_isstruct(tct->info) ?
ct               1374 lj_cparse.c    	  ct->info = CTINFO(CT_FIELD, ctypeid + (bsz << CTSHIFT_BITCSZ));
ct               1375 lj_cparse.c    	  ct->size = decl.attr;
ct               1376 lj_cparse.c    	  if (decl.name) ctype_setname(ct, decl.name);
ct               1430 lj_cparse.c    	CType *ct;
ct               1431 lj_cparse.c    	CTypeID constid = lj_ctype_new(cp->cts, &ct);
ct               1434 lj_cparse.c    	ctype_setname(ct, name);
ct               1435 lj_cparse.c    	ct->info = CTINFO(CT_CONSTVAL, CTF_CONST|k.id);
ct               1436 lj_cparse.c    	ct->size = k.u32++;
ct               1438 lj_cparse.c    	lj_ctype_addname(cp->cts, ct, constid);
ct               1469 lj_cparse.c          if (cp->ct->size) {
ct               1471 lj_cparse.c    	sz = cp->ct->size;
ct               1497 lj_cparse.c          if (ctype_istypedef(cp->ct->info)) {
ct               1498 lj_cparse.c    	tdef = ctype_cid(cp->ct->info);  /* Get typedef. */
ct               1587 lj_cparse.c          CType *ct;
ct               1598 lj_cparse.c          ct = ctype_raw(cp->cts, ctypeid);
ct               1599 lj_cparse.c          if (ctype_isvoid(ct->info))
ct               1601 lj_cparse.c          else if (ctype_isrefarray(ct->info))
ct               1603 lj_cparse.c    	  CTINFO(CT_PTR, CTALIGN_PTR|ctype_cid(ct->info)), CTSIZE_PTR);
ct               1604 lj_cparse.c          else if (ctype_isfunc(ct->info))
ct               1608 lj_cparse.c          fieldid = lj_ctype_new(cp->cts, &ct);
ct               1614 lj_cparse.c          if (decl.name) ctype_setname(ct, decl.name);
ct               1615 lj_cparse.c          ct->info = CTINFO(CT_FIELD, ctypeid);
ct               1616 lj_cparse.c          ct->size = nargs++;
ct               1804 lj_cparse.c    	CType *ct;
ct               1807 lj_cparse.c    	  id = lj_ctype_new(cp->cts, &ct);
ct               1808 lj_cparse.c    	  ct->info = CTINFO(CT_TYPEDEF, ctypeid);
ct               1812 lj_cparse.c    	  ct = ctype_get(cp->cts, ctypeid);
ct               1814 lj_cparse.c    	  lua_assert(gcref(ct->name) == NULL);
ct               1817 lj_cparse.c    	  id = cp_decl_constinit(cp, &ct, ctypeid);
ct               1820 lj_cparse.c    	  id = lj_ctype_new(cp->cts, &ct);
ct               1821 lj_cparse.c    	  ct->info = CTINFO(CT_EXTERN, ctypeid);
ct               1826 lj_cparse.c    	  ct = ctype_get(cp->cts, id);  /* Table may have been reallocated. */
ct               1828 lj_cparse.c    	  cta->sib = ct->sib;
ct               1829 lj_cparse.c    	  ct->sib = aid;
ct               1833 lj_cparse.c    	ctype_setname(ct, decl.name);
ct               1834 lj_cparse.c    	lj_ctype_addname(cp->cts, ct, id);
ct                 46 lj_cparse.h      CType *ct;		/* C type table entry. */
ct                 99 lj_crecord.c     if (ctype_isenum(ct->info)) ct = ctype_child(cts, ct);
ct                100 lj_crecord.c     if (LJ_LIKELY(ctype_isnum(ct->info))) {
ct                101 lj_crecord.c       if ((ct->info & CTF_FP)) {
ct                102 lj_crecord.c         if (ct->size == sizeof(double))
ct                104 lj_crecord.c         else if (ct->size == sizeof(float))
ct                107 lj_crecord.c         uint32_t b = lj_fls(ct->size);
ct                109 lj_crecord.c   	return IRT_I8 + 2*b + ((ct->info & CTF_UNSIGNED) ? 1 : 0);
ct                111 lj_crecord.c     } else if (ctype_isptr(ct->info)) {
ct                112 lj_crecord.c       return (LJ_64 && ct->size == 8) ? IRT_P64 : IRT_P32;
ct                113 lj_crecord.c     } else if (ctype_iscomplex(ct->info)) {
ct                114 lj_crecord.c       if (ct->size == 2*sizeof(double))
ct                116 lj_crecord.c       else if (ct->size == 2*sizeof(float))
ct                150 lj_crecord.c     CTypeID fid = ct->sib;
ct                238 lj_crecord.c       if (ct) {
ct                240 lj_crecord.c         lua_assert(ctype_isarray(ct->info) || ctype_isstruct(ct->info));
ct                241 lj_crecord.c         if (ctype_isarray(ct->info)) {
ct                242 lj_crecord.c   	CType *cct = ctype_rawchild(cts, ct);
ct                247 lj_crecord.c         } else if ((ct->info & CTF_UNION)) {
ct                248 lj_crecord.c   	step = (1u << ctype_align(ct->info));
ct                251 lj_crecord.c   	mlp = crec_copy_struct(ml, cts, ct);
ct                732 lj_crecord.c     CTypeID id = ctype_typeid(cts, ct);
ct                780 lj_crecord.c       CType *ct = ctype_get(cts,
ct                784 lj_crecord.c       TRef sp = crec_ct_tv(J, ct, 0, J->base[2], &rd->argv[2]);
ct                802 lj_crecord.c     CType *ct = ctype_raw(cts, cd->ctypeid);
ct                806 lj_crecord.c     if (ctype_isptr(ct->info)) {
ct                807 lj_crecord.c       IRType t = (LJ_64 && ct->size == 8) ? IRT_P64 : IRT_P32;
ct                808 lj_crecord.c       if (ctype_isref(ct->info)) ct = ctype_rawchild(cts, ct);
ct                818 lj_crecord.c       if (ctype_ispointer(ct->info)) {
ct                821 lj_crecord.c         if ((ct->info & CTF_COMPLEX))
ct                823 lj_crecord.c         sz = lj_ctype_size(cts, (sid = ctype_cid(ct->info)));
ct                843 lj_crecord.c       if (ctype_ispointer(ct->info) && t >= IRT_I8 && t <= IRT_U64) {
ct                864 lj_crecord.c         ct = ctype_raw(cts, crec_constructor(J, cd, ptr));
ct                865 lj_crecord.c       if (ctype_isstruct(ct->info)) {
ct                868 lj_crecord.c         fct = lj_ctype_getfield(cts, ct, name, &fofs);
ct                891 lj_crecord.c       } else if (ctype_iscomplex(ct->info)) {
ct                897 lj_crecord.c   	if (strdata(name)[0] == 'i') ofs += (ct->size >> 1);
ct                898 lj_crecord.c   	sid = ctype_cid(ct->info);
ct                903 lj_crecord.c       if (ctype_isptr(ct->info)) {  /* Automatically perform '->'. */
ct                904 lj_crecord.c         CType *cct = ctype_rawchild(cts, ct);
ct                906 lj_crecord.c   	ct = cct;
ct                911 lj_crecord.c       crec_index_meta(J, cts, ct, rd);
ct                919 lj_crecord.c     ct = ctype_get(cts, sid);
ct                920 lj_crecord.c     if (ctype_isref(ct->info)) {
ct                922 lj_crecord.c       sid = ctype_cid(ct->info);
ct                923 lj_crecord.c       ct = ctype_get(cts, sid);
ct                926 lj_crecord.c     while (ctype_isattrib(ct->info))
ct                927 lj_crecord.c       ct = ctype_child(cts, ct);  /* Skip attributes. */
ct                930 lj_crecord.c       J->base[0] = crec_tv_ct(J, ct, sid, ptr);
ct                934 lj_crecord.c       crec_ct_tv(J, ct, ptr, J->base[2], &rd->argv[2]);
ct               1090 lj_crecord.c     if (ctype_cconv(ct->info) == CTCC_THISCALL)
ct               1092 lj_crecord.c     else if (ctype_cconv(ct->info) == CTCC_FASTCALL)
ct               1097 lj_crecord.c     fid = ct->sib;
ct               1117 lj_crecord.c         if (!(ct->info & CTF_VARARG))
ct               1199 lj_crecord.c     CType *ct = ctype_raw(cts, cd->ctypeid);
ct               1201 lj_crecord.c     if (ctype_isptr(ct->info)) {
ct               1202 lj_crecord.c       tp = (LJ_64 && ct->size == 8) ? IRT_P64 : IRT_P32;
ct               1203 lj_crecord.c       ct = ctype_rawchild(cts, ct);
ct               1205 lj_crecord.c     if (ctype_isfunc(ct->info)) {
ct               1207 lj_crecord.c       CType *ctr = ctype_rawchild(cts, ct);
ct               1223 lj_crecord.c       if ((ct->info & CTF_VARARG)
ct               1225 lj_crecord.c   	|| ctype_cconv(ct->info) != CTCC_CDECL
ct               1229 lj_crecord.c   		    lj_ir_kint(J, ctype_typeid(cts, ct)));
ct               1230 lj_crecord.c       tr = emitir(IRT(IR_CALLXS, t), crec_call_args(J, rd, cts, ct), func);
ct               1248 lj_crecord.c         TRef trid = lj_ir_kint(J, ctype_cid(ct->info));
ct               1270 lj_crecord.c     CType *ct;
ct               1280 lj_crecord.c     ct = ctype_raw(cts, id);
ct               1281 lj_crecord.c     tv = lj_ctype_meta(cts, ctype_isptr(ct->info) ? ctype_cid(ct->info) : id, mm);
ct               1420 lj_crecord.c         CType *ct = ctype_raw(cts, id);
ct               1421 lj_crecord.c         if (ctype_isptr(ct->info)) id = ctype_cid(ct->info);
ct               1426 lj_crecord.c         CType *ct = ctype_raw(cts, id);
ct               1427 lj_crecord.c         if (ctype_isptr(ct->info)) id = ctype_cid(ct->info);
ct               1458 lj_crecord.c       CType *ct = ctype_get(cts, CTID_DOUBLE);
ct               1464 lj_crecord.c         ct = ctype_raw(cts, id);
ct               1465 lj_crecord.c         t = crec_ct2irt(cts, ct);
ct               1466 lj_crecord.c         if (ctype_isptr(ct->info)) {  /* Resolve pointer or reference. */
ct               1468 lj_crecord.c   	if (ctype_isref(ct->info)) {
ct               1469 lj_crecord.c   	  ct = ctype_rawchild(cts, ct);
ct               1470 lj_crecord.c   	  t = crec_ct2irt(cts, ct);
ct               1478 lj_crecord.c   	if (ctype_isenum(ct->info)) ct = ctype_child(cts, ct);
ct               1480 lj_crecord.c         } else if (ctype_isfunc(ct->info)) {
ct               1482 lj_crecord.c   	ct = ctype_get(cts,
ct               1488 lj_crecord.c         if (ctype_isenum(ct->info)) ct = ctype_child(cts, ct);
ct               1489 lj_crecord.c         if (ctype_isnum(ct->info)) {
ct               1499 lj_crecord.c         ct = ctype_get(cts, CTID_P_VOID);
ct               1501 lj_crecord.c         ct = ctype_get(cts, CTID_INT32);
ct               1505 lj_crecord.c         ct = ctype_raw(cts, id);
ct               1506 lj_crecord.c         if (ctype_isenum(ct->info)) {  /* Match string against enum constant. */
ct               1509 lj_crecord.c   	CType *cct = lj_ctype_getfield(cts, ct, str, &ofs);
ct               1513 lj_crecord.c   	  ct = ctype_child(cts, cct);
ct               1516 lj_crecord.c   	  ct = ctype_get(cts, CTID_P_VOID);
ct               1518 lj_crecord.c         } else if (ctype_isptr(ct->info)) {
ct               1521 lj_crecord.c   	ct = ctype_get(cts, CTID_P_VOID);
ct               1525 lj_crecord.c         ct = ctype_get(cts, CTID_P_VOID);
ct               1528 lj_crecord.c       s[i] = ct;
ct               1559 lj_crecord.c       CType *ct;
ct               1560 lj_crecord.c       CTypeID id = lj_ctype_getname(cts, &ct, name, CLNS_INDEX);
ct               1566 lj_crecord.c         if (ctype_isconstval(ct->info)) {
ct               1567 lj_crecord.c   	if (ct->size >= 0x80000000u &&
ct               1568 lj_crecord.c   	    (ctype_child(cts, ct)->info & CTF_UNSIGNED))
ct               1569 lj_crecord.c   	  J->base[0] = lj_ir_knum(J, (lua_Number)(uint32_t)ct->size);
ct               1571 lj_crecord.c   	  J->base[0] = lj_ir_kint(J, (int32_t)ct->size);
ct               1572 lj_crecord.c         } else if (ctype_isextern(ct->info)) {
ct               1573 lj_crecord.c   	CTypeID sid = ctype_cid(ct->info);
ct               1576 lj_crecord.c   	ct = ctype_raw(cts, sid);
ct               1582 lj_crecord.c   	  J->base[0] = crec_tv_ct(J, ct, sid, ptr);
ct               1585 lj_crecord.c   	  crec_ct_tv(J, ct, ptr, J->base[2], &rd->argv[2]);
ct               1659 lj_crecord.c         CType *ct = ctype_raw(cts, cdataV(&rd->argv[0])->ctypeid);
ct               1660 lj_crecord.c         if (ctype_isptr(ct->info))
ct               1661 lj_crecord.c   	ct = ctype_rawchild(cts, ct);
ct               1662 lj_crecord.c         step = (1u<<ctype_align(lj_ctype_info(cts, ctype_typeid(cts, ct), &sz)));
ct               1716 lj_crecord.c       CType *ct = lj_ctype_rawref(ctype_ctsG(J2G(J)), id);
ct               1717 lj_crecord.c       if (ctype_isvltype(ct->info))
ct               1743 lj_crecord.c       CType *ct = lj_ctype_rawref(cts, cdataV(tv)->ctypeid);
ct               1744 lj_crecord.c       if (ctype_isenum(ct->info)) ct = ctype_child(cts, ct);
ct               1745 lj_crecord.c       if ((ct->info & (CTMASK_NUM|CTF_BOOL|CTF_FP|CTF_UNSIGNED)) ==
ct               1746 lj_crecord.c   	CTINFO(CT_NUM, CTF_UNSIGNED) && ct->size == 8)
ct               1786 lj_crecord.c       CType *ct = ctype_get(cts, id);
ct               1788 lj_crecord.c       TRef tr = crec_ct_tv(J, ct, 0, J->base[0], &rd->argv[0]);
ct               1790 lj_crecord.c         TRef tr2 = crec_ct_tv(J, ct, 0, J->base[i], &rd->argv[i]);
ct               1872 lj_crecord.c     CType *d, *ct = lj_ctype_rawref(cts, cdataV(&rd->argv[0])->ctypeid);
ct               1873 lj_crecord.c     if (ctype_isenum(ct->info)) ct = ctype_child(cts, ct);
ct               1874 lj_crecord.c     if (ctype_isnum(ct->info) || ctype_iscomplex(ct->info)) {
ct               1875 lj_crecord.c       if (ctype_isinteger_or_bool(ct->info) && ct->size <= 4 &&
ct               1876 lj_crecord.c   	!(ct->size == 4 && (ct->info & CTF_UNSIGNED)))
ct                116 lj_ctype.c     #define CTTYINFODEF(id, sz, ct, info)	CTINFO((ct),(((sz)&0x3fu)<<10)+(info)),
ct                155 lj_ctype.c       CType *ct;
ct                160 lj_ctype.c         ct = lj_mem_newvec(cts->L, id+1, CType);
ct                161 lj_ctype.c         memcpy(ct, cts->tab, id*sizeof(CType));
ct                164 lj_ctype.c         cts->tab = ct;
ct                171 lj_ctype.c       *ctp = ct = &cts->tab[id];
ct                172 lj_ctype.c       ct->info = 0;
ct                173 lj_ctype.c       ct->size = 0;
ct                174 lj_ctype.c       ct->sib = 0;
ct                175 lj_ctype.c       ct->next = 0;
ct                176 lj_ctype.c       setgcrefnull(ct->name);
ct                187 lj_ctype.c         CType *ct = ctype_get(cts, id);
ct                188 lj_ctype.c         if (ct->info == info && ct->size == size)
ct                190 lj_ctype.c         id = ct->next;
ct                210 lj_ctype.c       uint32_t h = ct_hashtype(ct->info, ct->size);
ct                211 lj_ctype.c       ct->next = cts->hash[h];
ct                218 lj_ctype.c       uint32_t h = ct_hashname(gcref(ct->name));
ct                219 lj_ctype.c       ct->next = cts->hash[h];
ct                228 lj_ctype.c         CType *ct = ctype_get(cts, id);
ct                229 lj_ctype.c         if (gcref(ct->name) == obj2gco(name) &&
ct                230 lj_ctype.c     	((tmask >> ctype_type(ct->info)) & 1)) {
ct                231 lj_ctype.c           *ctp = ct;
ct                234 lj_ctype.c         id = ct->next;
ct                244 lj_ctype.c       while (ct->sib) {
ct                245 lj_ctype.c         ct = ctype_get(cts, ct->sib);
ct                246 lj_ctype.c         if (gcref(ct->name) == obj2gco(name)) {
ct                247 lj_ctype.c           *ofs = ct->size;
ct                248 lj_ctype.c           return ct;
ct                250 lj_ctype.c         if (ctype_isxattrib(ct->info, CTA_SUBTYPE)) {
ct                251 lj_ctype.c           CType *fct, *cct = ctype_child(cts, ct);
ct                260 lj_ctype.c     	*ofs += ct->size;
ct                273 lj_ctype.c       CType *ct = ctype_get(cts, id);
ct                274 lj_ctype.c       while (ctype_isattrib(ct->info) || ctype_isref(ct->info))
ct                275 lj_ctype.c         ct = ctype_child(cts, ct);
ct                276 lj_ctype.c       return ct;
ct                282 lj_ctype.c       CType *ct = ctype_raw(cts, id);
ct                283 lj_ctype.c       return ctype_hassize(ct->info) ? ct->size : CTSIZE_INVALID;
ct                290 lj_ctype.c       if (ctype_isstruct(ct->info)) {
ct                291 lj_ctype.c         CTypeID arrid = 0, fid = ct->sib;
ct                292 lj_ctype.c         xsz = ct->size;  /* Add the struct size. */
ct                299 lj_ctype.c         ct = ctype_raw(cts, arrid);
ct                301 lj_ctype.c       lua_assert(ctype_isvlarray(ct->info));  /* Must be a VLA. */
ct                302 lj_ctype.c       ct = ctype_rawchild(cts, ct);  /* Get array element. */
ct                303 lj_ctype.c       lua_assert(ctype_hassize(ct->info));
ct                305 lj_ctype.c       xsz += (uint64_t)ct->size * nelem;
ct                313 lj_ctype.c       CType *ct = ctype_get(cts, id);
ct                315 lj_ctype.c         CTInfo info = ct->info;
ct                320 lj_ctype.c     	qual |= ct->size;
ct                322 lj_ctype.c     	qual |= CTFP_ALIGNED + CTALIGN(ct->size);
ct                327 lj_ctype.c           *szp = ctype_isfunc(info) ? CTSIZE_INVALID : ct->size;
ct                330 lj_ctype.c         ct = ctype_get(cts, ctype_cid(info));
ct                338 lj_ctype.c       CType *ct = ctype_get(cts, id);
ct                340 lj_ctype.c       while (ctype_isattrib(ct->info) || ctype_isref(ct->info)) {
ct                341 lj_ctype.c         id = ctype_cid(ct->info);
ct                342 lj_ctype.c         ct = ctype_get(cts, id);
ct                344 lj_ctype.c       if (ctype_isptr(ct->info) &&
ct                345 lj_ctype.c           ctype_isfunc(ctype_get(cts, ctype_cid(ct->info))->info))
ct                429 lj_ctype.c       if (gcref(ct->name)) {
ct                430 lj_ctype.c         GCstr *str = gco2str(gcref(ct->name));
ct                434 lj_ctype.c         ctype_prepnum(ctr, ctype_typeid(ctr->cts, ct));
ct                443 lj_ctype.c       CType *ct = ctype_get(ctr->cts, id);
ct                447 lj_ctype.c         CTInfo info = ct->info;
ct                448 lj_ctype.c         CTSize size = ct->size;
ct                478 lj_ctype.c           ctype_preptype(ctr, ct, qual, (info & CTF_UNION) ? "union" : "struct");
ct                485 lj_ctype.c           ctype_preptype(ctr, ct, qual, "enum");
ct                508 lj_ctype.c     	  CTSize csize = ctype_child(ctr->cts, ct)->size;
ct                534 lj_ctype.c         ct = ctype_get(ctr->cts, ctype_cid(info));
ct                595 lj_ctype.c       CType *ct = lj_mem_newvec(L, CTTYPETAB_MIN, CType);
ct                599 lj_ctype.c       cts->tab = ct;
ct                604 lj_ctype.c       for (id = 0; id < CTTYPEINFO_NUM; id++, ct++) {
ct                606 lj_ctype.c         ct->size = (CTSize)((int32_t)(info << 16) >> 26);
ct                607 lj_ctype.c         ct->info = info & 0xffff03ffu;
ct                608 lj_ctype.c         ct->sib = 0;
ct                612 lj_ctype.c           ctype_setname(ct, str);
ct                614 lj_ctype.c           lj_ctype_addname(cts, ct, id);
ct                616 lj_ctype.c           setgcrefnull(ct->name);
ct                617 lj_ctype.c           ct->next = 0;
ct                618 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                723 lj_opt_fold.c      CType *ct = ctype_raw(ctype_ctsG(J2G(J)), gco2cd(o)->ctypeid);
ct                724 lj_opt_fold.c      if (ctype_isnum(ct->info) || ctype_isenum(ct->info) ||
ct                725 lj_opt_fold.c  	ctype_isptr(ct->info) || ctype_isfunc(ct->info) ||
ct                726 lj_opt_fold.c  	ctype_iscomplex(ct->info) || ctype_isvector(ct->info))
ct               1554 lj_record.c    	CType *ct = ctype_raw(ctype_ctsG(J2G(J)), cd->ctypeid);
ct               1555 lj_record.c    	if (!ctype_hassize(ct->info) || ct->size <= 16)