diff options
| author | mbalmer <mbalmer@NetBSD.org> | 2013-10-16 19:44:57 +0000 |
|---|---|---|
| committer | mbalmer <mbalmer@NetBSD.org> | 2013-10-16 19:44:57 +0000 |
| commit | e0fe45ce9c35c204a7c19d5a5291ca64b47b2452 (patch) | |
| tree | e871dc37f16f51aff76180bb26119b0ced6630a4 /sys | |
| parent | a1bd524499a4e93e3f6f934dc1e6f644595e0a89 (diff) | |
welcome lua(4), a devide driver that can create and control Lua states inside the kernel
Diffstat (limited to 'sys')
| -rw-r--r-- | sys/modules/lua/Makefile | 48 | ||||
| -rw-r--r-- | sys/modules/lua/assert.h | 34 | ||||
| -rw-r--r-- | sys/modules/lua/ctype.h | 66 | ||||
| -rw-r--r-- | sys/modules/lua/errno.h | 8 | ||||
| -rw-r--r-- | sys/modules/lua/infinite.lua | 2 | ||||
| -rw-r--r-- | sys/modules/lua/inttypes.h | 6 | ||||
| -rw-r--r-- | sys/modules/lua/limits.h | 8 | ||||
| -rw-r--r-- | sys/modules/lua/locale.h | 47 | ||||
| -rw-r--r-- | sys/modules/lua/lua.c | 862 | ||||
| -rw-r--r-- | sys/modules/lua/luaconf.h | 791 | ||||
| -rw-r--r-- | sys/modules/lua/luavar.h | 49 | ||||
| -rw-r--r-- | sys/modules/lua/math.h | 6 | ||||
| -rw-r--r-- | sys/modules/lua/setjmp.h | 10 | ||||
| -rw-r--r-- | sys/modules/lua/signal.h | 6 | ||||
| -rw-r--r-- | sys/modules/lua/stdarg.h | 8 | ||||
| -rw-r--r-- | sys/modules/lua/stddef.h | 16 | ||||
| -rw-r--r-- | sys/modules/lua/stdio.h | 49 | ||||
| -rw-r--r-- | sys/modules/lua/stdlib.h | 48 | ||||
| -rw-r--r-- | sys/modules/lua/string.h | 21 | ||||
| -rw-r--r-- | sys/modules/lua/test.lua | 8 |
20 files changed, 2093 insertions, 0 deletions
diff --git a/sys/modules/lua/Makefile b/sys/modules/lua/Makefile new file mode 100644 index 00000000000..c7abeb93028 --- /dev/null +++ b/sys/modules/lua/Makefile @@ -0,0 +1,48 @@ +# $NetBSD: Makefile,v 1.1 2013/10/16 19:44:57 mbalmer Exp $ + +.include "../Makefile.inc" + +.PATH: ${S}/../external/mit/lua/dist/src \ + ${S}/../lib/libc/string + +KMOD= lua +SRCS= lua.c + +WARNS= 1 + +# Lua source code +SRCS+= lapi.c \ + lcode.c \ + ldebug.c \ + ldo.c \ + ldump.c \ + lfunc.c \ + lgc.c \ + llex.c \ + lmem.c \ + lobject.c \ + lopcodes.c \ + lparser.c \ + lstate.c \ + lstring.c \ + ltable.c \ + ltm.c \ + lundump.c \ + lvm.c \ + lzio.c \ + # lauxlib.c \ + ltablib.c \ + lstrlib.c \ + lbaselib.c \ + linit.c + +# Compatability code +SRCS+= strcspn.c \ + strncat.c \ + strpbrk.c \ + strspn.c + +CPPFLAGS+= -include ${.CURDIR}/luaconf.h \ + -I${S}/../external/mit/lua/dist/src + +.include <bsd.kmodule.mk> diff --git a/sys/modules/lua/assert.h b/sys/modules/lua/assert.h new file mode 100644 index 00000000000..01d6c343a5b --- /dev/null +++ b/sys/modules/lua/assert.h @@ -0,0 +1,34 @@ +/* $NetBSD */ + +/* + * Copyright (c) 2011, Marc Balmer <mbalmer@NetBSD.org>. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. The name of the Author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +/* + * This file is a placeholder only, to allow Lua to be compiled from + * unchanged sources. + */ diff --git a/sys/modules/lua/ctype.h b/sys/modules/lua/ctype.h new file mode 100644 index 00000000000..192ae7dc17c --- /dev/null +++ b/sys/modules/lua/ctype.h @@ -0,0 +1,66 @@ +/* $NetBSD */ + +/* + * Copyright (c) 2011, Lourival Neto <lneto@NetBSD.org>. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. The name of the Author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +/* + * This file is a placeholder only, to allow Lua to be compiled from + * unchanged sources. + */ + +#include <sys/systm.h> + +#ifndef _LUA_INCLUDE_CTYPE_ +#define _LUA_INCLUDE_CTYPE_ + +LIBKERN_INLINE int +isalnum(int ch) +{ + return (isalpha(ch) || isdigit(ch)); +} + +LIBKERN_INLINE int +iscntrl(int ch) +{ + return ((ch >= 0x00 && ch <= 0x1F) || ch == 0x7F); +} + +LIBKERN_INLINE int +isprint(int ch) +{ + return (ch >= 0x20 && ch <= 0x7E); +} + +LIBKERN_INLINE int +ispunct(int ch) +{ + return (isprint(ch) && ch != ' ' && !isalnum(ch)); +} + +#endif + diff --git a/sys/modules/lua/errno.h b/sys/modules/lua/errno.h new file mode 100644 index 00000000000..c033853cb0e --- /dev/null +++ b/sys/modules/lua/errno.h @@ -0,0 +1,8 @@ +/* $NetBSD */ + +/* + * This file is a placeholder only, to allow Lua to be compiled from + * unchanged sources. + */ + +#include <sys/errno.h> diff --git a/sys/modules/lua/infinite.lua b/sys/modules/lua/infinite.lua new file mode 100644 index 00000000000..dba872d43f6 --- /dev/null +++ b/sys/modules/lua/infinite.lua @@ -0,0 +1,2 @@ +while (1) do end + diff --git a/sys/modules/lua/inttypes.h b/sys/modules/lua/inttypes.h new file mode 100644 index 00000000000..c36e14b0146 --- /dev/null +++ b/sys/modules/lua/inttypes.h @@ -0,0 +1,6 @@ +/* $NetBSD: inttypes.h,v 1.1 2013/10/16 19:44:57 mbalmer Exp $ */ + +/* + * This file is a placeholder only, to allow Lua to be compiled from + * unchanged sources. + */ diff --git a/sys/modules/lua/limits.h b/sys/modules/lua/limits.h new file mode 100644 index 00000000000..5c922c60c1e --- /dev/null +++ b/sys/modules/lua/limits.h @@ -0,0 +1,8 @@ +/* $NetBSD */ + +/* + * This file is a placeholder only, to allow Lua to be compiled from + * unchanged sources. + */ + +#include <machine/limits.h> diff --git a/sys/modules/lua/locale.h b/sys/modules/lua/locale.h new file mode 100644 index 00000000000..17cb5ebe29b --- /dev/null +++ b/sys/modules/lua/locale.h @@ -0,0 +1,47 @@ +/* $NetBSD */ + +/* + * Copyright (c) 2011, Lourival Neto <lneto@NetBSD.org>. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. The name of the Author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +/* + * This file is a placeholder only, to allow Lua to be compiled from + * unchanged sources. + */ + +#include <sys/null.h> + +#ifndef _LUA_INCLUDE_LOCALE_ +#define _LUA_INCLUDE_LOCALE_ + +struct lconv { + char *decimal_point; +}; + +#define localeconv() NULL +#endif + diff --git a/sys/modules/lua/lua.c b/sys/modules/lua/lua.c new file mode 100644 index 00000000000..7fd0001a186 --- /dev/null +++ b/sys/modules/lua/lua.c @@ -0,0 +1,862 @@ +/* $NetBSD */ + +/* + * Copyright (c) 2011 by Marc Balmer <mbalmer@NetBSD.org>. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. The name of the Author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +/* Lua device driver */ + +#include <sys/param.h> +#include <sys/fcntl.h> +#include <sys/conf.h> +#include <sys/condvar.h> +#include <sys/device.h> +#include <sys/ioctl.h> +#include <sys/lock.h> +#include <sys/lua.h> +#include <sys/malloc.h> +#include <sys/module.h> +#include <sys/mutex.h> +#include <sys/namei.h> +#include <sys/queue.h> +#include <sys/sysctl.h> +#include <sys/vnode.h> + +#include <lauxlib.h> + +#include "luavar.h" + +struct lua_softc { + device_t sc_dev; + + kmutex_t sc_lock; + kcondvar_t sc_inuse_cv; + bool sc_inuse; + + /* Locking access to state queues */ + kmutex_t sc_state_lock; + kcondvar_t sc_state_cv; + bool sc_state; + + struct sysctllog *sc_log; +}; + +static device_t sc_self; +static bool lua_autoload_on = true; +static bool lua_require_on = true; +static bool lua_bytecode_on = false; +static int lua_verbose; +static int lua_max_instr; + +static LIST_HEAD(, lua_state) lua_states; +static LIST_HEAD(, lua_module) lua_modules; + +static int lua_match(device_t, cfdata_t, void *); +static void lua_attach(device_t, device_t, void *); +static int lua_detach(device_t, int); +static klua_State *klua_find(const char *); +static const char *lua_reader(lua_State *, void *, size_t *); +static void lua_maxcount(lua_State *, lua_Debug *); + +static int lua_require(lua_State *); + +CFATTACH_DECL_NEW(lua, sizeof(struct lua_softc), + lua_match, lua_attach, lua_detach, NULL); + +dev_type_open(luaopen); +dev_type_close(luaclose); +dev_type_ioctl(luaioctl); + +const struct cdevsw lua_cdevsw = { + luaopen, luaclose, noread, nowrite, luaioctl, nostop, notty, + nopoll, nommap, nokqfilter, D_OTHER | D_MPSAFE +}; + +struct lua_loadstate { + struct vnode *vp; + size_t size; + off_t off; +}; + +extern struct cfdriver lua_cd; + +static int +lua_match(device_t parent, cfdata_t match, void *aux) +{ + return 1; +} + +static void +lua_attach(device_t parent, device_t self, void *aux) +{ + struct lua_softc *sc; + const struct sysctlnode *node; + + if (sc_self) + return; + + sc = device_private(self); + sc->sc_dev = self; + sc_self = self; + + mutex_init(&sc->sc_lock, MUTEX_DEFAULT, IPL_VM); + cv_init(&sc->sc_inuse_cv, "luactl"); + + mutex_init(&sc->sc_state_lock, MUTEX_DEFAULT, IPL_VM); + cv_init(&sc->sc_state_cv, "luastate"); + + pmf_device_register(self, NULL, NULL); + + /* Sysctl to provide some control over behaviour */ + sysctl_createv(NULL, 0, NULL, NULL, + CTLFLAG_PERMANENT, + CTLTYPE_NODE, "kern", NULL, + NULL, 0, NULL, 0, + CTL_KERN, CTL_EOL); + sysctl_createv(&sc->sc_log, 0, NULL, &node, + CTLFLAG_OWNDESC, + CTLTYPE_NODE, "lua", + SYSCTL_DESCR("Lua options"), + NULL, 0, NULL, 0, + CTL_KERN, CTL_CREATE, CTL_EOL); + + if (node == NULL) { + printf(": can't create sysctl node\n"); + return; + } + + /* + * XXX Some of the sysctl values must not be changed after the + * securelevel has been raised. + */ + sysctl_createv(&sc->sc_log, 0, &node, NULL, + CTLFLAG_READWRITE | CTLFLAG_OWNDESC, + CTLTYPE_BOOL, "require", + SYSCTL_DESCR("Enable the require command"), + NULL, 0, &lua_require_on, 0, + CTL_CREATE, CTL_EOL); + + sysctl_createv(&sc->sc_log, 0, &node, NULL, + CTLFLAG_READWRITE | CTLFLAG_OWNDESC, + CTLTYPE_BOOL, "autoload", + SYSCTL_DESCR("Enable automatic load of modules"), + NULL, 0, &lua_autoload_on, 0, + CTL_CREATE, CTL_EOL); + + sysctl_createv(&sc->sc_log, 0, &node, NULL, + CTLFLAG_READWRITE | CTLFLAG_OWNDESC, + CTLTYPE_BOOL, "bytecode", + SYSCTL_DESCR("Enable loading of bytecode"), + NULL, 0, &lua_bytecode_on, 0, + CTL_CREATE, CTL_EOL); + + sysctl_createv(&sc->sc_log, 0, &node, NULL, + CTLFLAG_READWRITE | CTLFLAG_OWNDESC, + CTLTYPE_INT, "verbose", + SYSCTL_DESCR("Enable verbose output"), + NULL, 0, &lua_verbose, 0, + CTL_CREATE, CTL_EOL); + + sysctl_createv(&sc->sc_log, 0, &node, NULL, + CTLFLAG_READWRITE | CTLFLAG_OWNDESC, + CTLTYPE_INT, "maxcount", + SYSCTL_DESCR("Limit maximum instruction count"), + NULL, 0, &lua_max_instr, 0, + CTL_CREATE, CTL_EOL); + + aprint_normal_dev(self, "%s %s\n", LUA_RELEASE, LUA_COPYRIGHT); +} + +static int +lua_detach(device_t self, int flags) +{ + struct lua_softc *sc; + struct lua_state *s; + + sc = device_private(self); + pmf_device_deregister(self); + + if (sc->sc_log != NULL) { + sysctl_teardown(&sc->sc_log); + sc->sc_log = NULL; + } + + /* Traverse the list of states and close them */ + while ((s = LIST_FIRST(&lua_states)) != NULL) { + LIST_REMOVE(s, lua_next); + klua_close(s->K); + if (lua_verbose) + device_printf(self, "state %s destroyed\n", + s->lua_name); + free(s, NULL); + } + mutex_destroy(&sc->sc_lock); + cv_destroy(&sc->sc_inuse_cv); + mutex_destroy(&sc->sc_state_lock); + cv_destroy(&sc->sc_state_cv); + sc_self = NULL; + return 0; +} + +int +luaopen(dev_t dev, int flag, int mode, struct lwp *l) +{ + struct lua_softc *sc; + int error; + + if (minor(dev) > 0) + return ENXIO; + + sc = device_lookup_private(&lua_cd, minor(dev)); + if (sc == NULL) + return ENXIO; + + mutex_enter(&sc->sc_lock); + while (sc->sc_inuse == true) { + error = cv_wait_sig(&sc->sc_inuse_cv, &sc->sc_lock); + if (error) + break; + } + if (!error) + sc->sc_inuse = true; + mutex_exit(&sc->sc_lock); + + if (error) + return error; + return 0; +} + +int +luaclose(dev_t dev, int flag, int mode, struct lwp *l) +{ + struct lua_softc *sc; + + if (minor(dev) > 0) + return ENXIO; + sc = device_lookup_private(&lua_cd, minor(dev)); + mutex_enter(&sc->sc_lock); + sc->sc_inuse = false; + cv_signal(&sc->sc_inuse_cv); + mutex_exit(&sc->sc_lock); + return 0; +} + +int +luaioctl(dev_t dev, u_long cmd, void *data, int flag, struct lwp *l) +{ + struct lua_softc *sc; + struct lua_info *info; + struct lua_create *create; + struct lua_require *require; + struct lua_load *load; + struct lua_state *s; + struct lua_module *m; + kauth_cred_t cred; + struct nameidata nd; + struct pathbuf *pb; + struct vattr va; + struct lua_loadstate ls; + int error, n; + klua_State *K; + + sc = device_lookup_private(&lua_cd, minor(dev)); + if (!device_is_active(sc->sc_dev)) + return EBUSY; + + switch (cmd) { + case LUAINFO: + info = data; + if (info->states == NULL) { + info->num_states = 0; + LIST_FOREACH(s, &lua_states, lua_next) + info->num_states++; + } else { + n = 0; + LIST_FOREACH(s, &lua_states, lua_next) { + if (n > info->num_states) + break; + copyoutstr(s->lua_name, info->states[n].name, + MAX_LUA_NAME, NULL); + copyoutstr(s->lua_desc, info->states[n].desc, + MAX_LUA_DESC, NULL); + info->states[n].user = s->K->ks_user; + n++; + } + info->num_states = n; + } + break; + case LUACREATE: + create = data; + + if (*create->name == '_') { + if (lua_verbose) + device_printf(sc->sc_dev, "names of user " + "created states must not begin with '_'"); + return ENXIO; + } + LIST_FOREACH(s, &lua_states, lua_next) + if (!strcmp(s->lua_name, create->name)) { + if (lua_verbose) + device_printf(sc->sc_dev, + "state %s exists\n", create->name); + return EBUSY; + } + + K = klua_newstate(lua_alloc, NULL, create->name, + create->desc); + K->ks_user = true; + + if (K == NULL) + return ENOMEM; + if (lua_verbose) + device_printf(sc->sc_dev, "state %s created\n", + create->name); + break; + case LUADESTROY: + create = data; + + K = klua_find(create->name); + + if (K != NULL && (K->ks_user == true)) { + klua_close(K); + return 0; + } + return EBUSY; + case LUAREQUIRE: /* 'require' a module in a State */ + require = data; + LIST_FOREACH(s, &lua_states, lua_next) + if (!strcmp(s->lua_name, require->state)) + LIST_FOREACH(m, &lua_modules, mod_next) + if (!strcmp(m->mod_name, + require->module)) { + if (lua_verbose) + device_printf( + sc->sc_dev, + "requiring module " + "%s to state %s\n", + m->mod_name, + s->lua_name); + m->open(s->K->L); + m->refcount++; + LIST_INSERT_HEAD( + &s->lua_modules, m, + mod_next); + return 0; + } + return ENXIO; + case LUALOAD: + load = data; + if (strrchr(load->path, '/') == NULL) + return ENXIO; + + LIST_FOREACH(s, &lua_states, lua_next) + if (!strcmp(s->lua_name, load->state)) { + if (lua_verbose) + device_printf(sc->sc_dev, + "loading %s into state %s\n", + load->path, s->lua_name); + cred = kauth_cred_get(); + pb = pathbuf_create(load->path); + if (pb == NULL) + return ENOMEM; + NDINIT(&nd, LOOKUP, FOLLOW | NOCHROOT, pb); + pathbuf_destroy(pb); + error = vn_open(&nd, FREAD, 0); + if (error) { + if (lua_verbose) + device_printf(sc->sc_dev, + "error vn_open %d\n", + error); + return error; + } + error = VOP_GETATTR(nd.ni_vp, &va, + kauth_cred_get()); + if (error) { + VOP_UNLOCK(nd.ni_vp); + vn_close(nd.ni_vp, FREAD, + kauth_cred_get()); + if (lua_verbose) + device_printf(sc->sc_dev, + "erro VOP_GETATTR %d\n", + error); + return error; + } + if (va.va_type != VREG) { + VOP_UNLOCK(nd.ni_vp); + vn_close(nd.ni_vp, FREAD, + kauth_cred_get()); + return EINVAL; + } + ls.vp = nd.ni_vp; + ls.off = 0L; + ls.size = va.va_size; + VOP_UNLOCK(nd.ni_vp); + error = lua_load(s->K->L, lua_reader, &ls, + strrchr(load->path, '/') + 1); + vn_close(nd.ni_vp, FREAD, cred); + switch (error) { + case 0: /* no error */ + break; + case LUA_ERRSYNTAX: + if (lua_verbose) + device_printf(sc->sc_dev, + "syntax error\n"); + return EINVAL; + case LUA_ERRMEM: + if (lua_verbose) + device_printf(sc->sc_dev, + "memory error\n"); + return ENOMEM; + default: + if (lua_verbose) + device_printf(sc->sc_dev, + "load error %d: %s\n", + error, + lua_tostring(s->K->L, -1)); + return EINVAL; + } + if (lua_max_instr > 0) + lua_sethook(s->K->L, lua_maxcount, + LUA_MASKCOUNT, lua_max_instr); + error = lua_pcall(s->K->L, 0, LUA_MULTRET, 0); + if (error) { + if (lua_verbose) { + device_printf(sc->sc_dev, + "execution error: %s\n", + lua_tostring(s->K->L, -1)); + } + return EINVAL; + } + return 0; + } + return ENXIO; + } + return 0; +} + +static int +lua_require(lua_State *L) +{ + struct lua_state *s; + struct lua_module *m, *md; + const char *module; + char name[MAXPATHLEN]; + + module = lua_tostring(L, -1); + md = NULL; + LIST_FOREACH(m, &lua_modules, mod_next) + if (!strcmp(m->mod_name, module)) { + md = m; + break; + } + + if (md == NULL && lua_autoload_on && strchr(module, '/') == NULL) { + snprintf(name, sizeof name, "lua%s", module); + if (lua_verbose) + device_printf(sc_self, "autoload %s\n", name); + module_autoload(name, MODULE_CLASS_LUA_BINDING); + LIST_FOREACH(m, &lua_modules, mod_next) + if (!strcmp(m->mod_name, module)) { + md = m; + break; + } + } + + if (md != NULL) + LIST_FOREACH(s, &lua_states, lua_next) + if (s->K->L == L) { + if (lua_verbose) + device_printf(sc_self, + "require module %s\n", + md->mod_name); + md->open(L); + md->refcount++; + LIST_INSERT_HEAD(&s->lua_modules, md, mod_next); + return 0; + } + + lua_pushstring(L, "module not found"); + return lua_error(L); +} + +void * +lua_alloc(void *ud, void *ptr, size_t osize, size_t nsize) +{ + if (nsize == 0) { + if (ptr != NULL) + free(ptr, NULL); + return NULL; + } else + return realloc(ptr, nsize, ud, 0); +} + +static const char * +lua_reader(lua_State *L, void *data, size_t *size) +{ + struct lua_loadstate *ls; + static char buf[1024]; + size_t rsiz; + + ls = data; + if (ls->size < sizeof(buf)) + rsiz = ls->size; + else + rsiz = sizeof(buf); + vn_rdwr(UIO_READ, ls->vp, buf, rsiz, ls->off, UIO_SYSSPACE, + 0, curlwp->l_cred, NULL, curlwp); + if (ls->off == 0L && lua_bytecode_on == false && buf[0] == 0x1b) { + *size = 0L; + lua_pushstring(L, "loading of bytecode is not allowed"); + lua_error(L); + return NULL; + } else { + *size = rsiz; + ls->off += *size; + ls->size -= *size; + } + return buf; +} + +static void +lua_maxcount(lua_State *L, lua_Debug *d) +{ + lua_pushstring(L, "maximum instruction count exceeded"); + lua_error(L); +} + +int +lua_mod_register(const char *name, int (*open)(void *)) +{ + struct lua_module *m; + + LIST_FOREACH(m, &lua_modules, mod_next) + if (!strcmp(m->mod_name, name)) + return EBUSY; + m = malloc(sizeof(struct lua_module), NULL, M_ZERO); + if (m == NULL) + return ENOMEM; + strlcpy(m->mod_name, name, LUA_MAX_MODNAME); + m->open = open; + m->refcount = 0; + LIST_INSERT_HEAD(&lua_modules, m, mod_next); + if (lua_verbose) + device_printf(sc_self, "registered lua module %s\n", name); + return 0; +} + +int +lua_mod_unregister(const char *name) +{ + struct lua_module *m; + + LIST_FOREACH(m, &lua_modules, mod_next) + if (!strcmp(m->mod_name, name)) { + if (m->refcount == 0) { + LIST_REMOVE(m, mod_next); + free(m, NULL); + if (lua_verbose) + device_printf(sc_self, + "unregistered lua module %s\n", + name); + return 0; + } else + return EBUSY; + } + return 0; +} + +klua_State * +klua_newstate(lua_Alloc f, void *ud, const char *name, const char *desc) +{ + klua_State *K; + struct lua_state *s; + struct lua_softc *sc; + int error; + + s = malloc(sizeof(struct lua_state), NULL, M_ZERO); + if (s == NULL) + return NULL; + + sc = device_private(sc_self); + mutex_enter(&sc->sc_state_lock); + while (sc->sc_state == true) { + error = cv_wait_sig(&sc->sc_state_cv, &sc->sc_state_lock); + if (error) + break; + } + if (!error) + sc->sc_state = true; + mutex_exit(&sc->sc_state_lock); + + if (error) + return NULL; + + K = malloc(sizeof(klua_State), NULL, M_ZERO); + if (K == NULL) + goto finish; + K->L = lua_newstate(f, ud); + K->ks_user = false; + if (K->L == NULL) { + free(K, NULL); + K = NULL; + goto finish; + } + + strlcpy(s->lua_name, name, MAX_LUA_NAME); + strlcpy(s->lua_desc, desc, MAX_LUA_DESC); + s->K = K; + + if (lua_require_on || lua_autoload_on) { + lua_pushcfunction(K->L, lua_require); + lua_setglobal(K->L, "require"); + } + LIST_INSERT_HEAD(&lua_states, s, lua_next); + + mutex_init(&K->ks_lock, MUTEX_DEFAULT, IPL_VM); + cv_init(&K->ks_inuse_cv, "luainuse"); + +finish: + mutex_enter(&sc->sc_state_lock); + sc->sc_state = false; + cv_signal(&sc->sc_state_cv); + mutex_exit(&sc->sc_state_lock); + return K; +} + +void +klua_close(klua_State *K) +{ + struct lua_state *s; + struct lua_softc *sc; + struct lua_module *m; + int error; + + /* Notify the Lua state that it is about to be closed */ + if (klua_lock(K)) + return; /* Nothing we can do about */ + + lua_getglobal(K->L, "onClose"); + if (lua_isfunction(K->L, -1)) + lua_pcall(K->L, -1, 0, 0); + + /* + * Don't unlock, make sure no one uses the state until it is destroyed + * klua_unlock(K); + */ + + sc = device_private(sc_self); + mutex_enter(&sc->sc_state_lock); + while (sc->sc_state == true) { + error = cv_wait_sig(&sc->sc_state_cv, &sc->sc_state_lock); + if (error) + break; + } + if (!error) + sc->sc_state = true; + mutex_exit(&sc->sc_state_lock); + + if (error) + return; /* Nothing we can do... */ + + LIST_FOREACH(s, &lua_states, lua_next) + if (s->K == K) { + LIST_REMOVE(s, lua_next); + LIST_FOREACH(m, &s->lua_modules, mod_next) + m->refcount--; + free(s, NULL); + } + + lua_close(K->L); + cv_destroy(&K->ks_inuse_cv); + mutex_destroy(&K->ks_lock); + free(K, NULL); + + mutex_enter(&sc->sc_state_lock); + sc->sc_state = false; + cv_signal(&sc->sc_state_cv); + mutex_exit(&sc->sc_state_lock); +} + +static klua_State * +klua_find(const char *name) +{ + struct lua_state *s; + struct lua_softc *sc; + klua_State *K; + int error; + + K = NULL; + sc = device_private(sc_self); + mutex_enter(&sc->sc_state_lock); + while (sc->sc_state == true) { + error = cv_wait_sig(&sc->sc_state_cv, &sc->sc_state_lock); + if (error) + break; + } + if (!error) + sc->sc_state = true; + mutex_exit(&sc->sc_state_lock); + + if (error) + return NULL; + + LIST_FOREACH(s, &lua_states, lua_next) + if (!strcmp(s->lua_name, name)) { + K = s->K; + break; + } + + mutex_enter(&sc->sc_state_lock); + sc->sc_state = false; + cv_signal(&sc->sc_state_cv); + mutex_exit(&sc->sc_state_lock); + return K; +} + +int +klua_lock(klua_State *K) +{ + int error; + + error = 0; + mutex_enter(&K->ks_lock); + while (K->ks_inuse == true) { + error = cv_wait_sig(&K->ks_inuse_cv, &K->ks_lock); + if (error) + break; + } + if (!error) + K->ks_inuse = true; + mutex_exit(&K->ks_lock); + + if (error) + return error; + return 0; +} + +void +klua_unlock(klua_State *K) +{ + mutex_enter(&K->ks_lock); + K->ks_inuse = false; + cv_signal(&K->ks_inuse_cv); + mutex_exit(&K->ks_lock); +} + +MODULE(MODULE_CLASS_MISC, lua, NULL); + +#ifdef _MODULE +static const struct cfiattrdata luabus_iattrdata = { + "luabus", 0, { { NULL, NULL, 0 },} +}; +static const struct cfiattrdata *const lua_attrs[] = { + &luabus_iattrdata, NULL +}; +CFDRIVER_DECL(lua, DV_DULL, lua_attrs); +extern struct cfattach lua_ca; +static int lualoc[] = { + -1, + -1, + -1 +}; +static struct cfdata lua_cfdata[] = { + { + .cf_name = "lua", + .cf_atname = "lua", + .cf_unit = 0, + .cf_fstate = FSTATE_STAR, + .cf_loc = lualoc, + .cf_flags = 0, + .cf_pspec = NULL, + }, + { NULL, NULL, 0, FSTATE_NOTFOUND, NULL, 0, NULL } +}; +#endif + +static int +lua_modcmd(modcmd_t cmd, void *opaque) +{ +#ifdef _MODULE + devmajor_t cmajor, bmajor; + int error = 0; + + cmajor = bmajor = NODEVMAJOR; +#endif + switch (cmd) { + case MODULE_CMD_INIT: +#ifdef _MODULE + error = config_cfdriver_attach(&lua_cd); + if (error) + return error; + + error = config_cfattach_attach(lua_cd.cd_name, + &lua_ca); + if (error) { + config_cfdriver_detach(&lua_cd); + aprint_error("%s: unable to register cfattach\n", + lua_cd.cd_name); + return error; + } + error = config_cfdata_attach(lua_cfdata, 1); + if (error) { + config_cfattach_detach(lua_cd.cd_name, + &lua_ca); + config_cfdriver_detach(&lua_cd); + aprint_error("%s: unable to register cfdata\n", + lua_cd.cd_name); + return error; + } + error = devsw_attach(lua_cd.cd_name, NULL, &bmajor, + &lua_cdevsw, &cmajor); + if (error) { + aprint_error("%s: unable to register devsw\n", + lua_cd.cd_name); + config_cfattach_detach(lua_cd.cd_name, &lua_ca); + config_cfdriver_detach(&lua_cd); + return error; + } + config_attach_pseudo(lua_cfdata); +#endif + return 0; + case MODULE_CMD_FINI: +#ifdef _MODULE + error = config_cfdata_detach(lua_cfdata); + if (error) + return error; + + config_cfattach_detach(lua_cd.cd_name, &lua_ca); + config_cfdriver_detach(&lua_cd); + devsw_detach(NULL, &lua_cdevsw); +#endif + return 0; + case MODULE_CMD_AUTOUNLOAD: + /* no auto-unload */ + return EBUSY; + default: + return ENOTTY; + } +} diff --git a/sys/modules/lua/luaconf.h b/sys/modules/lua/luaconf.h new file mode 100644 index 00000000000..c5655a37f5a --- /dev/null +++ b/sys/modules/lua/luaconf.h @@ -0,0 +1,791 @@ +/* +** $Id: luaconf.h,v 1.1 2013/10/16 19:44:57 mbalmer Exp $ +** Configuration file for Lua +** See Copyright Notice in lua.h +*/ + + +#ifndef lconfig_h +#define lconfig_h + +#include <limits.h> +#include <stddef.h> + +#ifndef LUA_CORE +#define LUA_CORE +#endif + +/* +** ================================================================== +** Search for "@@" to find all configurable definitions. +** =================================================================== +*/ + + +/* +@@ lUA_ANSI controls the use of non-ansi features. +** CHANGE it (define it) if you want Lua to avoid the use of any +** non-ansi feature or library. +*/ +#if defined(__STRICT_ANSI__) +#define LUA_ANSI +#endif + + +#if !defined(LUA_ANSI) && defined(_WIN32) +#define LUA_WIN +#endif + +#if defined(LUA_USE_LINUX) +#define LUA_USE_POSIX +#define LUA_USE_DLOPEN /* needs an extra library: -ldl */ +#define LUA_USE_READLINE /* needs some extra libraries */ +#endif + +#if defined(LUA_USE_MACOSX) +#define LUA_USE_POSIX +#define LUA_DL_DYLD /* does not need extra library */ +#endif + + + +/* +@@ LUA_USE_POSIX includes all functionallity listed as X/Open System +@* Interfaces Extension (XSI). +** CHANGE it (define it) if your system is XSI compatible. +*/ +#if defined(LUA_USE_POSIX) +#define LUA_USE_MKSTEMP +#define LUA_USE_ISATTY +#define LUA_USE_POPEN +#define LUA_USE_ULONGJMP +#endif + + +/* +@@ LUA_PATH and LUA_CPATH are the names of the environment variables that +@* Lua check to set its paths. +@@ LUA_INIT is the name of the environment variable that Lua +@* checks for initialization code. +** CHANGE them if you want different names. +*/ +#define LUA_PATH "LUA_PATH" +#define LUA_CPATH "LUA_CPATH" +#define LUA_INIT "LUA_INIT" + + +/* +@@ LUA_PATH_DEFAULT is the default path that Lua uses to look for +@* Lua libraries. +@@ LUA_CPATH_DEFAULT is the default path that Lua uses to look for +@* C libraries. +** CHANGE them if your machine has a non-conventional directory +** hierarchy or if you want to install your libraries in +** non-conventional directories. +*/ +#if defined(_WIN32) +/* +** In Windows, any exclamation mark ('!') in the path is replaced by the +** path of the directory of the executable file of the current process. +*/ +#define LUA_LDIR "!\\lua\\" +#define LUA_CDIR "!\\" +#define LUA_PATH_DEFAULT \ + ".\\?.lua;" LUA_LDIR"?.lua;" LUA_LDIR"?\\init.lua;" \ + LUA_CDIR"?.lua;" LUA_CDIR"?\\init.lua" +#define LUA_CPATH_DEFAULT \ + ".\\?.dll;" LUA_CDIR"?.dll;" LUA_CDIR"loadall.dll" + +#else +#define LUA_ROOT "/usr/local/" +#define LUA_LDIR LUA_ROOT "share/lua/5.1/" +#define LUA_CDIR LUA_ROOT "lib/lua/5.1/" +#define LUA_PATH_DEFAULT \ + "./?.lua;" LUA_LDIR"?.lua;" LUA_LDIR"?/init.lua;" \ + LUA_CDIR"?.lua;" LUA_CDIR"?/init.lua" +#define LUA_CPATH_DEFAULT \ + "./?.so;" LUA_CDIR"?.so;" LUA_CDIR"loadall.so" +#endif + + +/* +@@ LUA_DIRSEP is the directory separator (for submodules). +** CHANGE it if your machine does not use "/" as the directory separator +** and is not Windows. (On Windows Lua automatically uses "\".) +*/ +#if defined(_WIN32) +#define LUA_DIRSEP "\\" +#else +#define LUA_DIRSEP "/" +#endif + + +/* +@@ LUA_PATHSEP is the character that separates templates in a path. +@@ LUA_PATH_MARK is the string that marks the substitution points in a +@* template. +@@ LUA_EXECDIR in a Windows path is replaced by the executable's +@* directory. +@@ LUA_IGMARK is a mark to ignore all before it when bulding the +@* luaopen_ function name. +** CHANGE them if for some reason your system cannot use those +** characters. (E.g., if one of those characters is a common character +** in file/directory names.) Probably you do not need to change them. +*/ +#define LUA_PATHSEP ";" +#define LUA_PATH_MARK "?" +#define LUA_EXECDIR "!" +#define LUA_IGMARK "-" + + +/* +@@ LUA_INTEGER is the integral type used by lua_pushinteger/lua_tointeger. +** CHANGE that if ptrdiff_t is not adequate on your machine. (On most +** machines, ptrdiff_t gives a good choice between int or long.) +*/ +#define LUA_INTEGER ptrdiff_t + + +/* +@@ LUA_API is a mark for all core API functions. +@@ LUALIB_API is a mark for all standard library functions. +** CHANGE them if you need to define those functions in some special way. +** For instance, if you want to create one Windows DLL with the core and +** the libraries, you may want to use the following definition (define +** LUA_BUILD_AS_DLL to get it). +*/ +#if defined(LUA_BUILD_AS_DLL) + +#if defined(LUA_CORE) || defined(LUA_LIB) +#define LUA_API __declspec(dllexport) +#else +#define LUA_API __declspec(dllimport) +#endif + +#else + +#define LUA_API extern + +#endif + +/* more often than not the libs go together with the core */ +#define LUALIB_API LUA_API + + +/* +@@ LUAI_FUNC is a mark for all extern functions that are not to be +@* exported to outside modules. +@@ LUAI_DATA is a mark for all extern (const) variables that are not to +@* be exported to outside modules. +** CHANGE them if you need to mark them in some special way. Elf/gcc +** (versions 3.2 and later) mark them as "hidden" to optimize access +** when Lua is compiled as a shared library. +*/ +#if defined(luaall_c) +#define LUAI_FUNC static +#define LUAI_DATA /* empty */ + +#elif defined(__GNUC__) && ((__GNUC__*100 + __GNUC_MINOR__) >= 302) && \ + defined(__ELF__) +#define LUAI_FUNC __attribute__((visibility("hidden"))) extern +#define LUAI_DATA LUAI_FUNC + +#else +#define LUAI_FUNC extern +#define LUAI_DATA extern +#endif + + + +/* +@@ LUA_QL describes how error messages quote program elements. +** CHANGE it if you want a different appearance. +*/ +#define LUA_QL(x) "'" x "'" +#define LUA_QS LUA_QL("%s") + + +/* +@@ LUA_IDSIZE gives the maximum size for the description of the source +@* of a function in debug information. +** CHANGE it if you want a different size. +*/ +#define LUA_IDSIZE 60 + + +/* +** {================================================================== +** Stand-alone configuration +** =================================================================== +*/ + +#if defined(lua_c) || defined(luaall_c) + +/* +@@ lua_stdin_is_tty detects whether the standard input is a 'tty' (that +@* is, whether we're running lua interactively). +** CHANGE it if you have a better definition for non-POSIX/non-Windows +** systems. +*/ +#if defined(LUA_USE_ISATTY) +#include <unistd.h> +#define lua_stdin_is_tty() isatty(0) +#elif defined(LUA_WIN) +#include <io.h> +#include <stdio.h> +#define lua_stdin_is_tty() _isatty(_fileno(stdin)) +#else +#define lua_stdin_is_tty() 1 /* assume stdin is a tty */ +#endif + + +/* +@@ LUA_PROMPT is the default prompt used by stand-alone Lua. +@@ LUA_PROMPT2 is the default continuation prompt used by stand-alone Lua. +** CHANGE them if you want different prompts. (You can also change the +** prompts dynamically, assigning to globals _PROMPT/_PROMPT2.) +*/ +#define LUA_PROMPT "> " +#define LUA_PROMPT2 ">> " + + +/* +@@ LUA_PROGNAME is the default name for the stand-alone Lua program. +** CHANGE it if your stand-alone interpreter has a different name and +** your system is not able to detect that name automatically. +*/ +#define LUA_PROGNAME "lua" + + +/* +@@ LUA_MAXINPUT is the maximum length for an input line in the +@* stand-alone interpreter. +** CHANGE it if you need longer lines. +*/ +#define LUA_MAXINPUT 512 + + +/* +@@ lua_readline defines how to show a prompt and then read a line from +@* the standard input. +@@ lua_saveline defines how to "save" a read line in a "history". +@@ lua_freeline defines how to free a line read by lua_readline. +** CHANGE them if you want to improve this functionality (e.g., by using +** GNU readline and history facilities). +*/ +#if defined(LUA_USE_READLINE) +#include <stdio.h> +#include <readline/readline.h> +#include <readline/history.h> +#define lua_readline(L,b,p) ((void)L, ((b)=readline(p)) != NULL) +#define lua_saveline(L,idx) \ + if (lua_strlen(L,idx) > 0) /* non-empty line? */ \ + add_history(lua_tostring(L, idx)); /* add it to history */ +#define lua_freeline(L,b) ((void)L, free(b)) +#else +#define lua_readline(L,b,p) \ + ((void)L, fputs(p, stdout), fflush(stdout), /* show prompt */ \ + fgets(b, LUA_MAXINPUT, stdin) != NULL) /* get line */ +#define lua_saveline(L,idx) { (void)L; (void)idx; } +#define lua_freeline(L,b) { (void)L; (void)b; } +#endif + +#endif + +/* }================================================================== */ + + +/* +@@ LUAI_GCPAUSE defines the default pause between garbage-collector cycles +@* as a percentage. +** CHANGE it if you want the GC to run faster or slower (higher values +** mean larger pauses which mean slower collection.) You can also change +** this value dynamically. +*/ +#define LUAI_GCPAUSE 200 /* 200% (wait memory to double before next GC) */ + + +/* +@@ LUAI_GCMUL defines the default speed of garbage collection relative to +@* memory allocation as a percentage. +** CHANGE it if you want to change the granularity of the garbage +** collection. (Higher values mean coarser collections. 0 represents +** infinity, where each step performs a full collection.) You can also +** change this value dynamically. +*/ +#define LUAI_GCMUL 200 /* GC runs 'twice the speed' of memory allocation */ + + + +/* +@@ LUA_COMPAT_GETN controls compatibility with old getn behavior. +** CHANGE it (define it) if you want exact compatibility with the +** behavior of setn/getn in Lua 5.0. +*/ +#undef LUA_COMPAT_GETN + +/* +@@ LUA_COMPAT_LOADLIB controls compatibility about global loadlib. +** CHANGE it to undefined as soon as you do not need a global 'loadlib' +** function (the function is still available as 'package.loadlib'). +*/ +#undef LUA_COMPAT_LOADLIB + +/* +@@ LUA_COMPAT_VARARG controls compatibility with old vararg feature. +** CHANGE it to undefined as soon as your programs use only '...' to +** access vararg parameters (instead of the old 'arg' table). +*/ +#define LUA_COMPAT_VARARG + +/* +@@ LUA_COMPAT_MOD controls compatibility with old math.mod function. +** CHANGE it to undefined as soon as your programs use 'math.fmod' or +** the new '%' operator instead of 'math.mod'. +*/ +#define LUA_COMPAT_MOD + +/* +@@ LUA_COMPAT_LSTR controls compatibility with old long string nesting +@* facility. +** CHANGE it to 2 if you want the old behaviour, or undefine it to turn +** off the advisory error when nesting [[...]]. +*/ +#define LUA_COMPAT_LSTR 1 + +/* +@@ LUA_COMPAT_GFIND controls compatibility with old 'string.gfind' name. +** CHANGE it to undefined as soon as you rename 'string.gfind' to +** 'string.gmatch'. +*/ +#define LUA_COMPAT_GFIND + +/* +@@ LUA_COMPAT_OPENLIB controls compatibility with old 'luaL_openlib' +@* behavior. +** CHANGE it to undefined as soon as you replace to 'luaL_register' +** your uses of 'luaL_openlib' +*/ +#define LUA_COMPAT_OPENLIB + + + +/* +@@ luai_apicheck is the assert macro used by the Lua-C API. +** CHANGE luai_apicheck if you want Lua to perform some checks in the +** parameters it gets from API calls. This may slow down the interpreter +** a bit, but may be quite useful when debugging C code that interfaces +** with Lua. A useful redefinition is to use assert.h. +*/ +#if defined(LUA_USE_APICHECK) +#include <assert.h> +#define luai_apicheck(L,o) { (void)L; assert(o); } +#else +#define luai_apicheck(L,o) { (void)L; } +#endif + + +/* +@@ LUAI_BITSINT defines the number of bits in an int. +** CHANGE here if Lua cannot automatically detect the number of bits of +** your machine. Probably you do not need to change this. +*/ +/* avoid overflows in comparison */ +#if INT_MAX-20 < 32760 +#define LUAI_BITSINT 16 +#elif INT_MAX > 2147483640L +/* int has at least 32 bits */ +#define LUAI_BITSINT 32 +#else +#error "you must define LUA_BITSINT with number of bits in an integer" +#endif + + +/* +@@ LUAI_UINT32 is an unsigned integer with at least 32 bits. +@@ LUAI_INT32 is an signed integer with at least 32 bits. +@@ LUAI_UMEM is an unsigned integer big enough to count the total +@* memory used by Lua. +@@ LUAI_MEM is a signed integer big enough to count the total memory +@* used by Lua. +** CHANGE here if for some weird reason the default definitions are not +** good enough for your machine. (The definitions in the 'else' +** part always works, but may waste space on machines with 64-bit +** longs.) Probably you do not need to change this. +*/ +#if LUAI_BITSINT >= 32 +#define LUAI_UINT32 unsigned int +#define LUAI_INT32 int +#define LUAI_MAXINT32 INT_MAX +#define LUAI_UMEM size_t +#define LUAI_MEM ptrdiff_t +#else +/* 16-bit ints */ +#define LUAI_UINT32 unsigned long +#define LUAI_INT32 long +#define LUAI_MAXINT32 LONG_MAX +#define LUAI_UMEM unsigned long +#define LUAI_MEM long +#endif + + +/* +@@ LUAI_MAXCALLS limits the number of nested calls. +** CHANGE it if you need really deep recursive calls. This limit is +** arbitrary; its only purpose is to stop infinite recursion before +** exhausting memory. +*/ +#define LUAI_MAXCALLS 20000 + + +/* +@@ LUAI_MAXCSTACK limits the number of Lua stack slots that a C function +@* can use. +** CHANGE it if you need lots of (Lua) stack space for your C +** functions. This limit is arbitrary; its only purpose is to stop C +** functions to consume unlimited stack space. (must be smaller than +** -LUA_REGISTRYINDEX) +*/ +#define LUAI_MAXCSTACK 8000 + + + +/* +** {================================================================== +** CHANGE (to smaller values) the following definitions if your system +** has a small C stack. (Or you may want to change them to larger +** values if your system has a large C stack and these limits are +** too rigid for you.) Some of these constants control the size of +** stack-allocated arrays used by the compiler or the interpreter, while +** others limit the maximum number of recursive calls that the compiler +** or the interpreter can perform. Values too large may cause a C stack +** overflow for some forms of deep constructs. +** =================================================================== +*/ + + +/* +@@ LUAI_MAXCCALLS is the maximum depth for nested C calls (short) and +@* syntactical nested non-terminals in a program. +*/ +#define LUAI_MAXCCALLS 200 + + +/* +@@ LUAI_MAXVARS is the maximum number of local variables per function +@* (must be smaller than 250). +*/ +#define LUAI_MAXVARS 200 + + +/* +@@ LUAI_MAXUPVALUES is the maximum number of upvalues per function +@* (must be smaller than 250). +*/ +#define LUAI_MAXUPVALUES 60 + + +/* +@@ LUAL_BUFFERSIZE is the buffer size used by the lauxlib buffer system. +*/ +#define LUAL_BUFFERSIZE BUFSIZ + +/* }================================================================== */ + + + + +/* +** {================================================================== +@@ LUA_NUMBER is the type of numbers in Lua. +** CHANGE the following definitions only if you want to build Lua +** with a number type different from double. You may also need to +** change lua_number2int & lua_number2integer. +** =================================================================== +*/ + +#ifdef _KERNEL +#define LUA_NUMBER long long + +#else +#define LUA_NUMBER_DOUBLE +#define LUA_NUMBER double +#endif + +/* +@@ LUAI_UACNUMBER is the result of an 'usual argument conversion' +@* over a number. +*/ + +#define LUAI_UACNUMBER LUA_NUMBER + +/* +@@ LUA_NUMBER_SCAN is the format for reading numbers. +@@ LUA_NUMBER_FMT is the format for writing numbers. +@@ lua_number2str converts a number to a string. +@@ LUAI_MAXNUMBER2STR is maximum size of previous conversion. +@@ lua_str2number converts a string to a number. +*/ + +#ifdef _KERNEL +#define LUA_NUMBER_SCAN "%lld" +#define LUA_NUMBER_FMT "%lld" +#define lua_str2number(s,p) strtoll((s), (p), 10) +#else +#define LUA_NUMBER_SCAN "%lf" +#define LUA_NUMBER_FMT "%.14g" +#define lua_str2number(s,p) strtod((s), (p)) +#endif + +#define lua_number2str(s,n) sprintf((s), LUA_NUMBER_FMT, (n)) +#define LUAI_MAXNUMBER2STR 32 /* 16 digits, sign, point, and \0 */ + +/* +@@ The luai_num* macros define the primitive operations over numbers. +*/ +#if defined(LUA_CORE) +#ifdef _KERNEL +#define luai_nummod(a,b) ((a)%(b)) +#define luai_numpow(a,b) luai_nummul(a,b) +#else +#include <math.h> +#define luai_nummod(a,b) ((a) - floor((a)/(b))*(b)) +#define luai_numpow(a,b) (pow(a,b)) +#endif + +#define luai_numadd(a,b) ((a)+(b)) +#define luai_numsub(a,b) ((a)-(b)) +#define luai_nummul(a,b) ((a)*(b)) +#define luai_numdiv(a,b) ((a)/(b)) +#define luai_numunm(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 + + +/* +@@ lua_number2int is a macro to convert lua_Number to int. +@@ lua_number2integer is a macro to convert lua_Number to lua_Integer. +** CHANGE them if you know a faster way to convert a lua_Number to +** int (with any rounding method and without throwing errors) in your +** system. In Pentium machines, a naive typecast from double to int +** in C is extremely slow, so any alternative is worth trying. +*/ + +/* On a Pentium, resort to a trick */ +#if defined(LUA_NUMBER_DOUBLE) && !defined(LUA_ANSI) && !defined(__SSE2__) && \ + (defined(__i386) || defined (_M_IX86) || defined(__i386__)) + +/* On a Microsoft compiler, use assembler */ +#if defined(_MSC_VER) + +#define lua_number2int(i,d) __asm fld d __asm fistp i +#define lua_number2integer(i,n) lua_number2int(i, n) + +/* the next trick should work on any Pentium, but sometimes clashes + with a DirectX idiosyncrasy */ +#else + +union luai_Cast { double l_d; long l_l; }; +#define lua_number2int(i,d) \ + { volatile union luai_Cast u; u.l_d = (d) + 6755399441055744.0; (i) = u.l_l; } +#define lua_number2integer(i,n) lua_number2int(i, n) + +#endif + + +/* this option always works, but may be slow */ +#else +#define lua_number2int(i,d) ((i)=(int)(d)) +#define lua_number2integer(i,d) ((i)=(lua_Integer)(d)) + +#endif + +/* }================================================================== */ + + +/* +@@ LUAI_USER_ALIGNMENT_T is a type that requires maximum alignment. +** CHANGE it if your system requires alignments larger than double. (For +** instance, if your system supports long doubles and they must be +** aligned in 16-byte boundaries, then you should add long double in the +** union.) Probably you do not need to change this. +*/ +#define LUAI_USER_ALIGNMENT_T union { double u; void *s; long l; } + + +/* +@@ LUAI_THROW/LUAI_TRY define how Lua does exception handling. +** CHANGE them if you prefer to use longjmp/setjmp even with C++ +** or if want/don't to use _longjmp/_setjmp instead of regular +** longjmp/setjmp. By default, Lua handles errors with exceptions when +** compiling as C++ code, with _longjmp/_setjmp when asked to use them, +** and with longjmp/setjmp otherwise. +*/ +#ifdef _KERNEL +/* in NetBSD kernel */ +#define LUAI_THROW(L,c) longjmp(& ((c)->b)) +#define LUAI_TRY(L,c,a) if (setjmp(& ((c)->b)) == 0) { a } +//#define LUAI_TRY(L,c,a) setjmp(& ((c)->b)) +#define luai_jmpbuf label_t + +#elif defined(__cplusplus) +/* C++ exceptions */ +#define LUAI_THROW(L,c) throw(c) +#define LUAI_TRY(L,c,a) try { a } catch(...) \ + { if ((c)->status == 0) (c)->status = -1; } +#define luai_jmpbuf int /* dummy variable */ + +#elif defined(LUA_USE_ULONGJMP) +/* in Unix, try _longjmp/_setjmp (more efficient) */ +#define LUAI_THROW(L,c) _longjmp((c)->b, 1) +#define LUAI_TRY(L,c,a) if (_setjmp((c)->b) == 0) { a } +#define luai_jmpbuf jmp_buf + +#else +/* default handling with long jumps */ +#define LUAI_THROW(L,c) longjmp((c)->b, 1) +#define LUAI_TRY(L,c,a) if (setjmp((c)->b) == 0) { a } +#define luai_jmpbuf jmp_buf + +#endif + + +/* +@@ LUA_MAXCAPTURES is the maximum number of captures that a pattern +@* can do during pattern-matching. +** CHANGE it if you need more captures. This limit is arbitrary. +*/ +#define LUA_MAXCAPTURES 32 + + +/* +@@ lua_tmpnam is the function that the OS library uses to create a +@* temporary name. +@@ LUA_TMPNAMBUFSIZE is the maximum size of a name created by lua_tmpnam. +** CHANGE them if you have an alternative to tmpnam (which is considered +** insecure) or if you want the original tmpnam anyway. By default, Lua +** uses tmpnam except when POSIX is available, where it uses mkstemp. +*/ +#if defined(loslib_c) || defined(luaall_c) + +#if defined(LUA_USE_MKSTEMP) +#include <unistd.h> +#define LUA_TMPNAMBUFSIZE 32 +#define lua_tmpnam(b,e) { \ + strcpy(b, "/tmp/lua_XXXXXX"); \ + e = mkstemp(b); \ + if (e != -1) close(e); \ + e = (e == -1); } + +#else +#define LUA_TMPNAMBUFSIZE L_tmpnam +#define lua_tmpnam(b,e) { e = (tmpnam(b) == NULL); } +#endif + +#endif + + +/* +@@ lua_popen spawns a new process connected to the current one through +@* the file streams. +** CHANGE it if you have a way to implement it in your system. +*/ +#if defined(LUA_USE_POPEN) + +#define lua_popen(L,c,m) ((void)L, fflush(NULL), popen(c,m)) +#define lua_pclose(L,file) ((void)L, (pclose(file) != -1)) + +#elif defined(LUA_WIN) + +#define lua_popen(L,c,m) ((void)L, _popen(c,m)) +#define lua_pclose(L,file) ((void)L, (_pclose(file) != -1)) + +#else + +#define lua_popen(L,c,m) ((void)((void)c, m), \ + luaL_error(L, LUA_QL("popen") " not supported"), (FILE*)0) +#define lua_pclose(L,file) ((void)((void)L, file), 0) + +#endif + +/* +@@ LUA_DL_* define which dynamic-library system Lua should use. +** CHANGE here if Lua has problems choosing the appropriate +** dynamic-library system for your platform (either Windows' DLL, Mac's +** dyld, or Unix's dlopen). If your system is some kind of Unix, there +** is a good chance that it has dlopen, so LUA_DL_DLOPEN will work for +** it. To use dlopen you also need to adapt the src/Makefile (probably +** adding -ldl to the linker options), so Lua does not select it +** automatically. (When you change the makefile to add -ldl, you must +** also add -DLUA_USE_DLOPEN.) +** If you do not want any kind of dynamic library, undefine all these +** options. +** By default, _WIN32 gets LUA_DL_DLL and MAC OS X gets LUA_DL_DYLD. +*/ +#if defined(LUA_USE_DLOPEN) +#define LUA_DL_DLOPEN +#endif + +#if defined(LUA_WIN) +#define LUA_DL_DLL +#endif + + +/* +@@ LUAI_EXTRASPACE allows you to add user-specific data in a lua_State +@* (the data goes just *before* the lua_State pointer). +** CHANGE (define) this if you really need that. This value must be +** a multiple of the maximum alignment required for your machine. +*/ +#define LUAI_EXTRASPACE 0 + + +/* +@@ luai_userstate* allow user-specific actions on threads. +** CHANGE them if you defined LUAI_EXTRASPACE and need to do something +** extra when a thread is created/deleted/resumed/yielded. +*/ +#define luai_userstateopen(L) ((void)L) +#define luai_userstateclose(L) ((void)L) +#define luai_userstatethread(L,L1) ((void)L) +#define luai_userstatefree(L) ((void)L) +#define luai_userstateresume(L,n) ((void)L) +#define luai_userstateyield(L,n) ((void)L) + + +/* +@@ LUA_INTFRMLEN is the length modifier for integer conversions +@* in 'string.format'. +@@ LUA_INTFRM_T is the integer type correspoding to the previous length +@* modifier. +** CHANGE them if your system supports long long or does not support long. +*/ + +#if defined(LUA_USELONGLONG) + +#define LUA_INTFRMLEN "ll" +#define LUA_INTFRM_T long long + +#else + +#define LUA_INTFRMLEN "l" +#define LUA_INTFRM_T long + +#endif + + + +/* =================================================================== */ + +/* +** Local configuration. You can use this space to add your redefinitions +** without modifying the main part of the file. +*/ + + + +#endif +#undef LUA_CORE diff --git a/sys/modules/lua/luavar.h b/sys/modules/lua/luavar.h new file mode 100644 index 00000000000..a63500b6e41 --- /dev/null +++ b/sys/modules/lua/luavar.h @@ -0,0 +1,49 @@ +/* $NetBSD: luavar.h,v 1.1 2013/10/16 19:44:57 mbalmer Exp $ */ + +/* + * Copyright (c) 2011, Marc Balmer <mbalmer@NetBSD.org>. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. The name of the Author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _LUA_VAR_ +#define _LUA_VAR_ + +struct lua_module { + char mod_name[LUA_MAX_MODNAME]; + int (*open)(void *); + int refcount; + LIST_ENTRY(lua_module) mod_next; +}; + +struct lua_state { + char lua_name[MAX_LUA_NAME]; + char lua_desc[MAX_LUA_DESC]; + klua_State *K; + LIST_HEAD(, lua_module) lua_modules; + LIST_ENTRY(lua_state) lua_next; +}; + +#endif /* _LUA_VAR_ */ diff --git a/sys/modules/lua/math.h b/sys/modules/lua/math.h new file mode 100644 index 00000000000..5d079ed3467 --- /dev/null +++ b/sys/modules/lua/math.h @@ -0,0 +1,6 @@ +/* $NetBSD */ + +/* + * This file is a placeholder only, to allow Lua to be compiled from + * unchanged sources. + */ diff --git a/sys/modules/lua/setjmp.h b/sys/modules/lua/setjmp.h new file mode 100644 index 00000000000..3870f09efca --- /dev/null +++ b/sys/modules/lua/setjmp.h @@ -0,0 +1,10 @@ +/* $NetBSD */ + +/* + * This file is a placeholder only, to allow Lua to be compiled from + * unchanged sources. + */ + +#include <machine/types.h> +#include <sys/systm.h> + diff --git a/sys/modules/lua/signal.h b/sys/modules/lua/signal.h new file mode 100644 index 00000000000..5d079ed3467 --- /dev/null +++ b/sys/modules/lua/signal.h @@ -0,0 +1,6 @@ +/* $NetBSD */ + +/* + * This file is a placeholder only, to allow Lua to be compiled from + * unchanged sources. + */ diff --git a/sys/modules/lua/stdarg.h b/sys/modules/lua/stdarg.h new file mode 100644 index 00000000000..bde63f352e6 --- /dev/null +++ b/sys/modules/lua/stdarg.h @@ -0,0 +1,8 @@ +/* $NetBSD */ + +/* + * This file is a placeholder only, to allow Lua to be compiled from + * unchanged sources. + */ + +#include <sys/stdarg.h> diff --git a/sys/modules/lua/stddef.h b/sys/modules/lua/stddef.h new file mode 100644 index 00000000000..bb27b58f852 --- /dev/null +++ b/sys/modules/lua/stddef.h @@ -0,0 +1,16 @@ +/* $NetBSD */ + +/* + * This file is a placeholder only, to allow Lua to be compiled from + * unchanged sources. + */ + +#include <sys/types.h> + +#ifdef _BSD_PTRDIFF_T_ +typedef _BSD_PTRDIFF_T_ ptrdiff_t; +#undef _BSD_PTRDIFF_T_ +#endif + +#include <sys/null.h> + diff --git a/sys/modules/lua/stdio.h b/sys/modules/lua/stdio.h new file mode 100644 index 00000000000..218aae482e6 --- /dev/null +++ b/sys/modules/lua/stdio.h @@ -0,0 +1,49 @@ +/* $NetBSD */ +/* + * Copyright (c) 2011, Lourival Neto <lneto@NetBSD.org>. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. The name of the Author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +/* + * This file is a placeholder only, to allow Lua to be compiled from + * unchanged sources. + */ + +#include <sys/param.h> + +#ifndef _LUA_INCLUDE_STDIO +#define _LUA_INCLUDE_STDIO + +#define fprintf(output, ...) printf(__VA_ARGS__) + +#define BUFSIZ (1024) + +#define putchar(c) printf("%c", c) + +#define fputs(s, f) printf(s) + +#endif + diff --git a/sys/modules/lua/stdlib.h b/sys/modules/lua/stdlib.h new file mode 100644 index 00000000000..b67b5419878 --- /dev/null +++ b/sys/modules/lua/stdlib.h @@ -0,0 +1,48 @@ +/* $NetBSD */ + +/* + * Copyright (c) 2011, Lourival Neto <lneto@NetBSD.org>. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. The name of the Author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +/* + * This file is a placeholder only, to allow Lua to be compiled from + * unchanged sources. + */ + +#include <sys/param.h> +#include <sys/kmem.h> + +#ifndef _LUA_INCLUDE_STDLIB +#define _LUA_INCLUDE_STDLIB + +#define realloc(ptr, nsize) kmem_alloc(nsize, KM_SLEEP) +#define free(ptr) kmem_free(ptr, osize) + +#define exit(EXIT_FAILURE) return + +#endif + diff --git a/sys/modules/lua/string.h b/sys/modules/lua/string.h new file mode 100644 index 00000000000..f54ade99316 --- /dev/null +++ b/sys/modules/lua/string.h @@ -0,0 +1,21 @@ +/* $NetBSD */ + +/* + * This file is a placeholder only, to allow Lua to be compiled from + * unchanged sources. + */ + +#include <sys/param.h> + +#ifndef _LUA_INCLUDE_STRING_ +#define _LUA_INCLUDE_STRING_ + +#define strcoll strcmp + +char *strncat(char *dst, const char *src, size_t n); +size_t strspn(const char *s, const char *charset); +size_t strcspn(const char *s, const char *charset); +char *strpbrk(const char *s, const char *charset); + +#endif + diff --git a/sys/modules/lua/test.lua b/sys/modules/lua/test.lua new file mode 100644 index 00000000000..123dd493c87 --- /dev/null +++ b/sys/modules/lua/test.lua @@ -0,0 +1,8 @@ +require 'core' + +core.print("hello, kernel world!\n") + +function onClose() + core.print('I am about to be closed\n') +end + |
