LuaJIT
/
LuaJIT
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

FFI: Add C type management.

master
Mike Pall 2010-12-05 00:11:35 +01:00
parent 8679ca5792
commit 05973ee440
6 changed files with 1041 additions and 12 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/Makefile
View File

@ -327,6 +327,7 @@ LJCORE_O= lj_gc.o lj_err.o lj_char.o lj_bc.o lj_obj.o \
lj_ir.o lj_opt_mem.o lj_opt_fold.o lj_opt_narrow.o \
lj_opt_dce.o lj_opt_loop.o \
lj_mcode.o lj_snap.o lj_record.o lj_asm.o lj_trace.o lj_gdbjit.o \
lj_ctype.o \
lj_lib.o lj_alloc.o lib_aux.o \
$(LJLIB_O) lib_init.o

23
src/Makefile.dep
View File

@ -53,6 +53,8 @@ lj_asm.o: lj_asm.c lj_obj.h lua.h luaconf.h lj_def.h lj_arch.h lj_gc.h \
lj_bc.o: lj_bc.c lj_obj.h lua.h luaconf.h lj_def.h lj_arch.h lj_bc.h \
lj_bcdef.h
lj_char.o: lj_char.c lj_char.h lj_def.h lua.h luaconf.h
lj_ctype.o: lj_ctype.c lj_obj.h lua.h luaconf.h lj_def.h lj_arch.h \
lj_gc.h lj_err.h lj_errmsg.h lj_str.h lj_tab.h lj_ctype.h
lj_dispatch.o: lj_dispatch.c lj_obj.h lua.h luaconf.h lj_def.h lj_arch.h \
lj_err.h lj_errmsg.h lj_state.h lj_frame.h lj_bc.h lj_ff.h lj_ffdef.h \
lj_jit.h lj_ir.h lj_trace.h lj_dispatch.h lj_traceerr.h lj_vm.h luajit.h
@ -109,7 +111,7 @@ lj_snap.o: lj_snap.c lj_obj.h lua.h luaconf.h lj_def.h lj_arch.h lj_gc.h \
lj_dispatch.h lj_traceerr.h lj_snap.h lj_target.h lj_target_*.h
lj_state.o: lj_state.c lj_obj.h lua.h luaconf.h lj_def.h lj_arch.h \
lj_gc.h lj_err.h lj_errmsg.h lj_str.h lj_tab.h lj_func.h lj_meta.h \
lj_state.h lj_frame.h lj_bc.h lj_mcode.h lj_jit.h lj_ir.h lj_trace.h \
lj_state.h lj_frame.h lj_bc.h lj_ctype.h lj_trace.h lj_jit.h lj_ir.h \
lj_dispatch.h lj_traceerr.h lj_vm.h lj_lex.h lj_alloc.h
lj_str.o: lj_str.c lj_obj.h lua.h luaconf.h lj_def.h lj_arch.h lj_gc.h \
lj_err.h lj_errmsg.h lj_str.h lj_state.h lj_char.h
@ -130,13 +132,14 @@ ljamalg.o: ljamalg.c lua.h luaconf.h lauxlib.h lj_gc.c lj_obj.h lj_def.h \
lj_udata.h lj_meta.h lj_state.h lj_frame.h lj_bc.h lj_trace.h lj_jit.h \
lj_ir.h lj_dispatch.h lj_traceerr.h lj_vm.h lj_err.c lj_char.c lj_char.h \
lj_bc.c lj_bcdef.h lj_obj.c lj_str.c lj_tab.c lj_func.c lj_udata.c \
lj_meta.c lj_state.c lj_mcode.h lj_lex.h lj_alloc.h lj_dispatch.c \
lj_meta.c lj_state.c lj_ctype.h lj_lex.h lj_alloc.h lj_dispatch.c \
lj_ff.h lj_ffdef.h luajit.h lj_vmevent.c lj_vmevent.h lj_api.c \
lj_parse.h lj_lex.c lj_parse.c lj_lib.c lj_lib.h lj_ir.c lj_iropt.h \
lj_opt_mem.c lj_opt_fold.c lj_folddef.h lj_opt_narrow.c lj_opt_dce.c \
lj_opt_loop.c lj_snap.h lj_mcode.c lj_snap.c lj_target.h lj_target_*.h \
lj_record.c lj_record.h lj_asm.h lj_recdef.h lj_asm.c lj_trace.c \
lj_gdbjit.h lj_gdbjit.c lj_alloc.c lib_aux.c lib_base.c lualib.h \
lj_libdef.h lib_math.c lib_string.c lib_table.c lib_io.c lib_os.c \
lib_package.c lib_debug.c lib_bit.c lib_jit.c lib_init.c
luajit.o: luajit.c lua.h luaconf.h lauxlib.h lualib.h luajit.h
lj_parse.h lj_lex.c lj_parse.c lj_ctype.c lj_lib.c lj_lib.h lj_ir.c \
lj_iropt.h lj_opt_mem.c lj_opt_fold.c lj_folddef.h lj_opt_narrow.c \
lj_opt_dce.c lj_opt_loop.c lj_snap.h lj_mcode.c lj_mcode.h lj_snap.c \
lj_target.h lj_target_*.h lj_record.c lj_record.h lj_asm.h lj_recdef.h \
lj_asm.c lj_trace.c lj_gdbjit.h lj_gdbjit.c lj_alloc.c lib_aux.c \
lib_base.c lualib.h lj_libdef.h lib_math.c lib_string.c lib_table.c \
lib_io.c lib_os.c lib_package.c lib_debug.c lib_bit.c lib_jit.c \
lib_init.c
luajit.o: luajit.c lua.h luaconf.h lauxlib.h lualib.h luajit.h lj_arch.h

583
src/lj_ctype.c Normal file
View File

