git.zerfleddert.de Git - proxmark3-svn/blob

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 */

8 #ifndef lobject_h

9 #define lobject_h

12 #include <stdarg.h>

15 #include "llimits.h"

16 #include "lua.h"

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)

26 /*

27 ** number of all possible tags (including LUA_TNONE but excluding DEADKEY)

28 */

29 #define LUA_TOTALTAGS (LUA_TUPVAL+2)

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 */

39 #define VARBITS (3 << 4)

42 /*

43 ** LUA_TFUNCTION variants:

44 ** 0 - Lua function

45 ** 1 - light C function

46 ** 2 - regular C function (closure)

47 */

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 */

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 */

60 /* Bit mark for collectable types */

61 #define BIT_ISCOLLECTABLE (1 << 6)

63 /* mark a tag as collectable */

64 #define ctb(t) ((t) | BIT_ISCOLLECTABLE)

67 /*

68 ** Union of all collectable objects

69 */

70 typedef union GCObject GCObject;

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

80 /*

81 ** Common header in struct form

82 */

83 typedef struct GCheader {

84 CommonHeader;

85 } GCheader;

89 /*

90 ** Union of all Lua values

91 */

92 typedef union Value Value;

95 #define numfield lua_Number n; /* numbers */

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)

 #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__)

321 #endif /* } */

323 #endif /* } */

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 */

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;

   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

 LUAI_FUNC int luaO_int2fb (unsigned int x);

 LUAI_FUNC int luaO_fb2int (int x);

 LUAI_FUNC int luaO_ceillog2 (unsigned int x);

 LUAI_FUNC lua_Number luaO_arith (int op, lua_Number v1, lua_Number v2);

 LUAI_FUNC int luaO_str2d (const char *s, size_t len, lua_Number *result);

 LUAI_FUNC int luaO_hexavalue (int c);

 LUAI_FUNC const char *luaO_pushvfstring (lua_State *L, const char *fmt,

601 va_list argp);

 LUAI_FUNC const char *luaO_pushfstring (lua_State *L, const char *fmt, ...);

 LUAI_FUNC void luaO_chunkid (char *out, const char *source, size_t len);

604

605

606 #endif

607