stand/liblua/luaconf.h

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