1/* 2** $Id: luaconf.h,v 1.259 2016/12/22 13:08:50 roberto Exp $ 3** Configuration file for Lua 4** See Copyright Notice in lua.h 5*/ 6 7 8#ifndef luaconf_h 9#define luaconf_h 10 11#include <limits.h> 12#include <stddef.h> 13 14 15/* 16** =================================================================== 17** Search for "@@" to find all configurable definitions. 18** =================================================================== 19*/ 20 21 22/* 23** {==================================================================== 24** System Configuration: macros to adapt (if needed) Lua to some 25** particular platform, for instance compiling it with 32-bit numbers or 26** restricting it to C89. 27** ===================================================================== 28*/ 29 30/* 31@@ LUA_32BITS enables Lua with 32-bit integers and 32-bit floats. You 32** can also define LUA_32BITS in the make file, but changing here you 33** ensure that all software connected to Lua will be compiled with the 34** same configuration. 35*/ 36/* #define LUA_32BITS */ 37 38 39/* 40@@ LUA_USE_C89 controls the use of non-ISO-C89 features. 41** Define it if you want Lua to avoid the use of a few C99 features 42** or Windows-specific features on Windows. 43*/ 44/* #define LUA_USE_C89 */ 45 46 47/* 48** By default, Lua on Windows use (some) specific Windows features 49*/ 50#if !defined(LUA_USE_C89) && defined(_WIN32) && !defined(_WIN32_WCE) 51#define LUA_USE_WINDOWS /* enable goodies for regular Windows */ 52#endif 53 54 55#if defined(LUA_USE_WINDOWS) 56#define LUA_DL_DLL /* enable support for DLL */ 57#define LUA_USE_C89 /* broadly, Windows is C89 */ 58#endif 59 60 61#if defined(LUA_USE_LINUX) 62#define LUA_USE_POSIX 63#define LUA_USE_DLOPEN /* needs an extra library: -ldl */ 64#define LUA_USE_READLINE /* needs some extra libraries */ 65#endif 66 67 68#if defined(LUA_USE_MACOSX) 69#define LUA_USE_POSIX 70#define LUA_USE_DLOPEN /* MacOS does not need -ldl */ 71#define LUA_USE_READLINE /* needs an extra library: -lreadline */ 72#endif 73 74 75/* 76@@ LUA_C89_NUMBERS ensures that Lua uses the largest types available for 77** C89 ('long' and 'double'); Windows always has '__int64', so it does 78** not need to use this case. 79*/ 80#if defined(LUA_USE_C89) && !defined(LUA_USE_WINDOWS) 81#define LUA_C89_NUMBERS 82#endif 83 84 85 86/* 87@@ LUAI_BITSINT defines the (minimum) number of bits in an 'int'. 88*/ 89/* avoid undefined shifts */ 90#if ((INT_MAX >> 15) >> 15) >= 1 91#define LUAI_BITSINT 32 92#else 93/* 'int' always must have at least 16 bits */ 94#define LUAI_BITSINT 16 95#endif 96 97 98/* 99@@ LUA_INT_TYPE defines the type for Lua integers. 100@@ LUA_FLOAT_TYPE defines the type for Lua floats. 101** Lua should work fine with any mix of these options (if supported 102** by your C compiler). The usual configurations are 64-bit integers 103** and 'double' (the default), 32-bit integers and 'float' (for 104** restricted platforms), and 'long'/'double' (for C compilers not 105** compliant with C99, which may not have support for 'long long'). 106*/ 107 108/* predefined options for LUA_INT_TYPE */ 109#define LUA_INT_INT 1 110#define LUA_INT_LONG 2 111#define LUA_INT_LONGLONG 3 112 113/* predefined options for LUA_FLOAT_TYPE */ 114#define LUA_FLOAT_FLOAT 1 115#define LUA_FLOAT_DOUBLE 2 116#define LUA_FLOAT_LONGDOUBLE 3 117 118#if defined(LUA_32BITS) /* { */ 119/* 120** 32-bit integers and 'float' 121*/ 122#if LUAI_BITSINT >= 32 /* use 'int' if big enough */ 123#define LUA_INT_TYPE LUA_INT_INT 124#else /* otherwise use 'long' */ 125#define LUA_INT_TYPE LUA_INT_LONG 126#endif 127#define LUA_FLOAT_TYPE LUA_FLOAT_FLOAT 128 129#elif defined(LUA_C89_NUMBERS) /* }{ */ 130/* 131** largest types available for C89 ('long' and 'double') 132*/ 133#define LUA_INT_TYPE LUA_INT_LONG 134#define LUA_FLOAT_TYPE LUA_FLOAT_DOUBLE 135 136#endif /* } */ 137 138 139/* 140** default configuration for 64-bit Lua ('long long' and 'double') 141*/ 142#if !defined(LUA_INT_TYPE) 143#define LUA_INT_TYPE LUA_INT_LONGLONG 144#endif 145 146#if !defined(LUA_FLOAT_TYPE) 147#define LUA_FLOAT_TYPE LUA_FLOAT_DOUBLE 148#endif 149 150/* }================================================================== */ 151 152 153 154 155/* 156** {================================================================== 157** Configuration for Paths. 158** =================================================================== 159*/ 160 161/* 162** LUA_PATH_SEP is the character that separates templates in a path. 163** LUA_PATH_MARK is the string that marks the substitution points in a 164** template. 165** LUA_EXEC_DIR in a Windows path is replaced by the executable's 166** directory. 167*/ 168#define LUA_PATH_SEP ";" 169#define LUA_PATH_MARK "?" 170#define LUA_EXEC_DIR "!" 171 172 173/* 174@@ LUA_PATH_DEFAULT is the default path that Lua uses to look for 175** Lua libraries. 176@@ LUA_CPATH_DEFAULT is the default path that Lua uses to look for 177** C libraries. 178** CHANGE them if your machine has a non-conventional directory 179** hierarchy or if you want to install your libraries in 180** non-conventional directories. 181*/ 182#define LUA_VDIR LUA_VERSION_MAJOR "." LUA_VERSION_MINOR 183#if defined(_WIN32) /* { */ 184/* 185** In Windows, any exclamation mark ('!') in the path is replaced by the 186** path of the directory of the executable file of the current process. 187*/ 188#define LUA_LDIR "!\\lua\\" 189#define LUA_CDIR "!\\" 190#define LUA_SHRDIR "!\\..\\share\\lua\\" LUA_VDIR "\\" 191#define LUA_PATH_DEFAULT \ 192 LUA_LDIR"?.lua;" LUA_LDIR"?\\init.lua;" \ 193 LUA_CDIR"?.lua;" LUA_CDIR"?\\init.lua;" \ 194 LUA_SHRDIR"?.lua;" LUA_SHRDIR"?\\init.lua;" \ 195 ".\\?.lua;" ".\\?\\init.lua" 196#define LUA_CPATH_DEFAULT \ 197 LUA_CDIR"?.dll;" \ 198 LUA_CDIR"..\\lib\\lua\\" LUA_VDIR "\\?.dll;" \ 199 LUA_CDIR"loadall.dll;" ".\\?.dll" 200 201#else /* }{ */ 202 203#define LUA_ROOT "/usr/local/" 204#define LUA_LDIR LUA_ROOT "share/lua/" LUA_VDIR "/" 205#define LUA_CDIR LUA_ROOT "lib/lua/" LUA_VDIR "/" 206#define LUA_PATH_DEFAULT \ 207 LUA_LDIR"?.lua;" LUA_LDIR"?/init.lua;" \ 208 LUA_CDIR"?.lua;" LUA_CDIR"?/init.lua;" \ 209 "./?.lua;" "./?/init.lua" 210#define LUA_CPATH_DEFAULT \ 211 LUA_CDIR"?.so;" LUA_CDIR"loadall.so;" "./?.so" 212#endif /* } */ 213 214 215/* 216@@ LUA_DIRSEP is the directory separator (for submodules). 217** CHANGE it if your machine does not use "/" as the directory separator 218** and is not Windows. (On Windows Lua automatically uses "\".) 219*/ 220#if defined(_WIN32) 221#define LUA_DIRSEP "\\" 222#else 223#define LUA_DIRSEP "/" 224#endif 225 226/* }================================================================== */ 227 228 229/* 230** {================================================================== 231** Marks for exported symbols in the C code 232** =================================================================== 233*/ 234 235/* 236@@ LUA_API is a mark for all core API functions. 237@@ LUALIB_API is a mark for all auxiliary library functions. 238@@ LUAMOD_API is a mark for all standard library opening functions. 239** CHANGE them if you need to define those functions in some special way. 240** For instance, if you want to create one Windows DLL with the core and 241** the libraries, you may want to use the following definition (define 242** LUA_BUILD_AS_DLL to get it). 243*/ 244#if defined(LUA_BUILD_AS_DLL) /* { */ 245 246#if defined(LUA_CORE) || defined(LUA_LIB) /* { */ 247#define LUA_API __declspec(dllexport) 248#else /* }{ */ 249#define LUA_API __declspec(dllimport) 250#endif /* } */ 251 252#else /* }{ */ 253 254#define LUA_API extern 255 256#endif /* } */ 257 258 259/* more often than not the libs go together with the core */ 260#define LUALIB_API LUA_API 261#define LUAMOD_API LUALIB_API 262 263 264/* 265@@ LUAI_FUNC is a mark for all extern functions that are not to be 266** exported to outside modules. 267@@ LUAI_DDEF and LUAI_DDEC are marks for all extern (const) variables 268** that are not to be exported to outside modules (LUAI_DDEF for 269** definitions and LUAI_DDEC for declarations). 270** CHANGE them if you need to mark them in some special way. Elf/gcc 271** (versions 3.2 and later) mark them as "hidden" to optimize access 272** when Lua is compiled as a shared library. Not all elf targets support 273** this attribute. Unfortunately, gcc does not offer a way to check 274** whether the target offers that support, and those without support 275** give a warning about it. To avoid these warnings, change to the 276** default definition. 277*/ 278#if defined(__GNUC__) && ((__GNUC__*100 + __GNUC_MINOR__) >= 302) && \ 279 defined(__ELF__) /* { */ 280#define LUAI_FUNC __attribute__((visibility("hidden"))) extern 281#else /* }{ */ 282#define LUAI_FUNC extern 283#endif /* } */ 284 285#define LUAI_DDEC LUAI_FUNC 286#define LUAI_DDEF /* empty */ 287 288/* }================================================================== */ 289 290 291/* 292** {================================================================== 293** Compatibility with previous versions 294** =================================================================== 295*/ 296 297/* 298@@ LUA_COMPAT_5_2 controls other macros for compatibility with Lua 5.2. 299@@ LUA_COMPAT_5_1 controls other macros for compatibility with Lua 5.1. 300** You can define it to get all options, or change specific options 301** to fit your specific needs. 302*/ 303#if defined(LUA_COMPAT_5_2) /* { */ 304 305/* 306@@ LUA_COMPAT_MATHLIB controls the presence of several deprecated 307** functions in the mathematical library. 308*/ 309#define LUA_COMPAT_MATHLIB 310 311/* 312@@ LUA_COMPAT_BITLIB controls the presence of library 'bit32'. 313*/ 314#define LUA_COMPAT_BITLIB 315 316/* 317@@ LUA_COMPAT_IPAIRS controls the effectiveness of the __ipairs metamethod. 318*/ 319#define LUA_COMPAT_IPAIRS 320 321/* 322@@ LUA_COMPAT_APIINTCASTS controls the presence of macros for 323** manipulating other integer types (lua_pushunsigned, lua_tounsigned, 324** luaL_checkint, luaL_checklong, etc.) 325*/ 326#define LUA_COMPAT_APIINTCASTS 327 328#endif /* } */ 329 330 331#if defined(LUA_COMPAT_5_1) /* { */ 332 333/* Incompatibilities from 5.2 -> 5.3 */ 334#define LUA_COMPAT_MATHLIB 335#define LUA_COMPAT_APIINTCASTS 336 337/* 338@@ LUA_COMPAT_UNPACK controls the presence of global 'unpack'. 339** You can replace it with 'table.unpack'. 340*/ 341#define LUA_COMPAT_UNPACK 342 343/* 344@@ LUA_COMPAT_LOADERS controls the presence of table 'package.loaders'. 345** You can replace it with 'package.searchers'. 346*/ 347#define LUA_COMPAT_LOADERS 348 349/* 350@@ macro 'lua_cpcall' emulates deprecated function lua_cpcall. 351** You can call your C function directly (with light C functions). 352*/ 353#define lua_cpcall(L,f,u) \ 354 (lua_pushcfunction(L, (f)), \ 355 lua_pushlightuserdata(L,(u)), \ 356 lua_pcall(L,1,0,0)) 357 358 359/* 360@@ LUA_COMPAT_LOG10 defines the function 'log10' in the math library. 361** You can rewrite 'log10(x)' as 'log(x, 10)'. 362*/ 363#define LUA_COMPAT_LOG10 364 365/* 366@@ LUA_COMPAT_LOADSTRING defines the function 'loadstring' in the base 367** library. You can rewrite 'loadstring(s)' as 'load(s)'. 368*/ 369#define LUA_COMPAT_LOADSTRING 370 371/* 372@@ LUA_COMPAT_MAXN defines the function 'maxn' in the table library. 373*/ 374#define LUA_COMPAT_MAXN 375 376/* 377@@ The following macros supply trivial compatibility for some 378** changes in the API. The macros themselves document how to 379** change your code to avoid using them. 380*/ 381#define lua_strlen(L,i) lua_rawlen(L, (i)) 382 383#define lua_objlen(L,i) lua_rawlen(L, (i)) 384 385#define lua_equal(L,idx1,idx2) lua_compare(L,(idx1),(idx2),LUA_OPEQ) 386#define lua_lessthan(L,idx1,idx2) lua_compare(L,(idx1),(idx2),LUA_OPLT) 387 388/* 389@@ LUA_COMPAT_MODULE controls compatibility with previous 390** module functions 'module' (Lua) and 'luaL_register' (C). 391*/ 392#define LUA_COMPAT_MODULE 393 394#endif /* } */ 395 396 397/* 398@@ LUA_COMPAT_FLOATSTRING makes Lua format integral floats without a 399@@ a float mark ('.0'). 400** This macro is not on by default even in compatibility mode, 401** because this is not really an incompatibility. 402*/ 403/* #define LUA_COMPAT_FLOATSTRING */ 404 405/* }================================================================== */ 406 407 408 409/* 410** {================================================================== 411** Configuration for Numbers. 412** Change these definitions if no predefined LUA_FLOAT_* / LUA_INT_* 413** satisfy your needs. 414** =================================================================== 415*/ 416 417/* 418@@ LUA_NUMBER is the floating-point type used by Lua. 419@@ LUAI_UACNUMBER is the result of a 'default argument promotion' 420@@ over a floating number. 421@@ l_mathlim(x) corrects limit name 'x' to the proper float type 422** by prefixing it with one of FLT/DBL/LDBL. 423@@ LUA_NUMBER_FRMLEN is the length modifier for writing floats. 424@@ LUA_NUMBER_FMT is the format for writing floats. 425@@ lua_number2str converts a float to a string. 426@@ l_mathop allows the addition of an 'l' or 'f' to all math operations. 427@@ l_floor takes the floor of a float. 428@@ lua_str2number converts a decimal numeric string to a number. 429*/ 430 431 432/* The following definitions are good for most cases here */ 433 434#define l_floor(x) (l_mathop(floor)(x)) 435 436#define lua_number2str(s,sz,n) \ 437 l_sprintf((s), sz, LUA_NUMBER_FMT, (LUAI_UACNUMBER)(n)) 438 439/* 440@@ lua_numbertointeger converts a float number to an integer, or 441** returns 0 if float is not within the range of a lua_Integer. 442** (The range comparisons are tricky because of rounding. The tests 443** here assume a two-complement representation, where MININTEGER always 444** has an exact representation as a float; MAXINTEGER may not have one, 445** and therefore its conversion to float may have an ill-defined value.) 446*/ 447#define lua_numbertointeger(n,p) \ 448 ((n) >= (LUA_NUMBER)(LUA_MININTEGER) && \ 449 (n) < -(LUA_NUMBER)(LUA_MININTEGER) && \ 450 (*(p) = (LUA_INTEGER)(n), 1)) 451 452 453/* now the variable definitions */ 454 455#if LUA_FLOAT_TYPE == LUA_FLOAT_FLOAT /* { single float */ 456 457#define LUA_NUMBER float 458 459#define l_mathlim(n) (FLT_##n) 460 461#define LUAI_UACNUMBER double 462 463#define LUA_NUMBER_FRMLEN "" 464#define LUA_NUMBER_FMT "%.7g" 465 466#define l_mathop(op) op##f 467 468#define lua_str2number(s,p) strtof((s), (p)) 469 470 471#elif LUA_FLOAT_TYPE == LUA_FLOAT_LONGDOUBLE /* }{ long double */ 472 473#define LUA_NUMBER long double 474 475#define l_mathlim(n) (LDBL_##n) 476 477#define LUAI_UACNUMBER long double 478 479#define LUA_NUMBER_FRMLEN "L" 480#define LUA_NUMBER_FMT "%.19Lg" 481 482#define l_mathop(op) op##l 483 484#define lua_str2number(s,p) strtold((s), (p)) 485 486#elif LUA_FLOAT_TYPE == LUA_FLOAT_DOUBLE /* }{ double */ 487 488#define LUA_NUMBER double 489 490#define l_mathlim(n) (DBL_##n) 491 492#define LUAI_UACNUMBER double 493 494#define LUA_NUMBER_FRMLEN "" 495#define LUA_NUMBER_FMT "%.14g" 496 497#define l_mathop(op) op 498 499#define lua_str2number(s,p) strtod((s), (p)) 500 501#else /* }{ */ 502 503#error "numeric float type not defined" 504 505#endif /* } */ 506 507 508 509/* 510@@ LUA_INTEGER is the integer type used by Lua. 511** 512@@ LUA_UNSIGNED is the unsigned version of LUA_INTEGER. 513** 514@@ LUAI_UACINT is the result of a 'default argument promotion' 515@@ over a lUA_INTEGER. 516@@ LUA_INTEGER_FRMLEN is the length modifier for reading/writing integers. 517@@ LUA_INTEGER_FMT is the format for writing integers. 518@@ LUA_MAXINTEGER is the maximum value for a LUA_INTEGER. 519@@ LUA_MININTEGER is the minimum value for a LUA_INTEGER. 520@@ lua_integer2str converts an integer to a string. 521*/ 522 523 524/* The following definitions are good for most cases here */ 525 526#define LUA_INTEGER_FMT "%" LUA_INTEGER_FRMLEN "d" 527 528#define LUAI_UACINT LUA_INTEGER 529 530#define lua_integer2str(s,sz,n) \ 531 l_sprintf((s), sz, LUA_INTEGER_FMT, (LUAI_UACINT)(n)) 532 533/* 534** use LUAI_UACINT here to avoid problems with promotions (which 535** can turn a comparison between unsigneds into a signed comparison) 536*/ 537#define LUA_UNSIGNED unsigned LUAI_UACINT 538 539 540/* now the variable definitions */ 541 542#if LUA_INT_TYPE == LUA_INT_INT /* { int */ 543 544#define LUA_INTEGER int 545#define LUA_INTEGER_FRMLEN "" 546 547#define LUA_MAXINTEGER INT_MAX 548#define LUA_MININTEGER INT_MIN 549 550#elif LUA_INT_TYPE == LUA_INT_LONG /* }{ long */ 551 552#define LUA_INTEGER long 553#define LUA_INTEGER_FRMLEN "l" 554 555#define LUA_MAXINTEGER LONG_MAX 556#define LUA_MININTEGER LONG_MIN 557 558#elif LUA_INT_TYPE == LUA_INT_LONGLONG /* }{ long long */ 559 560/* use presence of macro LLONG_MAX as proxy for C99 compliance */ 561#if defined(LLONG_MAX) /* { */ 562/* use ISO C99 stuff */ 563 564#define LUA_INTEGER long long 565#define LUA_INTEGER_FRMLEN "ll" 566 567#define LUA_MAXINTEGER LLONG_MAX 568#define LUA_MININTEGER LLONG_MIN 569 570#elif defined(LUA_USE_WINDOWS) /* }{ */ 571/* in Windows, can use specific Windows types */ 572 573#define LUA_INTEGER __int64 574#define LUA_INTEGER_FRMLEN "I64" 575 576#define LUA_MAXINTEGER _I64_MAX 577#define LUA_MININTEGER _I64_MIN 578 579#else /* }{ */ 580 581#error "Compiler does not support 'long long'. Use option '-DLUA_32BITS' \ 582 or '-DLUA_C89_NUMBERS' (see file 'luaconf.h' for details)" 583 584#endif /* } */ 585 586#else /* }{ */ 587 588#error "numeric integer type not defined" 589 590#endif /* } */ 591 592/* }================================================================== */ 593 594 595/* 596** {================================================================== 597** Dependencies with C99 and other C details 598** =================================================================== 599*/ 600 601/* 602@@ l_sprintf is equivalent to 'snprintf' or 'sprintf' in C89. 603** (All uses in Lua have only one format item.) 604*/ 605#if !defined(LUA_USE_C89) 606#define l_sprintf(s,sz,f,i) snprintf(s,sz,f,i) 607#else 608#define l_sprintf(s,sz,f,i) ((void)(sz), sprintf(s,f,i)) 609#endif 610 611 612/* 613@@ lua_strx2number converts an hexadecimal numeric string to a number. 614** In C99, 'strtod' does that conversion. Otherwise, you can 615** leave 'lua_strx2number' undefined and Lua will provide its own 616** implementation. 617*/ 618#if !defined(LUA_USE_C89) 619#define lua_strx2number(s,p) lua_str2number(s,p) 620#endif 621 622 623/* 624@@ lua_number2strx converts a float to an hexadecimal numeric string. 625** In C99, 'sprintf' (with format specifiers '%a'/'%A') does that. 626** Otherwise, you can leave 'lua_number2strx' undefined and Lua will 627** provide its own implementation. 628*/ 629#if !defined(LUA_USE_C89) 630#define lua_number2strx(L,b,sz,f,n) \ 631 ((void)L, l_sprintf(b,sz,f,(LUAI_UACNUMBER)(n))) 632#endif 633 634 635/* 636** 'strtof' and 'opf' variants for math functions are not valid in 637** C89. Otherwise, the macro 'HUGE_VALF' is a good proxy for testing the 638** availability of these variants. ('math.h' is already included in 639** all files that use these macros.) 640*/ 641#if defined(LUA_USE_C89) || (defined(HUGE_VAL) && !defined(HUGE_VALF)) 642#undef l_mathop /* variants not available */ 643#undef lua_str2number 644#define l_mathop(op) (lua_Number)op /* no variant */ 645#define lua_str2number(s,p) ((lua_Number)strtod((s), (p))) 646#endif 647 648 649/* 650@@ LUA_KCONTEXT is the type of the context ('ctx') for continuation 651** functions. It must be a numerical type; Lua will use 'intptr_t' if 652** available, otherwise it will use 'ptrdiff_t' (the nearest thing to 653** 'intptr_t' in C89) 654*/ 655#define LUA_KCONTEXT ptrdiff_t 656 657#if !defined(LUA_USE_C89) && defined(__STDC_VERSION__) && \ 658 __STDC_VERSION__ >= 199901L 659#include <stdint.h> 660#if defined(INTPTR_MAX) /* even in C99 this type is optional */ 661#undef LUA_KCONTEXT 662#define LUA_KCONTEXT intptr_t 663#endif 664#endif 665 666 667/* 668@@ lua_getlocaledecpoint gets the locale "radix character" (decimal point). 669** Change that if you do not want to use C locales. (Code using this 670** macro must include header 'locale.h'.) 671*/ 672#if !defined(lua_getlocaledecpoint) 673#define lua_getlocaledecpoint() (localeconv()->decimal_point[0]) 674#endif 675 676/* }================================================================== */ 677 678 679/* 680** {================================================================== 681** Language Variations 682** ===================================================================== 683*/ 684 685/* 686@@ LUA_NOCVTN2S/LUA_NOCVTS2N control how Lua performs some 687** coercions. Define LUA_NOCVTN2S to turn off automatic coercion from 688** numbers to strings. Define LUA_NOCVTS2N to turn off automatic 689** coercion from strings to numbers. 690*/ 691/* #define LUA_NOCVTN2S */ 692/* #define LUA_NOCVTS2N */ 693 694 695/* 696@@ LUA_USE_APICHECK turns on several consistency checks on the C API. 697** Define it as a help when debugging C code. 698*/ 699#if defined(LUA_USE_APICHECK) 700#include <assert.h> 701#define luai_apicheck(l,e) assert(e) 702#endif 703 704/* }================================================================== */ 705 706 707/* 708** {================================================================== 709** Macros that affect the API and must be stable (that is, must be the 710** same when you compile Lua and when you compile code that links to 711** Lua). You probably do not want/need to change them. 712** ===================================================================== 713*/ 714 715/* 716@@ LUAI_MAXSTACK limits the size of the Lua stack. 717** CHANGE it if you need a different limit. This limit is arbitrary; 718** its only purpose is to stop Lua from consuming unlimited stack 719** space (and to reserve some numbers for pseudo-indices). 720*/ 721#if LUAI_BITSINT >= 32 722#define LUAI_MAXSTACK 1000000 723#else 724#define LUAI_MAXSTACK 15000 725#endif 726 727 728/* 729@@ LUA_EXTRASPACE defines the size of a raw memory area associated with 730** a Lua state with very fast access. 731** CHANGE it if you need a different size. 732*/ 733#define LUA_EXTRASPACE (sizeof(void *)) 734 735 736/* 737@@ LUA_IDSIZE gives the maximum size for the description of the source 738@@ of a function in debug information. 739** CHANGE it if you want a different size. 740*/ 741#define LUA_IDSIZE 60 742 743 744/* 745@@ LUAL_BUFFERSIZE is the buffer size used by the lauxlib buffer system. 746** CHANGE it if it uses too much C-stack space. (For long double, 747** 'string.format("%.99f", -1e4932)' needs 5034 bytes, so a 748** smaller buffer would force a memory allocation for each call to 749** 'string.format'.) 750*/ 751#if LUA_FLOAT_TYPE == LUA_FLOAT_LONGDOUBLE 752#define LUAL_BUFFERSIZE 8192 753#else 754#define LUAL_BUFFERSIZE ((int)(0x80 * sizeof(void*) * sizeof(lua_Integer))) 755#endif 756 757/* }================================================================== */ 758 759 760/* 761@@ LUA_QL describes how error messages quote program elements. 762** Lua does not use these macros anymore; they are here for 763** compatibility only. 764*/ 765#define LUA_QL(x) "'" x "'" 766#define LUA_QS LUA_QL("%s") 767 768 769 770 771/* =================================================================== */ 772 773/* 774** Local configuration. You can use this space to add your redefinitions 775** without modifying the main part of the file. 776*/ 777 778 779 780 781 782#endif 783 784