lua/src/luaconf.h.in at lua-5.1 · git99969/lua · GitHub

Repository navigation

History

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

409

410

411

412

413

414

415

416

417

418

419

420

421

422

423

424

425

426

427

428

429

430

431

432

433

434

435

436

437

438

439

440

441

442

443

444

445

446

447

448

449

450

451

452

453

454

455

456

457

458

459

460

461

462

463

464

465

466

467

468

469

470

471

472

473

474

475

476

477

478

479

480

481

482

483

484

485

486

487

488

489

490

491

492

493

494

495

496

497

498

499

500

501

502

503

504

505

506

507

508

509

510

511

512

513

514

515

516

517

518

519

520

521

522

523

524

525

526

527

528

529

530

531

532

533

534

535

536

537

538

539

540

541

542

543

544

545

546

547

548

549

550

551

552

553

554

555

556

557

558

559

560

561

562

563

564

565

566

567

568

569

570

571

572

573

574

575

576

577

578

579

580

581

582

583

584

585

586

587

588

589

590

591

592

593

594

595

596

597

598

599

600

601

602

603

604

605

606

607

608

609

610

611

612

613

614

615

616

617

618

619

620

621

622

623

624

625

626

627

628

629

630

631

632

633

634

635

636

637

638

639

640

641

642

643

644

645

646

647

648

649

650

651

652

653

654

655

656

657

658

659

660

661

662

663

664

665

666

667

668

669

670

671

672

673

674

675

676

677

678

679

680

681

682

683

684

685

686

687

688

689

690

691

692

693

694

695

696

697

698

699

700

701

702

703

704

705

706

707

708

709

710

711

712

713

714

715

716

717

718

719

720

721

722

723

** $Id: luaconf.h,v 1.82.1.7 2008/02/11 16:25:08 roberto Exp $

** Configuration file for Lua

** See Copyright Notice in lua.h

#ifndef lconfig_h

#define lconfig_h

#include <limits.h>

#include <stddef.h>

** ==================================================================

** Search for "@@" to find all configurable definitions.

** ===================================================================

@@ LUA_ANSI controls the use of non-ansi features.

** CHANGE it (define it) if you want Lua to avoid the use of any

** non-ansi feature or library.

#cmakedefine LUA_ANSI

#cmakedefine LUA_WIN

#cmakedefine LUA_USE_POSIX

#cmakedefine LUA_USE_DLOPEN /* needs an extra library: -ldl */

#cmakedefine LUA_USE_READLINE /* needs some extra libraries */

#cmakedefine LUA_USE_MKSTEMP

#cmakedefine LUA_USE_ISATTY

#cmakedefine LUA_USE_POPEN

#cmakedefine LUA_USE_ULONGJMP

//#if defined(LUA_USE_MACOSX)

//#define LUA_USE_POSIX

//#define LUA_DL_DYLD /* does not need extra library */

//#endif

@@ LUA_PATH and LUA_CPATH are the names of the environment variables that

@* Lua check to set its paths.

@@ LUA_INIT is the name of the environment variable that Lua

@* checks for initialization code.

** CHANGE them if you want different names.

#cmakedefine LUA_PATH "@LUA_PATH@"

#cmakedefine LUA_CPATH "@LUA_CPATH@"

#cmakedefine LUA_INIT "@LUA_INIT@"

@@ LUA_PATH_DEFAULT is the default path that Lua uses to look for

@* Lua libraries.

@@ LUA_CPATH_DEFAULT is the default path that Lua uses to look for

@* C libraries.

** CHANGE them if your machine has a non-conventional directory

** hierarchy or if you want to install your libraries in

** non-conventional directories.

** Any exclamation mark ('!') in the path is replaced by the

** path of the directory of the executable file of the current process.

#cmakedefine LUA_MODULE_SUFFIX "@LUA_MODULE_SUFFIX@"

#cmakedefine LUA_DIR "@LUA_DIR@"

#cmakedefine LUA_LDIR "@LUA_LDIR@"

#cmakedefine LUA_CDIR "@LUA_CDIR@"

#define LUA_PATH_DEFAULT "@LUA_PATH_DEFAULT@"

#define LUA_CPATH_DEFAULT "@LUA_CPATH_DEFAULT@"

@@ LUA_DIRSEP is the directory separator (for submodules).

