kpriv/pkgsrc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
pkgsrc/lang/lua/Makefile

49 lines
1.5 KiB
Makefile
Raw Normal View History

s/netbsd.org/NetBSD.org/
2003-07-17 23:41:05 +02:00
# $NetBSD: Makefile,v 1.7 2003/07/17 21:44:49 grant Exp $
Initial import of lua. 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.
2001-06-19 16:47:22 +02:00
Update to version 5.0. * 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-04-30 01:33:56 +02:00
DISTNAME= lua-5.0
Initial import of lua. 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.
2001-06-19 16:47:22 +02:00
CATEGORIES= lang
MASTER_SITES= ftp://ftp.tecgraf.puc-rio.br/pub/lua/ \
ftp://ftp.ntua.gr/pub/lang/lua/ \
Update to version 4.0.1. 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)
2003-02-22 01:51:58 +01:00
ftp://ftp.gwdg.de/pub/languages/lua/ \
Initial import of lua. 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.
2001-06-19 16:47:22 +02:00
ftp://ftp.u-aizu.ac.jp/pub/lang/lua/ \
Update to version 4.0.1. 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)
2003-02-22 01:51:58 +01:00
ftp://ftp.ucore.com/lua/dist/ \
ftp://sunsite.dk/pub/languages/lua/ \
ftp://ftp.chg.ru/pub/lang/lua/ \
http://www.lua.org/ftp/ \
http://www.tecgraf.puc-rio.br/lua/ftp/ \
http://ftp.gwdg.de/pub/languages/lua/ \
http://mirrors.sunsite.dk/lua/ \
http://ftp.chg.ru/pub/lang/lua/
Initial import of lua. 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.
2001-06-19 16:47:22 +02:00
s/netbsd.org/NetBSD.org/
2003-07-17 23:41:05 +02:00
MAINTAINER= tech-pkg@NetBSD.org
Initial import of lua. 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.
2001-06-19 16:47:22 +02:00
HOMEPAGE= http://www.lua.org
Shorten COMMENT
2003-04-04 19:32:51 +02:00
COMMENT= Powerful light-weight language for extending applications
Initial import of lua. 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.
2001-06-19 16:47:22 +02:00
Update to version 5.0. * 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-04-30 01:33:56 +02:00
USE_BUILDLINK2= yes
BUILD_DIRS= ${WRKSRC}/objdir
Initial import of lua. 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.
2001-06-19 16:47:22 +02:00
post-extract:
Update to version 4.0.1. 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)
2003-02-22 01:51:58 +01:00
${MKDIR} ${BUILD_DIRS}
post-patch:
${CP} ${WRKSRC}/doc/lua.1 ${BUILD_DIRS}/lua
${CP} ${WRKSRC}/doc/luac.1 ${BUILD_DIRS}/luac
Initial import of lua. 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.
2001-06-19 16:47:22 +02:00
post-install:
${INSTALL_DATA_DIR} ${PREFIX}/share/doc/lua
cd ${WRKSRC}; ${INSTALL_DATA} README COPYRIGHT \
HISTORY ${PREFIX}/share/doc/lua
${INSTALL_DATA_DIR} ${PREFIX}/share/doc/html/lua
cd ${WRKSRC}/doc; ${INSTALL_DATA} *.html *.gif \
${PREFIX}/share/doc/html/lua
${INSTALL_DATA_DIR} ${PREFIX}/share/examples/lua
Update to version 5.0. * 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-04-30 01:33:56 +02:00
cd ${WRKSRC}/test && ${INSTALL_DATA} README *.lua \
${PREFIX}/share/examples/lua
Update to version 4.0.1. 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)
2003-02-22 01:51:58 +01:00
${INSTALL_DATA_DIR} ${PREFIX}/share/examples/lua/etc
Update to version 5.0. * 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-04-30 01:33:56 +02:00
cd ${WRKSRC}/etc && ${INSTALL_DATA} README *.c *.h \
*.lua lua.magic lua.xpm \
${PREFIX}/share/examples/lua/etc
Initial import of lua. 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.
2001-06-19 16:47:22 +02:00
.include "../../mk/bsd.pkg.mk"
Reference in a new issue Copy permalink