Up to [cvs.NetBSD.org] / pkgsrc / lang / lua53
Request diff between arbitrary revisions
Keyword substitution: kv
Default branch: MAIN
lua53: update to 5.3.6. This is a bug-fix release. Full diffs here: https://www.lua.org/work/diffs-lua-5.3.5-lua-5.3.6.html
Update lang/lua53 to version 5.3.5. Lua 5.3.5 fixes all bugs listed in http://www.lua.org/bugs.html#5.3.4: 1. Wrong code generated for a 'goto' followed by a label inside an 'if'. 2. Lua crashes when building sequences with more than 2^30 elements. 3. Table length computation overflows for sequences larger than 2^31 elements. 4. Lua does not check GC when creating error messages. 5. Dead keys with nil values can stay in weak tables. 6. lua_pushcclosure should not call the garbage collector when n is zero. 7. Memory-allocation error when resizing a table can leave it in an inconsistent state..
Update lang/lua53 to version 5.3.4.
Lua 5.3.4 fixes all bugs listed in
http://www.lua.org/bugs.html#5.3.3
1. Expression list with four or more expressions in a 'for' loop can crash
the interpreter.
reported by Marco Scho:pl on 17 Jun 2016. existed since 5.2. fixed in 5.3.4.
2. Checking a format for os.date may read pass the format string.
reported by Nagaev Boris on 10 Jul 2016. existed since 5.3.3. fixed in 5.3.4.
3. Lua can generate wrong code in functions with too many constants.
reported by Marco Scho:pl on 17 Jul 2016. existed since 5.3.3. fixed in 5.3.4.
4. When a coroutine tries to resume a non-suspended coroutine, it can do some
mess (and break C assertions) before detecting the error.
reported by Marco Scho:pl on 20 Jul 2016. fixed in 5.3.4.
Lua 5.3.4 also contains several internal improvements and
includes a revised reference manual:
http://www.lua.org/manual/5.3/
Update lang/lua53 to version 5.3.3. This bugfix version fixes the following problems: 1. Metatable may access its own deallocated field when it has a self reference in __newindex. 2. Label between local definitions can mix-up their initializations. 3. gmatch iterator fails when called from a coroutine different from the one that created it.
Update Lua to version 5.3.2 and link with pthreads to fix pkg/47587.
Lua 5.3.2 fixes all bugs listed in
http://www.lua.org/bugs.html#5.3.1 [1]
Lua 5.3.2 also contains several internal improvements and includes a
revised reference manual:
http://www.lua.org/manual/5.3/
[1]
1. io.lines does not check maximum number of options.
reported by Patrick Donnell on 10 Jul 2015. existed since 3.0.
Example:
-- can crash in some machines
t ={}; for i = 1, 253 do t[i] = 1 end
io.lines("someexistingfile", table.unpack(t))()
Update lang/lua53 to 5.3.1.
The following bugs have been fixed (from http://www.lua.org/bugs.html):
1. string.format("%f") can cause a buffer overflow (only when
'lua_Number' is long double!).
reported by Roberto on 13 Jan 2015. existed since 5.3. fixed in
5.3.1.
2. debug.getlocal on a coroutine suspended in a hook can crash the
interpreter.
reported by on 11 Feb 2015. existed since 5.2. fixed in 5.3.1.
Example: See
http://lua-users.org/lists/lua-l/2015-02/msg00146.html.
3. Suspended __le metamethod can give wrong result.
reported by Eric Zhong on 07 Apr 2015. existed since 5.2. fixed in
5.3.1.
Example:
mt = {__le = function (a,b) coroutine.yield("yield"); return a.x <= b.x end}
t1 = setmetatable({x=1}, mt)
t2 = {x=2}
co = coroutine.wrap(function (a,b) return t2 <= t1 end)
co()
print(co()) --> true (should be false)
4. Return hook may not see correct values for active local variables
when function returns.
reported by Philipp Janda and Peng Yi on 19 May 2015. existed since
5.0. fixed in 5.3.1.
Example: See
http://lua-users.org/lists/lua-l/2015-05/msg00376.html.
Initial import of Lua 5.3.0. Lua is a powerful, light-weight programming language designed for extending applications. Lua is also frequently used as a general-purpose, stand-alone language. Lua combines simple procedural syntax (similar to Pascal) with powerful data description constructs based on associative arrays and extensible semantics. Lua is dynamically typed, interpreted from bytecodes, and has automatic memory management, making it ideal for configuration, scripting, and rapid prototyping. Lua is a language engine that you can embed into your application. This means that, besides syntax and semantics, Lua has an API that allows the application to exchange data with Lua programs and also to extend Lua with C functions. In this sense, Lua can be regarded as a language framework for building domain-specific languages. Lua is implemented as a small library of C functions, written in ANSI C, and compiles unmodified in all known platforms. The implementation goals are simplicity, efficiency, portability, and low embedding cost. The result is a fast language engine with small footprint, making it ideal in embedded systems too.
Initial revision