@ -0,0 +1,583 @@
/*
** C type management.
** Copyright (C) 2005-2010 Mike Pall. See Copyright Notice in luajit.h
*/
#include "lj_obj.h"
#if LJ_HASFFI
#include "lj_gc.h"
#include "lj_err.h"
#include "lj_str.h"
#include "lj_tab.h"
#include "lj_ctype.h"
/* -- C type definitions -------------------------------------------------- */
/* Predefined typedefs. */
#define CTTDDEF(_) \
/* Vararg handling. */ \
_("va_list", P_VOID) \
_("__builtin_va_list", P_VOID) \
_("__gnuc_va_list", P_VOID) \
/* From stddef.h. */ \
_("ptrdiff_t", INT_PSZ) \
_("size_t", UINT_PSZ) \
_("wchar_t", WCHAR) \
/* Subset of stdint.h. */ \
_("int8_t", INT8) \
_("int16_t", INT16) \
_("int32_t", INT32) \
_("int64_t", INT64) \
_("uint8_t", UINT8) \
_("uint16_t", UINT16) \
_("uint32_t", UINT32) \
_("uint64_t", UINT64) \
_("intptr_t", INT_PSZ) \
_("uintptr_t", UINT_PSZ) \
/* End of typedef list. */
/* Keywords (only the ones we actually care for). */
#define CTKWDEF(_) \
/* Type specifiers. */ \
_("void", -1, CTOK_VOID) \
_("_Bool", 1, CTOK_BOOL) \
_("bool", 1, CTOK_BOOL) \
_("char", 1, CTOK_CHAR) \
_("int", 4, CTOK_INT) \
_("__int8", 1, CTOK_INT) \
_("__int16", 2, CTOK_INT) \
_("__int32", 4, CTOK_INT) \
_("__int64", 8, CTOK_INT) \
_("float", 4, CTOK_FP) \
_("double", 8, CTOK_FP) \
_("long", 0, CTOK_LONG) \
_("short", 0, CTOK_SHORT) \
_("_Complex", 0, CTOK_COMPLEX) \
_("complex", 0, CTOK_COMPLEX) \
_("__complex", 0, CTOK_COMPLEX) \
_("__complex__", 0, CTOK_COMPLEX) \
_("signed", 0, CTOK_SIGNED) \
_("__signed", 0, CTOK_SIGNED) \
_("__signed__", 0, CTOK_SIGNED) \
_("unsigned", 0, CTOK_UNSIGNED) \
/* Type qualifiers. */ \
_("const", 0, CTOK_CONST) \
_("__const", 0, CTOK_CONST) \
_("__const__", 0, CTOK_CONST) \
_("volatile", 0, CTOK_VOLATILE) \
_("__volatile", 0, CTOK_VOLATILE) \
_("__volatile__", 0, CTOK_VOLATILE) \
_("restrict", 0, CTOK_RESTRICT) \
_("__restrict", 0, CTOK_RESTRICT) \
_("__restrict__", 0, CTOK_RESTRICT) \
_("inline", 0, CTOK_INLINE) \
_("__inline", 0, CTOK_INLINE) \
_("__inline__", 0, CTOK_INLINE) \
/* Storage class specifiers. */ \
_("typedef", 0, CTOK_TYPEDEF) \
_("extern", 0, CTOK_EXTERN) \
_("static", 0, CTOK_STATIC) \
_("auto", 0, CTOK_AUTO) \
_("register", 0, CTOK_REGISTER) \
/* GCC Attributes. */ \
_("__extension__", 0, CTOK_EXTENSION) \
_("__attribute", 0, CTOK_ATTRIBUTE) \
_("__attribute__", 0, CTOK_ATTRIBUTE) \
_("asm", 0, CTOK_ASM) \
_("__asm", 0, CTOK_ASM) \
_("__asm__", 0, CTOK_ASM) \
/* MSVC Attributes. */ \
_("__declspec", 0, CTOK_DECLSPEC) \
_("__cdecl", CTCC_CDECL, CTOK_CCDECL) \
_("__thiscall", CTCC_THISCALL, CTOK_CCDECL) \
_("__fastcall", CTCC_FASTCALL, CTOK_CCDECL) \
_("__stdcall", CTCC_STDCALL, CTOK_CCDECL) \
_("__ptr32", 4, CTOK_PTRSZ) \
_("__ptr64", 8, CTOK_PTRSZ) \
/* Other type specifiers. */ \
_("struct", 0, CTOK_STRUCT) \
_("union", 0, CTOK_UNION) \
_("enum", 0, CTOK_ENUM) \
/* Operators. */ \
_("sizeof", 0, CTOK_SIZEOF) \
_("__alignof", 0, CTOK_ALIGNOF) \
_("__alignof__", 0, CTOK_ALIGNOF) \
/* End of keyword list. */
/* Type info for predefined types. Size merged in. */
static CTInfo lj_ctype_typeinfo[] = {
#define CTTYINFODEF(id, sz, ct, info) CTINFO((ct),(((sz)&0x3fu)<<10)+(info)),
#define CTTDINFODEF(name, id) CTINFO(CT_TYPEDEF, CTID_##id),
#define CTKWINFODEF(name, sz, kw) CTINFO(CT_KW,(((sz)&0x3fu)<<10)+(kw)),
CTTYDEF(CTTYINFODEF)
CTTDDEF(CTTDINFODEF)
CTKWDEF(CTKWINFODEF)
#undef CTTYINFODEF
#undef CTTDINFODEF
#undef CTKWINFODEF
0
};
/* Predefined type names collected in a single string. */
static const char * const lj_ctype_typenames =
#define CTTDNAMEDEF(name, id) name "\0"
#define CTKWNAMEDEF(name, sz, cds) name "\0"
CTTDDEF(CTTDNAMEDEF)
CTKWDEF(CTKWNAMEDEF)
#undef CTTDNAMEDEF
#undef CTKWNAMEDEF
;
#define CTTYPEINFO_NUM (sizeof(lj_ctype_typeinfo)/sizeof(CTInfo)-1)
#define CTTYPETAB_MIN 128
/* -- C type interning ---------------------------------------------------- */
#define ct_hashtype(info, size) (hashrot(info, size) & CTHASH_MASK)
#define ct_hashname(name) \
(hashrot(u32ptr(name), u32ptr(name) + HASH_BIAS) & CTHASH_MASK)
/* Create new type element. */
CTypeID lj_ctype_new(CTState *cts, CType **ctp)
{
CTypeID id = cts->top;
CType *ct;
lua_assert(cts->L);
if (LJ_UNLIKELY(id >= cts->sizetab)) {
if (id >= CTID_MAX) lj_err_msg(cts->L, LJ_ERR_TABOV);
lj_mem_growvec(cts->L, cts->tab, cts->sizetab, CTID_MAX, CType);
}
cts->top = id+1;
*ctp = ct = &cts->tab[id];
ct->info = 0;
ct->size = 0;
ct->sib = 0;
ct->next = 0;
setgcrefnull(ct->name);
return id;
}
/* Intern a type element. */
CTypeID lj_ctype_intern(CTState *cts, CTInfo info, CTSize size)
{
uint32_t h = ct_hashtype(info, size);
CTypeID id = cts->hash[h];
lua_assert(cts->L);
while (id) {
CType *ct = ctype_get(cts, id);
if (ct->info == info && ct->size == size)
return id;
id = ct->next;
}
id = cts->top;
if (LJ_UNLIKELY(id >= cts->sizetab)) {
if (id >= CTID_MAX) lj_err_msg(cts->L, LJ_ERR_TABOV);
lj_mem_growvec(cts->L, cts->tab, cts->sizetab, CTID_MAX, CType);
}
cts->top = id+1;
cts->tab[id].info = info;
cts->tab[id].size = size;
cts->tab[id].sib = 0;
cts->tab[id].next = cts->hash[h];
setgcrefnull(cts->tab[id].name);
cts->hash[h] = (CTypeID1)id;
return id;
}
/* Add type element to hash table. */
static void ctype_addtype(CTState *cts, CType *ct, CTypeID id)
{
uint32_t h = ct_hashtype(ct->info, ct->size);
ct->next = cts->hash[h];
cts->hash[h] = (CTypeID1)id;
}
/* Add named element to hash table. */
void lj_ctype_addname(CTState *cts, CType *ct, CTypeID id)
{
uint32_t h = ct_hashname(gcref(ct->name));
ct->next = cts->hash[h];
cts->hash[h] = (CTypeID1)id;
}
/* Get a C type by name, matching the type mask. */
CTypeID lj_ctype_getname(CTState *cts, CType **ctp, GCstr *name, uint32_t tmask)
{
CTypeID id = cts->hash[ct_hashname(name)];
while (id) {
CType *ct = ctype_get(cts, id);
if (gcref(ct->name) == obj2gco(name) &&
((tmask >> ctype_type(ct->info)) & 1)) {
*ctp = ct;
return id;
}
id = ct->next;
}
*ctp = &cts->tab[0]; /* Simplify caller logic. ctype_get() would assert. */
return 0;
}
/* Get a struct/union/enum/function field by name. */
CType *lj_ctype_getfield(CTState *cts, CType *ct, GCstr *name, CTSize *ofs)
{
while (ct->sib) {
ct = ctype_get(cts, ct->sib);
if (gcref(ct->name) == obj2gco(name)) {
*ofs = ct->size;
return ct;
}
if (ctype_isxattrib(ct->info, CTA_SUBTYPE)) {
CType *fct = lj_ctype_getfield(cts, ctype_child(cts, ct), name, ofs);
if (fct) {
*ofs += ct->size;
return fct;
}
}
}
return NULL; /* Not found. */
}
/* -- C type information -------------------------------------------------- */
/* Follow references and get raw type for a C type ID. */
CType *lj_ctype_rawref(CTState *cts, CTypeID id)
{
CType *ct = ctype_get(cts, id);
while (ctype_isattrib(ct->info) || ctype_isref(ct->info))
ct = ctype_child(cts, ct);
return ct;
}
/* Get size for a C type ID. Does NOT support VLA/VLS. */
CTSize lj_ctype_size(CTState *cts, CTypeID id)
{
CType *ct = ctype_raw(cts, id);
return ctype_hassize(ct->info) ? ct->size : CTSIZE_INVALID;
}
/* Get size for a variable-length C type. Does NOT support other C types. */
CTSize lj_ctype_vlsize(CTState *cts, CType *ct, CTSize nelem)
{
uint64_t xsz = 0;
if (ctype_isstruct(ct->info)) {
CTypeID arrid = 0, fid = ct->sib;
xsz = ct->size; /* Add the struct size. */
while (fid) {
CType *ctf = ctype_get(cts, fid);
if (ctype_type(ctf->info) == CT_FIELD)
arrid = ctype_cid(ctf->info); /* Remember last field of VLS. */
fid = ctf->sib;
}
ct = ctype_raw(cts, arrid);
}
lua_assert(ctype_isvlarray(ct->info)); /* Must be a VLA. */
ct = ctype_rawchild(cts, ct); /* Get array element. */
lua_assert(ctype_hassize(ct->info));
/* Calculate actual size of VLA and check for overflow. */
xsz += (uint64_t)ct->size * nelem;
return xsz < 0x80000000u ? (CTSize)xsz : CTSIZE_INVALID;
}
/* Get type, qualifiers, size and alignment for a C type ID. */
CTInfo lj_ctype_info(CTState *cts, CTypeID id, CTSize *szp)
{
CTInfo qual = 0;
CType *ct = ctype_get(cts, id);
for (;;) {
CTInfo info = ct->info;
if (ctype_isenum(info)) {
/* Follow child. Need to look at its attributes, too. */
} else if (ctype_isattrib(info)) {
if (ctype_isxattrib(info, CTA_QUAL))
qual |= ct->size;
else if (ctype_isxattrib(info, CTA_ALIGN) && !(qual & CTFP_ALIGNED))
qual |= CTFP_ALIGNED + CTALIGN(ct->size);
} else {
if (!(qual & CTFP_ALIGNED)) qual |= (info & CTF_ALIGN);
qual |= (info & ~(CTF_ALIGN|CTMASK_CID));
lua_assert(ctype_hassize(info) || ctype_isfunc(info));
*szp = ctype_isfunc(info) ? CTSIZE_INVALID : ct->size;
break;
}
ct = ctype_get(cts, ctype_cid(info));
}
return qual;
}
/* -- C type representation ----------------------------------------------- */
/* Fixed max. length of a C type representation. */
#define CTREPR_MAX 512
typedef struct CTRepr {
char *pb, *pe;
CTState *cts;
lua_State *L;
int needsp;
int ok;
char buf[CTREPR_MAX];
} CTRepr;
/* Prepend string. */
static void ctype_prepstr(CTRepr *ctr, const char *str, MSize len)
{
char *p = ctr->pb;
if (ctr->buf + len+1 > p) { ctr->ok = 0; return; }
if (ctr->needsp) *--p = ' ';
ctr->needsp = 1;
p -= len;
while (len-- > 0) p[len] = str[len];
ctr->pb = p;
}
#define ctype_preplit(ctr, str) ctype_prepstr((ctr), "" str, sizeof(str)-1)
/* Prepend char. */
static void ctype_prepc(CTRepr *ctr, int c)
{
if (ctr->buf >= ctr->pb) { ctr->ok = 0; return; }
*--ctr->pb = c;
}
/* Prepend number. */
static void ctype_prepnum(CTRepr *ctr, uint32_t n)
{
char *p = ctr->pb;
if (ctr->buf + 10+1 > p) { ctr->ok = 0; return; }
do { *--p = (char)('0' + n % 10); } while (n /= 10);
ctr->pb = p;
ctr->needsp = 0;
}
/* Append char. */
static void ctype_appc(CTRepr *ctr, int c)
{
if (ctr->pe >= ctr->buf + CTREPR_MAX) { ctr->ok = 0; return; }
*ctr->pe++ = c;
}
/* Append number. */
static void ctype_appnum(CTRepr *ctr, uint32_t n)
{
char buf[10];
char *p = buf+sizeof(buf);
char *q = ctr->pe;
if (q > ctr->buf + CTREPR_MAX - 10) { ctr->ok = 0; return; }
do { *--p = (char)('0' + n % 10); } while (n /= 10);
do { *q++ = *p++; } while (p < buf+sizeof(buf));
ctr->pe = q;
}
/* Prepend qualifiers. */
static void ctype_prepqual(CTRepr *ctr, CTInfo info)
{
if ((info & CTF_VOLATILE)) ctype_preplit(ctr, "volatile");
if ((info & CTF_CONST)) ctype_preplit(ctr, "const");
}
/* Prepend named type. */
static void ctype_preptype(CTRepr *ctr, CType *ct, CTInfo qual, const char *t)
{
if (gcref(ct->name)) {
GCstr *str = gco2str(gcref(ct->name));
ctype_prepstr(ctr, strdata(str), str->len);
} else {
if (ctr->needsp) ctype_prepc(ctr, ' ');
ctype_prepnum(ctr, ctype_typeid(ctr->cts, ct));
ctr->needsp = 1;
}
ctype_prepstr(ctr, t, (MSize)strlen(t));
ctype_prepqual(ctr, qual);
}
void ctype_repr(CTRepr *ctr, CTypeID id)
{
CType *ct = ctype_get(ctr->cts, id);
CTInfo qual = 0;
int ptrto = 0;
for (;;) {
CTInfo info = ct->info;
CTSize size = ct->size;
switch (ctype_type(info)) {
case CT_NUM:
if ((info & CTF_BOOL)) {
ctype_preplit(ctr, "bool");
} else if ((info & CTF_FP)) {
if (size == sizeof(double)) ctype_preplit(ctr, "double");
else if (size == sizeof(float)) ctype_preplit(ctr, "float");
else ctype_preplit(ctr, "long double");
} else if (size == 1) {
if (!((info ^ CTF_UCHAR) & CTF_UNSIGNED)) ctype_preplit(ctr, "char");
else if (CTF_UCHAR) ctype_preplit(ctr, "signed char");
else ctype_preplit(ctr, "unsigned char");
} else if (size < 8) {
if (size == 4) ctype_preplit(ctr, "int");
else ctype_preplit(ctr, "short");
if ((info & CTF_UNSIGNED)) ctype_preplit(ctr, "unsigned");
} else {
ctype_preplit(ctr, "_t");
ctype_prepnum(ctr, size*8);
ctype_preplit(ctr, "int");
if ((info & CTF_UNSIGNED)) ctype_prepc(ctr, 'u');
}
ctype_prepqual(ctr, (qual|info));
return;
case CT_VOID:
ctype_preplit(ctr, "void");
ctype_prepqual(ctr, (qual|info));
return;
case CT_STRUCT:
ctype_preptype(ctr, ct, qual, (info & CTF_UNION) ? "union" : "struct");
return;
case CT_ENUM:
ctype_preptype(ctr, ct, qual, "enum");
return;
case CT_ATTRIB:
if (ctype_attrib(info) == CTA_QUAL) qual |= size;
break;
case CT_PTR:
if ((info & CTF_REF)) {
ctype_prepc(ctr, '&');
} else {
ctype_prepqual(ctr, (qual|info));
if (LJ_64 && size == 4) ctype_preplit(ctr, "__ptr32");
ctype_prepc(ctr, '*');
}
qual = 0;
ptrto = 1;
ctr->needsp = 1;
break;
case CT_ARRAY:
ctr->needsp = 1;
if (ctype_isrefarray(info)) {
if (ptrto) { ptrto = 0; ctype_prepc(ctr, '('); ctype_appc(ctr, ')'); }
ctype_appc(ctr, '[');
if (size != CTSIZE_INVALID) {
CTSize csize = ctype_child(ctr->cts, ct)->size;
ctype_appnum(ctr, csize ? size/csize : 0);
} else if ((info & CTF_VLA)) {
ctype_appc(ctr, '?');
}
ctype_appc(ctr, ']');
} else if ((info & CTF_COMPLEX)) {
if (size == 2*sizeof(float)) ctype_preplit(ctr, "float");
ctype_preplit(ctr, "complex");
return;
} else {
ctype_preplit(ctr, ")))");
ctype_prepnum(ctr, size);
ctype_preplit(ctr, "__attribute__((vector_size(");
}
break;
case CT_FUNC:
ctr->needsp = 1;
if (ptrto) { ptrto = 0; ctype_prepc(ctr, '('); ctype_appc(ctr, ')'); }
ctype_appc(ctr, '(');
ctype_appc(ctr, ')');
break;
default:
lua_assert(0);
break;
}
ct = ctype_get(ctr->cts, ctype_cid(info));
}
}
/* Return a printable representation of a C type. */
GCstr *lj_ctype_repr(lua_State *L, CTypeID id, GCstr *name)
{
global_State *g = G(L);
CTRepr ctr;
ctr.pb = ctr.pe = &ctr.buf[CTREPR_MAX/2];
ctr.cts = ctype_ctsG(g);
ctr.L = L;
ctr.ok = 1;
ctr.needsp = 0;
if (name) ctype_prepstr(&ctr, strdata(name), name->len);
ctype_repr(&ctr, id);
if (LJ_UNLIKELY(!ctr.ok)) return lj_str_newlit(L, "?");
return lj_str_new(L, ctr.pb, ctr.pe - ctr.pb);
}
/* Convert int64_t/uint64_t to string with 'LL' or 'ULL' suffix. */
GCstr *lj_ctype_repr_int64(lua_State *L, uint64_t n, int isunsigned)
{
char buf[1+20+3];
char *p = buf+sizeof(buf);
int sign = 0;
*--p = 'L'; *--p = 'L';
if (isunsigned) {
*--p = 'U';
} else if ((int64_t)n < 0) {
n = (uint64_t)-(int64_t)n;
sign = 1;
}
do { *--p = (char)('0' + n % 10); } while (n /= 10);
if (sign) *--p = '-';
return lj_str_new(L, p, (size_t)(buf+sizeof(buf)-p));
}
/* Convert complex to string with 'i' or 'I' suffix. */
GCstr *lj_ctype_repr_complex(lua_State *L, void *sp, CTSize size)
{
char buf[2*LUAI_MAXNUMBER2STR+2+1];
TValue re, im;
size_t len;
if (size == 2*sizeof(double)) {
re.n = *(double *)sp; im.n = ((double *)sp)[1];
} else {
re.n = (double)*(float *)sp; im.n = (double)((float *)sp)[1];
}
len = lj_str_bufnum(buf, &re);
if (!(im.u32.hi & 0x80000000u) || im.n != im.n) buf[len++] = '+';
len += lj_str_bufnum(buf+len, &im);
buf[len] = buf[len-1] >= 'a' ? 'I' : 'i';
return lj_str_new(L, buf, len+1);
}
/* -- C type state -------------------------------------------------------- */
/* Initialize C type table and state. */
void lj_ctype_init(lua_State *L)
{
CTState *cts = lj_mem_newt(L, sizeof(CTState), CTState);
CType *ct = lj_mem_newvec(L, CTTYPETAB_MIN, CType);
const char *name = lj_ctype_typenames;
CTypeID id;
memset(cts, 0, sizeof(CTState));
cts->tab = ct;
cts->sizetab = CTTYPETAB_MIN;
cts->top = CTTYPEINFO_NUM;
cts->L = NULL;
cts->g = G(L);
for (id = 0; id < CTTYPEINFO_NUM; id++, ct++) {
CTInfo info = lj_ctype_typeinfo[id];
ct->size = (CTSize)((int32_t)(info << 16) >> 26);
ct->info = info & 0xffff03ffu;
if (ctype_type(info) == CT_KW || ctype_istypedef(info)) {
size_t len = strlen(name);
GCstr *str = lj_str_new(L, name, len);
ctype_setname(ct, str);
name += len+1;
lj_ctype_addname(cts, ct, id);
} else {
setgcrefnull(ct->name);
if (!ctype_isenum(info)) ctype_addtype(cts, ct, id);
}
}
setmref(G(L)->ctype_state, cts);
}
/* Free C type table and state. */
void lj_ctype_freestate(global_State *g)
{
CTState *cts = ctype_ctsG(g);
if (cts) {
lj_mem_freevec(g, cts->tab, cts->sizetab, CType);
lj_mem_freet(g, cts);
}
}
#endif

