liblua/llimits.h

   1 /*
   2 ** $Id: llimits.h,v 1.103 2013/02/20 14:08:56 roberto Exp $
   3 ** Limits, basic types, and some other `installation-dependent' definitions
   4 ** See Copyright Notice in lua.h
   5 */
   6
   7 #ifndef llimits_h
   8 #define llimits_h
   9
  10
  11 #include <limits.h>
  12 #include <stddef.h>
  13
  14
  15 #include "lua.h"
  16
  17
  18 typedef unsigned LUA_INT32 lu_int32;
  19
  20 typedef LUAI_UMEM lu_mem;
  21
  22 typedef LUAI_MEM l_mem;
  23
  24
  25
  26 /* chars used as small naturals (so that `char' is reserved for characters) */
  27 typedef unsigned char lu_byte;
  28
  29
  30 #define MAX_SIZET       ((size_t)(~(size_t)0)-2)
  31
  32 #define MAX_LUMEM       ((lu_mem)(~(lu_mem)0)-2)
  33
  34 #define MAX_LMEM        ((l_mem) ((MAX_LUMEM >> 1) - 2))
  35
  36
  37 #define MAX_INT (INT_MAX-2)  /* maximum value of an int (-2 for safety) */
  38
  39 /*
  40 ** conversion of pointer to integer
  41 ** this is for hashing only; there is no problem if the integer
  42 ** cannot hold the whole pointer value
  43 */
  44 #define IntPoint(p)  ((unsigned int)(lu_mem)(p))
  45
  46
  47
  48 /* type to ensure maximum alignment */
  49 #if !defined(LUAI_USER_ALIGNMENT_T)
  50 #define LUAI_USER_ALIGNMENT_T   union { double u; void *s; long l; }
  51 #endif
  52
  53 typedef LUAI_USER_ALIGNMENT_T L_Umaxalign;
  54
  55
  56 /* result of a `usual argument conversion' over lua_Number */
  57 typedef LUAI_UACNUMBER l_uacNumber;
  58
  59
  60 /* internal assertions for in-house debugging */
  61 #if defined(lua_assert)
  62 #define check_exp(c,e)          (lua_assert(c), (e))
  63 /* to avoid problems with conditions too long */
  64 #define lua_longassert(c)       { if (!(c)) lua_assert(0); }
  65 #else
  66 #define lua_assert(c)           ((void)0)
  67 #define check_exp(c,e)          (e)
  68 #define lua_longassert(c)       ((void)0)
  69 #endif
  70
  71 /*
  72 ** assertion for checking API calls
  73 */
  74 #if !defined(luai_apicheck)
  75
  76 #if defined(LUA_USE_APICHECK)
  77 #include <assert.h>
  78 #define luai_apicheck(L,e)      assert(e)
  79 #else
  80 #define luai_apicheck(L,e)      lua_assert(e)
  81 #endif
  82
  83 #endif
  84
  85 #define api_check(l,e,msg)      luai_apicheck(l,(e) && msg)
  86
  87
  88 #if !defined(UNUSED)
  89 #define UNUSED(x)       ((void)(x))     /* to avoid warnings */
  90 #endif
  91
  92
  93 #define cast(t, exp)    ((t)(exp))
  94
  95 #define cast_byte(i)    cast(lu_byte, (i))
  96 #define cast_num(i)     cast(lua_Number, (i))
  97 #define cast_int(i)     cast(int, (i))
  98 #define cast_uchar(i)   cast(unsigned char, (i))
  99
 100
 101 /*
 102 ** non-return type
 103 */
 104 #if defined(__GNUC__)
 105 #define l_noret         void __attribute__((noreturn))
 106 #elif defined(_MSC_VER)
 107 #define l_noret         void __declspec(noreturn)
 108 #else
 109 #define l_noret         void
 110 #endif
 111
 112
 113
 114 /*
 115 ** maximum depth for nested C calls and syntactical nested non-terminals
 116 ** in a program. (Value must fit in an unsigned short int.)
 117 */
 118 #if !defined(LUAI_MAXCCALLS)
 119 #define LUAI_MAXCCALLS          200
 120 #endif
 121
 122 /*
 123 ** maximum number of upvalues in a closure (both C and Lua). (Value
 124 ** must fit in an unsigned char.)
 125 */
 126 #define MAXUPVAL        UCHAR_MAX
 127
 128
 129 /*
 130 ** type for virtual-machine instructions
 131 ** must be an unsigned with (at least) 4 bytes (see details in lopcodes.h)
 132 */
 133 typedef lu_int32 Instruction;
 134
 135
 136
 137 /* maximum stack for a Lua function */
 138 #define MAXSTACK        250
 139
 140
 141
 142 /* minimum size for the string table (must be power of 2) */
 143 #if !defined(MINSTRTABSIZE)
 144 #define MINSTRTABSIZE   32
 145 #endif
 146
 147
 148 /* minimum size for string buffer */
 149 #if !defined(LUA_MINBUFFER)
 150 #define LUA_MINBUFFER   32
 151 #endif
 152
 153
 154 #if !defined(lua_lock)
 155 #define lua_lock(L)     ((void) 0)
 156 #define lua_unlock(L)   ((void) 0)
 157 #endif
 158
 159 #if !defined(luai_threadyield)
 160 #define luai_threadyield(L)     {lua_unlock(L); lua_lock(L);}
 161 #endif
 162
 163
 164 /*
 165 ** these macros allow user-specific actions on threads when you defined
 166 ** LUAI_EXTRASPACE and need to do something extra when a thread is
 167 ** created/deleted/resumed/yielded.
 168 */
 169 #if !defined(luai_userstateopen)
 170 #define luai_userstateopen(L)           ((void)L)
 171 #endif
 172
 173 #if !defined(luai_userstateclose)
 174 #define luai_userstateclose(L)          ((void)L)
 175 #endif
 176
 177 #if !defined(luai_userstatethread)
 178 #define luai_userstatethread(L,L1)      ((void)L)
 179 #endif
 180
 181 #if !defined(luai_userstatefree)
 182 #define luai_userstatefree(L,L1)        ((void)L)
 183 #endif
 184
 185 #if !defined(luai_userstateresume)
 186 #define luai_userstateresume(L,n)       ((void)L)
 187 #endif
 188
 189 #if !defined(luai_userstateyield)
 190 #define luai_userstateyield(L,n)        ((void)L)
 191 #endif
 192
 193 /*
 194 ** lua_number2int is a macro to convert lua_Number to int.
 195 ** lua_number2integer is a macro to convert lua_Number to lua_Integer.
 196 ** lua_number2unsigned is a macro to convert a lua_Number to a lua_Unsigned.
 197 ** lua_unsigned2number is a macro to convert a lua_Unsigned to a lua_Number.
 198 ** luai_hashnum is a macro to hash a lua_Number value into an integer.
 199 ** The hash must be deterministic and give reasonable values for
 200 ** both small and large values (outside the range of integers).
 201 */
 202
 203 #if defined(MS_ASMTRICK) || defined(LUA_MSASMTRICK)     /* { */
 204 /* trick with Microsoft assembler for X86 */
 205
 206 #define lua_number2int(i,n)  __asm {__asm fld n   __asm fistp i}
 207 #define lua_number2integer(i,n)         lua_number2int(i, n)
 208 #define lua_number2unsigned(i,n)  \
 209   {__int64 l; __asm {__asm fld n   __asm fistp l} i = (unsigned int)l;}
 210
 211
 212 #elif defined(LUA_IEEE754TRICK)         /* }{ */
 213 /* the next trick should work on any machine using IEEE754 with
 214    a 32-bit int type */
 215
 216 union luai_Cast { double l_d; LUA_INT32 l_p[2]; };
 217
 218 #if !defined(LUA_IEEEENDIAN)    /* { */
 219 #define LUAI_EXTRAIEEE  \
 220   static const union luai_Cast ieeeendian = {-(33.0 + 6755399441055744.0)};
 221 #define LUA_IEEEENDIANLOC       (ieeeendian.l_p[1] == 33)
 222 #else
 223 #define LUA_IEEEENDIANLOC       LUA_IEEEENDIAN
 224 #define LUAI_EXTRAIEEE          /* empty */
 225 #endif                          /* } */
 226
 227 #define lua_number2int32(i,n,t) \
 228   { LUAI_EXTRAIEEE \
 229     volatile union luai_Cast u; u.l_d = (n) + 6755399441055744.0; \
 230     (i) = (t)u.l_p[LUA_IEEEENDIANLOC]; }
 231
 232 #define luai_hashnum(i,n)  \
 233   { volatile union luai_Cast u; u.l_d = (n) + 1.0;  /* avoid -0 */ \
 234     (i) = u.l_p[0]; (i) += u.l_p[1]; }  /* add double bits for his hash */
 235
 236 #define lua_number2int(i,n)             lua_number2int32(i, n, int)
 237 #define lua_number2unsigned(i,n)        lua_number2int32(i, n, lua_Unsigned)
 238
 239 /* the trick can be expanded to lua_Integer when it is a 32-bit value */
 240 #if defined(LUA_IEEELL)
 241 #define lua_number2integer(i,n)         lua_number2int32(i, n, lua_Integer)
 242 #endif
 243
 244 #endif                          /* } */
 245
 246
 247 /* the following definitions always work, but may be slow */
 248
 249 #if !defined(lua_number2int)
 250 #define lua_number2int(i,n)     ((i)=(int)(n))
 251 #endif
 252
 253 #if !defined(lua_number2integer)
 254 #define lua_number2integer(i,n) ((i)=(lua_Integer)(n))
 255 #endif
 256
 257 #if !defined(lua_number2unsigned)       /* { */
 258 /* the following definition assures proper modulo behavior */
 259 #if defined(LUA_NUMBER_DOUBLE) || defined(LUA_NUMBER_FLOAT)
 260 #include <math.h>
 261 #define SUPUNSIGNED     ((lua_Number)(~(lua_Unsigned)0) + 1)
 262 #define lua_number2unsigned(i,n)  \
 263         ((i)=(lua_Unsigned)((n) - floor((n)/SUPUNSIGNED)*SUPUNSIGNED))
 264 #else
 265 #define lua_number2unsigned(i,n)        ((i)=(lua_Unsigned)(n))
 266 #endif
 267 #endif                          /* } */
 268
 269
 270 #if !defined(lua_unsigned2number)
 271 /* on several machines, coercion from unsigned to double is slow,
 272    so it may be worth to avoid */
 273 #define lua_unsigned2number(u)  \
 274     (((u) <= (lua_Unsigned)INT_MAX) ? (lua_Number)(int)(u) : (lua_Number)(u))
 275 #endif
 276
 277
 278
 279 #if defined(ltable_c) && !defined(luai_hashnum)
 280
 281 #include <float.h>
 282 #include <math.h>
 283
 284 #define luai_hashnum(i,n) { int e;  \
 285   n = l_mathop(frexp)(n, &e) * (lua_Number)(INT_MAX - DBL_MAX_EXP);  \
 286   lua_number2int(i, n); i += e; }
 287
 288 #endif
 289
 290
 291
 292 /*
 293 ** macro to control inclusion of some hard tests on stack reallocation
 294 */
 295 #if !defined(HARDSTACKTESTS)
 296 #define condmovestack(L)        ((void)0)
 297 #else
 298 /* realloc stack keeping its size */
 299 #define condmovestack(L)        luaD_reallocstack((L), (L)->stacksize)
 300 #endif
 301
 302 #if !defined(HARDMEMTESTS)
 303 #define condchangemem(L)        condmovestack(L)
 304 #else
 305 #define condchangemem(L)  \
 306         ((void)(!(G(L)->gcrunning) || (luaC_fullgc(L, 0), 1)))
 307 #endif
 308
 309 #endif