diff -r lua-5.3.0/Makefile lua-5.3.1/Makefile 49c49 < R= $V.0 --- > R= $V.1 diff -r lua-5.3.0/README lua-5.3.1/README 2c2 < This is Lua 5.3.0, released on 06 Jan 2015. --- > This is Lua 5.3.1, released on 10 Jun 2015. diff -r lua-5.3.0/doc/contents.html lua-5.3.1/doc/contents.html 5a6 > 7,12d7 < 17d11 <

19c13 <

--- >

24a19 >
28c23 <

--- >

34c29,33 <

--- > · > other versions >

> >

42c41 <

548a548 >

609,610c609 <

Lua 5.3 Reference Manual

< --- >

> 17c15 <

20,21c19,21 <

< --- > >

> 25,27c25 < <

--- > 29c27,30 < contents --- >

> contents > · > index 31c32,33 < index --- > other versions >

Nil

nil

nil

nil

Boolean

false

true

boolean

false

true

Number

number

String

string

Not a Number

0/0

Not a Number

0/0

obj

<      rawget(getmetatable(obj) or {}, "__" .. event_name)
<

__lt

__le

> It is a good practice to add all needed metamethods to a table > before setting it as a metatable of some object. > In particular, the "__gc" metamethod works only when this order > is followed (see §2.5.1). > > 755,756d761 < However, after an object has been marked, < you can freely change the __gc field of its metatable. 797c802 < the object memory is freed only in the GC cycle where --- > the object memory is freed only in a GC cycle where 825,826c830,831 < A table with weak keys allows the collection of its keys, < but prevents the collection of its values. --- > A table with weak values allows the collection of its values, > but prevents the collection of its keys. 916,917c921,922 < the coroutine starts its execution, < at the first line of its main function. --- > the coroutine starts its execution by > calling its main function. 919c924 < as arguments to the coroutine's main function. --- > as arguments to that function. 1114c1119 < we can specify any byte in a literal string by its numerical value. --- > we can specify any byte in a literal string by its numeric value. 1189c1194 < A numerical constant (or numeral) --- > A numeric constant (or numeral) 1584c1589 < one numeric and one generic. --- > one numerical and one generic. 1588c1593 < The numeric for loop repeats a block of code while a --- > The numerical for loop repeats a block of code while a 1882c1887 < that rounds the quotient towards minus infinite, --- > that rounds the quotient towards minus infinity, 1888c1893 < that rounds the quotient towards minus infinite (floor division). --- > that rounds the quotient towards minus infinity (floor division). 1975,1976c1980,1982 < Then, the resulting number is converted to the required type < (float or integer) according to the previous rules. --- > Then, the resulting number (float or integer) > is converted to the type (float or integer) required by the context > (e.g., the operation that forced the conversion). 2009,2013c2015 < Numbers follow the usual rule for binary operations: < if both operands are integers, < they are compared as integers; < otherwise, they are converted to floats < and compared as such. --- > Numbers are equal if they denote the same mathematical value. 2048,2049c2050,2051 < then they are compared following < the usual rule for binary operations. --- > then they are compared according to their mathematical values > (regardless of their subtypes). 2057a2060,2065 >

> Following the IEEE 754 standard, > NaN is considered neither smaller than, > nor equal to, nor greater than any value (including itself). > > 2639,2652c2647,2654 < real position within the stack, that is, < its position lies between 1 and the stack top < (1 ≤ abs(index) ≤ top). < < Usually, functions that can modify the value at an index < require valid indices. < < <

< Unless otherwise noted, < any function that accepts valid indices also accepts pseudo-indices, < which represent some Lua values that are accessible to C code < but which are not in the stack. < Pseudo-indices are used to access the registry --- > position that stores a modifiable Lua value. > It comprises stack indices between 1 and the stack top > (1 ≤ abs(index) ≤ top) > > plus pseudo-indices, > which represent some positions that are accessible to C code > but that are not in the stack. > Pseudo-indices are used to access the registry (see §4.5) 2657,2658c2659,2660 < Functions that do not need a specific stack position, < but only a value in the stack (e.g., query functions), --- > Functions that do not need a specific mutable position, > but only a value (e.g., query functions), 2661d2662 < including the pseudo-indices, 2704c2705 < The first value associated with a function is at position --- > The first upvalue associated with a function is at index 2722,2723c2723 < LUA_REGISTRYINDEX, < which is a valid index. --- > LUA_REGISTRYINDEX. 2984c2984,2985 < Converts the acceptable index idx into an absolute index --- > Converts the acceptable index idx > into an equivalent absolute index 3227c3228 < of numerical arguments and returns their average and their sum: --- > of numeric arguments and returns their average and their sum: 3386,3387c3387,3389 < the binary representation is created without debug information < about the function. --- > the binary representation may not include all debug information > about the function, > to save space. 3664c3666 < (See LUA_INT in luaconf.h.) --- > (See LUA_INT_TYPE in luaconf.h.) 3853c3855 < It must be a numerical type. --- > It must be a numeric type. 4071c4073 <

typedef double lua_Number;

typedef ... lua_Number;

LUA_REAL

luaconf.h

LUA_FLOAT_TYPE

luaconf.h

< lua_pushcfunction is defined as a macro: < <

<      #define lua_pushcfunction(L,f)  lua_pushcclosure(L,f,0)
<

< Note that f is used twice. < < 4312c4305 < '%L' (inserts a lua_Integer), --- > '%I' (inserts a lua_Integer), 4372,4374c4365,4366 < This macro is equivalent to lua_pushlstring, < but can be used only when s is a literal string. < It automatically provides the string length. --- > This macro is equivalent to lua_pushstring, > but should be used only when s is a literal string. 4601c4593 < Does the equivalent of t[k] = v, --- > Does the equivalent of t[p] = v, 4603c4595 < k is the pointer p represented as a light userdata, --- > p is encoded as a light userdata, 4675c4667 < (therefore replacing the value at the given index), --- > (therefore replacing the value at that given index), 4687c4679 < Starts and resumes a coroutine in a given thread. --- > Starts and resumes a coroutine in the given thread L. 4734,4735c4726,4729 < Rotates the stack elements from idx to the top n positions < in the direction of the top, for a positive n, --- > Rotates the stack elements between the valid index idx > and the top of the stack. > The elements are rotated n positions in the direction of the top, > for a positive n, 4739a4734,4735 > This function cannot be called with a pseudo-index, > because a pseudo-index is not an actual stack position. 5075c5071 < Typically this function is used only for debug information. --- > Typically this function is used only for hashing and debug information. 5130c5126 < LUA_TNIL, --- > LUA_TNIL (0), 5621,5626c5617,5619 < Gets information about a closure's upvalue. < (For Lua functions, < upvalues are the external local variables that the function uses, < and that are consequently included in its closure.) < lua_getupvalue gets the index n of an upvalue, < pushes the upvalue's value onto the stack, --- > Gets information about the n-th upvalue > of the closure at index funcindex. > It pushes the upvalue's value onto the stack 5628,5631c5621,5622 < funcindex points to the closure in the stack. < (Upvalues have no particular order, < as they are active through the whole function. < So, they are numbered in an arbitrary order.) --- > Returns NULL (and pushes nothing) > when the index n is greater than the number of upvalues. 5635,5636d5625 < Returns NULL (and pushes nothing) < when the index is greater than the number of upvalues. 5638a5628,5636 > (For Lua functions, > upvalues are the external local variables that the function uses, > and that are consequently included in its closure.) > > >

> Upvalues have no particular order, > as they are active through the whole function. > They are numbered in an arbitrary order. 5683,5686c5681,5684 < Only count and line events can yield < and they cannot yield any value; < to yield a hook function must finish its execution < calling lua_yield with nresults equal to zero. --- > Only count and line events can yield; > to yield, a hook function must finish its execution > calling lua_yield with nresults equal to zero > (that is, with no values). 5751,5753c5749 < Parameters ar and n are as in lua_getlocal < (see lua_getlocal). < lua_setlocal assigns the value at the top of the stack --- > It assigns the value at the top of the stack 5763a5760,5763 >

> Parameters ar and n are as in function lua_getlocal. > > 5776,5777d5775 < Parameters funcindex and n are as in the lua_getupvalue < (see lua_getupvalue). 5782c5780,5784 < when the index is greater than the number of upvalues. --- > when the index n is greater than the number of upvalues. > > >

> Parameters funcindex and n are as in function lua_getupvalue. 5795,5797d5796 < Parameters funcindex and n are as in the lua_getupvalue < (see lua_getupvalue) < (but n cannot be greater than the number of upvalues). 5807a5807,5811 >