438
src/lj_ctype.h Normal file
View File

@ -0,0 +1,438 @@
/*
** C type management.
** Copyright (C) 2005-2010 Mike Pall. See Copyright Notice in luajit.h
*/
#ifndef _LJ_CTYPE_H
#define _LJ_CTYPE_H
#include "lj_obj.h"
#include "lj_gc.h"
#if LJ_HASFFI
/* -- C type definitions -------------------------------------------------- */
/* C type numbers. Highest 4 bits of C type info. ORDER CT. */
enum {
/* Externally visible types. */
CT_NUM, /* Integer or floating-point numbers. */
CT_STRUCT, /* Struct or union. */
CT_PTR, /* Pointer or reference. */
CT_ARRAY, /* Array or complex type. */
CT_MAYCONVERT = CT_ARRAY,
CT_VOID, /* Void type. */
CT_ENUM, /* Enumeration. */
CT_HASSIZE = CT_ENUM, /* Last type where ct->size holds the actual size. */
CT_FUNC, /* Function. */
CT_TYPEDEF, /* Typedef. */
CT_ATTRIB, /* Miscellaneous attributes. */
/* Internal element types. */
CT_FIELD, /* Struct/union field or function parameter. */
CT_BITFIELD, /* Struct/union bitfield. */
CT_CONSTVAL, /* Constant value. */
CT_EXTERN, /* External reference. */
CT_KW /* Keyword. */
};
/*
** ---------- info ------------
** |type flags... A cid | size | sib | next | name |
** +----------------------------+--------+-------+-------+-------+--
** |NUM BFvcUL.. A | size | | type | |
** |STRUCT ..vcU..V A | size | field | name? | name? |
** |PTR ..vcR... A cid | size | | type | |
** |ARRAY VCvc...V A cid | size | | type | |
** |VOID ..vc.... A | size | | type | |
** |ENUM A cid | size | const | name? | name? |
** |FUNC ....VS.. cc cid | nargs | field | name? | name? |
** |TYPEDEF cid | | | name | name |
** |ATTRIB attrnum cid | attr | sib? | type? | |
** |FIELD cid | offset | field | | name? |
** |BITFIELD B.vcU csz bsz pos | offset | field | | name? |
** |CONSTVAL c cid | value | const | name | name |
** |EXTERN cid | | | name | name |
** |KW tok | size | | name | name |
** +----------------------------+--------+-------+-------+-------+--
** ^^ ^^--- bits used for C type conversion dispatch
*/
/* C type info flags. TFFArrrr */
#define CTF_BOOL 0x08000000u /* Boolean: NUM, BITFIELD. */
#define CTF_FP 0x04000000u /* Floating-point: NUM. */
#define CTF_CONST 0x02000000u /* Const qualifier. */
#define CTF_VOLATILE 0x01000000u /* Volatile qualifier. */
#define CTF_UNSIGNED 0x00800000u /* Unsigned: NUM, BITFIELD. */
#define CTF_LONG 0x00400000u /* Long: NUM. */
#define CTF_VLA 0x00100000u /* Variable-length: ARRAY, STRUCT. */
#define CTF_REF 0x00800000u /* Reference: PTR. */
#define CTF_VECTOR 0x08000000u /* Vector: ARRAY. */
#define CTF_COMPLEX 0x04000000u /* Complex: ARRAY. */
#define CTF_UNION 0x00800000u /* Union: STRUCT. */
#define CTF_VARARG 0x00800000u /* Vararg: FUNC. */
#define CTF_SSEREGPARM 0x00400000u /* SSE register parameters: FUNC. */
#define CTF_QUAL (CTF_CONST|CTF_VOLATILE)
#define CTF_ALIGN (CTMASK_ALIGN<<CTSHIFT_ALIGN)
#define CTF_UCHAR ((char)-1 > 0 ? CTF_UNSIGNED : 0)
/* Flags used in parser. .F.Ammvf cp->attr */
#define CTFP_ALIGNED 0x00000001u /* cp->attr + ALIGN */
#define CTFP_PACKED 0x00000002u /* cp->attr */
/* ...C...f cp->fattr */
#define CTFP_CCONV 0x00000001u /* cp->fattr + CCONV/[SSE]REGPARM */
/* C type info bitfields. */
#define CTMASK_CID 0x0000ffffu /* Max. 65536 type IDs. */
#define CTMASK_NUM 0xf0000000u /* Max. 16 type numbers. */
#define CTSHIFT_NUM 28
#define CTMASK_ALIGN 15 /* Max. alignment is 2^15. */
#define CTSHIFT_ALIGN 16
#define CTMASK_ATTRIB 255 /* Max. 256 attributes. */
#define CTSHIFT_ATTRIB 16
#define CTMASK_CCONV 3 /* Max. 4 calling conventions. */
#define CTSHIFT_CCONV 16
#define CTMASK_REGPARM 3 /* Max. 0-3 regparms. */
#define CTSHIFT_REGPARM 18
/* Bitfields only used in parser. */
#define CTMASK_VSIZEP 15 /* Max. vector size is 2^15. */
#define CTSHIFT_VSIZEP 4
#define CTMASK_MSIZEP 255 /* Max. type size (via mode) is 128. */
#define CTSHIFT_MSIZEP 8
/* Info bits for BITFIELD. Max. size of bitfield is 64 bits. */
#define CTBSZ_MAX 32 /* Max. size of bitfield is 32 bit. */
#define CTBSZ_FIELD 127 /* Temp. marker for regular field. */
#define CTMASK_BITPOS 127
#define CTMASK_BITBSZ 127
#define CTMASK_BITCSZ 127
#define CTSHIFT_BITPOS 0
#define CTSHIFT_BITBSZ 8
#define CTSHIFT_BITCSZ 16
#define CTF_INSERT(info, field, val) \
info = (info & ~(CTMASK_##field<<CTSHIFT_##field)) | \
(((CTSize)(val) & CTMASK_##field) << CTSHIFT_##field)
/* Calling conventions. */
enum { CTCC_CDECL, CTCC_THISCALL, CTCC_FASTCALL, CTCC_STDCALL };
/* Attribute numbers. */
enum {
CTA_NONE, /* Ignored attribute. Must be zero. */
CTA_QUAL, /* Unmerged qualifiers. */
CTA_ALIGN, /* Alignment override. */
CTA_SUBTYPE, /* Transparent sub-type. */
CTA_BAD, /* To catch bad IDs. */
CTA__MAX
};
/* Special sizes. */
#define CTSIZE_INVALID 0xffffffffu
typedef uint32_t CTInfo; /* Type info. */
typedef uint32_t CTSize; /* Type size. */
typedef uint32_t CTypeID; /* Type ID. */
typedef uint16_t CTypeID1; /* Minimum-sized type ID. */
/* C type table element. */
typedef struct CType {
CTInfo info; /* Type info. */
CTSize size; /* Type size or other info. */
CTypeID1 sib; /* Sibling element. */
CTypeID1 next; /* Next element in hash chain. */
GCRef name; /* Element name (GCstr). */
} CType;
#define CTHASH_SIZE 128 /* Number of hash anchors. */
#define CTHASH_MASK (CTHASH_SIZE-1)
/* C type state. */
typedef struct CTState {
CType *tab; /* C type table. */
CTypeID top; /* Current top of C type table. */
MSize sizetab; /* Size of C type table. */
lua_State *L; /* Lua state (needed for errors and allocations). */
global_State *g; /* Global state. */
CTypeID1 hash[CTHASH_SIZE]; /* Hash anchors for C type table. */
} CTState;
#define CTINFO(ct, flags) (((CTInfo)(ct) << CTSHIFT_NUM) + (flags))
#define CTALIGN(al) ((CTSize)(al) << CTSHIFT_ALIGN)
#define CTATTRIB(at) ((CTInfo)(at) << CTSHIFT_ATTRIB)
#define ctype_type(info) ((info) >> CTSHIFT_NUM)
#define ctype_cid(info) ((CTypeID)((info) & CTMASK_CID))
#define ctype_align(info) (((info) >> CTSHIFT_ALIGN) & CTMASK_ALIGN)
#define ctype_attrib(info) (((info) >> CTSHIFT_ATTRIB) & CTMASK_ATTRIB)
#define ctype_bitpos(info) (((info) >> CTSHIFT_BITPOS) & CTMASK_BITPOS)
#define ctype_bitbsz(info) (((info) >> CTSHIFT_BITBSZ) & CTMASK_BITBSZ)
#define ctype_bitcsz(info) (((info) >> CTSHIFT_BITCSZ) & CTMASK_BITCSZ)
#define ctype_vsizeP(info) (((info) >> CTSHIFT_VSIZEP) & CTMASK_VSIZEP)
#define ctype_msizeP(info) (((info) >> CTSHIFT_MSIZEP) & CTMASK_MSIZEP)
/* Simple type checks. */
#define ctype_isnum(info) (ctype_type((info)) == CT_NUM)
#define ctype_isvoid(info) (ctype_type((info)) == CT_VOID)
#define ctype_isptr(info) (ctype_type((info)) == CT_PTR)
#define ctype_isarray(info) (ctype_type((info)) == CT_ARRAY)
#define ctype_isstruct(info) (ctype_type((info)) == CT_STRUCT)
#define ctype_isfunc(info) (ctype_type((info)) == CT_FUNC)
#define ctype_isenum(info) (ctype_type((info)) == CT_ENUM)
#define ctype_istypedef(info) (ctype_type((info)) == CT_TYPEDEF)
#define ctype_isattrib(info) (ctype_type((info)) == CT_ATTRIB)
#define ctype_isfield(info) (ctype_type((info)) == CT_FIELD)
#define ctype_isbitfield(info) (ctype_type((info)) == CT_BITFIELD)
#define ctype_isconstval(info) (ctype_type((info)) == CT_CONSTVAL)
#define ctype_hassize(info) (ctype_type((info)) <= CT_HASSIZE)
/* Combined type and flag checks. */
#define ctype_isinteger(info) \
(((info) & (CTMASK_NUM|CTF_BOOL|CTF_FP)) == CTINFO(CT_NUM, 0))
#define ctype_isinteger_or_bool(info) \
(((info) & (CTMASK_NUM|CTF_FP)) == CTINFO(CT_NUM, 0))
#define ctype_isbool(info) \
(((info) & (CTMASK_NUM|CTF_BOOL)) == CTINFO(CT_NUM, CTF_BOOL))
#define ctype_isconstchar(ct) \
(((ct)->info & (CTMASK_NUM|CTF_CONST|CTF_BOOL|CTF_FP)) == \
CTINFO(CT_NUM, CTF_CONST) && (ct)->size == 1)
#define ctype_ispointer(info) \
((ctype_type(info) >> 1) == (CT_PTR >> 1)) /* Pointer or array. */
#define ctype_isref(info) \
(((info) & (CTMASK_NUM|CTF_REF)) == CTINFO(CT_PTR, CTF_REF))
#define ctype_isrefarray(info) \
(((info) & (CTMASK_NUM|CTF_VECTOR|CTF_COMPLEX)) == CTINFO(CT_ARRAY, 0))
#define ctype_isvalarray(info) \
(ctype_isarray(info) && (info & (CTF_VECTOR|CTF_COMPLEX)))
#define ctype_isvector(info) \
(((info) & (CTMASK_NUM|CTF_VECTOR)) == CTINFO(CT_ARRAY, CTF_VECTOR))
#define ctype_iscomplex(info) \
(((info) & (CTMASK_NUM|CTF_COMPLEX)) == CTINFO(CT_ARRAY, CTF_COMPLEX))
#define ctype_isvltype(info) \
(((info) & ((CTMASK_NUM|CTF_VLA) - (2u<<CTSHIFT_NUM))) == \
CTINFO(CT_STRUCT, CTF_VLA)) /* VL array or VL struct. */
#define ctype_isvlarray(info) \
(((info) & (CTMASK_NUM|CTF_VLA)) == CTINFO(CT_ARRAY, CTF_VLA))
#define ctype_isvlstruct(info) \
(((info) & (CTMASK_NUM|CTF_VLA)) == CTINFO(CT_STRUCT, CTF_VLA))
#define ctype_isxattrib(info, at) \
(((info) & (CTMASK_NUM|CTATTRIB(CTMASK_ATTRIB))) == \
CTINFO(CT_ATTRIB, CTATTRIB(at)))
LJ_STATIC_ASSERT(((int)CT_PTR & (int)CT_ARRAY) == CT_PTR);
LJ_STATIC_ASSERT(((int)CT_STRUCT & (int)CT_ARRAY) == CT_STRUCT);
/* Target-dependent sizes and alignments. */
#if LJ_64
#define CTSIZE_PTR 8
#define CTALIGN_PTR CTALIGN(3)
#else
#define CTSIZE_PTR 4
#define CTALIGN_PTR CTALIGN(2)
#endif
#define CTINFO_REF(ref) \
CTINFO(CT_PTR, (CTF_CONST|CTF_REF|CTALIGN_PTR) + (ref))
#define CT_MEMALIGN 3 /* Alignment guaranteed by memory allocator. */
/* -- Predefined types ---------------------------------------------------- */
/* Target-dependent types. */
#if LJ_TARGET_PPC
#define CTTYDEFP(_) \
_(LINT32, 4, CT_NUM, CTF_LONG|CTALIGN(2))
#else
#define CTTYDEFP(_)
#endif
/* Common types. */
#define CTTYDEF(_) \
_(NONE, 0, CT_ATTRIB, CTATTRIB(CTA_BAD)) \
_(VOID, -1, CT_VOID, CTALIGN(0)) \
_(CVOID, -1, CT_VOID, CTF_CONST|CTALIGN(0)) \
_(BOOL, 1, CT_NUM, CTF_BOOL|CTF_UNSIGNED|CTALIGN(0)) \
_(CCHAR, 1, CT_NUM, CTF_CONST|CTF_UCHAR|CTALIGN(0)) \
_(INT8, 1, CT_NUM, CTALIGN(0)) \
_(UINT8, 1, CT_NUM, CTF_UNSIGNED|CTALIGN(0)) \
_(INT16, 2, CT_NUM, CTALIGN(1)) \
_(UINT16, 2, CT_NUM, CTF_UNSIGNED|CTALIGN(1)) \
_(INT32, 4, CT_NUM, CTALIGN(2)) \
_(UINT32, 4, CT_NUM, CTF_UNSIGNED|CTALIGN(2)) \
_(INT64, 8, CT_NUM, CTF_LONG|CTALIGN(3)) \
_(UINT64, 8, CT_NUM, CTF_UNSIGNED|CTF_LONG|CTALIGN(3)) \
_(FLOAT, 4, CT_NUM, CTF_FP|CTALIGN(2)) \
_(DOUBLE, 8, CT_NUM, CTF_FP|CTALIGN(3)) \
_(COMPLEX_FLOAT, 8, CT_ARRAY, CTF_COMPLEX|CTALIGN(2)|CTID_FLOAT) \
_(COMPLEX_DOUBLE, 16, CT_ARRAY, CTF_COMPLEX|CTALIGN(3)|CTID_DOUBLE) \
_(P_VOID, CTSIZE_PTR, CT_PTR, CTALIGN_PTR|CTID_VOID) \
_(P_CVOID, CTSIZE_PTR, CT_PTR, CTALIGN_PTR|CTID_CVOID) \
_(P_CCHAR, CTSIZE_PTR, CT_PTR, CTALIGN_PTR|CTID_CCHAR) \
_(A_CCHAR, -1, CT_ARRAY, CTF_CONST|CTALIGN(0)|CTID_CCHAR) \
_(CTYPEID, 4, CT_ENUM, CTALIGN(2)|CTID_INT32) \
CTTYDEFP(_) \
/* End of type list. */
/* Public predefined type IDs. */
enum {
#define CTTYIDDEF(id, sz, ct, info) CTID_##id,
CTTYDEF(CTTYIDDEF)
#undef CTTYIDDEF
/* Predefined typedefs and keywords follow. */
CTID_MAX = 65536
};
/* Target-dependent type IDs. */
#if LJ_64
#define CTID_INT_PSZ CTID_INT64
#define CTID_UINT_PSZ CTID_UINT64
#else
#define CTID_INT_PSZ CTID_INT32
#define CTID_UINT_PSZ CTID_UINT32
#endif
#if LJ_ABI_WIN
#define CTID_WCHAR CTID_UINT16
#elif LJ_TARGET_PPC
#define CTID_WCHAR CTID_LINT32
#else
#define CTID_WCHAR CTID_INT32
#endif
/* -- C tokens and keywords ----------------------------------------------- */
/* C lexer keywords. */
#define CTOKDEF(_) \
_(IDENT, "<identifier>") _(STRING, "<string>") \
_(INTEGER, "<integer>") _(EOF, "<eof>") \
_(OROR, "||") _(ANDAND, "&&") _(EQ, "==") _(NE, "!=") \
_(LE, "<=") _(GE, ">=") _(SHL, "<<") _(SHR, ">>") _(DEREF, "->")
/* Simple declaration specifiers. */
#define CDSDEF(_) \
_(VOID) _(BOOL) _(CHAR) _(INT) _(FP) \
_(LONG) _(LONGLONG) _(SHORT) _(COMPLEX) _(SIGNED) _(UNSIGNED) \
_(CONST) _(VOLATILE) _(RESTRICT) _(INLINE) \
_(TYPEDEF) _(EXTERN) _(STATIC) _(AUTO) _(REGISTER)
/* C keywords. */
#define CKWDEF(_) \
CDSDEF(_) _(EXTENSION) _(ASM) _(ATTRIBUTE) \
_(DECLSPEC) _(CCDECL) _(PTRSZ) \
_(STRUCT) _(UNION) _(ENUM) \
_(SIZEOF) _(ALIGNOF)
/* C token numbers. */
enum {
CTOK_OFS = 255,
#define CTOKNUM(name, sym) CTOK_##name,
#define CKWNUM(name) CTOK_##name,
CTOKDEF(CTOKNUM)
CKWDEF(CKWNUM)
#undef CTOKNUM
#undef CKWNUM
CTOK_FIRSTDECL = CTOK_VOID,
CTOK_FIRSTSCL = CTOK_TYPEDEF,
CTOK_LASTDECLFLAG = CTOK_REGISTER,
CTOK_LASTDECL = CTOK_ENUM
};
/* Declaration specifier flags. */
enum {
#define CDSFLAG(name) CDF_##name = (1u << (CTOK_##name - CTOK_FIRSTDECL)),
CDSDEF(CDSFLAG)
#undef CDSFLAG
CDF__END
};
#define CDF_SCL (CDF_TYPEDEF|CDF_EXTERN|CDF_STATIC|CDF_AUTO|CDF_REGISTER)
/* -- C type management --------------------------------------------------- */
#define ctype_ctsG(g) (mref((g)->ctype_state, CTState))
/* Get C type state. */
static LJ_AINLINE CTState *ctype_cts(lua_State *L)
{
CTState *cts = ctype_ctsG(G(L));
cts->L = L; /* Save L for errors and allocations. */
return cts;
}
/* Save and restore state of C type table. */
#define LJ_CTYPE_SAVE(cts) CTState savects_ = *(cts)
#define LJ_CTYPE_RESTORE(cts) \
((cts)->top = savects_.top, \
memcpy((cts)->hash, savects_.hash, sizeof(savects_.hash)))
/* Check C type ID for validity when assertions are enabled. */
static LJ_AINLINE CTypeID ctype_check(CTState *cts, CTypeID id)
{
lua_assert(id > 0 && id < cts->top); UNUSED(cts);
return id;
}
/* Get C type for C type ID. */
static LJ_AINLINE CType *ctype_get(CTState *cts, CTypeID id)
{
return &cts->tab[ctype_check(cts, id)];
}
/* Get C type ID for a C type. */
#define ctype_typeid(cts, ct) ((CTypeID)((ct) - (cts)->tab))
/* Get child C type. */
static LJ_AINLINE CType *ctype_child(CTState *cts, CType *ct)
{
lua_assert(!(ctype_isvoid(ct->info) || ctype_isstruct(ct->info) ||
ctype_isbitfield(ct->info))); /* These don't have children. */
return ctype_get(cts, ctype_cid(ct->info));
}
/* Get raw type for a C type ID. */
static LJ_AINLINE CType *ctype_raw(CTState *cts, CTypeID id)
{
CType *ct = ctype_get(cts, id);
while (ctype_isattrib(ct->info)) ct = ctype_child(cts, ct);
return ct;
}
/* Get raw type of the child of a C type. */
static LJ_AINLINE CType *ctype_rawchild(CTState *cts, CType *ct)
{
do { ct = ctype_child(cts, ct); } while (ctype_isattrib(ct->info));
return ct;
}
/* Set the name of a C type table element. */
static LJ_AINLINE void ctype_setname(CType *ct, GCstr *s)
{
/* NOBARRIER: mark string as fixed -- the C type table is never collected. */
fixstring(s);
setgcref(ct->name, obj2gco(s));
}
LJ_FUNC CTypeID lj_ctype_new(CTState *cts, CType **ctp);
LJ_FUNC CTypeID lj_ctype_intern(CTState *cts, CTInfo info, CTSize size);
LJ_FUNC void lj_ctype_addname(CTState *cts, CType *ct, CTypeID id);
LJ_FUNC CTypeID lj_ctype_getname(CTState *cts, CType **ctp, GCstr *name,
uint32_t tmask);
LJ_FUNC CType *lj_ctype_getfield(CTState *cts, CType *ct, GCstr *name,
CTSize *ofs);
LJ_FUNC CType *lj_ctype_rawref(CTState *cts, CTypeID id);
LJ_FUNC CTSize lj_ctype_size(CTState *cts, CTypeID id);
LJ_FUNC CTSize lj_ctype_vlsize(CTState *cts, CType *ct, CTSize nelem);
LJ_FUNC CTInfo lj_ctype_info(CTState *cts, CTypeID id, CTSize *szp);
LJ_FUNC GCstr *lj_ctype_repr(lua_State *L, CTypeID id, GCstr *name);
LJ_FUNC GCstr *lj_ctype_repr_int64(lua_State *L, uint64_t n, int isunsigned);
LJ_FUNC GCstr *lj_ctype_repr_complex(lua_State *L, void *sp, CTSize size);
LJ_FUNC void lj_ctype_init(lua_State *L);
LJ_FUNC void lj_ctype_freestate(global_State *g);
#endif
#endif

7
src/lj_state.c
View File

@ -18,8 +18,8 @@
#include "lj_meta.h"
#include "lj_state.h"
#include "lj_frame.h"
#if LJ_HASJIT
#include "lj_mcode.h"
#if LJ_HASFFI
#include "lj_ctype.h"
#endif
#include "lj_trace.h"
#include "lj_dispatch.h"
@ -160,6 +160,9 @@ static void close_state(lua_State *L)
lua_assert(gcref(g->gc.root) == obj2gco(L));
lua_assert(g->strnum == 0);
lj_trace_freestate(g);
#if LJ_HASFFI
lj_ctype_freestate(g);
#endif
lj_mem_freevec(g, g->strhash, g->strmask+1, GCRef);
lj_str_freebuf(g, &g->tmpbuf);
lj_mem_freevec(g, tvref(L->stack), L->stacksize, TValue);

1
src/ljamalg.c
View File

@ -40,6 +40,7 @@
#include "lj_api.c"
#include "lj_lex.c"
#include "lj_parse.c"
#include "lj_ctype.c"
#include "lj_lib.c"
#include "lj_ir.c"
#include "lj_opt_mem.c"