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*/ 70typedef 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*/ 83typedef struct GCheader { 84 CommonHeader; 85} GCheader; 86 87 88 89/* 90** Union of all Lua values 91*/ 92typedef 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 106typedef 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 388union 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 397struct lua_TValue { 398 TValuefields; 399}; 400 401 402typedef 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*/ 410typedef 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*/ 431typedef 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*/ 446typedef 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*/ 457typedef 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*/ 467typedef 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*/ 496typedef 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 516typedef struct CClosure { 517 ClosureHeader; 518 lua_CFunction f; 519 TValue upvalue[1]; /* list of upvalues */ 520} CClosure; 521 522 523typedef struct LClosure { 524 ClosureHeader; 525 struct Proto *p; 526 UpVal *upvals[1]; /* list of upvalues */ 527} LClosure; 528 529 530typedef 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 545typedef union TKey { 546 struct { 547 TValuefields; 548 struct Node *next; /* for chaining */ 549 } nk; 550 TValue tvk; 551} TKey; 552 553 554typedef struct Node { 555 TValue i_val; 556 TKey i_key; 557} Node; 558 559 560typedef 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 591LUAI_DDEC const TValue luaO_nilobject_; 592 593 594LUAI_FUNC int luaO_int2fb (unsigned int x); 595LUAI_FUNC int luaO_fb2int (int x); 596LUAI_FUNC int luaO_ceillog2 (unsigned int x); 597LUAI_FUNC lua_Number luaO_arith (int op, lua_Number v1, lua_Number v2); 598LUAI_FUNC int luaO_str2d (const char *s, size_t len, lua_Number *result); 599LUAI_FUNC int luaO_hexavalue (int c); 600LUAI_FUNC const char *luaO_pushvfstring (lua_State *L, const char *fmt, 601 va_list argp); 602LUAI_FUNC const char *luaO_pushfstring (lua_State *L, const char *fmt, ...); 603LUAI_FUNC void luaO_chunkid (char *out, const char *source, size_t len); 604 605 606#endif 607 608