> Parameters funcindex and n are as in function lua_getupvalue, > but n cannot be greater than the number of upvalues. > > 6370,6372c6374,6376 < in the registry (see luaL_newmetatable). < If there is no metatable associated with tname, < returns false and pushes nil. --- > in the registry (see luaL_newmetatable) > (nil if there is no metatable associated with that name). > Returns the type of the pushed value. 7336c7340 < (To traverse a table in numeric order, --- > (To traverse a table in numerical order, 7525,7526d7528 < Floats always produce strings with some < floating-point indication (either a decimal dot or an exponent). 7582,7583c7584,7585 < The operations related to coroutines comprise a sub-library of < the basic library and come inside the table coroutine. --- > This library comprises the operations to manipulate coroutines, > which come inside the table coroutine. 7593c7595 < f must be a Lua function. --- > f must be a function. 7677c7679 < f must be a Lua function. --- > f must be a function. 8076c8078 < Returns the internal numerical codes of the characters s[i], --- > Returns the internal numeric codes of the characters s[i], 8085c8087 < Numerical codes are not necessarily portable across platforms. --- > Numeric codes are not necessarily portable across platforms. 8094c8096 < in which each character has the internal numerical code equal --- > in which each character has the internal numeric code equal 8099c8101 < Numerical codes are not necessarily portable across platforms. --- > Numeric codes are not necessarily portable across platforms. 8115,8117c8117,8119 < the binary representation is created without debug information < about the function < (local variable names, lines, etc.). --- > the binary representation may not include all debug information > about the function, > to save space. 8141c8143 < A third, optional numerical argument init specifies --- > A third, optional numeric argument init specifies 8189,8190c8191 < A and a (when available), < E, e, f, --- > A, a, E, e, f, 8195,8197c8196,8198 < Option q expects a string; < option s expects a string without embedded zeros. < If the argument to option s is not a string, --- > Option q expects a string. > Option s expects a string without embedded zeros; > if its argument is not a string, 8200a8202,8207 >

> When Lua is compiled with a non-C99 compiler, > options A and a (hexadecimal floats) > do not support any modifier (flags, width, length). > > 8347c8354 < A third, optional numerical argument init specifies --- > A third, optional numeric argument init specifies 8502c8509 < (including all punctuations, even the non-magical) --- > (including all punctuation characters, even the non-magical) 8907c8914 < Index f must be positive. --- > The number of elements to be moved must fit in a Lua integer. 9123c9130 < a value larger than any other numerical value. --- > a value larger than any other numeric value. 9605,9606c9612,9613 < is a valid prefix for a number; < if that prefix does not form a valid number --- > is a valid prefix for a numeral; > if that prefix does not form a valid numeral 9611,9614d9617 <

"i": < reads an integral number and returns it as an integer. <

sec

hour

10096c10108 < a table with a name for the current function, --- > a name for the current function, 10602c10614,10615 < while the bitwise operators in standard Lua operate on 64-bit integers.) --- > while the bitwise operators in Lua 5.3 operate on Lua integers, > which by default have 64 bits.) 10617c10630 < For compatibility, Lua will continue to ignore this character. --- > For compatibility, Lua will continue to accept (and ignore) this character. 10643a10657,10662 >

> The call collectgarbage("count") now returns only one result. > (You can compute that second result from the fractional part > of the first result.) >

--- >

46a46 >

lua-5.3.0

lua-5.3.x

readline

libreadline-dev

readline-devel

319c316 < [osi certified] --- > 321,322d317 < <

361,362c356 <

