pkgsrc - [no description]

Age	Commit message (Collapse)	Author	Files	Lines
2013-10-30	Reimport lang/lua as lang/lua52, and bring back the previous Lua 5.1	dholland	1	-74/+0
	package as lang/lua51. I've adjusted the depends and switched the PKGNAMEs but these packages are otherwise unchanged. This means that you can't install both at once. There are preliminary patches for that (see tech-pkg) but they aren't quite ready yet. This also doesn't include agc's builtin.mk, although it should be possible to drop it into the lua51 package with only very minor modifications. I don't think the builtin packages will allow having one builtin.mk for both lua51 and lua52, but I'd be happy to be shown wrong about that. Add infrastructure support for Lua module packages (including multiversion support), application packages written in Lua, and a redirecting bl3.mk file for packages that just link Lua in. This is based on the Python infrastructure. The new variable LUA_VERSION_DEFAULT picks which Lua package you get by default; it is set to 52 so as to maintain the status quo. Packages can set LUA_VERSIONS_ACCEPTED and/or LUA_VERSIONS_INCOMPATIBLE. I have found (I think) most or all the packages that don't work with lua51 and will be marking those; I have not tracked down most of the ones that don't work with lua52 yet as I was originally intending to roll back to 5.1 as the default.
2013-07-04	Lua 5.2 was released on 16 Dec 2011. Its main new features are yieldable ↵	adam	1	-42/+36
	pcall and metamethods, new lexical scheme for globals, ephemeron tables, new library for bitwise operations, light C functions, emergency garbage collector, goto statement, and finalizers for tables.
2012-03-12	Update to 5.1.5.	wiz	1	-4/+4
	Lua 5.1.5 released. This is a bug-fix release. (no further changelog found) Remove master site that doesn't have new tarball. Fix pkglint warning in patch-ac.
2011-01-19	Pass LDFLAGS during linking; pkglint clean-up	adam	1	-3/+3

2009-12-17	Fix build with new libtool by specifying --tag=CC in all calls.	jmmv	1	-7/+7

2009-10-30	Honour compiler selection.	ahoka	1	-4/+6

2007-07-02	Override /usr/local as LUA_ROOT and ensure that the default search path	joerg	1	-2/+11
	matches the pkgsrc environment. Bump revision. From Simon Schubert via IRC.
2007-06-15	Update lua to 5.1.2.	obache	1	-9/+8
	Patch provided by Holger Weiss in PR 36333. And specify more platform target. This release fixes all known bugs in 5.1.1.
2006-09-06	update lua to 5.1.1nb1 - fix build on linux (and hopefully some others)	abs	1	-8/+8

2006-08-14	Update to 5.1.1. Almost all dependencies need adaptation -> bump API.	wiz	1	-21/+69
	Changes: * Changes from version 5.0 to 5.1 ------------------------------- Language: + new module system. + new semantics for control variables of fors. + new semantics for setn/getn. + new syntax/semantics for varargs. + new long strings and comments. + new `mod' operator (`%') + new length operator #t + metatables for all types API: + new functions: lua_createtable, lua_get(set)field, lua_push(to)integer. + user supplies memory allocator (lua_open becomes lua_newstate). + luaopen_* functionst must be called through Lua. Implementation: + new configuration scheme via luaconf.h. + incremental garbage collection. + better handling of end-of-line in the lexer. + fully reentrant parser (new Lua function `load') + better support for 64-bit machines. + native loadlib support for Mac OS X. + standard distribution in only one library (lualib.a merged into lua.a)
2005-09-04	Libtoolize lua build. Since the shared library version has changed,	jlam	1	-10/+17
	bump the PKGREVISION to 4, and set BUILDLINK_RECOMMENDED.lua appropriately in the buildlink3.mk file.
2005-06-07	Make libraries link against libdl if it is available. This fixes PR	minskim	1	-4/+4
	pkg/29389. Bump PKGREVISION.
2004-04-05	Update lua to 5.0.2, from Bruce J.A. Nourish via tech-pkg@.	xtraeme	1	-32/+14
	Lua 5.0.2 is a bugfix release, which contains the following fixes: src/ldo.c Attempt to resume running coroutine crashed Lua src/lgc.c C functions also may have stacks larger than current top Userdata to be collected still counted into new GC threshold src/lgc.h Userdata to be collected still counted into new GC threshold src/lparser.c Syntax `local function' did not increment stack size src/lvm.c `pc' address was invalidated when a coroutine was suspended Count hook might be called without being set src/lib/lbaselib.c Buffer overflow for unusual %p representation Wrong number of returns from chunks loaded from stdin src/lib/liolib.c `file.close()' could not be called without arguments Buffer overflow for unusual %p representation src/luac/luac.c Missing lock/unlock
2003-04-29	Update to version 5.0.	jtb	1	-7/+7
	* Changes from version 4.0 to 5.0 ------------------------------- Language: + lexical scoping. + Lua coroutines. + standard libraries now packaged in tables. + tags replaced by metatables and tag methods replaced by metamethods, stored in metatables. + proper tail calls. + each function can have its own global table, which can be shared. + new __newindex metamethod, called when we insert a new key into a table. + new block comments: --[[ ... ]]. + new generic for. + new weak tables. + new boolean type. + new syntax "local function". + (f()) returns the first value returned by f. + {f()} fills a table with all values returned by f. + \n ignored in [[\n . + fixed and-or priorities. + more general syntax for function definition (e.g. function a.x.y:f()...end). + more general syntax for function calls (e.g. (print or write)(9)). + new functions (time/date, tmpfile, unpack, require, load, etc.). API: + chunks are loaded by using lua_load; new luaL_loadfile and luaL_loadbuffer. + introduced lightweight userdata, a simple "void" without a metatable. + new error handling protocol: the core no longer prints error messages; all errors are reported to the caller on the stack. + new lua_atpanic for host cleanup. + new, signal-safe, hook scheme. Implementation: + new license: MIT. + new, faster, register-based virtual machine. + support for external multithreading and coroutines. + new and consistent error message format. + the core no longer needs "stdio.h" for anything (except for a single use of sprintf to convert numbers to strings). + lua.c now runs the environment variable LUA_INIT, if present. It can be "@filename", to run a file, or the chunk itself. + support for user extensions in lua.c. sample implementation given for command line editing. + new dynamic loading library, active by default on several platforms. + safe garbage-collector metamethods. + precompiled bytecodes checked for integrity (secure binary dostring). + strings are fully aligned. + position capture in string.find. + read('*l') can read lines with embedded zeros.
2003-02-22	Update to version 4.0.1.	jtb	1	-12/+32
	Added my own makefiles to create shared versions of the libraries using bsd.lib.mk. Changes in Lua itself: lua/src/lapi.c lua/src/lstring.c Fixed a bug in lua_pushuserdata(L, NULL) lua/src/ldo.c lua/src/lgc.c lua/src/lgc.h Give a good chance for GC before parsing lua/src/lparser.c Fixed a bug (did not accept `;' after a `return') lua/src/lvm.c Fixed a bug (linehook off by 1) lua/src/lib/lbaselib.c Fixed a bug in rawget and rawset (seg. fault if given extra arguments) Fixed a bug in dostring (identification of precompiled chunks)
2001-06-19	Initial import of lua.	jtb	1	-0/+13
	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.