Mercurial > vba-clojure
comparison src/lua/lobject.h @ 11:27763b933818
raise lua sources up one level
author | Robert McIntyre <rlm@mit.edu> |
---|---|
date | Sat, 03 Mar 2012 11:07:39 -0600 |
parents | src/lua/src/lobject.h@f9f4f1b99eed |
children |
comparison
equal
deleted
inserted
replaced
10:48b74a4e4692 | 11:27763b933818 |
---|---|
1 /* | |
2 ** $Id: lobject.h,v 2.20.1.2 2008/08/06 13:29:48 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 /* tags for values visible from Lua */ | |
20 #define LAST_TAG LUA_TTHREAD | |
21 | |
22 #define NUM_TAGS (LAST_TAG+1) | |
23 | |
24 | |
25 /* | |
26 ** Extra tags for non-values | |
27 */ | |
28 #define LUA_TPROTO (LAST_TAG+1) | |
29 #define LUA_TUPVAL (LAST_TAG+2) | |
30 #define LUA_TDEADKEY (LAST_TAG+3) | |
31 | |
32 | |
33 /* | |
34 ** Union of all collectable objects | |
35 */ | |
36 typedef union GCObject GCObject; | |
37 | |
38 | |
39 /* | |
40 ** Common Header for all collectable objects (in macro form, to be | |
41 ** included in other objects) | |
42 */ | |
43 #define CommonHeader GCObject *next; lu_byte tt; lu_byte marked | |
44 | |
45 | |
46 /* | |
47 ** Common header in struct form | |
48 */ | |
49 typedef struct GCheader { | |
50 CommonHeader; | |
51 } GCheader; | |
52 | |
53 | |
54 | |
55 | |
56 /* | |
57 ** Union of all Lua values | |
58 */ | |
59 typedef union { | |
60 GCObject *gc; | |
61 void *p; | |
62 lua_Number n; | |
63 int b; | |
64 } Value; | |
65 | |
66 | |
67 /* | |
68 ** Tagged Values | |
69 */ | |
70 | |
71 #define TValuefields Value value; int tt | |
72 | |
73 typedef struct lua_TValue { | |
74 TValuefields; | |
75 } TValue; | |
76 | |
77 | |
78 /* Macros to test type */ | |
79 #define ttisnil(o) (ttype(o) == LUA_TNIL) | |
80 #define ttisnumber(o) (ttype(o) == LUA_TNUMBER) | |
81 #define ttisstring(o) (ttype(o) == LUA_TSTRING) | |
82 #define ttistable(o) (ttype(o) == LUA_TTABLE) | |
83 #define ttisfunction(o) (ttype(o) == LUA_TFUNCTION) | |
84 #define ttisboolean(o) (ttype(o) == LUA_TBOOLEAN) | |
85 #define ttisuserdata(o) (ttype(o) == LUA_TUSERDATA) | |
86 #define ttisthread(o) (ttype(o) == LUA_TTHREAD) | |
87 #define ttislightuserdata(o) (ttype(o) == LUA_TLIGHTUSERDATA) | |
88 | |
89 /* Macros to access values */ | |
90 #define ttype(o) ((o)->tt) | |
91 #define gcvalue(o) check_exp(iscollectable(o), (o)->value.gc) | |
92 #define pvalue(o) check_exp(ttislightuserdata(o), (o)->value.p) | |
93 #define nvalue(o) check_exp(ttisnumber(o), (o)->value.n) | |
94 #define rawtsvalue(o) check_exp(ttisstring(o), &(o)->value.gc->ts) | |
95 #define tsvalue(o) (&rawtsvalue(o)->tsv) | |
96 #define rawuvalue(o) check_exp(ttisuserdata(o), &(o)->value.gc->u) | |
97 #define uvalue(o) (&rawuvalue(o)->uv) | |
98 #define clvalue(o) check_exp(ttisfunction(o), &(o)->value.gc->cl) | |
99 #define hvalue(o) check_exp(ttistable(o), &(o)->value.gc->h) | |
100 #define bvalue(o) check_exp(ttisboolean(o), (o)->value.b) | |
101 #define thvalue(o) check_exp(ttisthread(o), &(o)->value.gc->th) | |
102 | |
103 #define l_isfalse(o) (ttisnil(o) || (ttisboolean(o) && bvalue(o) == 0)) | |
104 | |
105 /* | |
106 ** for internal debug only | |
107 */ | |
108 #define checkconsistency(obj) \ | |
109 lua_assert(!iscollectable(obj) || (ttype(obj) == (obj)->value.gc->gch.tt)) | |
110 | |
111 #define checkliveness(g,obj) \ | |
112 lua_assert(!iscollectable(obj) || \ | |
113 ((ttype(obj) == (obj)->value.gc->gch.tt) && !isdead(g, (obj)->value.gc))) | |
114 | |
115 | |
116 /* Macros to set values */ | |
117 #define setnilvalue(obj) ((obj)->tt=LUA_TNIL) | |
118 | |
119 #define setnvalue(obj,x) \ | |
120 { TValue *i_o=(obj); i_o->value.n=(x); i_o->tt=LUA_TNUMBER; } | |
121 | |
122 #define setpvalue(obj,x) \ | |
123 { TValue *i_o=(obj); i_o->value.p=(x); i_o->tt=LUA_TLIGHTUSERDATA; } | |
124 | |
125 #define setbvalue(obj,x) \ | |
126 { TValue *i_o=(obj); i_o->value.b=(x); i_o->tt=LUA_TBOOLEAN; } | |
127 | |
128 #define setsvalue(L,obj,x) \ | |
129 { TValue *i_o=(obj); \ | |
130 i_o->value.gc=cast(GCObject *, (x)); i_o->tt=LUA_TSTRING; \ | |
131 checkliveness(G(L),i_o); } | |
132 | |
133 #define setuvalue(L,obj,x) \ | |
134 { TValue *i_o=(obj); \ | |
135 i_o->value.gc=cast(GCObject *, (x)); i_o->tt=LUA_TUSERDATA; \ | |
136 checkliveness(G(L),i_o); } | |
137 | |
138 #define setthvalue(L,obj,x) \ | |
139 { TValue *i_o=(obj); \ | |
140 i_o->value.gc=cast(GCObject *, (x)); i_o->tt=LUA_TTHREAD; \ | |
141 checkliveness(G(L),i_o); } | |
142 | |
143 #define setclvalue(L,obj,x) \ | |
144 { TValue *i_o=(obj); \ | |
145 i_o->value.gc=cast(GCObject *, (x)); i_o->tt=LUA_TFUNCTION; \ | |
146 checkliveness(G(L),i_o); } | |
147 | |
148 #define sethvalue(L,obj,x) \ | |
149 { TValue *i_o=(obj); \ | |
150 i_o->value.gc=cast(GCObject *, (x)); i_o->tt=LUA_TTABLE; \ | |
151 checkliveness(G(L),i_o); } | |
152 | |
153 #define setptvalue(L,obj,x) \ | |
154 { TValue *i_o=(obj); \ | |
155 i_o->value.gc=cast(GCObject *, (x)); i_o->tt=LUA_TPROTO; \ | |
156 checkliveness(G(L),i_o); } | |
157 | |
158 | |
159 | |
160 | |
161 #define setobj(L,obj1,obj2) \ | |
162 { const TValue *o2=(obj2); TValue *o1=(obj1); \ | |
163 o1->value = o2->value; o1->tt=o2->tt; \ | |
164 checkliveness(G(L),o1); } | |
165 | |
166 | |
167 /* | |
168 ** different types of sets, according to destination | |
169 */ | |
170 | |
171 /* from stack to (same) stack */ | |
172 #define setobjs2s setobj | |
173 /* to stack (not from same stack) */ | |
174 #define setobj2s setobj | |
175 #define setsvalue2s setsvalue | |
176 #define sethvalue2s sethvalue | |
177 #define setptvalue2s setptvalue | |
178 /* from table to same table */ | |
179 #define setobjt2t setobj | |
180 /* to table */ | |
181 #define setobj2t setobj | |
182 /* to new object */ | |
183 #define setobj2n setobj | |
184 #define setsvalue2n setsvalue | |
185 | |
186 #define setttype(obj, tt) (ttype(obj) = (tt)) | |
187 | |
188 | |
189 #define iscollectable(o) (ttype(o) >= LUA_TSTRING) | |
190 | |
191 | |
192 | |
193 typedef TValue *StkId; /* index to stack elements */ | |
194 | |
195 | |
196 /* | |
197 ** String headers for string table | |
198 */ | |
199 typedef union TString { | |
200 L_Umaxalign dummy; /* ensures maximum alignment for strings */ | |
201 struct { | |
202 CommonHeader; | |
203 lu_byte reserved; | |
204 unsigned int hash; | |
205 size_t len; | |
206 } tsv; | |
207 } TString; | |
208 | |
209 | |
210 #define getstr(ts) cast(const char *, (ts) + 1) | |
211 #define svalue(o) getstr(rawtsvalue(o)) | |
212 | |
213 | |
214 | |
215 typedef union Udata { | |
216 L_Umaxalign dummy; /* ensures maximum alignment for `local' udata */ | |
217 struct { | |
218 CommonHeader; | |
219 struct Table *metatable; | |
220 struct Table *env; | |
221 size_t len; | |
222 } uv; | |
223 } Udata; | |
224 | |
225 | |
226 | |
227 | |
228 /* | |
229 ** Function Prototypes | |
230 */ | |
231 typedef struct Proto { | |
232 CommonHeader; | |
233 TValue *k; /* constants used by the function */ | |
234 Instruction *code; | |
235 struct Proto **p; /* functions defined inside the function */ | |
236 int *lineinfo; /* map from opcodes to source lines */ | |
237 struct LocVar *locvars; /* information about local variables */ | |
238 TString **upvalues; /* upvalue names */ | |
239 TString *source; | |
240 int sizeupvalues; | |
241 int sizek; /* size of `k' */ | |
242 int sizecode; | |
243 int sizelineinfo; | |
244 int sizep; /* size of `p' */ | |
245 int sizelocvars; | |
246 int linedefined; | |
247 int lastlinedefined; | |
248 GCObject *gclist; | |
249 lu_byte nups; /* number of upvalues */ | |
250 lu_byte numparams; | |
251 lu_byte is_vararg; | |
252 lu_byte maxstacksize; | |
253 } Proto; | |
254 | |
255 | |
256 /* masks for new-style vararg */ | |
257 #define VARARG_HASARG 1 | |
258 #define VARARG_ISVARARG 2 | |
259 #define VARARG_NEEDSARG 4 | |
260 | |
261 | |
262 typedef struct LocVar { | |
263 TString *varname; | |
264 int startpc; /* first point where variable is active */ | |
265 int endpc; /* first point where variable is dead */ | |
266 } LocVar; | |
267 | |
268 | |
269 | |
270 /* | |
271 ** Upvalues | |
272 */ | |
273 | |
274 typedef struct UpVal { | |
275 CommonHeader; | |
276 TValue *v; /* points to stack or to its own value */ | |
277 union { | |
278 TValue value; /* the value (when closed) */ | |
279 struct { /* double linked list (when open) */ | |
280 struct UpVal *prev; | |
281 struct UpVal *next; | |
282 } l; | |
283 } u; | |
284 } UpVal; | |
285 | |
286 | |
287 /* | |
288 ** Closures | |
289 */ | |
290 | |
291 #define ClosureHeader \ | |
292 CommonHeader; lu_byte isC; lu_byte nupvalues; GCObject *gclist; \ | |
293 struct Table *env | |
294 | |
295 typedef struct CClosure { | |
296 ClosureHeader; | |
297 lua_CFunction f; | |
298 TValue upvalue[1]; | |
299 } CClosure; | |
300 | |
301 | |
302 typedef struct LClosure { | |
303 ClosureHeader; | |
304 struct Proto *p; | |
305 UpVal *upvals[1]; | |
306 } LClosure; | |
307 | |
308 | |
309 typedef union Closure { | |
310 CClosure c; | |
311 LClosure l; | |
312 } Closure; | |
313 | |
314 | |
315 #define iscfunction(o) (ttype(o) == LUA_TFUNCTION && clvalue(o)->c.isC) | |
316 #define isLfunction(o) (ttype(o) == LUA_TFUNCTION && !clvalue(o)->c.isC) | |
317 | |
318 | |
319 /* | |
320 ** Tables | |
321 */ | |
322 | |
323 typedef union TKey { | |
324 struct { | |
325 TValuefields; | |
326 struct Node *next; /* for chaining */ | |
327 } nk; | |
328 TValue tvk; | |
329 } TKey; | |
330 | |
331 | |
332 typedef struct Node { | |
333 TValue i_val; | |
334 TKey i_key; | |
335 } Node; | |
336 | |
337 | |
338 typedef struct Table { | |
339 CommonHeader; | |
340 lu_byte flags; /* 1<<p means tagmethod(p) is not present */ | |
341 lu_byte lsizenode; /* log2 of size of `node' array */ | |
342 struct Table *metatable; | |
343 TValue *array; /* array part */ | |
344 Node *node; | |
345 Node *lastfree; /* any free position is before this position */ | |
346 GCObject *gclist; | |
347 int sizearray; /* size of `array' array */ | |
348 } Table; | |
349 | |
350 | |
351 | |
352 /* | |
353 ** `module' operation for hashing (size is always a power of 2) | |
354 */ | |
355 #define lmod(s,size) \ | |
356 (check_exp((size&(size-1))==0, (cast(int, (s) & ((size)-1))))) | |
357 | |
358 | |
359 #define twoto(x) (1<<(x)) | |
360 #define sizenode(t) (twoto((t)->lsizenode)) | |
361 | |
362 | |
363 #define luaO_nilobject (&luaO_nilobject_) | |
364 | |
365 LUAI_DATA const TValue luaO_nilobject_; | |
366 | |
367 #define ceillog2(x) (luaO_log2((x)-1) + 1) | |
368 | |
369 LUAI_FUNC int luaO_log2 (unsigned int x); | |
370 LUAI_FUNC int luaO_int2fb (unsigned int x); | |
371 LUAI_FUNC int luaO_fb2int (int x); | |
372 LUAI_FUNC int luaO_rawequalObj (const TValue *t1, const TValue *t2); | |
373 LUAI_FUNC int luaO_str2d (const char *s, lua_Number *result); | |
374 LUAI_FUNC const char *luaO_pushvfstring (lua_State *L, const char *fmt, | |
375 va_list argp); | |
376 LUAI_FUNC const char *luaO_pushfstring (lua_State *L, const char *fmt, ...); | |
377 LUAI_FUNC void luaO_chunkid (char *out, const char *source, size_t len); | |
378 | |
379 | |
380 #endif | |
381 |