< #define luai_apicheck(e) assert(e) < #else < #define luai_apicheck(e) lua_assert(e) --- > #if !defined(luai_apicheck) > #define luai_apicheck(l,e) lua_assert(e) 98,99c95 < < #define api_check(e,msg) luai_apicheck((e) && msg) --- > #define api_check(l,e,msg) luai_apicheck(l,(e) && msg) 101a98 > /* macro to avoid warnings about unused variables */ 103c100 < #define UNUSED(x) ((void)(x)) /* to avoid warnings */ --- > #define UNUSED(x) ((void)(x)) 106a104 > /* type casts (a macro highlights casts in the code) */ 152,156d149 < /* < ** maximum number of upvalues in a closure (both C and Lua). (Value < ** must fit in an unsigned char.) < */ < #define MAXUPVAL UCHAR_MAX 170a164,172 > /* > ** Maximum length for short strings, that is, strings that are > ** internalized. (Cannot be smaller than reserved words or tags for > ** metamethods, as these strings must be internalized; > ** #("function") = 8, #("__newindex") = 10.) > */ > #if !defined(LUAI_MAXSHORTLEN) > #define LUAI_MAXSHORTLEN 40 > #endif 172c174,180 < /* minimum size for the string table (must be power of 2) */ --- > > /* > ** Initial size for the string table (must be power of 2). > ** The Lua core alone registers ~50 strings (reserved words + > ** metaevent keys + a few others). Libraries would typically add > ** a few dozens more. > */ 174c182,190 < #define MINSTRTABSIZE 64 /* minimum size for "predefined" strings */ --- > #define MINSTRTABSIZE 128 > #endif > > > /* > ** Size of cache for strings in the API (better be a prime) > */ > #if !defined(STRCACHE_SIZE) > #define STRCACHE_SIZE 127 183a200,203 > /* > ** macros that are executed whenether program enters the Lua core > ** ('lua_lock') and leaves the core ('lua_unlock') > */ 188a209,212 > /* > ** macro executed during Lua functions at points where the > ** function can yield. > */ 225a250,296 > ** 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'; this definition gives NaN when > ** 'b' is huge, but the result should be 'a'. '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, which is equivalent to the test below. > */ > #if !defined(luai_nummod) > #define luai_nummod(L,a,b,m) \ > { (m) = l_mathop(fmod)(a,b); if ((m)*(b) < 0) (m) += (b); } > #endif > > /* exponentiation */ > #if !defined(luai_numpow) > #define luai_numpow(L,a,b) ((void)L, 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_numisnan(a) (!luai_numeq((a), (a))) > #endif > > > > > > /* diff -r lua-5.3.0/src/lmathlib.c lua-5.3.1/src/lmathlib.c 2c2 < ** $Id: lmathlib.c,v 1.114 2014/12/27 20:32:26 roberto Exp $ --- > ** $Id: lmathlib.c,v 1.115 2015/03/12 14:04:04 roberto Exp $ 185a186,188 > #if !defined(LUA_USE_C89) > if (base == 2.0) res = l_mathop(log2)(x); else > #endif diff -r lua-5.3.0/src/lmem.c lua-5.3.1/src/lmem.c 2c2 < ** $Id: lmem.c,v 1.89 2014/11/02 19:33:33 roberto Exp $ --- > ** $Id: lmem.c,v 1.91 2015/03/06 19:45:54 roberto Exp $ 88,91c88,92 < api_check( nsize > realosize, < "realloc cannot fail when shrinking a block"); < luaC_fullgc(L, 1); /* try to free some memory... */ < newblock = (*g->frealloc)(g->ud, block, osize, nsize); /* try again */ --- > lua_assert(nsize > realosize); /* cannot fail when shrinking a block */ > if (g->version) { /* is state fully built? */ > luaC_fullgc(L, 1); /* try to free some memory... */ > newblock = (*g->frealloc)(g->ud, block, osize, nsize); /* try again */ > } diff -r lua-5.3.0/src/loadlib.c lua-5.3.1/src/loadlib.c 2c2 < ** $Id: loadlib.c,v 1.124 2015/01/05 13:51:39 roberto Exp $ --- > ** $Id: loadlib.c,v 1.126 2015/02/16 13:14:33 roberto Exp $ 16a17 > #include 139,140c140,141 < ** Macro to covert pointer to void* to pointer to function. This cast < ** is undefined according to ISO C, but POSIX assumes that it must work. --- > ** Macro to convert pointer-to-void* to pointer-to-function. This cast > ** is undefined according to ISO C, but POSIX assumes that it works. diff -r lua-5.3.0/src/lobject.c lua-5.3.1/src/lobject.c 2c2 < ** $Id: lobject.c,v 2.101 2014/12/26 14:43:45 roberto Exp $ --- > ** $Id: lobject.c,v 2.104 2015/04/11 18:30:08 roberto Exp $ 12a13,14 > #include > #include 42,43c44,49 < while (x >= 0x10) { < x = (x+1) >> 1; --- > while (x >= (8 << 4)) { /* coarse steps */ > x = (x + 0xf) >> 4; /* x = ceil(x / 16) */ > e += 4; > } > while (x >= (8 << 1)) { /* fine steps */ > x = (x + 1) >> 1; /* x = ceil(x / 2) */ 57a64,66 > /* > ** Computes ceil(log2(x)) > */ 59c68 < static const lu_byte log_2[256] = { --- > static const lu_byte log_2[256] = { /* log_2[i] = ceil(log2(i - 1)) */ 152c161 < luaT_trybinTM(L, p1, p2, res, cast(TMS, op - LUA_OPADD + TM_ADD)); --- > luaT_trybinTM(L, p1, p2, res, cast(TMS, (op - LUA_OPADD) + TM_ADD)); 158c167 < else return ltolower(c) - 'a' + 10; --- > else return (ltolower(c) - 'a') + 10; 175d183 < #if !defined(lua_strx2number) 177c185 < #include --- > #if !defined(lua_strx2number) 187a196 > int dot = lua_getlocaledecpoint(); 193c202 < int dot = 0; /* true after seen a dot */ --- > int hasdot = 0; /* true after seen a dot */ 200,202c209,211 < if (*s == '.') { < if (dot) break; /* second dot? stop loop */ < else dot = 1; --- > if (*s == dot) { > if (hasdot) break; /* second dot? stop loop */ > else hasdot = 1; 210c219 < if (dot) e--; /* decimal digit? correct exponent */ --- > if (hasdot) e--; /* decimal digit? correct exponent */ 247c256 < if (endptr == s) return 0; /* nothing recognized */ --- > if (endptr == s) return NULL; /* nothing recognized */ 293c302 < return (e - s + 1); /* success; return string size */ --- > return (e - s) + 1; /* success; return string size */ 332c341 < buff[len++] = '.'; --- > buff[len++] = lua_getlocaledecpoint(); diff -r lua-5.3.0/src/lobject.h lua-5.3.1/src/lobject.h 2c2 < ** $Id: lobject.h,v 2.106 2015/01/05 13:52:37 roberto Exp $ --- > ** $Id: lobject.h,v 2.111 2015/06/09 14:21:42 roberto Exp $ 38,39d37 < #define VARBITS (3 << 4) < 192a191,193 > #define chgfltvalue(obj,x) \ > { TValue *io=(obj); lua_assert(ttisfloat(io)); val_(io).n=(x); } > 195a197,199 > #define chgivalue(obj,x) \ > { TValue *io=(obj); lua_assert(ttisinteger(io)); val_(io).i=(x); } > 305a310 > lu_byte shrlen; /* length for short strings */ 307,308c312,315 < size_t len; /* number of characters in string */ < struct TString *hnext; /* linked list for hash table */ --- > union { > size_t lnglen; /* length for long strings */ > struct TString *hnext; /* linked list for hash table */ > } u; 331a339,344 > /* get string length from 'TString *s' */ > #define tsslen(s) ((s)->tt == LUA_TSHRSTR ? (s)->shrlen : (s)->u.lnglen) > > /* get string length from 'TValue *o' */ > #define vslen(o) tsslen(tsvalue(o)) > 364c377 < iu->user_ = io->value_; iu->ttuv_ = io->tt_; \ --- > iu->user_ = io->value_; iu->ttuv_ = rttype(io); \ 370c383 < io->value_ = iu->user_; io->tt_ = iu->ttuv_; \ --- > io->value_ = iu->user_; settt_(io, iu->ttuv_); \ 379c392 < lu_byte instack; /* whether it is in stack */ --- > lu_byte instack; /* whether it is in stack (register) */ 402c415 < lu_byte maxstacksize; /* maximum stack used by this function */ --- > lu_byte maxstacksize; /* number of registers needed by this function */ 412c425 < Instruction *code; --- > Instruction *code; /* opcodes */ 417c430 < struct LClosure *cache; /* last created closure with this prototype */ --- > struct LClosure *cache; /* last-created closure with this prototype */ diff -r lua-5.3.0/src/loslib.c lua-5.3.1/src/loslib.c 2c2 < ** $Id: loslib.c,v 1.54 2014/12/26 14:46:07 roberto Exp $ --- > ** $Id: loslib.c,v 1.57 2015/04/10 17:41:04 roberto Exp $ 25d24 < #if !defined(LUA_STRFTIMEOPTIONS) /* { */ 26a26 > ** {================================================================== 27a28 > ** =================================================================== 28a30 > #if !defined(LUA_STRFTIMEOPTIONS) /* { */ 39a42 > /* }================================================================== */ 41a45,49 > /* > ** {================================================================== > ** Configuration for time-related stuff > ** =================================================================== > */ 53a62,84 > #if !defined(l_gmtime) /* { */ > /* > ** By default, Lua uses gmtime/localtime, except when POSIX is available, > ** where it uses gmtime_r/localtime_r > */ > > #if defined(LUA_USE_POSIX) /* { */ > > #define l_gmtime(t,r) gmtime_r(t,r) > #define l_localtime(t,r) localtime_r(t,r) > > #else /* }{ */ > > /* ISO C definitions */ > #define l_gmtime(t,r) ((void)(r)->tm_sec, gmtime(t)) > #define l_localtime(t,r) ((void)(r)->tm_sec, localtime(t)) > > #endif /* } */ > > #endif /* } */ > > /* }================================================================== */ > 55d85 < #if !defined(lua_tmpnam) /* { */ 57,58c87,91 < ** By default, Lua uses tmpnam except when POSIX is available, where it < ** uses mkstemp. --- > ** {================================================================== > ** Configuration for 'tmpnam': > ** By default, Lua uses tmpnam except when POSIX is available, where > ** it uses mkstemp. > ** =================================================================== 59a93 > #if !defined(lua_tmpnam) /* { */ 85a120 > /* }================================================================== */ 89,110d123 < #if !defined(l_gmtime) /* { */ < /* < ** By default, Lua uses gmtime/localtime, except when POSIX is available, < ** where it uses gmtime_r/localtime_r < */ < < #if defined(LUA_USE_POSIX) /* { */ < < #define l_gmtime(t,r) gmtime_r(t,r) < #define l_localtime(t,r) localtime_r(t,r) < < #else /* }{ */ < < /* ISO C definitions */ < #define l_gmtime(t,r) ((void)(r)->tm_sec, gmtime(t)) < #define l_localtime(t,r) ((void)(r)->tm_sec, localtime(t)) < < #endif /* } */ < < #endif /* } */ < < 290c303 < luaL_error(L, "time result cannot be represented in this Lua instalation"); --- > luaL_error(L, "time result cannot be represented in this Lua installation"); 300,301c313,315 < double res = difftime((l_checktime(L, 1)), (l_checktime(L, 2))); < lua_pushnumber(L, (lua_Number)res); --- > time_t t1 = l_checktime(L, 1); > time_t t2 = l_checktime(L, 2); > lua_pushnumber(L, (lua_Number)difftime(t1, t2)); diff -r lua-5.3.0/src/lstate.c lua-5.3.1/src/lstate.c 2c2 < ** $Id: lstate.c,v 2.127 2014/11/02 19:33:33 roberto Exp $ --- > ** $Id: lstate.c,v 2.128 2015/03/04 13:31:21 roberto Exp $ 40,42d39 < #define MEMERRMSG "not enough memory" < < 203c200 < luaS_resize(L, MINSTRTABSIZE); /* initial size of string table */ --- > luaS_init(L); 206,208d202 < /* pre-create memory-error message */ < g->memerrmsg = luaS_newliteral(L, MEMERRMSG); < luaC_fix(L, obj2gco(g->memerrmsg)); /* it should never be collected */ diff -r lua-5.3.0/src/lstate.h lua-5.3.1/src/lstate.h 2c2 < ** $Id: lstate.h,v 2.119 2014/10/30 18:53:28 roberto Exp $ --- > ** $Id: lstate.h,v 2.122 2015/06/01 16:34:37 roberto Exp $ 96a97 > #define CIST_LEQ (1<<7) /* using __lt for __le */ 142a144 > TString *strcache[STRCACHE_SIZE][1]; /* cache for strings in API */ diff -r lua-5.3.0/src/lstring.c lua-5.3.1/src/lstring.c 2c2 < ** $Id: lstring.c,v 2.45 2014/11/02 19:19:04 roberto Exp $ --- > ** $Id: lstring.c,v 2.49 2015/06/01 16:34:37 roberto Exp $ 24a25,26 > #define MEMERRMSG "not enough memory" > 39c41 < size_t len = a->len; --- > size_t len = a->u.lnglen; 42c44 < ((len == b->len) && /* equal length and ... */ --- > ((len == b->u.lnglen) && /* equal length and ... */ 72c74 < TString *hnext = p->hnext; /* save next */ --- > TString *hnext = p->u.hnext; /* save next */ 74c76 < p->hnext = tb->hash[h]; /* chain it */ --- > p->u.hnext = tb->hash[h]; /* chain it */ 87a90,117 > /* > ** Clear API string cache. (Entries cannot be empty, so fill them with > ** a non-collectable string.) > */ > void luaS_clearcache (global_State *g) { > int i; > for (i = 0; i < STRCACHE_SIZE; i++) { > if (iswhite(g->strcache[i][0])) /* will entry be collected? */ > g->strcache[i][0] = g->memerrmsg; /* replace it with something fixed */ > } > } > > > /* > ** Initialize the string table and the string cache > */ > void luaS_init (lua_State *L) { > global_State *g = G(L); > int i; > luaS_resize(L, MINSTRTABSIZE); /* initial size of string table */ > /* pre-create memory-error message */ > g->memerrmsg = luaS_newliteral(L, MEMERRMSG); > luaC_fix(L, obj2gco(g->memerrmsg)); /* it should never be collected */ > for (i = 0; i < STRCACHE_SIZE; i++) /* fill cache with valid strings */ > g->strcache[i][0] = g->memerrmsg; > } > > 100d129 < ts->len = l; 113,114c142,143 < p = &(*p)->hnext; < *p = (*p)->hnext; /* remove element from its list */ --- > p = &(*p)->u.hnext; > *p = (*p)->u.hnext; /* remove element from its list */ 127,128c156,157 < for (ts = *list; ts != NULL; ts = ts->hnext) { < if (l == ts->len && --- > for (ts = *list; ts != NULL; ts = ts->u.hnext) { > if (l == ts->shrlen && 141c170,171 < ts->hnext = *list; --- > ts->shrlen = cast_byte(l); > ts->u.hnext = *list; 154a185 > TString *ts; 157c188,190 < return createstrobj(L, str, l, LUA_TLNGSTR, G(L)->seed); --- > ts = createstrobj(L, str, l, LUA_TLNGSTR, G(L)->seed); > ts->u.lnglen = l; > return ts; 163c196,199 < ** new zero-terminated string --- > ** Create or reuse a zero-terminated string, first checking in the > ** cache (using the string address as a key). The cache can contain > ** only zero-terminated strings, so it is safe to use 'strcmp' to > ** check hits. 166c202,210 < return luaS_newlstr(L, str, strlen(str)); --- > unsigned int i = point2uint(str) % STRCACHE_SIZE; /* hash */ > TString **p = G(L)->strcache[i]; > if (strcmp(str, getstr(p[0])) == 0) /* hit? */ > return p[0]; /* that it is */ > else { /* normal route */ > TString *s = luaS_newlstr(L, str, strlen(str)); > p[0] = s; > return s; > } diff -r lua-5.3.0/src/lstring.h lua-5.3.1/src/lstring.h 2c2 < ** $Id: lstring.h,v 1.56 2014/07/18 14:46:47 roberto Exp $ --- > ** $Id: lstring.h,v 1.59 2015/03/25 13:42:19 roberto Exp $ 16d15 < #define sizestring(s) sizelstring((s)->len) 39a39,40 > LUAI_FUNC void luaS_clearcache (global_State *g); > LUAI_FUNC void luaS_init (lua_State *L); diff -r lua-5.3.0/src/lstrlib.c lua-5.3.1/src/lstrlib.c 2c2 < ** $Id: lstrlib.c,v 1.221 2014/12/11 14:03:07 roberto Exp $ --- > ** $Id: lstrlib.c,v 1.229 2015/05/20 17:39:23 roberto Exp $ 13a14 > #include 73c74 < lua_pushlstring(L, s + start - 1, (size_t)(end - start + 1)); --- > lua_pushlstring(L, s + start - 1, (size_t)(end - start) + 1); 152,153c153 < n = (int)(pose - posi + 1); < if (posi + n <= pose) /* arithmetic overflow? */ --- > if (pose - posi >= INT_MAX) /* arithmetic overflow? */ 154a155 > n = (int)(pose - posi) + 1; 502c503 < /* go through */ --- > /* FALLTHROUGH */ 557c558 < lua_pushinteger(ms->L, ms->capture[i].init - ms->src_init + 1); --- > lua_pushinteger(ms->L, (ms->capture[i].init - ms->src_init) + 1); 601,602c602,603 < lua_pushinteger(L, s2 - s + 1); < lua_pushinteger(L, s2 - s + lp); --- > lua_pushinteger(L, (s2 - s) + 1); > lua_pushinteger(L, (s2 - s) + lp); 624c625 < lua_pushinteger(L, s1 - s + 1); /* start */ --- > lua_pushinteger(L, (s1 - s) + 1); /* start */ 800,801c801,886 < /* maximum size of each formatted item (> len(format('%99.99f', -1e308))) */ < #define MAX_ITEM 512 --- > #if !defined(lua_number2strx) /* { */ > > /* > ** Hexadecimal floating-point formatter > */ > > #include > #include > > #define SIZELENMOD (sizeof(LUA_NUMBER_FRMLEN)/sizeof(char)) > > > /* > ** Number of bits that goes into the first digit. It can be any value > ** between 1 and 4; the following definition tries to align the number > ** to nibble boundaries by making what is left after that first digit a > ** multiple of 4. > */ > #define L_NBFD ((l_mathlim(MANT_DIG) - 1)%4 + 1) > > > /* > ** Add integer part of 'x' to buffer and return new 'x' > */ > static lua_Number adddigit (char *buff, int n, lua_Number x) { > lua_Number dd = l_mathop(floor)(x); /* get integer part from 'x' */ > int d = (int)dd; > buff[n] = (d < 10 ? d + '0' : d - 10 + 'a'); /* add to buffer */ > return x - dd; /* return what is left */ > } > > > static int num2straux (char *buff, lua_Number x) { > if (x != x || x == HUGE_VAL || x == -HUGE_VAL) /* inf or NaN? */ > return sprintf(buff, LUA_NUMBER_FMT, x); /* equal to '%g' */ > else if (x == 0) { /* can be -0... */ > sprintf(buff, LUA_NUMBER_FMT, x); > strcat(buff, "x0p+0"); /* reuses '0/-0' from 'sprintf'... */ > return strlen(buff); > } > else { > int e; > lua_Number m = l_mathop(frexp)(x, &e); /* 'x' fraction and exponent */ > int n = 0; /* character count */ > if (m < 0) { /* is number negative? */ > buff[n++] = '-'; /* add signal */ > m = -m; /* make it positive */ > } > buff[n++] = '0'; buff[n++] = 'x'; /* add "0x" */ > m = adddigit(buff, n++, m * (1 << L_NBFD)); /* add first digit */ > e -= L_NBFD; /* this digit goes before the radix point */ > if (m > 0) { /* more digits? */ > buff[n++] = lua_getlocaledecpoint(); /* add radix point */ > do { /* add as many digits as needed */ > m = adddigit(buff, n++, m * 16); > } while (m > 0); > } > n += sprintf(buff + n, "p%+d", e); /* add exponent */ > return n; > } > } > > > static int lua_number2strx (lua_State *L, char *buff, const char *fmt, > lua_Number x) { > int n = num2straux(buff, x); > if (fmt[SIZELENMOD] == 'A') { > int i; > for (i = 0; i < n; i++) > buff[i] = toupper(uchar(buff[i])); > } > else if (fmt[SIZELENMOD] != 'a') > luaL_error(L, "modifiers for format '%%a'/'%%A' not implemented"); > return n; > } > > #endif /* } */ > > > /* > ** Maximum size of each formatted item. This maximum size is produced > ** by format('%.99f', minfloat), and is equal to 99 + 2 ('-' and '.') + > ** number of decimal digits to represent minfloat. > */ > #define MAX_ITEM (120 + l_mathlim(MAX_10_EXP)) > 808d892 < ** (+2 for length modifiers; +10 accounts for %99.99x plus margin of error) 810c894 < #define MAX_FORMAT (sizeof(FLAGS) + 2 + 10) --- > #define MAX_FORMAT 32 852,853c936,937 < memcpy(form, strfrmt, (p - strfrmt + 1) * sizeof(char)); < form += p - strfrmt + 1; --- > memcpy(form, strfrmt, ((p - strfrmt) + 1) * sizeof(char)); > form += (p - strfrmt) + 1; 904d987 < #if defined(LUA_USE_AFORMAT) 906c989,991 < #endif --- > addlenmod(form, LUA_NUMBER_FRMLEN); > nb = lua_number2strx(L, buff, form, luaL_checknumber(L, arg)); > break; 924d1008 < break; 929d1012 < break; 930a1014 > break; 1252c1336 < case Kpadding: luaL_addchar(&b, LUA_PACKPADBYTE); /* go through */ --- > case Kpadding: luaL_addchar(&b, LUA_PACKPADBYTE); /* FALLTHROUGH */ diff -r lua-5.3.0/src/ltable.c lua-5.3.1/src/ltable.c 2c2 < ** $Id: ltable.c,v 2.100 2015/01/05 13:52:37 roberto Exp $ --- > ** $Id: ltable.c,v 2.111 2015/06/09 14:21:13 roberto Exp $ 17,18c17,18 < ** part. The actual size of the array is the largest 'n' such that at < ** least half the slots between 0 and n are in use. --- > ** part. The actual size of the array is the largest 'n' such that > ** more than half the slots between 1 and n are in use. 26d25 < #include 28d26 < #include 74c72 < #define hashpointer(t,p) hashmod(t, point2int(p)) --- > #define hashpointer(t,p) hashmod(t, point2uint(p)) 88,89c86,96 < ** Checks whether a float has a value representable as a lua_Integer < ** (and does the conversion if so) --- > ** Hash for floating-point numbers. > ** The main computation should be just > ** n = frepx(n, &i); return (n * INT_MAX) + i > ** but there are some numerical subtleties. > ** In a two-complement representation, INT_MAX does not has an exact > ** representation as a float, but INT_MIN does; because the absolute > ** value of 'frexp' is smaller than 1 (unless 'n' is inf/NaN), the > ** absolute value of the product 'frexp * -INT_MIN' is smaller or equal > ** to INT_MAX. Next, the use of 'unsigned int' avoids overflows when > ** adding 'i'; the use of '~u' (instead of '-u') avoids problems with > ** INT_MIN. 91,101c98,99 < static int numisinteger (lua_Number x, lua_Integer *p) { < if ((x) == l_floor(x)) /* integral value? */ < return lua_numbertointeger(x, p); /* try as an integer */ < else return 0; < } < < < /* < ** hash for floating-point numbers < */ < static Node *hashfloat (const Table *t, lua_Number n) { --- > #if !defined(l_hashfloat) > static int l_hashfloat (lua_Number n) { 103,108c101,109 < n = l_mathop(frexp)(n, &i) * cast_num(INT_MAX - DBL_MAX_EXP); < i += cast_int(n); < if (i < 0) { < if (cast(unsigned int, i) == 0u - i) /* use unsigned to avoid overflows */ < i = 0; /* handle INT_MIN */ < i = -i; /* must be a positive value */ --- > lua_Integer ni; > n = l_mathop(frexp)(n, &i) * -cast_num(INT_MIN); > if (!lua_numbertointeger(n, &ni)) { /* is 'n' inf/-inf/NaN? */ > lua_assert(luai_numisnan(n) || l_mathop(fabs)(n) == HUGE_VAL); > return 0; > } > else { /* normal case */ > unsigned int u = cast(unsigned int, i) + cast(unsigned int, ni); > return cast_int(u <= cast(unsigned int, INT_MAX) ? u : ~u); 110d110 < return hashmod(t, i); 112c112 < --- > #endif 124c124 < return hashfloat(t, fltvalue(key)); --- > return hashmod(t, l_hashfloat(fltvalue(key))); 130c130 < s->hash = luaS_hash(getstr(s), s->len, s->hash); --- > s->hash = luaS_hash(getstr(s), s->u.lnglen, s->hash); 222,223c222,224 < ** between 2^(i - 1) + 1 and 2^i. Put in '*narray' the optimal size, and < ** return the number of elements that will go to that part. --- > ** between 2^(i - 1) + 1 and 2^i. 'pna' enters with the total number of > ** integer keys in the table and leaves with the number of keys that > ** will go to the array part; return the optimal size. 225c226 < static unsigned int computesizes (unsigned int nums[], unsigned int *narray) { --- > static unsigned int computesizes (unsigned int nums[], unsigned int *pna) { 227c228 < unsigned int twotoi; /* 2^i */ --- > unsigned int twotoi; /* 2^i (candidate for optimal size) */ 230,231c231,233 < unsigned int n = 0; /* optimal size for array part */ < for (i = 0, twotoi = 1; twotoi/2 < *narray; i++, twotoi *= 2) { --- > unsigned int optimal = 0; /* optimal size for array part */ > /* loop while keys can fill more than half of total size */ > for (i = 0, twotoi = 1; *pna > twotoi / 2; i++, twotoi *= 2) { 235,236c237,238 < n = twotoi; /* optimal size (till now) */ < na = a; /* all elements up to 'n' will go to array part */ --- > optimal = twotoi; /* optimal size (till now) */ > na = a; /* all elements up to 'optimal' will go to array part */ 239d240 < if (a == *narray) break; /* all elements already counted */ 241,243c242,244 < *narray = n; < lua_assert(*narray/2 <= na && na <= *narray); < return na; --- > lua_assert((optimal == 0 || optimal / 2 < na) && na <= optimal); > *pna = na; > return optimal; 257a259,263 > /* > ** Count keys in array part of table 't': Fill 'nums[i]' with > ** number of keys that will go into corresponding slice and return > ** total number of non-nil keys. > */ 284,285c290 < static int numusehash (const Table *t, unsigned int *nums, < unsigned int *pnasize) { --- > static int numusehash (const Table *t, unsigned int *nums, unsigned int *pna) { 296c301 < *pnasize += ause; --- > *pna += ause; 366c371 < luaM_freearray(L, nold, cast(size_t, twoto(oldhsize))); /* free old array */ --- > luaM_freearray(L, nold, cast(size_t, twoto(oldhsize))); /* free old hash */ 379c384,385 < unsigned int nasize, na; --- > unsigned int asize; /* optimal size for array part */ > unsigned int na; /* number of keys in the array part */ 384,386c390,392 < nasize = numusearray(t, nums); /* count keys in array part */ < totaluse = nasize; /* all those keys are integer keys */ < totaluse += numusehash(t, nums, &nasize); /* count keys in hash part */ --- > na = numusearray(t, nums); /* count keys in array part */ > totaluse = na; /* all those keys are integer keys */ > totaluse += numusehash(t, nums, &na); /* count keys in hash part */ 388c394 < nasize += countint(ek, nums); --- > na += countint(ek, nums); 391c397 < na = computesizes(nums, &nasize); --- > asize = computesizes(nums, &na); 393c399 < luaH_resize(L, t, nasize, totaluse - na); --- > luaH_resize(L, t, asize, totaluse - na); 446d451 < lua_Number n = fltvalue(key); 448,450c453 < if (luai_numisnan(n)) < luaG_runerror(L, "table index is NaN"); < if (numisinteger(n, &k)) { /* index is int? */ --- > if (luaV_tointeger(key, &k, 0)) { /* index is int? */ 453a457,458 > else if (luai_numisnan(fltvalue(key))) > luaG_runerror(L, "table index is NaN"); 547c552 < if (numisinteger(fltvalue(key), &k)) /* index is int? */ --- > if (luaV_tointeger(key, &k, 0)) /* index is int? */ 549,550c554,555 < /* else go through */ < } --- > /* else... */ > } /* FALLTHROUGH */ diff -r lua-5.3.0/src/ltablib.c lua-5.3.1/src/ltablib.c 2c2 < ** $Id: ltablib.c,v 1.79 2014/11/02 19:19:04 roberto Exp $ --- > ** $Id: ltablib.c,v 1.80 2015/01/13 16:27:29 roberto Exp $ 127,128d126 < /* the following restriction avoids several problems with overflows */ < luaL_argcheck(L, f > 0, 2, "initial position must be positive"); 136a135,136 > luaL_argcheck(L, f > 0 || e < LUA_MAXINTEGER + f, 3, > "too many elements to move"); 137a138,139 > luaL_argcheck(L, t <= LUA_MAXINTEGER - n + 1, 4, > "destination wrap around"); diff -r lua-5.3.0/src/ltm.c lua-5.3.1/src/ltm.c 2c2 < ** $Id: ltm.c,v 2.33 2014/11/21 12:15:57 roberto Exp $ --- > ** $Id: ltm.c,v 2.34 2015/03/30 15:42:27 roberto Exp $ 119a120 > /* call never returns, but to avoid warnings: *//* FALLTHROUGH */ 127d127 < /* else go through */ 128a129 > /* calls never return, but to avoid warnings: *//* FALLTHROUGH */ diff -r lua-5.3.0/src/lua.c lua-5.3.1/src/lua.c 2c2 < ** $Id: lua.c,v 1.222 2014/11/11 19:41:27 roberto Exp $ --- > ** $Id: lua.c,v 1.225 2015/03/30 15:42:59 roberto Exp $ 83,85c83 < #define lua_saveline(L,idx) \ < if (lua_rawlen(L,idx) > 0) /* non-empty line? */ \ < add_history(lua_tostring(L, idx)); /* add it to history */ --- > #define lua_saveline(L,line) ((void)L, add_history(line)) 93c91 < #define lua_saveline(L,idx) { (void)L; (void)idx; } --- > #define lua_saveline(L,line) { (void)L; (void)line; } 318c316 < b[l-1] = '\0'; /* remove it */ --- > b[--l] = '\0'; /* remove it */ 322c320 < lua_pushstring(L, b); --- > lua_pushlstring(L, b, l); 339c337 < if ((status = luaL_loadbuffer(L, line, len, "=stdin")) == LUA_OK) --- > if ((status = luaL_loadbuffer(L, line, len, "=stdin")) == LUA_OK) { 340a339,342 > line += sizeof("return")/sizeof(char); /* remove 'return' for history */ > if (line[0] != '\0') /* non empty? */ > lua_saveline(L, line); /* keep history */ > } 355c357,358 < if (!incomplete(L, status) || !pushline(L, 0)) --- > if (!incomplete(L, status) || !pushline(L, 0)) { > lua_saveline(L, line); /* keep history */ 356a360 > } 377d380 < lua_saveline(L, 1); /* keep history */ 485c488 < args |= has_i; /* goes through (-i implies -v) */ --- > args |= has_i; /* (-i implies -v) *//* FALLTHROUGH */ 492c495 < args |= has_e; /* go through */ --- > args |= has_e; /* FALLTHROUGH */ 516d518 < int status; 519a522 > int status; 523,526c526,528 < if (option == 'e') < status = dostring(L, extra, "=(command line)"); < else < status = dolibrary(L, extra); --- > status = (option == 'e') > ? dostring(L, extra, "=(command line)") > : dolibrary(L, extra); diff -r lua-5.3.0/src/lua.h lua-5.3.1/src/lua.h 2c2 < ** $Id: lua.h,v 1.325 2014/12/26 17:24:27 roberto Exp $ --- > ** $Id: lua.h,v 1.328 2015/06/03 13:03:38 roberto Exp $ 22c22 < #define LUA_VERSION_RELEASE "0" --- > #define LUA_VERSION_RELEASE "1" 38c38,40 < ** pseudo-indices --- > ** Pseudo-indices > ** (-LUAI_MAXSTACK is the minimum valid index; we keep some free empty > ** space after that to help overflow detection) 40c42 < #define LUA_REGISTRYINDEX LUAI_FIRSTPSEUDOIDX --- > #define LUA_REGISTRYINDEX (-LUAI_MAXSTACK - 1000) 359,360c361 < #define lua_pushliteral(L, s) \ < lua_pushlstring(L, "" s, (sizeof(s)/sizeof(char))-1) --- > #define lua_pushliteral(L, s) lua_pushstring(L, "" s) diff -r lua-5.3.0/src/luac.c lua-5.3.1/src/luac.c 2c2 < ** $Id: luac.c,v 1.72 2015/01/06 03:09:13 lhf Exp $ --- > ** $Id: luac.c,v 1.75 2015/03/12 01:58:27 lhf Exp $ 209c209 < ** $Id: print.c,v 1.76 2015/01/05 16:12:50 lhf Exp $ --- > ** $Id: luac.c,v 1.75 2015/03/12 01:58:27 lhf Exp $ 229c229 < size_t i,n=ts->len; --- > size_t i,n=tsslen(ts); diff -r lua-5.3.0/src/luaconf.h lua-5.3.1/src/luaconf.h 2c2 < ** $Id: luaconf.h,v 1.238 2014/12/29 13:27:55 roberto Exp $ --- > ** $Id: luaconf.h,v 1.251 2015/05/20 17:39:23 roberto Exp $ 99,102c99,100 < @@ LUA_INT_INT / LUA_INT_LONG / LUA_INT_LONGLONG defines the type for < ** Lua integers. < @@ LUA_REAL_FLOAT / LUA_REAL_DOUBLE / LUA_REAL_LONGDOUBLE defines < ** the type for Lua floats. --- > @@ LUA_INT_TYPE defines the type for Lua integers. > @@ LUA_FLOAT_TYPE defines the type for Lua floats. 109a108,117 > /* predefined options for LUA_INT_TYPE */ > #define LUA_INT_INT 1 > #define LUA_INT_LONG 2 > #define LUA_INT_LONGLONG 3 > > /* predefined options for LUA_FLOAT_TYPE */ > #define LUA_FLOAT_FLOAT 1 > #define LUA_FLOAT_DOUBLE 2 > #define LUA_FLOAT_LONGDOUBLE 3 > 115c123 < #define LUA_INT_INT --- > #define LUA_INT_TYPE LUA_INT_INT 117c125 < #define LUA_INT_LONG --- > #define LUA_INT_TYPE LUA_INT_LONG 119c127 < #define LUA_REAL_FLOAT --- > #define LUA_FLOAT_TYPE LUA_FLOAT_FLOAT 125,126c133,137 < #define LUA_INT_LONG < #define LUA_REAL_DOUBLE --- > #define LUA_INT_TYPE LUA_INT_LONG > #define LUA_FLOAT_TYPE LUA_FLOAT_DOUBLE > > #endif /* } */ > 128d138 < #else /* }{ */ 132,133c142,144 < #define LUA_INT_LONGLONG < #define LUA_REAL_DOUBLE --- > #if !defined(LUA_INT_TYPE) > #define LUA_INT_TYPE LUA_INT_LONGLONG > #endif 134a146,147 > #if !defined(LUA_FLOAT_TYPE) > #define LUA_FLOAT_TYPE LUA_FLOAT_DOUBLE 158c171 < #if defined(_WIN32) /* { */ --- > #if defined(_WIN32) /* { */ 303,311d315 < < /* < @@ LUA_COMPAT_FLOATSTRING makes Lua format integral floats without a < @@ a float mark ('.0'). < ** This macro is not on by default even in compatibility mode, < ** because this is not really an incompatibility. < */ < /* #define LUA_COMPAT_FLOATSTRING */ < 316a321,324 > /* Incompatibilities from 5.2 -> 5.3 */ > #define LUA_COMPAT_MATHLIB > #define LUA_COMPAT_APIINTCASTS > 375a384,392 > > /* > @@ LUA_COMPAT_FLOATSTRING makes Lua format integral floats without a > @@ a float mark ('.0'). > ** This macro is not on by default even in compatibility mode, > ** because this is not really an incompatibility. > */ > /* #define LUA_COMPAT_FLOATSTRING */ > 383c400 < ** Change these definitions if no predefined LUA_REAL_* / LUA_INT_* --- > ** Change these definitions if no predefined LUA_FLOAT_* / LUA_INT_* 390d406 < ** 393c409,410 < ** --- > @@ l_mathlim(x) corrects limit name 'x' to the proper float type > ** by prefixing it with one of FLT/DBL/LDBL. 397d413 < ** 399d414 < ** 403c418 < #if defined(LUA_REAL_FLOAT) /* { single float */ --- > #if LUA_FLOAT_TYPE == LUA_FLOAT_FLOAT /* { single float */ 406a422,423 > #define l_mathlim(n) (FLT_##n) > 417c434 < #elif defined(LUA_REAL_LONGDOUBLE) /* }{ long double */ --- > #elif LUA_FLOAT_TYPE == LUA_FLOAT_LONGDOUBLE /* }{ long double */ 420a438,439 > #define l_mathlim(n) (LDBL_##n) > 430c449 < #elif defined(LUA_REAL_DOUBLE) /* }{ double */ --- > #elif LUA_FLOAT_TYPE == LUA_FLOAT_DOUBLE /* }{ double */ 433a453,454 > #define l_mathlim(n) (DBL_##n) > 443c464 < #else /* }{ */ --- > #else /* }{ */ 445c466 < #error "numeric real type not defined" --- > #error "numeric float type not defined" 469,508d489 < /* < @@ The luai_num* macros define the primitive operations over numbers. < ** They should work for any size of floating numbers. < */ < < /* the following operations need the math library */ < #if defined(lobject_c) || defined(lvm_c) < #include < < /* floor division (defined as 'floor(a/b)') */ < #define luai_numidiv(L,a,b) ((void)L, l_mathop(floor)(luai_numdiv(L,a,b))) < < /* < ** module: defined as 'a - floor(a/b)*b'; the previous definition gives < ** NaN when 'b' is huge, but the result should be 'a'. '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, which is equivalent to the test below < */ < #define luai_nummod(L,a,b,m) \ < { (m) = l_mathop(fmod)(a,b); if ((m)*(b) < 0) (m) += (b); } < < /* exponentiation */ < #define luai_numpow(L,a,b) ((void)L, l_mathop(pow)(a,b)) < < #endif < < /* these are quite standard operations */ < #if defined(LUA_CORE) < #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_numdiv(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_numisnan(a) (!luai_numeq((a), (a))) < #endif < 541c522 < #if defined(LUA_INT_INT) /* { int */ --- > #if LUA_INT_TYPE == LUA_INT_INT /* { int */ 549c530 < #elif defined(LUA_INT_LONG) /* }{ long */ --- > #elif LUA_INT_TYPE == LUA_INT_LONG /* }{ long */ 557c538 < #elif defined(LUA_INT_LONGLONG) /* }{ long long */ --- > #elif LUA_INT_TYPE == LUA_INT_LONGLONG /* }{ long long */ 595c576 < ** Dependencies with C99 --- > ** Dependencies with C99 and other C details 601c582 < ** In C99, 'strtod' does both conversions. Otherwise, you can --- > ** In C99, 'strtod' does that conversion. Otherwise, you can 611,613c592,595 < @@ LUA_USE_AFORMAT allows '%a'/'%A' specifiers in 'string.format' < ** Enable it if the C function 'printf' supports these specifiers. < ** (C99 demands it and Windows also supports it.) --- > @@ lua_number2strx converts a float to an hexadecimal numeric string. > ** In C99, 'sprintf' (with format specifiers '%a'/'%A') does that. > ** Otherwise, you can leave 'lua_number2strx' undefined and Lua will > ** provide its own implementation. 615,616c597,598 < #if !defined(LUA_USE_C89) || defined(LUA_USE_WINDOWS) < #define LUA_USE_AFORMAT --- > #if !defined(LUA_USE_C89) > #define lua_number2strx(L,b,f,n) sprintf(b,f,n) 645c627 < #if defined (INTPTR_MAX) /* even in C99 this type is optional */ --- > #if defined(INTPTR_MAX) /* even in C99 this type is optional */ 650a633,670 > > /* > @@ lua_getlocaledecpoint gets the locale "radix character" (decimal point). > ** Change that if you do not want to use C locales. (Code using this > ** macro must include header 'locale.h'.) > */ > #if !defined(lua_getlocaledecpoint) > #define lua_getlocaledecpoint() (localeconv()->decimal_point[0]) > #endif > > /* }================================================================== */ > > > /* > ** {================================================================== > ** Language Variations > ** ===================================================================== > */ > > /* > @@ LUA_NOCVTN2S/LUA_NOCVTS2N control how Lua performs some > ** coercions. Define LUA_NOCVTN2S to turn off automatic coercion from > ** numbers to strings. Define LUA_NOCVTS2N to turn off automatic > ** coercion from strings to numbers. > */ > /* #define LUA_NOCVTN2S */ > /* #define LUA_NOCVTS2N */ > > > /* > @@ LUA_USE_APICHECK turns on several consistency checks on the C API. > ** Define it as a help when debugging C code. > */ > #if defined(LUA_USE_APICHECK) > #include > #define luai_apicheck(l,e) assert(e) > #endif > 674,676d693 < /* reserve some space for error handling */ < #define LUAI_FIRSTPSEUDOIDX (-LUAI_MAXSTACK - 1000) < 695,703d711 < @@ LUAI_MAXSHORTLEN is the maximum length for short strings, that is, < ** strings that are internalized. (Cannot be smaller than reserved words < ** or tags for metamethods, as these strings must be internalized; < ** #("function") = 8, #("__newindex") = 10.) < */ < #define LUAI_MAXSHORTLEN 40 < < < /* 705c713,716 < ** CHANGE it if it uses too much C-stack space. --- > ** CHANGE it if it uses too much C-stack space. (For long double, > ** 'string.format("%.99f", 1e4932)' needs ~5030 bytes, so a > ** smaller buffer would force a memory allocation for each call to > ** 'string.format'.) 707c718,722 < #define LUAL_BUFFERSIZE ((int)(0x80 * sizeof(void*) * sizeof(lua_Integer))) --- > #if defined(LUA_FLOAT_LONGDOUBLE) > #define LUAL_BUFFERSIZE 8192 > #else > #define LUAL_BUFFERSIZE ((int)(0x80 * sizeof(void*) * sizeof(lua_Integer))) > #endif diff -r lua-5.3.0/src/lutf8lib.c lua-5.3.1/src/lutf8lib.c 2c2 < ** $Id: lutf8lib.c,v 1.13 2014/11/02 19:19:04 roberto Exp $ --- > ** $Id: lutf8lib.c,v 1.15 2015/03/28 19:16:55 roberto Exp $ 13a14 > #include 40c41 < static unsigned int limits[] = {0xFF, 0x7F, 0x7FF, 0xFFFF}; --- > static const unsigned int limits[] = {0xFF, 0x7F, 0x7FF, 0xFFFF}; 109,110c110 < n = (int)(pose - posi + 1); < if (posi + n <= pose) /* (lua_Integer -> int) overflow? */ --- > if (pose - posi >= INT_MAX) /* (lua_Integer -> int) overflow? */ 111a112 > n = (int)(pose - posi) + 1; 237c238 < static struct luaL_Reg funcs[] = { --- > static const luaL_Reg funcs[] = { 251c252 < lua_pushliteral(L, UTF8PATT); --- > lua_pushlstring(L, UTF8PATT, sizeof(UTF8PATT)/sizeof(char) - 1); diff -r lua-5.3.0/src/lvm.c lua-5.3.1/src/lvm.c 2c2 < ** $Id: lvm.c,v 2.232 2014/12/27 20:30:38 roberto Exp $ --- > ** $Id: lvm.c,v 2.245 2015/06/09 15:53:35 roberto Exp $ 12c12 < --- > #include 13a14 > #include 33,42d33 < /* < ** You can define LUA_FLOORN2I if you want to convert floats to integers < ** by flooring them (instead of raising an error if they are not < ** integral values) < */ < #if !defined(LUA_FLOORN2I) < #define LUA_FLOORN2I 0 < #endif < < 46a38 > 48,49c40,42 < ** Similar to 'tonumber', but does not attempt to convert strings and < ** ensure correct precision (no extra bits). Used in comparisons. --- > ** 'l_intfitsf' checks whether a given integer can be converted to a > ** float without rounding. Used in comparisons. Left undefined if > ** all integers fit in a float precisely. 51,62c44,65 < static int tofloat (const TValue *obj, lua_Number *n) { < if (ttisfloat(obj)) *n = fltvalue(obj); < else if (ttisinteger(obj)) { < volatile lua_Number x = cast_num(ivalue(obj)); /* avoid extra precision */ < *n = x; < } < else { < *n = 0; /* to avoid warnings */ < return 0; < } < return 1; < } --- > #if !defined(l_intfitsf) > > /* number of bits in the mantissa of a float */ > #define NBM (l_mathlim(MANT_DIG)) > > /* > ** Check whether some integers may not fit in a float, that is, whether > ** (maxinteger >> NBM) > 0 (that implies (1 << NBM) <= maxinteger). > ** (The shifts are done in parts to avoid shifting by more than the size > ** of an integer. In a worst case, NBM == 113 for long double and > ** sizeof(integer) == 32.) > */ > #if ((((LUA_MAXINTEGER >> (NBM / 4)) >> (NBM / 4)) >> (NBM / 4)) \ > >> (NBM - (3 * (NBM / 4)))) > 0 > > #define l_intfitsf(i) \ > (-((lua_Integer)1 << NBM) <= (i) && (i) <= ((lua_Integer)1 << NBM)) > > #endif > > #endif > 76c79 < luaO_str2num(svalue(obj), &v) == tsvalue(obj)->len + 1) { --- > luaO_str2num(svalue(obj), &v) == vslen(obj) + 1) { 91c94 < static int tointeger_aux (const TValue *obj, lua_Integer *p, int mode) { --- > int luaV_tointeger (const TValue *obj, lua_Integer *p, int mode) { 109c112 < luaO_str2num(svalue(obj), &v) == tsvalue(obj)->len + 1) { --- > luaO_str2num(svalue(obj), &v) == vslen(obj) + 1) { 118,125d120 < ** try to convert a value to an integer < */ < int luaV_tointeger_ (const TValue *obj, lua_Integer *p) { < return tointeger_aux(obj, p, LUA_FLOORN2I); < } < < < /* 143c138 < if (!tointeger_aux(obj, p, (step < 0 ? 2 : 1))) { /* not fit in integer? */ --- > if (!luaV_tointeger(obj, p, (step < 0 ? 2 : 1))) { /* not fit in integer? */ 147c142 < if (n > 0) { /* if true, float is larger than max integer */ --- > if (luai_numlt(0, n)) { /* if true, float is larger than max integer */ 242c237 < size_t ll = ls->len; --- > size_t ll = tsslen(ls); 244c239 < size_t lr = rs->len; --- > size_t lr = tsslen(rs); 263a259,348 > ** Check whether integer 'i' is less than float 'f'. If 'i' has an > ** exact representation as a float ('l_intfitsf'), compare numbers as > ** floats. Otherwise, if 'f' is outside the range for integers, result > ** is trivial. Otherwise, compare them as integers. (When 'i' has no > ** float representation, either 'f' is "far away" from 'i' or 'f' has > ** no precision left for a fractional part; either way, how 'f' is > ** truncated is irrelevant.) When 'f' is NaN, comparisons must result > ** in false. > */ > static int LTintfloat (lua_Integer i, lua_Number f) { > #if defined(l_intfitsf) > if (!l_intfitsf(i)) { > if (f >= -cast_num(LUA_MININTEGER)) /* -minint == maxint + 1 */ > return 1; /* f >= maxint + 1 > i */ > else if (f > cast_num(LUA_MININTEGER)) /* minint < f <= maxint ? */ > return (i < cast(lua_Integer, f)); /* compare them as integers */ > else /* f <= minint <= i (or 'f' is NaN) --> not(i < f) */ > return 0; > } > #endif > return luai_numlt(cast_num(i), f); /* compare them as floats */ > } > > > /* > ** Check whether integer 'i' is less than or equal to float 'f'. > ** See comments on previous function. > */ > static int LEintfloat (lua_Integer i, lua_Number f) { > #if defined(l_intfitsf) > if (!l_intfitsf(i)) { > if (f >= -cast_num(LUA_MININTEGER)) /* -minint == maxint + 1 */ > return 1; /* f >= maxint + 1 > i */ > else if (f >= cast_num(LUA_MININTEGER)) /* minint <= f <= maxint ? */ > return (i <= cast(lua_Integer, f)); /* compare them as integers */ > else /* f < minint <= i (or 'f' is NaN) --> not(i <= f) */ > return 0; > } > #endif > return luai_numle(cast_num(i), f); /* compare them as floats */ > } > > > /* > ** Return 'l < r', for numbers. > */ > static int LTnum (const TValue *l, const TValue *r) { > if (ttisinteger(l)) { > lua_Integer li = ivalue(l); > if (ttisinteger(r)) > return li < ivalue(r); /* both are integers */ > else /* 'l' is int and 'r' is float */ > return LTintfloat(li, fltvalue(r)); /* l < r ? */ > } > else { > lua_Number lf = fltvalue(l); /* 'l' must be float */ > if (ttisfloat(r)) > return luai_numlt(lf, fltvalue(r)); /* both are float */ > else if (luai_numisnan(lf)) /* 'r' is int and 'l' is float */ > return 0; /* NaN < i is always false */ > else /* without NaN, (l < r) <--> not(r <= l) */ > return !LEintfloat(ivalue(r), lf); /* not (r <= l) ? */ > } > } > > > /* > ** Return 'l <= r', for numbers. > */ > static int LEnum (const TValue *l, const TValue *r) { > if (ttisinteger(l)) { > lua_Integer li = ivalue(l); > if (ttisinteger(r)) > return li <= ivalue(r); /* both are integers */ > else /* 'l' is int and 'r' is float */ > return LEintfloat(li, fltvalue(r)); /* l <= r ? */ > } > else { > lua_Number lf = fltvalue(l); /* 'l' must be float */ > if (ttisfloat(r)) > return luai_numle(lf, fltvalue(r)); /* both are float */ > else if (luai_numisnan(lf)) /* 'r' is int and 'l' is float */ > return 0; /* NaN <= i is always false */ > else /* without NaN, (l <= r) <--> not(r < l) */ > return !LTintfloat(ivalue(r), lf); /* not (r < l) ? */ > } > } > > > /* 268,272c353,354 < lua_Number nl, nr; < if (ttisinteger(l) && ttisinteger(r)) /* both operands are integers? */ < return (ivalue(l) < ivalue(r)); < else if (tofloat(l, &nl) && tofloat(r, &nr)) /* both are numbers? */ < return luai_numlt(nl, nr); --- > if (ttisnumber(l) && ttisnumber(r)) /* both operands are numbers? */ > return LTnum(l, r); 282c364,369 < ** Main operation less than or equal to; return 'l <= r'. --- > ** Main operation less than or equal to; return 'l <= r'. If it needs > ** a metamethod and there is no '__le', try '__lt', based on > ** l <= r iff !(r < l) (assuming a total order). If the metamethod > ** yields during this substitution, the continuation has to know > ** about it (to negate the result of r ** status keeps that information. 286,290c373,374 < lua_Number nl, nr; < if (ttisinteger(l) && ttisinteger(r)) /* both operands are integers? */ < return (ivalue(l) <= ivalue(r)); < else if (tofloat(l, &nl) && tofloat(r, &nr)) /* both are numbers? */ < return luai_numle(nl, nr); --- > if (ttisnumber(l) && ttisnumber(r)) /* both operands are numbers? */ > return LEnum(l, r); 293c377 < else if ((res = luaT_callorderTM(L, l, r, TM_LE)) >= 0) /* first try 'le' */ --- > else if ((res = luaT_callorderTM(L, l, r, TM_LE)) >= 0) /* try 'le' */ 295,297c379,386 < else if ((res = luaT_callorderTM(L, r, l, TM_LT)) < 0) /* else try 'lt' */ < luaG_ordererror(L, l, r); < return !res; --- > else { /* try 'lt': */ > L->ci->callstatus |= CIST_LEQ; /* mark it is doing 'lt' for 'le' */ > res = luaT_callorderTM(L, r, l, TM_LT); > L->ci->callstatus ^= CIST_LEQ; /* clear mark */ > if (res < 0) > luaG_ordererror(L, l, r); > return !res; /* result is negated */ > } 302c391 < ** Main operation for equality of Lua values; return 't1 == t2'. --- > ** Main operation for equality of Lua values; return 't1 == t2'. 311,314c400,401 < lua_Number n1, n2; /* compare them as floats */ < lua_assert(ttisnumber(t1) && ttisnumber(t2)); < cast_void(tofloat(t1, &n1)); cast_void(tofloat(t2, &n2)); < return luai_numeq(n1, n2); --- > lua_Integer i1, i2; /* compare them as integers */ > return (tointeger(t1, &i1) && tointeger(t2, &i2) && i1 == i2); 356a444,445 > #define isemptystr(o) (ttisshrstring(o) && tsvalue(o)->shrlen == 0) > 368c457 < else if (tsvalue(top-1)->len == 0) /* second operand is empty? */ --- > else if (isemptystr(top - 1)) /* second operand is empty? */ 370c459 < else if (ttisstring(top-2) && tsvalue(top-2)->len == 0) { --- > else if (isemptystr(top - 2)) { /* first operand is an empty string? */ 375c464 < size_t tl = tsvalue(top-1)->len; --- > size_t tl = vslen(top - 1); 380c469 < size_t l = tsvalue(top-i-1)->len; --- > size_t l = vslen(top - i - 1); 389c478 < size_t l = tsvalue(top-i)->len; --- > size_t l = vslen(top - i); 406c495 < switch (ttnov(rb)) { --- > switch (ttype(rb)) { 414,415c503,508 < case LUA_TSTRING: { < setivalue(ra, tsvalue(rb)->len); --- > case LUA_TSHRSTR: { > setivalue(ra, tsvalue(rb)->shrlen); > return; > } > case LUA_TLNGSTR: { > setivalue(ra, tsvalue(rb)->u.lnglen); 451c544 < ** Integer modulus; return 'm % n'. (Assume that C '%' with --- > ** Integer modulus; return 'm % n'. (Assume that C '%' with 556,560c649,653 < /* metamethod should not be called when operand is K */ < lua_assert(!ISK(GETARG_B(inst))); < if (op == OP_LE && /* "<=" using "<" instead? */ < ttisnil(luaT_gettmbyobj(L, base + GETARG_B(inst), TM_LE))) < res = !res; /* invert result */ --- > if (ci->callstatus & CIST_LEQ) { /* "<=" using "<" instead? */ > lua_assert(op == OP_LE); > ci->callstatus ^= CIST_LEQ; /* clear mark */ > res = !res; /* negate result */ > } 610c703 < #if !defined luai_runtimecheck --- > #if !defined(luai_runtimecheck) 746c839 < vmcase(OP_ADD) { --- > vmcase(OP_ADD) { 931c1024 < rb = b + base; --- > rb = base + b; 1034d1126 < if (b != 0) L->top = ra+b-1; 1036c1128 < b = luaD_poscall(L, ra); --- > b = luaD_poscall(L, ra, (b != 0 ? b - 1 : L->top - ra)); 1054c1146 < setivalue(ra, idx); /* update internal index... */ --- > chgivalue(ra, idx); /* update internal index... */ 1065c1157 < setfltvalue(ra, idx); /* update internal index... */ --- > chgfltvalue(ra, idx); /* update internal index... */ diff -r lua-5.3.0/src/lvm.h lua-5.3.1/src/lvm.h 2c2 < ** $Id: lvm.h,v 2.34 2014/08/01 17:24:02 roberto Exp $ --- > ** $Id: lvm.h,v 2.35 2015/02/20 14:27:53 roberto Exp $ 29a30,39 > /* > ** You can define LUA_FLOORN2I if you want to convert floats to integers > ** by flooring them (instead of raising an error if they are not > ** integral values) > */ > #if !defined(LUA_FLOORN2I) > #define LUA_FLOORN2I 0 > #endif > > 34c44 < (ttisinteger(o) ? (*(i) = ivalue(o), 1) : luaV_tointeger_(o,i)) --- > (ttisinteger(o) ? (*(i) = ivalue(o), 1) : luaV_tointeger(o,i,LUA_FLOORN2I)) 45c55 < LUAI_FUNC int luaV_tointeger_ (const TValue *obj, lua_Integer *p); --- > LUAI_FUNC int luaV_tointeger (const TValue *obj, lua_Integer *p, int mode);