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