mirror of
https://github.com/lua/lua
synced 2024-11-22 04:41:23 +03:00
55ac40f859
Several definitions that don't need to be "global" (that is, that concerns only specific parts of the code) moved out of llimits.h, to more appropriate places.
248 lines
6.2 KiB
C
248 lines
6.2 KiB
C
/*
|
|
** $Id: llimits.h $
|
|
** Limits, basic types, and some other 'installation-dependent' definitions
|
|
** See Copyright Notice in lua.h
|
|
*/
|
|
|
|
#ifndef llimits_h
|
|
#define llimits_h
|
|
|
|
|
|
#include <limits.h>
|
|
#include <stddef.h>
|
|
|
|
|
|
#include "lua.h"
|
|
|
|
|
|
/*
|
|
** 'lu_mem' is an unsigned integer big enough to count the total memory
|
|
** used by Lua (in bytes). 'l_obj' is a signed integer big enough to
|
|
** count the total number of objects used by Lua. (It is signed due
|
|
** to the use of debt in several computations.) Usually, 'size_t' and
|
|
** 'ptrdiff_t' should work, but we use 'long' for 16-bit machines.
|
|
*/
|
|
#if defined(LUAI_MEM) /* { external definitions? */
|
|
typedef LUAI_UMEM lu_mem;
|
|
typedef LUAI_MEM l_obj;
|
|
#elif LUAI_IS32INT /* }{ */
|
|
typedef size_t lu_mem;
|
|
typedef ptrdiff_t l_obj;
|
|
#else /* 16-bit ints */ /* }{ */
|
|
typedef unsigned long lu_mem;
|
|
typedef long l_obj;
|
|
#endif /* } */
|
|
|
|
#define MAX_LOBJ \
|
|
cast(l_obj, (cast(lu_mem, 1) << (sizeof(l_obj) * CHAR_BIT - 1)) - 1)
|
|
|
|
|
|
/* chars used as small naturals (so that 'char' is reserved for characters) */
|
|
typedef unsigned char lu_byte;
|
|
typedef signed char ls_byte;
|
|
|
|
|
|
/* maximum value for size_t */
|
|
#define MAX_SIZET ((size_t)(~(size_t)0))
|
|
|
|
/*
|
|
** Maximum size for strings and userdata visible for Lua; should be
|
|
** representable as a lua_Integer and as a size_t.
|
|
*/
|
|
#define MAX_SIZE (sizeof(size_t) < sizeof(lua_Integer) ? MAX_SIZET \
|
|
: cast_sizet(LUA_MAXINTEGER))
|
|
|
|
/*
|
|
** floor of the log2 of the maximum signed value for integral type 't'.
|
|
** (That is, maximum 'n' such that '2^n' fits in the given signed type.)
|
|
*/
|
|
#define log2maxs(t) cast_int(sizeof(t) * 8 - 2)
|
|
|
|
|
|
/*
|
|
** test whether an unsigned value is a power of 2 (or zero)
|
|
*/
|
|
#define ispow2(x) (((x) & ((x) - 1)) == 0)
|
|
|
|
|
|
/* number of chars of a literal string without the ending \0 */
|
|
#define LL(x) (sizeof(x)/sizeof(char) - 1)
|
|
|
|
|
|
/*
|
|
** conversion of pointer to unsigned integer: this is for hashing only;
|
|
** there is no problem if the integer cannot hold the whole pointer
|
|
** value. (In strict ISO C this may cause undefined behavior, but no
|
|
** actual machine seems to bother.)
|
|
*/
|
|
#if !defined(LUA_USE_C89) && defined(__STDC_VERSION__) && \
|
|
__STDC_VERSION__ >= 199901L
|
|
#include <stdint.h>
|
|
#if defined(UINTPTR_MAX) /* even in C99 this type is optional */
|
|
#define L_P2I uintptr_t
|
|
#else /* no 'intptr'? */
|
|
#define L_P2I uintmax_t /* use the largest available integer */
|
|
#endif
|
|
#else /* C89 option */
|
|
#define L_P2I size_t
|
|
#endif
|
|
|
|
#define point2uint(p) cast_uint((L_P2I)(p) & UINT_MAX)
|
|
|
|
|
|
|
|
/* types of 'usual argument conversions' for lua_Number and lua_Integer */
|
|
typedef LUAI_UACNUMBER l_uacNumber;
|
|
typedef LUAI_UACINT l_uacInt;
|
|
|
|
|
|
/*
|
|
** Internal assertions for in-house debugging
|
|
*/
|
|
#if defined LUAI_ASSERT
|
|
#undef NDEBUG
|
|
#include <assert.h>
|
|
#define lua_assert(c) assert(c)
|
|
#endif
|
|
|
|
#if defined(lua_assert)
|
|
#define check_exp(c,e) (lua_assert(c), (e))
|
|
/* to avoid problems with conditions too long */
|
|
#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0))
|
|
#else
|
|
#define lua_assert(c) ((void)0)
|
|
#define check_exp(c,e) (e)
|
|
#define lua_longassert(c) ((void)0)
|
|
#endif
|
|
|
|
|
|
/* macro to avoid warnings about unused variables */
|
|
#if !defined(UNUSED)
|
|
#define UNUSED(x) ((void)(x))
|
|
#endif
|
|
|
|
|
|
/* type casts (a macro highlights casts in the code) */
|
|
#define cast(t, exp) ((t)(exp))
|
|
|
|
#define cast_void(i) cast(void, (i))
|
|
#define cast_voidp(i) cast(void *, (i))
|
|
#define cast_num(i) cast(lua_Number, (i))
|
|
#define cast_int(i) cast(int, (i))
|
|
#define cast_uint(i) cast(unsigned int, (i))
|
|
#define cast_byte(i) cast(lu_byte, (i))
|
|
#define cast_uchar(i) cast(unsigned char, (i))
|
|
#define cast_char(i) cast(char, (i))
|
|
#define cast_charp(i) cast(char *, (i))
|
|
#define cast_sizet(i) cast(size_t, (i))
|
|
|
|
|
|
/* cast a signed lua_Integer to lua_Unsigned */
|
|
#if !defined(l_castS2U)
|
|
#define l_castS2U(i) ((lua_Unsigned)(i))
|
|
#endif
|
|
|
|
/*
|
|
** cast a lua_Unsigned to a signed lua_Integer; this cast is
|
|
** not strict ISO C, but two-complement architectures should
|
|
** work fine.
|
|
*/
|
|
#if !defined(l_castU2S)
|
|
#define l_castU2S(i) ((lua_Integer)(i))
|
|
#endif
|
|
|
|
|
|
/*
|
|
** non-return type
|
|
*/
|
|
#if !defined(l_noret)
|
|
|
|
#if defined(__GNUC__)
|
|
#define l_noret void __attribute__((noreturn))
|
|
#elif defined(_MSC_VER) && _MSC_VER >= 1200
|
|
#define l_noret void __declspec(noreturn)
|
|
#else
|
|
#define l_noret void
|
|
#endif
|
|
|
|
#endif
|
|
|
|
|
|
/*
|
|
** Inline functions
|
|
*/
|
|
#if !defined(LUA_USE_C89)
|
|
#define l_inline inline
|
|
#elif defined(__GNUC__)
|
|
#define l_inline __inline__
|
|
#else
|
|
#define l_inline /* empty */
|
|
#endif
|
|
|
|
#define l_sinline static l_inline
|
|
|
|
|
|
/*
|
|
** An unsigned with (at least) 4 bytes
|
|
*/
|
|
#if LUAI_IS32INT
|
|
typedef unsigned int l_uint32;
|
|
#else
|
|
typedef unsigned long l_uint32;
|
|
#endif
|
|
|
|
|
|
/*
|
|
** The luai_num* macros define the primitive operations over numbers.
|
|
*/
|
|
|
|
/* floor division (defined as 'floor(a/b)') */
|
|
#if !defined(luai_numidiv)
|
|
#define luai_numidiv(L,a,b) ((void)L, l_floor(luai_numdiv(L,a,b)))
|
|
#endif
|
|
|
|
/* float division */
|
|
#if !defined(luai_numdiv)
|
|
#define luai_numdiv(L,a,b) ((a)/(b))
|
|
#endif
|
|
|
|
/*
|
|
** modulo: defined as 'a - floor(a/b)*b'; the direct computation
|
|
** using this definition has several problems with rounding errors,
|
|
** so it is better to use 'fmod'. 'fmod' gives the result of
|
|
** 'a - trunc(a/b)*b', and therefore must be corrected when
|
|
** 'trunc(a/b) ~= floor(a/b)'. That happens when the division has a
|
|
** non-integer negative result: non-integer result is equivalent to
|
|
** a non-zero remainder 'm'; negative result is equivalent to 'a' and
|
|
** 'b' with different signs, or 'm' and 'b' with different signs
|
|
** (as the result 'm' of 'fmod' has the same sign of 'a').
|
|
*/
|
|
#if !defined(luai_nummod)
|
|
#define luai_nummod(L,a,b,m) \
|
|
{ (void)L; (m) = l_mathop(fmod)(a,b); \
|
|
if (((m) > 0) ? (b) < 0 : ((m) < 0 && (b) > 0)) (m) += (b); }
|
|
#endif
|
|
|
|
/* exponentiation */
|
|
#if !defined(luai_numpow)
|
|
#define luai_numpow(L,a,b) \
|
|
((void)L, (b == 2) ? (a)*(a) : l_mathop(pow)(a,b))
|
|
#endif
|
|
|
|
/* the others are quite standard operations */
|
|
#if !defined(luai_numadd)
|
|
#define luai_numadd(L,a,b) ((a)+(b))
|
|
#define luai_numsub(L,a,b) ((a)-(b))
|
|
#define luai_nummul(L,a,b) ((a)*(b))
|
|
#define luai_numunm(L,a) (-(a))
|
|
#define luai_numeq(a,b) ((a)==(b))
|
|
#define luai_numlt(a,b) ((a)<(b))
|
|
#define luai_numle(a,b) ((a)<=(b))
|
|
#define luai_numgt(a,b) ((a)>(b))
|
|
#define luai_numge(a,b) ((a)>=(b))
|
|
#define luai_numisnan(a) (!luai_numeq((a), (a)))
|
|
#endif
|
|
|
|
|
|
#endif
|