One Level Up Top Level

src/lj_ctype.c - luajit-2.0-src

Global variables defined

Data types defined

Functions defined

Macros defined

Source code

  1. /*
  2. ** C type management.
  3. ** Copyright (C) 2005-2015 Mike Pall. See Copyright Notice in luajit.h
  4. */

  6. #include "lj_obj.h"

  8. #if LJ_HASFFI

  10. #include "lj_gc.h"
  11. #include "lj_err.h"
  12. #include "lj_str.h"
  13. #include "lj_tab.h"
  14. #include "lj_strfmt.h"
  15. #include "lj_ctype.h"
  16. #include "lj_ccallback.h"

  18. /* -- C type definitions -------------------------------------------------- */

  20. /* Predefined typedefs. */
  21. ‌#define CTTDDEF(_) \
  22.   /* Vararg handling. */ \
  23.   _("va_list",                        P_VOID) \
  24.   _("__builtin_va_list",        P_VOID) \
  25.   _("__gnuc_va_list",                P_VOID) \
  26.   /* From stddef.h. */ \
  27.   _("ptrdiff_t",                INT_PSZ) \
  28.   _("size_t",                        UINT_PSZ) \
  29.   _("wchar_t",                        WCHAR) \
  30.   /* Subset of stdint.h. */ \
  31.   _("int8_t",                        INT8) \
  32.   _("int16_t",                        INT16) \
  33.   _("int32_t",                        INT32) \
  34.   _("int64_t",                        INT64) \
  35.   _("uint8_t",                        UINT8) \
  36.   _("uint16_t",                        UINT16) \
  37.   _("uint32_t",                        UINT32) \
  38.   _("uint64_t",                        UINT64) \
  39.   _("intptr_t",                        INT_PSZ) \
  40.   _("uintptr_t",                UINT_PSZ) \
  41.   /* End of typedef list. */

  43. /* Keywords (only the ones we actually care for). */
  44. ‌#define CTKWDEF(_) \
  45.   /* Type specifiers. */ \
  46.   _("void",                -1,        CTOK_VOID) \
  47.   _("_Bool",                0,        CTOK_BOOL) \
  48.   _("bool",                1,        CTOK_BOOL) \
  49.   _("char",                1,        CTOK_CHAR) \
  50.   _("int",                4,        CTOK_INT) \
  51.   _("__int8",                1,        CTOK_INT) \
  52.   _("__int16",                2,        CTOK_INT) \
  53.   _("__int32",                4,        CTOK_INT) \
  54.   _("__int64",                8,        CTOK_INT) \
  55.   _("float",                4,        CTOK_FP) \
  56.   _("double",                8,        CTOK_FP) \
  57.   _("long",                0,        CTOK_LONG) \
  58.   _("short",                0,        CTOK_SHORT) \
  59.   _("_Complex",                0,        CTOK_COMPLEX) \
  60.   _("complex",                0,        CTOK_COMPLEX) \
  61.   _("__complex",        0,        CTOK_COMPLEX) \
  62.   _("__complex__",        0,        CTOK_COMPLEX) \
  63.   _("signed",                0,        CTOK_SIGNED) \
  64.   _("__signed",                0,        CTOK_SIGNED) \
  65.   _("__signed__",        0,        CTOK_SIGNED) \
  66.   _("unsigned",                0,        CTOK_UNSIGNED) \
  67.   /* Type qualifiers. */ \
  68.   _("const",                0,        CTOK_CONST) \
  69.   _("__const",                0,        CTOK_CONST) \
  70.   _("__const__",        0,        CTOK_CONST) \
  71.   _("volatile",                0,        CTOK_VOLATILE) \
  72.   _("__volatile",        0,        CTOK_VOLATILE) \
  73.   _("__volatile__",        0,        CTOK_VOLATILE) \
  74.   _("restrict",                0,        CTOK_RESTRICT) \
  75.   _("__restrict",        0,        CTOK_RESTRICT) \
  76.   _("__restrict__",        0,        CTOK_RESTRICT) \
  77.   _("inline",                0,        CTOK_INLINE) \
  78.   _("__inline",                0,        CTOK_INLINE) \
  79.   _("__inline__",        0,        CTOK_INLINE) \
  80.   /* Storage class specifiers. */ \
  81.   _("typedef",                0,        CTOK_TYPEDEF) \
  82.   _("extern",                0,        CTOK_EXTERN) \
  83.   _("static",                0,        CTOK_STATIC) \
  84.   _("auto",                0,        CTOK_AUTO) \
  85.   _("register",                0,        CTOK_REGISTER) \
  86.   /* GCC Attributes. */ \
  87.   _("__extension__",        0,        CTOK_EXTENSION) \
  88.   _("__attribute",        0,        CTOK_ATTRIBUTE) \
  89.   _("__attribute__",        0,        CTOK_ATTRIBUTE) \
  90.   _("asm",                0,        CTOK_ASM) \
  91.   _("__asm",                0,        CTOK_ASM) \
  92.   _("__asm__",                0,        CTOK_ASM) \
  93.   /* MSVC Attributes. */ \
  94.   _("__declspec",        0,        CTOK_DECLSPEC) \
  95.   _("__cdecl",                CTCC_CDECL,        CTOK_CCDECL) \
  96.   _("__thiscall",        CTCC_THISCALL,        CTOK_CCDECL) \
  97.   _("__fastcall",        CTCC_FASTCALL,        CTOK_CCDECL) \
  98.   _("__stdcall",        CTCC_STDCALL,        CTOK_CCDECL) \
  99.   _("__ptr32",                4,        CTOK_PTRSZ) \
  100.   _("__ptr64",                8,        CTOK_PTRSZ) \
  101.   /* Other type specifiers. */ \
  102.   _("struct",                0,        CTOK_STRUCT) \
  103.   _("union",                0,        CTOK_UNION) \
  104.   _("enum",                0,        CTOK_ENUM) \
  105.   /* Operators. */ \
  106.   _("sizeof",                0,        CTOK_SIZEOF) \
  107.   _("__alignof",        0,        CTOK_ALIGNOF) \
  108.   _("__alignof__",        0,        CTOK_ALIGNOF) \
  109.   /* End of keyword list. */

  111. /* Type info for predefined types. Size merged in. */
  112. ‌static CTInfo lj_ctype_typeinfo[] = {
  113. ‌#define CTTYINFODEF(id, sz, ct, info)        CTINFO((ct),(((sz)&0x3fu)<<10)+(info)),
  114. ‌#define CTTDINFODEF(name, id)                CTINFO(CT_TYPEDEF, CTID_##id),
  115. ‌#define CTKWINFODEF(name, sz, kw)        CTINFO(CT_KW,(((sz)&0x3fu)<<10)+(kw)),
  116. CTTYDEF(CTTYINFODEF)
  117. CTTDDEF(CTTDINFODEF)
  118. CTKWDEF(CTKWINFODEF)
  119. ‌#undef CTTYINFODEF
  120. ‌#undef CTTDINFODEF
  121. ‌#undef CTKWINFODEF
  122.   0
  123. };

  125. /* Predefined type names collected in a single string. */
  126. ‌static const char * const lj_ctype_typenames =
  127. ‌#define CTTDNAMEDEF(name, id)                name "\0"
  128. ‌#define CTKWNAMEDEF(name, sz, cds)        name "\0"
  129. CTTDDEF(CTTDNAMEDEF)
  130. CTKWDEF(CTKWNAMEDEF)
  131. ‌#undef CTTDNAMEDEF
  132. ‌#undef CTKWNAMEDEF
  133. ;

  135. ‌#define CTTYPEINFO_NUM                (sizeof(lj_ctype_typeinfo)/sizeof(CTInfo)-1)
  136. #ifdef LUAJIT_CTYPE_CHECK_ANCHOR
  137. ‌#define CTTYPETAB_MIN                CTTYPEINFO_NUM
  138. #else
  139. ‌#define CTTYPETAB_MIN                128
  140. #endif

  142. /* -- C type interning ---------------------------------------------------- */

  144. ‌#define ct_hashtype(info, size)        (hashrot(info, size) & CTHASH_MASK)
  145. ‌#define ct_hashname(name) \
  146.   (hashrot(u32ptr(name), u32ptr(name) + HASH_BIAS) & CTHASH_MASK)

  148. /* Create new type element. */
  149. ‌CTypeID lj_ctype_new(CTState *cts, CType **ctp)
  150. {
  151.   CTypeID id = cts->top;
  152.   CType *ct;
  153.   lua_assert(cts->L);
  154.   if (LJ_UNLIKELY(id >= cts->sizetab)) {
  155.     if (id >= CTID_MAX) lj_err_msg(cts->L, LJ_ERR_TABOV);
  156. #ifdef LUAJIT_CTYPE_CHECK_ANCHOR
  157.     ct = lj_mem_newvec(cts->L, id+1, CType);
  158.     memcpy(ct, cts->tab, id*sizeof(CType));
  159.     memset(cts->tab, 0, id*sizeof(CType));
  160.     lj_mem_freevec(cts->g, cts->tab, cts->sizetab, CType);
  161.     cts->tab = ct;
  162.     cts->sizetab = id+1;
  163. #else
  164.     lj_mem_growvec(cts->L, cts->tab, cts->sizetab, CTID_MAX, CType);
  165. #endif
  166.   }
  167.   cts->top = id+1;
  168.   *ctp = ct = &cts->tab[id];
  169.   ct->info = 0;
  170.   ct->size = 0;
  171.   ct->sib = 0;
  172.   ct->next = 0;
  173.   setgcrefnull(ct->name);
  174.   return id;
  175. }

  177. /* Intern a type element. */
  178. ‌CTypeID lj_ctype_intern(CTState *cts, CTInfo info, CTSize size)
  179. {
  180.   uint32_t h = ct_hashtype(info, size);
  181.   CTypeID id = cts->hash[h];
  182.   lua_assert(cts->L);
  183.   while (id) {
  184.     CType *ct = ctype_get(cts, id);
  185.     if (ct->info == info && ct->size == size)
  186.       return id;
  187.     id = ct->next;
  188.   }
  189.   id = cts->top;
  190.   if (LJ_UNLIKELY(id >= cts->sizetab)) {
  191.     if (id >= CTID_MAX) lj_err_msg(cts->L, LJ_ERR_TABOV);
  192.     lj_mem_growvec(cts->L, cts->tab, cts->sizetab, CTID_MAX, CType);
  193.   }
  194.   cts->top = id+1;
  195.   cts->tab[id].info = info;
  196.   cts->tab[id].size = size;
  197.   cts->tab[id].sib = 0;
  198.   cts->tab[id].next = cts->hash[h];
  199.   setgcrefnull(cts->tab[id].name);
  200.   cts->hash[h] = (CTypeID1)id;
  201.   return id;
  202. }

  204. /* Add type element to hash table. */
  205. ‌static void ctype_addtype(CTState *cts, CType *ct, CTypeID id)
  206. {
  207.   uint32_t h = ct_hashtype(ct->info, ct->size);
  208.   ct->next = cts->hash[h];
  209.   cts->hash[h] = (CTypeID1)id;
  210. }

  212. /* Add named element to hash table. */
  213. ‌void lj_ctype_addname(CTState *cts, CType *ct, CTypeID id)
  214. {
  215.   uint32_t h = ct_hashname(gcref(ct->name));
  216.   ct->next = cts->hash[h];
  217.   cts->hash[h] = (CTypeID1)id;
  218. }

  220. /* Get a C type by name, matching the type mask. */
  221. ‌CTypeID lj_ctype_getname(CTState *cts, CType **ctp, GCstr *name, uint32_t tmask)
  222. {
  223.   CTypeID id = cts->hash[ct_hashname(name)];
  224.   while (id) {
  225.     CType *ct = ctype_get(cts, id);
  226.     if (gcref(ct->name) == obj2gco(name) &&
  227.         ((tmask >> ctype_type(ct->info)) & 1)) {
  228.       *ctp = ct;
  229.       return id;
  230.     }
  231.     id = ct->next;
  232.   }
  233.   *ctp = &cts->tab[0];  /* Simplify caller logic. ctype_get() would assert. */
  234.   return 0;
  235. }

  237. /* Get a struct/union/enum/function field by name. */
  238. ‌CType *lj_ctype_getfieldq(CTState *cts, CType *ct, GCstr *name, CTSize *ofs,
  239.                           CTInfo *qual)
  240. {
  241.   while (ct->sib) {
  242.     ct = ctype_get(cts, ct->sib);
  243.     if (gcref(ct->name) == obj2gco(name)) {
  244.       *ofs = ct->size;
  245.       return ct;
  246.     }
  247.     if (ctype_isxattrib(ct->info, CTA_SUBTYPE)) {
  248.       CType *fct, *cct = ctype_child(cts, ct);
  249.       CTInfo q = 0;
  250.       while (ctype_isattrib(cct->info)) {
  251.         if (ctype_attrib(cct->info) == CTA_QUAL) q |= cct->size;
  252.         cct = ctype_child(cts, cct);
  253.       }
  254.       fct = lj_ctype_getfieldq(cts, cct, name, ofs, qual);
  255.       if (fct) {
  256.         if (qual) *qual |= q;
  257.         *ofs += ct->size;
  258.         return fct;
  259.       }
  260.     }
  261.   }
  262.   return NULL;  /* Not found. */
  263. }

  265. /* -- C type information -------------------------------------------------- */

  267. /* Follow references and get raw type for a C type ID. */
  268. ‌CType *lj_ctype_rawref(CTState *cts, CTypeID id)
  269. {
  270.   CType *ct = ctype_get(cts, id);
  271.   while (ctype_isattrib(ct->info) || ctype_isref(ct->info))
  272.     ct = ctype_child(cts, ct);
  273.   return ct;
  274. }

  276. /* Get size for a C type ID. Does NOT support VLA/VLS. */
  277. ‌CTSize lj_ctype_size(CTState *cts, CTypeID id)
  278. {
  279.   CType *ct = ctype_raw(cts, id);
  280.   return ctype_hassize(ct->info) ? ct->size : CTSIZE_INVALID;
  281. }

  283. /* Get size for a variable-length C type. Does NOT support other C types. */
  284. ‌CTSize lj_ctype_vlsize(CTState *cts, CType *ct, CTSize nelem)
  285. {
  286.   uint64_t xsz = 0;
  287.   if (ctype_isstruct(ct->info)) {
  288.     CTypeID arrid = 0, fid = ct->sib;
  289.     xsz = ct->size;  /* Add the struct size. */
  290.     while (fid) {
  291.       CType *ctf = ctype_get(cts, fid);
  292.       if (ctype_type(ctf->info) == CT_FIELD)
  293.         arrid = ctype_cid(ctf->info);  /* Remember last field of VLS. */
  294.       fid = ctf->sib;
  295.     }
  296.     ct = ctype_raw(cts, arrid);
  297.   }
  298.   lua_assert(ctype_isvlarray(ct->info));  /* Must be a VLA. */
  299.   ct = ctype_rawchild(cts, ct);  /* Get array element. */
  300.   lua_assert(ctype_hassize(ct->info));
  301.   /* Calculate actual size of VLA and check for overflow. */
  302.   xsz += (uint64_t)ct->size * nelem;
  303.   return xsz < 0x80000000u ? (CTSize)xsz : CTSIZE_INVALID;
  304. }

  306. /* Get type, qualifiers, size and alignment for a C type ID. */
  307. ‌CTInfo lj_ctype_info(CTState *cts, CTypeID id, CTSize *szp)
  308. {
  309.   CTInfo qual = 0;
  310.   CType *ct = ctype_get(cts, id);
  311.   for (;;) {
  312.     CTInfo info = ct->info;
  313.     if (ctype_isenum(info)) {
  314.       /* Follow child. Need to look at its attributes, too. */
  315.     } else if (ctype_isattrib(info)) {
  316.       if (ctype_isxattrib(info, CTA_QUAL))
  317.         qual |= ct->size;
  318.       else if (ctype_isxattrib(info, CTA_ALIGN) && !(qual & CTFP_ALIGNED))
  319.         qual |= CTFP_ALIGNED + CTALIGN(ct->size);
  320.     } else {
  321.       if (!(qual & CTFP_ALIGNED)) qual |= (info & CTF_ALIGN);
  322.       qual |= (info & ~(CTF_ALIGN|CTMASK_CID));
  323.       lua_assert(ctype_hassize(info) || ctype_isfunc(info));
  324.       *szp = ctype_isfunc(info) ? CTSIZE_INVALID : ct->size;
  325.       break;
  326.     }
  327.     ct = ctype_get(cts, ctype_cid(info));
  328.   }
  329.   return qual;
  330. }

  332. /* Get ctype metamethod. */
  333. ‌cTValue *lj_ctype_meta(CTState *cts, CTypeID id, MMS mm)
  334. {
  335.   CType *ct = ctype_get(cts, id);
  336.   cTValue *tv;
  337.   while (ctype_isattrib(ct->info) || ctype_isref(ct->info)) {
  338.     id = ctype_cid(ct->info);
  339.     ct = ctype_get(cts, id);
  340.   }
  341.   if (ctype_isptr(ct->info) &&
  342.       ctype_isfunc(ctype_get(cts, ctype_cid(ct->info))->info))
  343.     tv = lj_tab_getstr(cts->miscmap, &cts->g->strempty);
  344.   else
  345.     tv = lj_tab_getinth(cts->miscmap, -(int32_t)id);
  346.   if (tv && tvistab(tv) &&
  347.       (tv = lj_tab_getstr(tabV(tv), mmname_str(cts->g, mm))) && !tvisnil(tv))
  348.     return tv;
  349.   return NULL;
  350. }

  352. /* -- C type representation ----------------------------------------------- */

  354. /* Fixed max. length of a C type representation. */
  355. ‌#define CTREPR_MAX                512

  357. ‌typedef struct CTRepr {
  358.   char *pb, *pe;
  359.   CTState *cts;
  360.   lua_State *L;
  361.   int needsp;
  362.   int ok;
  363.   char buf[CTREPR_MAX];
  364. ‌} CTRepr;

  366. /* Prepend string. */
  367. ‌static void ctype_prepstr(CTRepr *ctr, const char *str, MSize len)
  368. {
  369.   char *p = ctr->pb;
  370.   if (ctr->buf + len+1 > p) { ctr->ok = 0; return; }
  371.   if (ctr->needsp) *--p = ' ';
  372.   ctr->needsp = 1;
  373.   p -= len;
  374.   while (len-- > 0) p[len] = str[len];
  375.   ctr->pb = p;
  376. }

  378. ‌#define ctype_preplit(ctr, str)        ctype_prepstr((ctr), "" str, sizeof(str)-1)

  380. /* Prepend char. */
  381. ‌static void ctype_prepc(CTRepr *ctr, int c)
  382. {
  383.   if (ctr->buf >= ctr->pb) { ctr->ok = 0; return; }
  384.   *--ctr->pb = c;
  385. }

  387. /* Prepend number. */
  388. ‌static void ctype_prepnum(CTRepr *ctr, uint32_t n)
  389. {
  390.   char *p = ctr->pb;
  391.   if (ctr->buf + 10+1 > p) { ctr->ok = 0; return; }
  392.   do { *--p = (char)('0' + n % 10); } while (n /= 10);
  393.   ctr->pb = p;
  394.   ctr->needsp = 0;
  395. }

  397. /* Append char. */
  398. ‌static void ctype_appc(CTRepr *ctr, int c)
  399. {
  400.   if (ctr->pe >= ctr->buf + CTREPR_MAX) { ctr->ok = 0; return; }
  401.   *ctr->pe++ = c;
  402. }

  404. /* Append number. */
  405. ‌static void ctype_appnum(CTRepr *ctr, uint32_t n)
  406. {
  407.   char buf[10];
  408.   char *p = buf+sizeof(buf);
  409.   char *q = ctr->pe;
  410.   if (q > ctr->buf + CTREPR_MAX - 10) { ctr->ok = 0; return; }
  411.   do { *--p = (char)('0' + n % 10); } while (n /= 10);
  412.   do { *q++ = *p++; } while (p < buf+sizeof(buf));
  413.   ctr->pe = q;
  414. }

  416. /* Prepend qualifiers. */
  417. ‌static void ctype_prepqual(CTRepr *ctr, CTInfo info)
  418. {
  419.   if ((info & CTF_VOLATILE)) ctype_preplit(ctr, "volatile");
  420.   if ((info & CTF_CONST)) ctype_preplit(ctr, "const");
  421. }

  423. /* Prepend named type. */
  424. ‌static void ctype_preptype(CTRepr *ctr, CType *ct, CTInfo qual, const char *t)
  425. {
  426.   if (gcref(ct->name)) {
  427.     GCstr *str = gco2str(gcref(ct->name));
  428.     ctype_prepstr(ctr, strdata(str), str->len);
  429.   } else {
  430.     if (ctr->needsp) ctype_prepc(ctr, ' ');
  431.     ctype_prepnum(ctr, ctype_typeid(ctr->cts, ct));
  432.     ctr->needsp = 1;
  433.   }
  434.   ctype_prepstr(ctr, t, (MSize)strlen(t));
  435.   ctype_prepqual(ctr, qual);
  436. }

  438. ‌static void ctype_repr(CTRepr *ctr, CTypeID id)
  439. {
  440.   CType *ct = ctype_get(ctr->cts, id);
  441.   CTInfo qual = 0;
  442.   int ptrto = 0;
  443.   for (;;) {
  444.     CTInfo info = ct->info;
  445.     CTSize size = ct->size;
  446.     switch (ctype_type(info)) {
  447.     case CT_NUM:
  448.       if ((info & CTF_BOOL)) {
  449.         ctype_preplit(ctr, "bool");
  450.       } else if ((info & CTF_FP)) {
  451.         if (size == sizeof(double)) ctype_preplit(ctr, "double");
  452.         else if (size == sizeof(float)) ctype_preplit(ctr, "float");
  453.         else ctype_preplit(ctr, "long double");
  454.       } else if (size == 1) {
  455.         if (!((info ^ CTF_UCHAR) & CTF_UNSIGNED)) ctype_preplit(ctr, "char");
  456.         else if (CTF_UCHAR) ctype_preplit(ctr, "signed char");
  457.         else ctype_preplit(ctr, "unsigned char");
  458.       } else if (size < 8) {
  459.         if (size == 4) ctype_preplit(ctr, "int");
  460.         else ctype_preplit(ctr, "short");
  461.         if ((info & CTF_UNSIGNED)) ctype_preplit(ctr, "unsigned");
  462.       } else {
  463.         ctype_preplit(ctr, "_t");
  464.         ctype_prepnum(ctr, size*8);
  465.         ctype_preplit(ctr, "int");
  466.         if ((info & CTF_UNSIGNED)) ctype_prepc(ctr, 'u');
  467.       }
  468.       ctype_prepqual(ctr, (qual|info));
  469.       return;
  470.     case CT_VOID:
  471.       ctype_preplit(ctr, "void");
  472.       ctype_prepqual(ctr, (qual|info));
  473.       return;
  474.     case CT_STRUCT:
  475.       ctype_preptype(ctr, ct, qual, (info & CTF_UNION) ? "union" : "struct");
  476.       return;
  477.     case CT_ENUM:
  478.       if (id == CTID_CTYPEID) {
  479.         ctype_preplit(ctr, "ctype");
  480.         return;
  481.       }
  482.       ctype_preptype(ctr, ct, qual, "enum");
  483.       return;
  484.     case CT_ATTRIB:
  485.       if (ctype_attrib(info) == CTA_QUAL) qual |= size;
  486.       break;
  487.     case CT_PTR:
  488.       if ((info & CTF_REF)) {
  489.         ctype_prepc(ctr, '&');
  490.       } else {
  491.         ctype_prepqual(ctr, (qual|info));
  492.         if (LJ_64 && size == 4) ctype_preplit(ctr, "__ptr32");
  493.         ctype_prepc(ctr, '*');
  494.       }
  495.       qual = 0;
  496.       ptrto = 1;
  497.       ctr->needsp = 1;
  498.       break;
  499.     case CT_ARRAY:
  500.       if (ctype_isrefarray(info)) {
  501.         ctr->needsp = 1;
  502.         if (ptrto) { ptrto = 0; ctype_prepc(ctr, '('); ctype_appc(ctr, ')'); }
  503.         ctype_appc(ctr, '[');
  504.         if (size != CTSIZE_INVALID) {
  505.           CTSize csize = ctype_child(ctr->cts, ct)->size;
  506.           ctype_appnum(ctr, csize ? size/csize : 0);
  507.         } else if ((info & CTF_VLA)) {
  508.           ctype_appc(ctr, '?');
  509.         }
  510.         ctype_appc(ctr, ']');
  511.       } else if ((info & CTF_COMPLEX)) {
  512.         if (size == 2*sizeof(float)) ctype_preplit(ctr, "float");
  513.         ctype_preplit(ctr, "complex");
  514.         return;
  515.       } else {
  516.         ctype_preplit(ctr, ")))");
  517.         ctype_prepnum(ctr, size);
  518.         ctype_preplit(ctr, "__attribute__((vector_size(");
  519.       }
  520.       break;
  521.     case CT_FUNC:
  522.       ctr->needsp = 1;
  523.       if (ptrto) { ptrto = 0; ctype_prepc(ctr, '('); ctype_appc(ctr, ')'); }
  524.       ctype_appc(ctr, '(');
  525.       ctype_appc(ctr, ')');
  526.       break;
  527.     default:
  528.       lua_assert(0);
  529.       break;
  530.     }
  531.     ct = ctype_get(ctr->cts, ctype_cid(info));
  532.   }
  533. }

  535. /* Return a printable representation of a C type. */
  536. ‌GCstr *lj_ctype_repr(lua_State *L, CTypeID id, GCstr *name)
  537. {
  538.   global_State *g = G(L);
  539.   CTRepr ctr;
  540.   ctr.pb = ctr.pe = &ctr.buf[CTREPR_MAX/2];
  541.   ctr.cts = ctype_ctsG(g);
  542.   ctr.L = L;
  543.   ctr.ok = 1;
  544.   ctr.needsp = 0;
  545.   if (name) ctype_prepstr(&ctr, strdata(name), name->len);
  546.   ctype_repr(&ctr, id);
  547.   if (LJ_UNLIKELY(!ctr.ok)) return lj_str_newlit(L, "?");
  548.   return lj_str_new(L, ctr.pb, ctr.pe - ctr.pb);
  549. }

  551. /* Convert int64_t/uint64_t to string with 'LL' or 'ULL' suffix. */
  552. ‌GCstr *lj_ctype_repr_int64(lua_State *L, uint64_t n, int isunsigned)
  553. {
  554.   char buf[1+20+3];
  555.   char *p = buf+sizeof(buf);
  556.   int sign = 0;
  557.   *--p = 'L'; *--p = 'L';
  558.   if (isunsigned) {
  559.     *--p = 'U';
  560.   } else if ((int64_t)n < 0) {
  561.     n = (uint64_t)-(int64_t)n;
  562.     sign = 1;
  563.   }
  564.   do { *--p = (char)('0' + n % 10); } while (n /= 10);
  565.   if (sign) *--p = '-';
  566.   return lj_str_new(L, p, (size_t)(buf+sizeof(buf)-p));
  567. }

  569. /* Convert complex to string with 'i' or 'I' suffix. */
  570. ‌GCstr *lj_ctype_repr_complex(lua_State *L, void *sp, CTSize size)
  571. {
  572.   char buf[2*STRFMT_MAXBUF_NUM+2+1], *p = buf;
  573.   TValue re, im;
  574.   if (size == 2*sizeof(double)) {
  575.     re.n = *(double *)sp; im.n = ((double *)sp)[1];
  576.   } else {
  577.     re.n = (double)*(float *)sp; im.n = (double)((float *)sp)[1];
  578.   }
  579.   p = lj_strfmt_wnum(p, &re);
  580.   if (!(im.u32.hi & 0x80000000u) || im.n != im.n) *p++ = '+';
  581.   p = lj_strfmt_wnum(p, &im);
  582.   *p = *(p-1) >= 'a' ? 'I' : 'i';
  583.   p++;
  584.   return lj_str_new(L, buf, p-buf);
  585. }

  587. /* -- C type state -------------------------------------------------------- */

  589. /* Initialize C type table and state. */
  590. ‌CTState *lj_ctype_init(lua_State *L)
  591. {
  592.   CTState *cts = lj_mem_newt(L, sizeof(CTState), CTState);
  593.   CType *ct = lj_mem_newvec(L, CTTYPETAB_MIN, CType);
  594.   const char *name = lj_ctype_typenames;
  595.   CTypeID id;
  596.   memset(cts, 0, sizeof(CTState));
  597.   cts->tab = ct;
  598.   cts->sizetab = CTTYPETAB_MIN;
  599.   cts->top = CTTYPEINFO_NUM;
  600.   cts->L = NULL;
  601.   cts->g = G(L);
  602.   for (id = 0; id < CTTYPEINFO_NUM; id++, ct++) {
  603.     CTInfo info = lj_ctype_typeinfo[id];
  604.     ct->size = (CTSize)((int32_t)(info << 16) >> 26);
  605.     ct->info = info & 0xffff03ffu;
  606.     ct->sib = 0;
  607.     if (ctype_type(info) == CT_KW || ctype_istypedef(info)) {
  608.       size_t len = strlen(name);
  609.       GCstr *str = lj_str_new(L, name, len);
  610.       ctype_setname(ct, str);
  611.       name += len+1;
  612.       lj_ctype_addname(cts, ct, id);
  613.     } else {
  614.       setgcrefnull(ct->name);
  615.       ct->next = 0;
  616.       if (!ctype_isenum(info)) ctype_addtype(cts, ct, id);
  617.     }
  618.   }
  619.   setmref(G(L)->ctype_state, cts);
  620.   return cts;
  621. }

  623. /* Free C type table and state. */
  624. ‌void lj_ctype_freestate(global_State *g)
  625. {
  626.   CTState *cts = ctype_ctsG(g);
  627.   if (cts) {
  628.     lj_ccallback_mcode_free(cts);
  629.     lj_mem_freevec(g, cts->tab, cts->sizetab, CType);
  630.     lj_mem_freevec(g, cts->cb.cbid, cts->cb.sizeid, CTypeID1);
  631.     lj_mem_freet(g, cts);
  632.   }
  633. }

  635. #endif

One Level Up Top Level