1/* BEGIN CSTYLED */
2/*
3** $Id: lobject.h,v 2.71.1.2 2014/05/07 14:14:58 roberto Exp $
4** Type definitions for Lua objects
5** See Copyright Notice in lua.h
6*/
7
8
9#ifndef lobject_h
10#define lobject_h
11
12
13#include "llimits.h"
14#include <sys/lua/lua.h>
15
16
17/*
18** Extra tags for non-values
19*/
20#define LUA_TPROTO	LUA_NUMTAGS
21#define LUA_TUPVAL	(LUA_NUMTAGS+1)
22#define LUA_TDEADKEY	(LUA_NUMTAGS+2)
23
24/*
25** number of all possible tags (including LUA_TNONE but excluding DEADKEY)
26*/
27#define LUA_TOTALTAGS	(LUA_TUPVAL+2)
28
29
30/*
31** tags for Tagged Values have the following use of bits:
32** bits 0-3: actual tag (a LUA_T* value)
33** bits 4-5: variant bits
34** bit 6: whether value is collectable
35*/
36
37#define VARBITS		(3 << 4)
38
39
40/*
41** LUA_TFUNCTION variants:
42** 0 - Lua function
43** 1 - light C function
44** 2 - regular C function (closure)
45*/
46
47/* Variant tags for functions */
48#define LUA_TLCL	(LUA_TFUNCTION | (0 << 4))  /* Lua closure */
49#define LUA_TLCF	(LUA_TFUNCTION | (1 << 4))  /* light C function */
50#define LUA_TCCL	(LUA_TFUNCTION | (2 << 4))  /* C closure */
51
52
53/* Variant tags for strings */
54#define LUA_TSHRSTR	(LUA_TSTRING | (0 << 4))  /* short strings */
55#define LUA_TLNGSTR	(LUA_TSTRING | (1 << 4))  /* long strings */
56
57
58/* Bit mark for collectable types */
59#define BIT_ISCOLLECTABLE	(1 << 6)
60
61/* mark a tag as collectable */
62#define ctb(t)			((t) | BIT_ISCOLLECTABLE)
63
64
65/*
66** Union of all collectable objects
67*/
68typedef union GCObject GCObject;
69
70
71/*
72** Common Header for all collectable objects (in macro form, to be
73** included in other objects)
74*/
75#define CommonHeader	GCObject *next; lu_byte tt; lu_byte marked
76
77
78/*
79** Common header in struct form
80*/
81typedef struct GCheader {
82  CommonHeader;
83} GCheader;
84
85
86
87/*
88** Union of all Lua values
89*/
90typedef union Value Value;
91
92
93#define numfield	lua_Number n;    /* numbers */
94
95
96
97/*
98** Tagged Values. This is the basic representation of values in Lua,
99** an actual value plus a tag with its type.
100*/
101
102#define TValuefields	Value value_; int tt_
103
104typedef struct lua_TValue TValue;
105
106
107/* macro defining a nil value */
108#define NILCONSTANT	{NULL}, LUA_TNIL
109
110
111#define val_(o)		((o)->value_)
112#define num_(o)		(val_(o).n)
113
114
115/* raw type tag of a TValue */
116#define rttype(o)	((o)->tt_)
117
118/* tag with no variants (bits 0-3) */
119#define novariant(x)	((x) & 0x0F)
120
121/* type tag of a TValue (bits 0-3 for tags + variant bits 4-5) */
122#define ttype(o)	(rttype(o) & 0x3F)
123
124/* type tag of a TValue with no variants (bits 0-3) */
125#define ttypenv(o)	(novariant(rttype(o)))
126
127
128/* Macros to test type */
129#define checktag(o,t)		(rttype(o) == (t))
130#define checktype(o,t)		(ttypenv(o) == (t))
131#define ttisnumber(o)		checktag((o), LUA_TNUMBER)
132#define ttisnil(o)		checktag((o), LUA_TNIL)
133#define ttisboolean(o)		checktag((o), LUA_TBOOLEAN)
134#define ttislightuserdata(o)	checktag((o), LUA_TLIGHTUSERDATA)
135#define ttisstring(o)		checktype((o), LUA_TSTRING)
136#define ttisshrstring(o)	checktag((o), ctb(LUA_TSHRSTR))
137#define ttislngstring(o)	checktag((o), ctb(LUA_TLNGSTR))
138#define ttistable(o)		checktag((o), ctb(LUA_TTABLE))
139#define ttisfunction(o)		checktype(o, LUA_TFUNCTION)
140#define ttisclosure(o)		((rttype(o) & 0x1F) == LUA_TFUNCTION)
141#define ttisCclosure(o)		checktag((o), ctb(LUA_TCCL))
142#define ttisLclosure(o)		checktag((o), ctb(LUA_TLCL))
143#define ttislcf(o)		checktag((o), LUA_TLCF)
144#define ttisuserdata(o)		checktag((o), ctb(LUA_TUSERDATA))
145#define ttisthread(o)		checktag((o), ctb(LUA_TTHREAD))
146#define ttisdeadkey(o)		checktag((o), LUA_TDEADKEY)
147
148#define ttisequal(o1,o2)	(rttype(o1) == rttype(o2))
149
150/* Macros to access values */
151#define nvalue(o)	check_exp(ttisnumber(o), num_(o))
152#define gcvalue(o)	check_exp(iscollectable(o), val_(o).gc)
153#define pvalue(o)	check_exp(ttislightuserdata(o), val_(o).p)
154#define rawtsvalue(o)	check_exp(ttisstring(o), &val_(o).gc->ts)
155#define tsvalue(o)	(&rawtsvalue(o)->tsv)
156#define rawuvalue(o)	check_exp(ttisuserdata(o), &val_(o).gc->u)
157#define uvalue(o)	(&rawuvalue(o)->uv)
158#define clvalue(o)	check_exp(ttisclosure(o), &val_(o).gc->cl)
159#define clLvalue(o)	check_exp(ttisLclosure(o), &val_(o).gc->cl.l)
160#define clCvalue(o)	check_exp(ttisCclosure(o), &val_(o).gc->cl.c)
161#define fvalue(o)	check_exp(ttislcf(o), val_(o).f)
162#define hvalue(o)	check_exp(ttistable(o), &val_(o).gc->h)
163#define bvalue(o)	check_exp(ttisboolean(o), val_(o).b)
164#define thvalue(o)	check_exp(ttisthread(o), &val_(o).gc->th)
165/* a dead value may get the 'gc' field, but cannot access its contents */
166#define deadvalue(o)	check_exp(ttisdeadkey(o), cast(void *, val_(o).gc))
167
168#define l_isfalse(o)	(ttisnil(o) || (ttisboolean(o) && bvalue(o) == 0))
169
170
171#define iscollectable(o)	(rttype(o) & BIT_ISCOLLECTABLE)
172
173
174/* Macros for internal tests */
175#define righttt(obj)		(ttype(obj) == gcvalue(obj)->gch.tt)
176
177#define checkliveness(g,obj) \
178	lua_longassert(!iscollectable(obj) || \
179			(righttt(obj) && !isdead(g,gcvalue(obj))))
180
181
182/* Macros to set values */
183#define settt_(o,t)	((o)->tt_=(t))
184
185#define setnvalue(obj,x) \
186  { TValue *io=(obj); num_(io)=(x); settt_(io, LUA_TNUMBER); }
187
188#define setnilvalue(obj) settt_(obj, LUA_TNIL)
189
190#define setfvalue(obj,x) \
191  { TValue *io=(obj); val_(io).f=(x); settt_(io, LUA_TLCF); }
192
193#define setpvalue(obj,x) \
194  { TValue *io=(obj); val_(io).p=(x); settt_(io, LUA_TLIGHTUSERDATA); }
195
196#define setbvalue(obj,x) \
197  { TValue *io=(obj); val_(io).b=(x); settt_(io, LUA_TBOOLEAN); }
198
199#define setgcovalue(L,obj,x) \
200  { TValue *io=(obj); GCObject *i_g=(x); \
201    val_(io).gc=i_g; settt_(io, ctb(gch(i_g)->tt)); }
202
203#define setsvalue(L,obj,x) \
204  { TValue *io=(obj); \
205    TString *x_ = (x); \
206    val_(io).gc=cast(GCObject *, x_); settt_(io, ctb(x_->tsv.tt)); \
207    checkliveness(G(L),io); }
208
209#define setuvalue(L,obj,x) \
210  { TValue *io=(obj); \
211    val_(io).gc=cast(GCObject *, (x)); settt_(io, ctb(LUA_TUSERDATA)); \
212    checkliveness(G(L),io); }
213
214#define setthvalue(L,obj,x) \
215  { TValue *io=(obj); \
216    val_(io).gc=cast(GCObject *, (x)); settt_(io, ctb(LUA_TTHREAD)); \
217    checkliveness(G(L),io); }
218
219#define setclLvalue(L,obj,x) \
220  { TValue *io=(obj); \
221    val_(io).gc=cast(GCObject *, (x)); settt_(io, ctb(LUA_TLCL)); \
222    checkliveness(G(L),io); }
223
224#define setclCvalue(L,obj,x) \
225  { TValue *io=(obj); \
226    val_(io).gc=cast(GCObject *, (x)); settt_(io, ctb(LUA_TCCL)); \
227    checkliveness(G(L),io); }
228
229#define sethvalue(L,obj,x) \
230  { TValue *io=(obj); \
231    val_(io).gc=cast(GCObject *, (x)); settt_(io, ctb(LUA_TTABLE)); \
232    checkliveness(G(L),io); }
233
234#define setdeadvalue(obj)	settt_(obj, LUA_TDEADKEY)
235
236
237
238#define setobj(L,obj1,obj2) \
239	{ const TValue *io2=(obj2); TValue *io1=(obj1); \
240	  io1->value_ = io2->value_; io1->tt_ = io2->tt_; \
241	  checkliveness(G(L),io1); }
242
243
244/*
245** different types of assignments, according to destination
246*/
247
248/* from stack to (same) stack */
249#define setobjs2s	setobj
250/* to stack (not from same stack) */
251#define setobj2s	setobj
252#define setsvalue2s	setsvalue
253#define sethvalue2s	sethvalue
254#define setptvalue2s	setptvalue
255/* from table to same table */
256#define setobjt2t	setobj
257/* to table */
258#define setobj2t	setobj
259/* to new object */
260#define setobj2n	setobj
261#define setsvalue2n	setsvalue
262
263
264/* check whether a number is valid (useful only for NaN trick) */
265#define luai_checknum(L,o,c)	{ /* empty */ }
266
267
268/*
269** {======================================================
270** NaN Trick
271** =======================================================
272*/
273#if defined(LUA_NANTRICK)
274
275/*
276** numbers are represented in the 'd_' field. All other values have the
277** value (NNMARK | tag) in 'tt__'. A number with such pattern would be
278** a "signaled NaN", which is never generated by regular operations by
279** the CPU (nor by 'strtod')
280*/
281
282/* allows for external implementation for part of the trick */
283#if !defined(NNMARK)	/* { */
284
285
286#if !defined(LUA_IEEEENDIAN)
287#error option 'LUA_NANTRICK' needs 'LUA_IEEEENDIAN'
288#endif
289
290
291#define NNMARK		0x7FF7A500
292#define NNMASK		0x7FFFFF00
293
294#undef TValuefields
295#undef NILCONSTANT
296
297#if (LUA_IEEEENDIAN == 0)	/* { */
298
299/* little endian */
300#define TValuefields  \
301	union { struct { Value v__; int tt__; } i; double d__; } u
302#define NILCONSTANT	{{{NULL}, tag2tt(LUA_TNIL)}}
303/* field-access macros */
304#define v_(o)		((o)->u.i.v__)
305#define d_(o)		((o)->u.d__)
306#define tt_(o)		((o)->u.i.tt__)
307
308#else				/* }{ */
309
310/* big endian */
311#define TValuefields  \
312	union { struct { int tt__; Value v__; } i; double d__; } u
313#define NILCONSTANT	{{tag2tt(LUA_TNIL), {NULL}}}
314/* field-access macros */
315#define v_(o)		((o)->u.i.v__)
316#define d_(o)		((o)->u.d__)
317#define tt_(o)		((o)->u.i.tt__)
318
319#endif				/* } */
320
321#endif			/* } */
322
323
324/* correspondence with standard representation */
325#undef val_
326#define val_(o)		v_(o)
327#undef num_
328#define num_(o)		d_(o)
329
330
331#undef numfield
332#define numfield	/* no such field; numbers are the entire struct */
333
334/* basic check to distinguish numbers from non-numbers */
335#undef ttisnumber
336#define ttisnumber(o)	((tt_(o) & NNMASK) != NNMARK)
337
338#define tag2tt(t)	(NNMARK | (t))
339
340#undef rttype
341#define rttype(o)	(ttisnumber(o) ? LUA_TNUMBER : tt_(o) & 0xff)
342
343#undef settt_
344#define settt_(o,t)	(tt_(o) = tag2tt(t))
345
346#undef setnvalue
347#define setnvalue(obj,x) \
348	{ TValue *io_=(obj); num_(io_)=(x); lua_assert(ttisnumber(io_)); }
349
350#undef setobj
351#define setobj(L,obj1,obj2) \
352	{ const TValue *o2_=(obj2); TValue *o1_=(obj1); \
353	  o1_->u = o2_->u; \
354	  checkliveness(G(L),o1_); }
355
356
357/*
358** these redefinitions are not mandatory, but these forms are more efficient
359*/
360
361#undef checktag
362#undef checktype
363#define checktag(o,t)	(tt_(o) == tag2tt(t))
364#define checktype(o,t)	(ctb(tt_(o) | VARBITS) == ctb(tag2tt(t) | VARBITS))
365
366#undef ttisequal
367#define ttisequal(o1,o2)  \
368	(ttisnumber(o1) ? ttisnumber(o2) : (tt_(o1) == tt_(o2)))
369
370
371#undef luai_checknum
372#define luai_checknum(L,o,c)	{ if (!ttisnumber(o)) c; }
373
374#endif
375/* }====================================================== */
376
377
378
379/*
380** {======================================================
381** types and prototypes
382** =======================================================
383*/
384
385
386union Value {
387  GCObject *gc;    /* collectable objects */
388  void *p;         /* light userdata */
389  int b;           /* booleans */
390  lua_CFunction f; /* light C functions */
391  numfield         /* numbers */
392};
393
394
395struct lua_TValue {
396  TValuefields;
397};
398
399
400typedef TValue *StkId;  /* index to stack elements */
401
402
403
404
405/*
406** Header for string value; string bytes follow the end of this structure
407*/
408typedef union TString {
409  L_Umaxalign dummy;  /* ensures maximum alignment for strings */
410  struct {
411    CommonHeader;
412    lu_byte extra;  /* reserved words for short strings; "has hash" for longs */
413    unsigned int hash;
414    size_t len;  /* number of characters in string */
415  } tsv;
416} TString;
417
418
419/* get the actual string (array of bytes) from a TString */
420#define getstr(ts)	cast(const char *, (ts) + 1)
421
422/* get the actual string (array of bytes) from a Lua value */
423#define svalue(o)       getstr(rawtsvalue(o))
424
425
426/*
427** Header for userdata; memory area follows the end of this structure
428*/
429typedef union Udata {
430  L_Umaxalign dummy;  /* ensures maximum alignment for `local' udata */
431  struct {
432    CommonHeader;
433    struct Table *metatable;
434    struct Table *env;
435    size_t len;  /* number of bytes */
436  } uv;
437} Udata;
438
439
440
441/*
442** Description of an upvalue for function prototypes
443*/
444typedef struct Upvaldesc {
445  TString *name;  /* upvalue name (for debug information) */
446  lu_byte instack;  /* whether it is in stack */
447  lu_byte idx;  /* index of upvalue (in stack or in outer function's list) */
448} Upvaldesc;
449
450
451/*
452** Description of a local variable for function prototypes
453** (used for debug information)
454*/
455typedef struct LocVar {
456  TString *varname;
457  int startpc;  /* first point where variable is active */
458  int endpc;    /* first point where variable is dead */
459} LocVar;
460
461
462/*
463** Function Prototypes
464*/
465typedef struct Proto {
466  CommonHeader;
467  TValue *k;  /* constants used by the function */
468  Instruction *code;
469  struct Proto **p;  /* functions defined inside the function */
470  int *lineinfo;  /* map from opcodes to source lines (debug information) */
471  LocVar *locvars;  /* information about local variables (debug information) */
472  Upvaldesc *upvalues;  /* upvalue information */
473  union Closure *cache;  /* last created closure with this prototype */
474  TString  *source;  /* used for debug information */
475  int sizeupvalues;  /* size of 'upvalues' */
476  int sizek;  /* size of `k' */
477  int sizecode;
478  int sizelineinfo;
479  int sizep;  /* size of `p' */
480  int sizelocvars;
481  int linedefined;
482  int lastlinedefined;
483  GCObject *gclist;
484  lu_byte numparams;  /* number of fixed parameters */
485  lu_byte is_vararg;
486  lu_byte maxstacksize;  /* maximum stack used by this function */
487} Proto;
488
489
490
491/*
492** Lua Upvalues
493*/
494typedef struct UpVal {
495  CommonHeader;
496  TValue *v;  /* points to stack or to its own value */
497  union {
498    TValue value;  /* the value (when closed) */
499    struct {  /* double linked list (when open) */
500      struct UpVal *prev;
501      struct UpVal *next;
502    } l;
503  } u;
504} UpVal;
505
506
507/*
508** Closures
509*/
510
511#define ClosureHeader \
512	CommonHeader; lu_byte nupvalues; GCObject *gclist
513
514typedef struct CClosure {
515  ClosureHeader;
516  lua_CFunction f;
517  TValue upvalue[1];  /* list of upvalues */
518} CClosure;
519
520
521typedef struct LClosure {
522  ClosureHeader;
523  struct Proto *p;
524  UpVal *upvals[1];  /* list of upvalues */
525} LClosure;
526
527
528typedef union Closure {
529  CClosure c;
530  LClosure l;
531} Closure;
532
533
534#define isLfunction(o)	ttisLclosure(o)
535
536#define getproto(o)	(clLvalue(o)->p)
537
538
539/*
540** Tables
541*/
542
543typedef union TKey {
544  struct {
545    TValuefields;
546    struct Node *next;  /* for chaining */
547  } nk;
548  TValue tvk;
549} TKey;
550
551
552typedef struct Node {
553  TValue i_val;
554  TKey i_key;
555} Node;
556
557
558typedef struct Table {
559  CommonHeader;
560  lu_byte flags;  /* 1<<p means tagmethod(p) is not present */
561  lu_byte lsizenode;  /* log2 of size of `node' array */
562  int sizearray;  /* size of `array' array */
563  TValue *array;  /* array part */
564  Node *node;
565  Node *lastfree;  /* any free position is before this position */
566  struct Table *metatable;
567  GCObject *gclist;
568} Table;
569
570
571
572/*
573** `module' operation for hashing (size is always a power of 2)
574*/
575#define lmod(s,size) \
576	(check_exp((size&(size-1))==0, (cast(int, (s) & ((size)-1)))))
577
578
579#define twoto(x)	(1<<(x))
580#define sizenode(t)	(twoto((t)->lsizenode))
581
582
583/*
584** (address of) a fixed nil value
585*/
586#define luaO_nilobject		(&luaO_nilobject_)
587
588
589LUAI_DDEC const TValue luaO_nilobject_;
590
591
592LUAI_FUNC int luaO_int2fb (unsigned int x);
593LUAI_FUNC int luaO_fb2int (int x);
594LUAI_FUNC int luaO_ceillog2 (unsigned int x);
595LUAI_FUNC lua_Number luaO_arith (int op, lua_Number v1, lua_Number v2);
596LUAI_FUNC int luaO_str2d (const char *s, size_t len, lua_Number *result);
597LUAI_FUNC int luaO_hexavalue (int c);
598LUAI_FUNC const char *luaO_pushvfstring (lua_State *L, const char *fmt,
599                                                       va_list argp);
600LUAI_FUNC const char *luaO_pushfstring (lua_State *L, const char *fmt, ...);
601LUAI_FUNC void luaO_chunkid (char *out, const char *source, size_t len);
602
603
604#endif
605/* END CSTYLED */
606