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