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