** CHANGE it if your machine does not use "/" as the directory separator

** and is not Windows. (On Windows Lua automatically uses "\".)

#cmakedefine LUA_DIRSEP "@LUA_DIRSEP@"

@@ LUA_PATHSEP is the character that separates templates in a path.

@@ LUA_PATH_MARK is the string that marks the substitution points in a

@* template.

@@ LUA_EXECDIR in a Windows path is replaced by the executable's

@* directory.

@@ LUA_IGMARK is a mark to ignore all before it when bulding the

@* luaopen_ function name.

** CHANGE them if for some reason your system cannot use those

** characters. (E.g., if one of those characters is a common character

** in file/directory names.) Probably you do not need to change them.

#define LUA_PATHSEP ";"

#define LUA_PATH_MARK "?"

#define LUA_EXECDIR "!"

#define LUA_IGMARK "-"

@@ LUA_INTEGER is the integral type used by lua_pushinteger/lua_tointeger.

** CHANGE that if ptrdiff_t is not adequate on your machine. (On most

** machines, ptrdiff_t gives a good choice between int or long.)

#define LUA_INTEGER ptrdiff_t

@@ LUA_API is a mark for all core API functions.

@@ LUALIB_API is a mark for all standard library functions.

** CHANGE them if you need to define those functions in some special way.

** For instance, if you want to create one Windows DLL with the core and

** the libraries, you may want to use the following definition (define

** LUA_BUILD_AS_DLL to get it).

#if defined(LUA_BUILD_AS_DLL)

#if defined(LUA_CORE) || defined(LUA_LIB)

#define LUA_API __declspec(dllexport)

#else

#define LUA_API __declspec(dllimport)

#endif

#else

#define LUA_API extern

#endif

/* more often than not the libs go together with the core */

#define LUALIB_API LUA_API

@@ LUAI_FUNC is a mark for all extern functions that are not to be

@* exported to outside modules.

@@ LUAI_DATA is a mark for all extern (const) variables that are not to

@* be exported to outside modules.

** CHANGE them if you need to mark them in some special way. Elf/gcc

** (versions 3.2 and later) mark them as "hidden" to optimize access

** when Lua is compiled as a shared library.

#if defined(luaall_c)

#define LUAI_FUNC static

#define LUAI_DATA /* empty */

#elif defined(__GNUC__) && ((__GNUC__*100 + __GNUC_MINOR__) >= 302) && \

defined(__ELF__)

#define LUAI_FUNC __attribute__((visibility("hidden"))) extern

#define LUAI_DATA LUAI_FUNC

#else

#define LUAI_FUNC extern

#define LUAI_DATA extern

#endif

@@ LUA_QL describes how error messages quote program elements.

** CHANGE it if you want a different appearance.

#define LUA_QL(x) "'" x "'"

#define LUA_QS LUA_QL("%s")

@@ LUA_IDSIZE gives the maximum size for the description of the source

@* of a function in debug information.

** CHANGE it if you want a different size.

#cmakedefine LUA_IDSIZE @LUA_IDSIZE@

** {==================================================================

** Stand-alone configuration

** ===================================================================

#if defined(lua_c) || defined(luaall_c)

@@ lua_stdin_is_tty detects whether the standard input is a 'tty' (that

@* is, whether we're running lua interactively).

** CHANGE it if you have a better definition for non-POSIX/non-Windows

** systems.

#if defined(LUA_USE_ISATTY)

#include <unistd.h>

#define lua_stdin_is_tty() isatty(0)

#elif defined(LUA_WIN)

#include <io.h>

#include <stdio.h>

#define lua_stdin_is_tty() _isatty(_fileno(stdin))

#else

#define lua_stdin_is_tty() 1 /* assume stdin is a tty */

#endif

@@ LUA_PROMPT is the default prompt used by stand-alone Lua.

@@ LUA_PROMPT2 is the default continuation prompt used by stand-alone Lua.

** CHANGE them if you want different prompts. (You can also change the

** prompts dynamically, assigning to globals _PROMPT/_PROMPT2.)

#cmakedefine LUA_PROMPT "@LUA_PROMPT@"

#cmakedefine LUA_PROMPT2 "@LUA_PROMPT2@"

@@ LUA_PROGNAME is the default name for the stand-alone Lua program.

** CHANGE it if your stand-alone interpreter has a different name and

** your system is not able to detect that name automatically.

#define LUA_PROGNAME "lua"

@@ LUA_MAXINPUT is the maximum length for an input line in the

@* stand-alone interpreter.

** CHANGE it if you need longer lines.

#cmakedefine LUA_MAXINPUT @LUA_MAXINPUT@

@@ lua_readline defines how to show a prompt and then read a line from

@* the standard input.

@@ lua_saveline defines how to "save" a read line in a "history".

@@ lua_freeline defines how to free a line read by lua_readline.

** CHANGE them if you want to improve this functionality (e.g., by using

** GNU readline and history facilities).

#if defined(LUA_USE_READLINE)

#include <stdio.h>

#include <readline/readline.h>

#include <readline/history.h>

#define lua_readline(L,b,p) ((void)L, ((b)=readline(p)) != NULL)

#define lua_saveline(L,idx) \

if (lua_strlen(L,idx) > 0) /* non-empty line? */ \

add_history(lua_tostring(L, idx)); /* add it to history */

#define lua_freeline(L,b) ((void)L, free(b))

#else

#define lua_readline(L,b,p) \

((void)L, fputs(p, stdout), fflush(stdout), /* show prompt */ \

fgets(b, LUA_MAXINPUT, stdin) != NULL) /* get line */

#define lua_saveline(L,idx) { (void)L; (void)idx; }

#define lua_freeline(L,b) { (void)L; (void)b; }

#endif

/* }================================================================== */

@@ LUAI_GCPAUSE defines the default pause between garbage-collector cycles

@* as a percentage.

** CHANGE it if you want the GC to run faster or slower (higher values

** mean larger pauses which mean slower collection.) You can also change

** this value dynamically.

#define LUAI_GCPAUSE 200 /* 200% (wait memory to double before next GC) */

@@ LUAI_GCMUL defines the default speed of garbage collection relative to

@* memory allocation as a percentage.

** CHANGE it if you want to change the granularity of the garbage

** collection. (Higher values mean coarser collections. 0 represents

** infinity, where each step performs a full collection.) You can also

** change this value dynamically.

#define LUAI_GCMUL 200 /* GC runs 'twice the speed' of memory allocation */

@@ LUA_COMPAT_GETN controls compatibility with old getn behavior.

** CHANGE it (define it) if you want exact compatibility with the

** behavior of setn/getn in Lua 5.0.

#undef LUA_COMPAT_GETN

@@ LUA_COMPAT_LOADLIB controls compatibility about global loadlib.

** CHANGE it to undefined as soon as you do not need a global 'loadlib'

** function (the function is still available as 'package.loadlib').

#undef LUA_COMPAT_LOADLIB

@@ LUA_COMPAT_VARARG controls compatibility with old vararg feature.

** CHANGE it to undefined as soon as your programs use only '...' to

** access vararg parameters (instead of the old 'arg' table).

#define LUA_COMPAT_VARARG

@@ LUA_COMPAT_MOD controls compatibility with old math.mod function.

** CHANGE it to undefined as soon as your programs use 'math.fmod' or

** the new '%' operator instead of 'math.mod'.

#define LUA_COMPAT_MOD

@@ LUA_COMPAT_LSTR controls compatibility with old long string nesting

@* facility.

** CHANGE it to 2 if you want the old behaviour, or undefine it to turn

** off the advisory error when nesting [[...]].

#define LUA_COMPAT_LSTR 1

@@ LUA_COMPAT_GFIND controls compatibility with old 'string.gfind' name.

** CHANGE it to undefined as soon as you rename 'string.gfind' to

** 'string.gmatch'.

#define LUA_COMPAT_GFIND

@@ LUA_COMPAT_OPENLIB controls compatibility with old 'luaL_openlib'

@* behavior.

** CHANGE it to undefined as soon as you replace to 'luaL_register'

** your uses of 'luaL_openlib'

#define LUA_COMPAT_OPENLIB

@@ luai_apicheck is the assert macro used by the Lua-C API.

** CHANGE luai_apicheck if you want Lua to perform some checks in the

** parameters it gets from API calls. This may slow down the interpreter

** a bit, but may be quite useful when debugging C code that interfaces

** with Lua. A useful redefinition is to use assert.h.

#if defined(LUA_USE_APICHECK)

#include <assert.h>

#define luai_apicheck(L,o) { (void)L; assert(o); }

#else

#define luai_apicheck(L,o) { (void)L; }

#endif

@@ LUAI_BITSINT defines the number of bits in an int.

** CHANGE here if Lua cannot automatically detect the number of bits of

** your machine. Probably you do not need to change this.

/* avoid overflows in comparison */

#if INT_MAX-20 < 32760

#define LUAI_BITSINT 16

#elif INT_MAX > 2147483640L

/* int has at least 32 bits */

#define LUAI_BITSINT 32

#else

#error "you must define LUA_BITSINT with number of bits in an integer"

#endif

@@ LUAI_UINT32 is an unsigned integer with at least 32 bits.

@@ LUAI_INT32 is an signed integer with at least 32 bits.

@@ LUAI_UMEM is an unsigned integer big enough to count the total

@* memory used by Lua.

@@ LUAI_MEM is a signed integer big enough to count the total memory

@* used by Lua.

** CHANGE here if for some weird reason the default definitions are not

** good enough for your machine. (The definitions in the 'else'

** part always works, but may waste space on machines with 64-bit

** longs.) Probably you do not need to change this.

#if LUAI_BITSINT >= 32

#define LUAI_UINT32 unsigned int

#define LUAI_INT32 int

#define LUAI_MAXINT32 INT_MAX

#define LUAI_UMEM size_t

#define LUAI_MEM ptrdiff_t

#else

/* 16-bit ints */

#define LUAI_UINT32 unsigned long

#define LUAI_INT32 long

#define LUAI_MAXINT32 LONG_MAX

#define LUAI_UMEM unsigned long

#define LUAI_MEM long

#endif

@@ LUAI_MAXCALLS limits the number of nested calls.

** CHANGE it if you need really deep recursive calls. This limit is

** arbitrary; its only purpose is to stop infinite recursion before

** exhausting memory.

#define LUAI_MAXCALLS 20000

@@ LUAI_MAXCSTACK limits the number of Lua stack slots that a C function

@* can use.

** CHANGE it if you need lots of (Lua) stack space for your C

** functions. This limit is arbitrary; its only purpose is to stop C

** functions to consume unlimited stack space. (must be smaller than

** -LUA_REGISTRYINDEX)

#define LUAI_MAXCSTACK 8000

** {==================================================================

** CHANGE (to smaller values) the following definitions if your system

** has a small C stack. (Or you may want to change them to larger

** values if your system has a large C stack and these limits are

** too rigid for you.) Some of these constants control the size of

** stack-allocated arrays used by the compiler or the interpreter, while

** others limit the maximum number of recursive calls that the compiler

** or the interpreter can perform. Values too large may cause a C stack

** overflow for some forms of deep constructs.

** ===================================================================

@@ LUAI_MAXCCALLS is the maximum depth for nested C calls (short) and

@* syntactical nested non-terminals in a program.

#define LUAI_MAXCCALLS 200

@@ LUAI_MAXVARS is the maximum number of local variables per function

@* (must be smaller than 250).

#define LUAI_MAXVARS 200

@@ LUAI_MAXUPVALUES is the maximum number of upvalues per function

@* (must be smaller than 250).

#define LUAI_MAXUPVALUES 60

@@ LUAL_BUFFERSIZE is the buffer size used by the lauxlib buffer system.

#define LUAL_BUFFERSIZE BUFSIZ

/* }================================================================== */

** {==================================================================

@@ LUA_NUMBER is the type of numbers in Lua.

** CHANGE the following definitions only if you want to build Lua

** with a number type different from double. You may also need to

** change lua_number2int & lua_number2integer.

** ===================================================================

#define LUA_NUMBER_DOUBLE

#define LUA_NUMBER double

@@ LUAI_UACNUMBER is the result of an 'usual argument conversion'

@* over a number.

#define LUAI_UACNUMBER double

@@ LUA_NUMBER_SCAN is the format for reading numbers.

@@ LUA_NUMBER_FMT is the format for writing numbers.

@@ lua_number2str converts a number to a string.

@@ LUAI_MAXNUMBER2STR is maximum size of previous conversion.

@@ lua_str2number converts a string to a number.

#define LUA_NUMBER_SCAN "%lf"

#define LUA_NUMBER_FMT "%.14g"

#define lua_number2str(s,n) sprintf((s), LUA_NUMBER_FMT, (n))

#define LUAI_MAXNUMBER2STR 32 /* 16 digits, sign, point, and \0 */

#define lua_str2number(s,p) strtod((s), (p))

@@ The luai_num* macros define the primitive operations over numbers.

#if defined(LUA_CORE)

#include <math.h>

#define luai_numadd(a,b) ((a)+(b))

#define luai_numsub(a,b) ((a)-(b))

#define luai_nummul(a,b) ((a)*(b))

#define luai_numdiv(a,b) ((a)/(b))

#define luai_nummod(a,b) ((a) - floor((a)/(b))*(b))

#define luai_numpow(a,b) (pow(a,b))

#define luai_numunm(a) (-(a))

#define luai_numeq(a,b) ((a)==(b))

#define luai_numlt(a,b) ((a)<(b))

#define luai_numle(a,b) ((a)<=(b))

#define luai_numisnan(a) (!luai_numeq((a), (a)))

#endif

@@ lua_number2int is a macro to convert lua_Number to int.

@@ lua_number2integer is a macro to convert lua_Number to lua_Integer.

** CHANGE them if you know a faster way to convert a lua_Number to

** int (with any rounding method and without throwing errors) in your

** system. In Pentium machines, a naive typecast from double to int

** in C is extremely slow, so any alternative is worth trying.

/* On a Pentium, resort to a trick */

#if defined(LUA_NUMBER_DOUBLE) && !defined(LUA_ANSI) && !defined(__SSE2__) && \

(defined(__i386) || defined (_M_IX86) || defined(__i386__))

/* On a Microsoft compiler, use assembler */

#if defined(_MSC_VER)

#define lua_number2int(i,d) __asm fld d __asm fistp i

#define lua_number2integer(i,n) lua_number2int(i, n)

/* the next trick should work on any Pentium, but sometimes clashes

with a DirectX idiosyncrasy */

#else

union luai_Cast { double l_d; long l_l; };

#define lua_number2int(i,d) \

{ volatile union luai_Cast u; u.l_d = (d) + 6755399441055744.0; (i) = u.l_l; }

#define lua_number2integer(i,n) lua_number2int(i, n)

#endif

/* this option always works, but may be slow */

#else

#define lua_number2int(i,d) ((i)=(int)(d))

#define lua_number2integer(i,d) ((i)=(lua_Integer)(d))

#endif

/* }================================================================== */

@@ LUAI_USER_ALIGNMENT_T is a type that requires maximum alignment.

** CHANGE it if your system requires alignments larger than double. (For

** instance, if your system supports long doubles and they must be

** aligned in 16-byte boundaries, then you should add long double in the

** union.) Probably you do not need to change this.

#define LUAI_USER_ALIGNMENT_T union { double u; void *s; long l; }

@@ LUAI_THROW/LUAI_TRY define how Lua does exception handling.

** CHANGE them if you prefer to use longjmp/setjmp even with C++

** or if want/don't to use _longjmp/_setjmp instead of regular

** longjmp/setjmp. By default, Lua handles errors with exceptions when

** compiling as C++ code, with _longjmp/_setjmp when asked to use them,

** and with longjmp/setjmp otherwise.

#if defined(__cplusplus)

/* C++ exceptions */

#define LUAI_THROW(L,c) throw(c)

#define LUAI_TRY(L,c,a) try { a } catch(...) \

{ if ((c)->status == 0) (c)->status = -1; }

#define luai_jmpbuf int /* dummy variable */

#elif defined(LUA_USE_ULONGJMP)

/* in Unix, try _longjmp/_setjmp (more efficient) */

#define LUAI_THROW(L,c) _longjmp((c)->b, 1)

#define LUAI_TRY(L,c,a) if (_setjmp((c)->b) == 0) { a }

#define luai_jmpbuf jmp_buf

#else

/* default handling with long jumps */

#define LUAI_THROW(L,c) longjmp((c)->b, 1)

#define LUAI_TRY(L,c,a) if (setjmp((c)->b) == 0) { a }

#define luai_jmpbuf jmp_buf

#endif

@@ LUA_MAXCAPTURES is the maximum number of captures that a pattern

@* can do during pattern-matching.

** CHANGE it if you need more captures. This limit is arbitrary.

#define LUA_MAXCAPTURES 32

@@ lua_tmpnam is the function that the OS library uses to create a

@* temporary name.

@@ LUA_TMPNAMBUFSIZE is the maximum size of a name created by lua_tmpnam.

** CHANGE them if you have an alternative to tmpnam (which is considered

** insecure) or if you want the original tmpnam anyway. By default, Lua

** uses tmpnam except when POSIX is available, where it uses mkstemp.

#if defined(loslib_c) || defined(luaall_c)

#if defined(LUA_USE_MKSTEMP)

#include <unistd.h>

#define LUA_TMPNAMBUFSIZE 32

#define lua_tmpnam(b,e) { \

strcpy(b, "/tmp/lua_XXXXXX"); \

e = mkstemp(b); \

if (e != -1) close(e); \

e = (e == -1); }

#else

#define LUA_TMPNAMBUFSIZE L_tmpnam

#define lua_tmpnam(b,e) { e = (tmpnam(b) == NULL); }

#endif

@@ lua_popen spawns a new process connected to the current one through

@* the file streams.

** CHANGE it if you have a way to implement it in your system.

#if defined(LUA_USE_POPEN)

#define lua_popen(L,c,m) ((void)L, fflush(NULL), popen(c,m))

#define lua_pclose(L,file) ((void)L, (pclose(file) != -1))

#elif defined(LUA_WIN)

#define lua_popen(L,c,m) ((void)L, _popen(c,m))

#define lua_pclose(L,file) ((void)L, (_pclose(file) != -1))

#else

#define lua_popen(L,c,m) ((void)((void)c, m), \

luaL_error(L, LUA_QL("popen") " not supported"), (FILE*)0)

#define lua_pclose(L,file) ((void)((void)L, file), 0)

#endif

@@ LUA_DL_* define which dynamic-library system Lua should use.

** CHANGE here if Lua has problems choosing the appropriate

** dynamic-library system for your platform (either Windows' DLL, Mac's

** dyld, or Unix's dlopen). If your system is some kind of Unix, there

** is a good chance that it has dlopen, so LUA_DL_DLOPEN will work for

** it. To use dlopen you also need to adapt the src/Makefile (probably

** adding -ldl to the linker options), so Lua does not select it

** automatically. (When you change the makefile to add -ldl, you must

** also add -DLUA_USE_DLOPEN.)

** If you do not want any kind of dynamic library, undefine all these

** options.

** By default, _WIN32 gets LUA_DL_DLL and MAC OS X gets LUA_DL_DYLD.

#if defined(LUA_USE_DLOPEN)

#define LUA_DL_DLOPEN

#endif

#if defined(LUA_WIN)

#define LUA_DL_DLL

#endif

@@ LUAI_EXTRASPACE allows you to add user-specific data in a lua_State

@* (the data goes just *before* the lua_State pointer).

** CHANGE (define) this if you really need that. This value must be

** a multiple of the maximum alignment required for your machine.

#define LUAI_EXTRASPACE 0

@@ luai_userstate* allow user-specific actions on threads.

** CHANGE them if you defined LUAI_EXTRASPACE and need to do something

** extra when a thread is created/deleted/resumed/yielded.

#define luai_userstateopen(L) ((void)L)

#define luai_userstateclose(L) ((void)L)

#define luai_userstatethread(L,L1) ((void)L)

#define luai_userstatefree(L) ((void)L)

#define luai_userstateresume(L,n) ((void)L)

#define luai_userstateyield(L,n) ((void)L)

@@ LUA_INTFRMLEN is the length modifier for integer conversions

@* in 'string.format'.

@@ LUA_INTFRM_T is the integer type correspoding to the previous length

@* modifier.

** CHANGE them if your system supports long long or does not support long.

#if defined(LUA_USELONGLONG)

#define LUA_INTFRMLEN "ll"

#define LUA_INTFRM_T long long

#else

#define LUA_INTFRMLEN "l"

#define LUA_INTFRM_T long

#endif

/* =================================================================== */

** Local configuration. You can use this space to add your redefinitions

** without modifying the main part of the file.

#endif

lua/src/luaconf.h.in at lua-5.1 · git99969/lua · GitHub

Repository navigation

Expand file tree

Breadcrumbs

luaconf.h.in

Latest commit

History

Breadcrumbs

luaconf.h.in

File metadata and controls