?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
beta-0.89.2
[luatex.git] / source / libs / luajit / LuaJIT-src / src / lj_ctype.c
blob2e23c994bb0587e9d4b5c5bc546c73115b72a8f2
1 /*
2 ** C type management.
3 ** Copyright (C) 2005-2015 Mike Pall. See Copyright Notice in luajit.h
4 */
5
6 #include "lj_obj.h"
7
8 #if LJ_HASFFI
9
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"
17
18 /* -- C type definitions -------------------------------------------------- */
19
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. */
42
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. */
110
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 };
124
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 ;
134
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
141
142 /* -- C type interning ---------------------------------------------------- */
143
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)
147
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 }
176
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 }
203
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 }
211
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 }
219
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 }
236
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 }
264
265 /* -- C type information -------------------------------------------------- */
266
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 }
275
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 }
282
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 }
305
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 }
331
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 }
351
352 /* -- C type representation ----------------------------------------------- */
353
354 /* Fixed max. length of a C type representation. */
355 #define CTREPR_MAX 512
356
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;
365
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 }
377
378 #define ctype_preplit(ctr, str) ctype_prepstr((ctr), "" str, sizeof(str)-1)
379
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 }
386
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 }
396
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 }
403
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 }
415
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 }
422
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 }
437
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 }
534
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 }
550
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 }
568
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 }
586
587 /* -- C type state -------------------------------------------------------- */
588
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 }
622
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 }
634
635 #endif
LuaTeX git mirror