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