src/lj_ctype.h - 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. */

  5. #ifndef _LJ_CTYPE_H
  6. #define _LJ_CTYPE_H

  7. #include "lj_obj.h"
  8. #include "lj_gc.h"

  9. #if LJ_HASFFI

  10. /* -- C type definitions -------------------------------------------------- */

  11. /* C type numbers. Highest 4 bits of C type info. ORDER CT. */
  12. enum {
  13.   /* Externally visible types. */
  14.   CT_NUM,                /* Integer or floating-point numbers. */
  15.   CT_STRUCT,                /* Struct or union. */
  16.   CT_PTR,                /* Pointer or reference. */
  17.   CT_ARRAY,                /* Array or complex type. */
  18.   CT_MAYCONVERT = CT_ARRAY,
  19.   CT_VOID,                /* Void type. */
  20.   CT_ENUM,                /* Enumeration. */
  21.   CT_HASSIZE = CT_ENUM,  /* Last type where ct->size holds the actual size. */
  22.   CT_FUNC,                /* Function. */
  23.   CT_TYPEDEF,                /* Typedef. */
  24.   CT_ATTRIB,                /* Miscellaneous attributes. */
  25.   /* Internal element types. */
  26.   CT_FIELD,                /* Struct/union field or function parameter. */
  27.   CT_BITFIELD,                /* Struct/union bitfield. */
  28.   CT_CONSTVAL,                /* Constant value. */
  29.   CT_EXTERN,                /* External reference. */
  30.   CT_KW                        /* Keyword. */
  31. };

  32. LJ_STATIC_ASSERT(((int)CT_PTR & (int)CT_ARRAY) == CT_PTR);
  33. LJ_STATIC_ASSERT(((int)CT_STRUCT & (int)CT_ARRAY) == CT_STRUCT);

  34. /*
  35. **  ---------- info ------------
  36. ** |type      flags...  A   cid | size   |  sib  | next  | name  |
  37. ** +----------------------------+--------+-------+-------+-------+--
  38. ** |NUM       BFvcUL..  A       | size   |       | type  |       |
  39. ** |STRUCT    ..vcU..V  A       | size   | field | name? | name? |
  40. ** |PTR       ..vcR...  A   cid | size   |       | type  |       |
  41. ** |ARRAY     VCvc...V  A   cid | size   |       | type  |       |
  42. ** |VOID      ..vc....  A       | size   |       | type  |       |
  43. ** |ENUM                A   cid | size   | const | name? | name? |
  44. ** |FUNC      ....VS.. cc   cid | nargs  | field | name? | name? |
  45. ** |TYPEDEF                 cid |        |       | name  | name  |
  46. ** |ATTRIB        attrnum   cid | attr   | sib?  | type? |       |
  47. ** |FIELD                   cid | offset | field |       | name? |
  48. ** |BITFIELD  B.vcU csz bsz pos | offset | field |       | name? |
  49. ** |CONSTVAL     c          cid | value  | const | name  | name  |
  50. ** |EXTERN                  cid |        | sib?  | name  | name  |
  51. ** |KW                      tok | size   |       | name  | name  |
  52. ** +----------------------------+--------+-------+-------+-------+--
  53. **        ^^  ^^--- bits used for C type conversion dispatch
  54. */

  55. /* C type info flags.     TFFArrrr  */
  56. #define CTF_BOOL        0x08000000u        /* Boolean: NUM, BITFIELD. */
  57. #define CTF_FP                0x04000000u        /* Floating-point: NUM. */
  58. #define CTF_CONST        0x02000000u        /* Const qualifier. */
  59. #define CTF_VOLATILE        0x01000000u        /* Volatile qualifier. */
  60. #define CTF_UNSIGNED        0x00800000u        /* Unsigned: NUM, BITFIELD. */
  61. #define CTF_LONG        0x00400000u        /* Long: NUM. */
  62. #define CTF_VLA                0x00100000u        /* Variable-length: ARRAY, STRUCT. */
  63. #define CTF_REF                0x00800000u        /* Reference: PTR. */
  64. #define CTF_VECTOR        0x08000000u        /* Vector: ARRAY. */
  65. #define CTF_COMPLEX        0x04000000u        /* Complex: ARRAY. */
  66. #define CTF_UNION        0x00800000u        /* Union: STRUCT. */
  67. #define CTF_VARARG        0x00800000u        /* Vararg: FUNC. */
  68. #define CTF_SSEREGPARM        0x00400000u        /* SSE register parameters: FUNC. */

  69. #define CTF_QUAL        (CTF_CONST|CTF_VOLATILE)
  70. #define CTF_ALIGN        (CTMASK_ALIGN<<CTSHIFT_ALIGN)
  71. #define CTF_UCHAR        ((char)-1 > 0 ? CTF_UNSIGNED : 0)

  72. /* Flags used in parser.  .F.Ammvf   cp->attr  */
  73. #define CTFP_ALIGNED        0x00000001u        /* cp->attr + ALIGN */
  74. #define CTFP_PACKED        0x00000002u        /* cp->attr */
  75. /*                        ...C...f   cp->fattr */
  76. #define CTFP_CCONV        0x00000001u        /* cp->fattr + CCONV/[SSE]REGPARM */

  77. /* C type info bitfields. */
  78. #define CTMASK_CID        0x0000ffffu        /* Max. 65536 type IDs. */
  79. #define CTMASK_NUM        0xf0000000u        /* Max. 16 type numbers. */
  80. #define CTSHIFT_NUM        28
  81. #define CTMASK_ALIGN        15                /* Max. alignment is 2^15. */
  82. #define CTSHIFT_ALIGN        16
  83. #define CTMASK_ATTRIB        255                /* Max. 256 attributes. */
  84. #define CTSHIFT_ATTRIB        16
  85. #define CTMASK_CCONV        3                /* Max. 4 calling conventions. */
  86. #define CTSHIFT_CCONV        16
  87. #define CTMASK_REGPARM        3                /* Max. 0-3 regparms. */
  88. #define CTSHIFT_REGPARM        18
  89. /* Bitfields only used in parser. */
  90. #define CTMASK_VSIZEP        15                /* Max. vector size is 2^15. */
  91. #define CTSHIFT_VSIZEP        4
  92. #define CTMASK_MSIZEP        255                /* Max. type size (via mode) is 128. */
  93. #define CTSHIFT_MSIZEP        8

  94. /* Info bits for BITFIELD. Max. size of bitfield is 64 bits. */
  95. #define CTBSZ_MAX        32                /* Max. size of bitfield is 32 bit. */
  96. #define CTBSZ_FIELD        127                /* Temp. marker for regular field. */
  97. #define CTMASK_BITPOS        127
  98. #define CTMASK_BITBSZ        127
  99. #define CTMASK_BITCSZ        127
  100. #define CTSHIFT_BITPOS        0
  101. #define CTSHIFT_BITBSZ        8
  102. #define CTSHIFT_BITCSZ        16

  103. #define CTF_INSERT(info, field, val) \
  104.   info = (info & ~(CTMASK_##field<<CTSHIFT_##field)) | \
  105.           (((CTSize)(val) & CTMASK_##field) << CTSHIFT_##field)

  106. /* Calling conventions. ORDER CC */
  107. enum { CTCC_CDECL, CTCC_THISCALL, CTCC_FASTCALL, CTCC_STDCALL };

  108. /* Attribute numbers. */
  109. enum {
  110.   CTA_NONE,                /* Ignored attribute. Must be zero. */
  111.   CTA_QUAL,                /* Unmerged qualifiers. */
  112.   CTA_ALIGN,                /* Alignment override. */
  113.   CTA_SUBTYPE,                /* Transparent sub-type. */
  114.   CTA_REDIR,                /* Redirected symbol name. */
  115.   CTA_BAD,                /* To catch bad IDs. */
  116.   CTA__MAX
  117. };

  118. /* Special sizes. */
  119. #define CTSIZE_INVALID        0xffffffffu

  120. typedef uint32_t CTInfo;        /* Type info. */
  121. typedef uint32_t CTSize;        /* Type size. */
  122. typedef uint32_t CTypeID;        /* Type ID. */
  123. typedef uint16_t CTypeID1;        /* Minimum-sized type ID. */

  124. /* C type table element. */
  125. typedef struct CType {
  126.   CTInfo info;                /* Type info. */
  127.   CTSize size;                /* Type size or other info. */
  128.   CTypeID1 sib;                /* Sibling element. */
  129.   CTypeID1 next;        /* Next element in hash chain. */
  130.   GCRef name;                /* Element name (GCstr). */
  131. } CType;

  132. #define CTHASH_SIZE        128        /* Number of hash anchors. */
  133. #define CTHASH_MASK        (CTHASH_SIZE-1)

  134. /* Simplify target-specific configuration. Checked in lj_ccall.h. */
  135. #define CCALL_MAX_GPR                8
  136. #define CCALL_MAX_FPR                8

  137. typedef LJ_ALIGN(8) union FPRCBArg { double d; float f[2]; } FPRCBArg;

  138. /* C callback state. Defined here, to avoid dragging in lj_ccall.h. */

  139. typedef LJ_ALIGN(8) struct CCallback {
  140.   FPRCBArg fpr[CCALL_MAX_FPR];        /* Arguments/results in FPRs. */
  141.   intptr_t gpr[CCALL_MAX_GPR];        /* Arguments/results in GPRs. */
  142.   intptr_t *stack;                /* Pointer to arguments on stack. */
  143.   void *mcode;                        /* Machine code for callback func. pointers. */
  144.   CTypeID1 *cbid;                /* Callback type table. */
  145.   MSize sizeid;                        /* Size of callback type table. */
  146.   MSize topid;                        /* Highest unused callback type table slot. */
  147.   MSize slot;                        /* Current callback slot. */
  148. } CCallback;

  149. /* C type state. */
  150. typedef struct CTState {
  151.   CType *tab;                /* C type table. */
  152.   CTypeID top;                /* Current top of C type table. */
  153.   MSize sizetab;        /* Size of C type table. */
  154.   lua_State *L;                /* Lua state (needed for errors and allocations). */
  155.   global_State *g;        /* Global state. */
  156.   GCtab *finalizer;        /* Map of cdata to finalizer. */
  157.   GCtab *miscmap;        /* Map of -CTypeID to metatable and cb slot to func. */
  158.   CCallback cb;                /* Temporary callback state. */
  159.   CTypeID1 hash[CTHASH_SIZE];  /* Hash anchors for C type table. */
  160. } CTState;

  161. #define CTINFO(ct, flags)        (((CTInfo)(ct) << CTSHIFT_NUM) + (flags))
  162. #define CTALIGN(al)                ((CTSize)(al) << CTSHIFT_ALIGN)
  163. #define CTATTRIB(at)                ((CTInfo)(at) << CTSHIFT_ATTRIB)

  164. #define ctype_type(info)        ((info) >> CTSHIFT_NUM)
  165. #define ctype_cid(info)                ((CTypeID)((info) & CTMASK_CID))
  166. #define ctype_align(info)        (((info) >> CTSHIFT_ALIGN) & CTMASK_ALIGN)
  167. #define ctype_attrib(info)        (((info) >> CTSHIFT_ATTRIB) & CTMASK_ATTRIB)
  168. #define ctype_bitpos(info)        (((info) >> CTSHIFT_BITPOS) & CTMASK_BITPOS)
  169. #define ctype_bitbsz(info)        (((info) >> CTSHIFT_BITBSZ) & CTMASK_BITBSZ)
  170. #define ctype_bitcsz(info)        (((info) >> CTSHIFT_BITCSZ) & CTMASK_BITCSZ)
  171. #define ctype_vsizeP(info)        (((info) >> CTSHIFT_VSIZEP) & CTMASK_VSIZEP)
  172. #define ctype_msizeP(info)        (((info) >> CTSHIFT_MSIZEP) & CTMASK_MSIZEP)
  173. #define ctype_cconv(info)        (((info) >> CTSHIFT_CCONV) & CTMASK_CCONV)

  174. /* Simple type checks. */
  175. #define ctype_isnum(info)        (ctype_type((info)) == CT_NUM)
  176. #define ctype_isvoid(info)        (ctype_type((info)) == CT_VOID)
  177. #define ctype_isptr(info)        (ctype_type((info)) == CT_PTR)
  178. #define ctype_isarray(info)        (ctype_type((info)) == CT_ARRAY)
  179. #define ctype_isstruct(info)        (ctype_type((info)) == CT_STRUCT)
  180. #define ctype_isfunc(info)        (ctype_type((info)) == CT_FUNC)
  181. #define ctype_isenum(info)        (ctype_type((info)) == CT_ENUM)
  182. #define ctype_istypedef(info)        (ctype_type((info)) == CT_TYPEDEF)
  183. #define ctype_isattrib(info)        (ctype_type((info)) == CT_ATTRIB)
  184. #define ctype_isfield(info)        (ctype_type((info)) == CT_FIELD)
  185. #define ctype_isbitfield(info)        (ctype_type((info)) == CT_BITFIELD)
  186. #define ctype_isconstval(info)        (ctype_type((info)) == CT_CONSTVAL)
  187. #define ctype_isextern(info)        (ctype_type((info)) == CT_EXTERN)
  188. #define ctype_hassize(info)        (ctype_type((info)) <= CT_HASSIZE)

  189. /* Combined type and flag checks. */
  190. #define ctype_isinteger(info) \
  191.   (((info) & (CTMASK_NUM|CTF_BOOL|CTF_FP)) == CTINFO(CT_NUM, 0))
  192. #define ctype_isinteger_or_bool(info) \
  193.   (((info) & (CTMASK_NUM|CTF_FP)) == CTINFO(CT_NUM, 0))
  194. #define ctype_isbool(info) \
  195.   (((info) & (CTMASK_NUM|CTF_BOOL)) == CTINFO(CT_NUM, CTF_BOOL))
  196. #define ctype_isfp(info) \
  197.   (((info) & (CTMASK_NUM|CTF_FP)) == CTINFO(CT_NUM, CTF_FP))

  198. #define ctype_ispointer(info) \
  199.   ((ctype_type(info) >> 1) == (CT_PTR >> 1))  /* Pointer or array. */
  200. #define ctype_isref(info) \
  201.   (((info) & (CTMASK_NUM|CTF_REF)) == CTINFO(CT_PTR, CTF_REF))

  202. #define ctype_isrefarray(info) \
  203.   (((info) & (CTMASK_NUM|CTF_VECTOR|CTF_COMPLEX)) == CTINFO(CT_ARRAY, 0))
  204. #define ctype_isvector(info) \
  205.   (((info) & (CTMASK_NUM|CTF_VECTOR)) == CTINFO(CT_ARRAY, CTF_VECTOR))
  206. #define ctype_iscomplex(info) \
  207.   (((info) & (CTMASK_NUM|CTF_COMPLEX)) == CTINFO(CT_ARRAY, CTF_COMPLEX))

  208. #define ctype_isvltype(info) \
  209.   (((info) & ((CTMASK_NUM|CTF_VLA) - (2u<<CTSHIFT_NUM))) == \
  210.    CTINFO(CT_STRUCT, CTF_VLA))  /* VL array or VL struct. */
  211. #define ctype_isvlarray(info) \
  212.   (((info) & (CTMASK_NUM|CTF_VLA)) == CTINFO(CT_ARRAY, CTF_VLA))

  213. #define ctype_isxattrib(info, at) \
  214.   (((info) & (CTMASK_NUM|CTATTRIB(CTMASK_ATTRIB))) == \
  215.    CTINFO(CT_ATTRIB, CTATTRIB(at)))

  216. /* Target-dependent sizes and alignments. */
  217. #if LJ_64
  218. #define CTSIZE_PTR        8
  219. #define CTALIGN_PTR        CTALIGN(3)
  220. #else
  221. #define CTSIZE_PTR        4
  222. #define CTALIGN_PTR        CTALIGN(2)
  223. #endif

  224. #define CTINFO_REF(ref) \
  225.   CTINFO(CT_PTR, (CTF_CONST|CTF_REF|CTALIGN_PTR) + (ref))

  226. #define CT_MEMALIGN        3        /* Alignment guaranteed by memory allocator. */

  227. /* -- Predefined types ---------------------------------------------------- */

  228. /* Target-dependent types. */
  229. #if LJ_TARGET_PPC
  230. #define CTTYDEFP(_) \
  231.   _(LINT32,                4,        CT_NUM, CTF_LONG|CTALIGN(2))
  232. #else
  233. #define CTTYDEFP(_)
  234. #endif

  235. /* Common types. */
  236. #define CTTYDEF(_) \
  237.   _(NONE,                0,        CT_ATTRIB, CTATTRIB(CTA_BAD)) \
  238.   _(VOID,                -1,        CT_VOID, CTALIGN(0)) \
  239.   _(CVOID,                -1,        CT_VOID, CTF_CONST|CTALIGN(0)) \
  240.   _(BOOL,                1,        CT_NUM, CTF_BOOL|CTF_UNSIGNED|CTALIGN(0)) \
  241.   _(CCHAR,                1,        CT_NUM, CTF_CONST|CTF_UCHAR|CTALIGN(0)) \
  242.   _(INT8,                1,        CT_NUM, CTALIGN(0)) \
  243.   _(UINT8,                1,        CT_NUM, CTF_UNSIGNED|CTALIGN(0)) \
  244.   _(INT16,                2,        CT_NUM, CTALIGN(1)) \
  245.   _(UINT16,                2,        CT_NUM, CTF_UNSIGNED|CTALIGN(1)) \
  246.   _(INT32,                4,        CT_NUM, CTALIGN(2)) \
  247.   _(UINT32,                4,        CT_NUM, CTF_UNSIGNED|CTALIGN(2)) \
  248.   _(INT64,                8,        CT_NUM, CTF_LONG|CTALIGN(3)) \
  249.   _(UINT64,                8,        CT_NUM, CTF_UNSIGNED|CTF_LONG|CTALIGN(3)) \
  250.   _(FLOAT,                4,        CT_NUM, CTF_FP|CTALIGN(2)) \
  251.   _(DOUBLE,                8,        CT_NUM, CTF_FP|CTALIGN(3)) \
  252.   _(COMPLEX_FLOAT,        8,        CT_ARRAY, CTF_COMPLEX|CTALIGN(2)|CTID_FLOAT) \
  253.   _(COMPLEX_DOUBLE,        16,        CT_ARRAY, CTF_COMPLEX|CTALIGN(3)|CTID_DOUBLE) \
  254.   _(P_VOID,        CTSIZE_PTR,        CT_PTR, CTALIGN_PTR|CTID_VOID) \
  255.   _(P_CVOID,        CTSIZE_PTR,        CT_PTR, CTALIGN_PTR|CTID_CVOID) \
  256.   _(P_CCHAR,        CTSIZE_PTR,        CT_PTR, CTALIGN_PTR|CTID_CCHAR) \
  257.   _(A_CCHAR,                -1,        CT_ARRAY, CTF_CONST|CTALIGN(0)|CTID_CCHAR) \
  258.   _(CTYPEID,                4,        CT_ENUM, CTALIGN(2)|CTID_INT32) \
  259.   CTTYDEFP(_) \
  260.   /* End of type list. */

  261. /* Public predefined type IDs. */
  262. enum {
  263. #define CTTYIDDEF(id, sz, ct, info)        CTID_##id,
  264. CTTYDEF(CTTYIDDEF)
  265. #undef CTTYIDDEF
  266.   /* Predefined typedefs and keywords follow. */
  267.   CTID_MAX = 65536
  268. };

  269. /* Target-dependent type IDs. */
  270. #if LJ_64
  271. #define CTID_INT_PSZ        CTID_INT64
  272. #define CTID_UINT_PSZ        CTID_UINT64
  273. #else
  274. #define CTID_INT_PSZ        CTID_INT32
  275. #define CTID_UINT_PSZ        CTID_UINT32
  276. #endif

  277. #if LJ_ABI_WIN
  278. #define CTID_WCHAR        CTID_UINT16
  279. #elif LJ_TARGET_PPC
  280. #define CTID_WCHAR        CTID_LINT32
  281. #else
  282. #define CTID_WCHAR        CTID_INT32
  283. #endif

  284. /* -- C tokens and keywords ----------------------------------------------- */

  285. /* C lexer keywords. */
  286. #define CTOKDEF(_) \
  287.   _(IDENT, "<identifier>") _(STRING, "<string>") \
  288.   _(INTEGER, "<integer>") _(EOF, "<eof>") \
  289.   _(OROR, "||") _(ANDAND, "&&") _(EQ, "==") _(NE, "!=") \
  290.   _(LE, "<=") _(GE, ">=") _(SHL, "<<") _(SHR, ">>") _(DEREF, "->")

  291. /* Simple declaration specifiers. */
  292. #define CDSDEF(_) \
  293.   _(VOID) _(BOOL) _(CHAR) _(INT) _(FP) \
  294.   _(LONG) _(LONGLONG) _(SHORT) _(COMPLEX) _(SIGNED) _(UNSIGNED) \
  295.   _(CONST) _(VOLATILE) _(RESTRICT) _(INLINE) \
  296.   _(TYPEDEF) _(EXTERN) _(STATIC) _(AUTO) _(REGISTER)

  297. /* C keywords. */
  298. #define CKWDEF(_) \
  299.   CDSDEF(_) _(EXTENSION) _(ASM) _(ATTRIBUTE) \
  300.   _(DECLSPEC) _(CCDECL) _(PTRSZ) \
  301.   _(STRUCT) _(UNION) _(ENUM) \
  302.   _(SIZEOF) _(ALIGNOF)

  303. /* C token numbers. */
  304. enum {
  305.   CTOK_OFS = 255,
  306. #define CTOKNUM(name, sym)        CTOK_##name,
  307. #define CKWNUM(name)                CTOK_##name,
  308. CTOKDEF(CTOKNUM)
  309. CKWDEF(CKWNUM)
  310. #undef CTOKNUM
  311. #undef CKWNUM
  312.   CTOK_FIRSTDECL = CTOK_VOID,
  313.   CTOK_FIRSTSCL = CTOK_TYPEDEF,
  314.   CTOK_LASTDECLFLAG = CTOK_REGISTER,
  315.   CTOK_LASTDECL = CTOK_ENUM
  316. };

  317. /* Declaration specifier flags. */
  318. enum {
  319. #define CDSFLAG(name)        CDF_##name = (1u << (CTOK_##name - CTOK_FIRSTDECL)),
  320. CDSDEF(CDSFLAG)
  321. #undef CDSFLAG
  322.   CDF__END
  323. };

  324. #define CDF_SCL  (CDF_TYPEDEF|CDF_EXTERN|CDF_STATIC|CDF_AUTO|CDF_REGISTER)

  325. /* -- C type management --------------------------------------------------- */

  326. #define ctype_ctsG(g)                (mref((g)->ctype_state, CTState))

  327. /* Get C type state. */
  328. static LJ_AINLINE CTState *ctype_cts(lua_State *L)
  329. {
  330.   CTState *cts = ctype_ctsG(G(L));
  331.   cts->L = L;  /* Save L for errors and allocations. */
  332.   return cts;
  333. }

  334. /* Save and restore state of C type table. */
  335. #define LJ_CTYPE_SAVE(cts)        CTState savects_ = *(cts)
  336. #define LJ_CTYPE_RESTORE(cts) \
  337.   ((cts)->top = savects_.top, \
  338.    memcpy((cts)->hash, savects_.hash, sizeof(savects_.hash)))

  339. /* Check C type ID for validity when assertions are enabled. */
  340. static LJ_AINLINE CTypeID ctype_check(CTState *cts, CTypeID id)
  341. {
  342.   lua_assert(id > 0 && id < cts->top); UNUSED(cts);
  343.   return id;
  344. }

  345. /* Get C type for C type ID. */
  346. static LJ_AINLINE CType *ctype_get(CTState *cts, CTypeID id)
  347. {
  348.   return &cts->tab[ctype_check(cts, id)];
  349. }

  350. /* Get C type ID for a C type. */
  351. #define ctype_typeid(cts, ct)        ((CTypeID)((ct) - (cts)->tab))

  352. /* Get child C type. */
  353. static LJ_AINLINE CType *ctype_child(CTState *cts, CType *ct)
  354. {
  355.   lua_assert(!(ctype_isvoid(ct->info) || ctype_isstruct(ct->info) ||
  356.              ctype_isbitfield(ct->info)));  /* These don't have children. */
  357.   return ctype_get(cts, ctype_cid(ct->info));
  358. }

  359. /* Get raw type for a C type ID. */
  360. static LJ_AINLINE CType *ctype_raw(CTState *cts, CTypeID id)
  361. {
  362.   CType *ct = ctype_get(cts, id);
  363.   while (ctype_isattrib(ct->info)) ct = ctype_child(cts, ct);
  364.   return ct;
  365. }

  366. /* Get raw type of the child of a C type. */
  367. static LJ_AINLINE CType *ctype_rawchild(CTState *cts, CType *ct)
  368. {
  369.   do { ct = ctype_child(cts, ct); } while (ctype_isattrib(ct->info));
  370.   return ct;
  371. }

  372. /* Set the name of a C type table element. */
  373. static LJ_AINLINE void ctype_setname(CType *ct, GCstr *s)
  374. {
  375.   /* NOBARRIER: mark string as fixed -- the C type table is never collected. */
  376.   fixstring(s);
  377.   setgcref(ct->name, obj2gco(s));
  378. }

  379. LJ_FUNC CTypeID lj_ctype_new(CTState *cts, CType **ctp);
  380. LJ_FUNC CTypeID lj_ctype_intern(CTState *cts, CTInfo info, CTSize size);
  381. LJ_FUNC void lj_ctype_addname(CTState *cts, CType *ct, CTypeID id);
  382. LJ_FUNC CTypeID lj_ctype_getname(CTState *cts, CType **ctp, GCstr *name,
  383.                                  uint32_t tmask);
  384. LJ_FUNC CType *lj_ctype_getfieldq(CTState *cts, CType *ct, GCstr *name,
  385.                                   CTSize *ofs, CTInfo *qual);
  386. #define lj_ctype_getfield(cts, ct, name, ofs) \
  387.   lj_ctype_getfieldq((cts), (ct), (name), (ofs), NULL)
  388. LJ_FUNC CType *lj_ctype_rawref(CTState *cts, CTypeID id);
  389. LJ_FUNC CTSize lj_ctype_size(CTState *cts, CTypeID id);
  390. LJ_FUNC CTSize lj_ctype_vlsize(CTState *cts, CType *ct, CTSize nelem);
  391. LJ_FUNC CTInfo lj_ctype_info(CTState *cts, CTypeID id, CTSize *szp);
  392. LJ_FUNC cTValue *lj_ctype_meta(CTState *cts, CTypeID id, MMS mm);
  393. LJ_FUNC GCstr *lj_ctype_repr(lua_State *L, CTypeID id, GCstr *name);
  394. LJ_FUNC GCstr *lj_ctype_repr_int64(lua_State *L, uint64_t n, int isunsigned);
  395. LJ_FUNC GCstr *lj_ctype_repr_complex(lua_State *L, void *sp, CTSize size);
  396. LJ_FUNC CTState *lj_ctype_init(lua_State *L);
  397. LJ_FUNC void lj_ctype_freestate(global_State *g);

  398. #endif

  399. #endif