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