176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman/* 276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman** $Id: lauxlib.c,v 1.248.1.1 2013/04/12 18:48:47 roberto Exp $ 376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman** Auxiliary functions for building Lua libraries 476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman** See Copyright Notice in lua.h 576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman*/ 676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman#include <errno.h> 976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman#include <stdarg.h> 1076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman#include <stdio.h> 1176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman#include <stdlib.h> 1276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman#include <string.h> 1376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 1476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 1576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman/* This file uses only the official API of Lua. 1676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman** Any function declared here could be written as an application function. 1776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman*/ 1876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 1976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman#define lauxlib_c 2076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman#define LUA_LIB 2176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 2276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman#include "lua.h" 2376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 2476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman#include "lauxlib.h" 2576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 2676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 2776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman/* 2876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman** {====================================================== 2976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman** Traceback 3076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman** ======================================================= 3176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman*/ 3276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 3376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 3476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman#define LEVELS1 12 /* size of the first part of the stack */ 3576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman#define LEVELS2 10 /* size of the second part of the stack */ 3676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 3776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 3876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 3976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman/* 4076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman** search for 'objidx' in table at index -1. 4176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman** return 1 + string at top if find a good name. 4276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman*/ 4376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartmanstatic int findfield (lua_State *L, int objidx, int level) { 4476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman if (level == 0 || !lua_istable(L, -1)) 4576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman return 0; /* not found */ 4676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_pushnil(L); /* start 'next' loop */ 4776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman while (lua_next(L, -2)) { /* for each pair in table */ 4876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman if (lua_type(L, -2) == LUA_TSTRING) { /* ignore non-string keys */ 4976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman if (lua_rawequal(L, objidx, -1)) { /* found object? */ 5076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_pop(L, 1); /* remove value (but keep name) */ 5176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman return 1; 5276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman } 5376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman else if (findfield(L, objidx, level - 1)) { /* try recursively */ 5476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_remove(L, -2); /* remove table (but keep name) */ 5576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_pushliteral(L, "."); 5676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_insert(L, -2); /* place '.' between the two names */ 5776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_concat(L, 3); 5876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman return 1; 5976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman } 6076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman } 6176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_pop(L, 1); /* remove value */ 6276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman } 6376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman return 0; /* not found */ 6476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman} 6576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 6676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 6776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartmanstatic int pushglobalfuncname (lua_State *L, lua_Debug *ar) { 6876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman int top = lua_gettop(L); 6976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_getinfo(L, "f", ar); /* push function */ 7076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_pushglobaltable(L); 7176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman if (findfield(L, top + 1, 2)) { 7276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_copy(L, -1, top + 1); /* move name to proper place */ 7376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_pop(L, 2); /* remove pushed values */ 7476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman return 1; 7576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman } 7676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman else { 7776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_settop(L, top); /* remove function and global table */ 7876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman return 0; 7976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman } 8076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman} 8176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 8276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 8376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartmanstatic void pushfuncname (lua_State *L, lua_Debug *ar) { 8476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman if (*ar->namewhat != '\0') /* is there a name? */ 8576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_pushfstring(L, "function " LUA_QS, ar->name); 8676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman else if (*ar->what == 'm') /* main? */ 8776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_pushliteral(L, "main chunk"); 8876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman else if (*ar->what == 'C') { 8976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman if (pushglobalfuncname(L, ar)) { 9076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_pushfstring(L, "function " LUA_QS, lua_tostring(L, -1)); 9176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_remove(L, -2); /* remove name */ 9276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman } 9376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman else 9476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_pushliteral(L, "?"); 9576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman } 9676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman else 9776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_pushfstring(L, "function <%s:%d>", ar->short_src, ar->linedefined); 9876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman} 9976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 10076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 10176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartmanstatic int countlevels (lua_State *L) { 10276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_Debug ar; 10376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman int li = 1, le = 1; 10476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman /* find an upper bound */ 10576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman while (lua_getstack(L, le, &ar)) { li = le; le *= 2; } 10676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman /* do a binary search */ 10776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman while (li < le) { 10876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman int m = (li + le)/2; 10976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman if (lua_getstack(L, m, &ar)) li = m + 1; 11076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman else le = m; 11176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman } 11276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman return le - 1; 11376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman} 11476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 11576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 11676d05dc695b06c4e987bb8078f78032441e1430cGreg HartmanLUALIB_API void luaL_traceback (lua_State *L, lua_State *L1, 11776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman const char *msg, int level) { 11876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_Debug ar; 11976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman int top = lua_gettop(L); 12076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman int numlevels = countlevels(L1); 12176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman int mark = (numlevels > LEVELS1 + LEVELS2) ? LEVELS1 : 0; 12276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman if (msg) lua_pushfstring(L, "%s\n", msg); 12376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_pushliteral(L, "stack traceback:"); 12476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman while (lua_getstack(L1, level++, &ar)) { 12576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman if (level == mark) { /* too many levels? */ 12676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_pushliteral(L, "\n\t..."); /* add a '...' */ 12776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman level = numlevels - LEVELS2; /* and skip to last ones */ 12876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman } 12976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman else { 13076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_getinfo(L1, "Slnt", &ar); 13176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_pushfstring(L, "\n\t%s:", ar.short_src); 13276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman if (ar.currentline > 0) 13376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_pushfstring(L, "%d:", ar.currentline); 13476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_pushliteral(L, " in "); 13576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman pushfuncname(L, &ar); 13676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman if (ar.istailcall) 13776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_pushliteral(L, "\n\t(...tail calls...)"); 13876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_concat(L, lua_gettop(L) - top); 13976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman } 14076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman } 14176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_concat(L, lua_gettop(L) - top); 14276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman} 14376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 14476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman/* }====================================================== */ 14576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 14676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 14776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman/* 14876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman** {====================================================== 14976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman** Error-report functions 15076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman** ======================================================= 15176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman*/ 15276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 15376d05dc695b06c4e987bb8078f78032441e1430cGreg HartmanLUALIB_API int luaL_argerror (lua_State *L, int narg, const char *extramsg) { 15476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_Debug ar; 15576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman if (!lua_getstack(L, 0, &ar)) /* no stack frame? */ 15676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman return luaL_error(L, "bad argument #%d (%s)", narg, extramsg); 15776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_getinfo(L, "n", &ar); 15876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman if (strcmp(ar.namewhat, "method") == 0) { 15976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman narg--; /* do not count `self' */ 16076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman if (narg == 0) /* error is in the self argument itself? */ 16176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman return luaL_error(L, "calling " LUA_QS " on bad self (%s)", 16276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman ar.name, extramsg); 16376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman } 16476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman if (ar.name == NULL) 16576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman ar.name = (pushglobalfuncname(L, &ar)) ? lua_tostring(L, -1) : "?"; 16676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman return luaL_error(L, "bad argument #%d to " LUA_QS " (%s)", 16776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman narg, ar.name, extramsg); 16876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman} 16976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 17076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 17176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartmanstatic int typeerror (lua_State *L, int narg, const char *tname) { 17276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman const char *msg = lua_pushfstring(L, "%s expected, got %s", 17376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman tname, luaL_typename(L, narg)); 17476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman return luaL_argerror(L, narg, msg); 17576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman} 17676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 17776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 17876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartmanstatic void tag_error (lua_State *L, int narg, int tag) { 17976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman typeerror(L, narg, lua_typename(L, tag)); 18076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman} 18176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 18276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 18376d05dc695b06c4e987bb8078f78032441e1430cGreg HartmanLUALIB_API void luaL_where (lua_State *L, int level) { 18476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_Debug ar; 18576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman if (lua_getstack(L, level, &ar)) { /* check function at level */ 18676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_getinfo(L, "Sl", &ar); /* get info about it */ 18776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman if (ar.currentline > 0) { /* is there info? */ 18876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_pushfstring(L, "%s:%d: ", ar.short_src, ar.currentline); 18976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman return; 19076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman } 19176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman } 19276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_pushliteral(L, ""); /* else, no information available... */ 19376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman} 19476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 19576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 19676d05dc695b06c4e987bb8078f78032441e1430cGreg HartmanLUALIB_API int luaL_error (lua_State *L, const char *fmt, ...) { 19776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman va_list argp; 19876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman va_start(argp, fmt); 19976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman luaL_where(L, 1); 20076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_pushvfstring(L, fmt, argp); 20176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman va_end(argp); 20276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_concat(L, 2); 20376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman return lua_error(L); 20476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman} 20576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 20676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 20776d05dc695b06c4e987bb8078f78032441e1430cGreg HartmanLUALIB_API int luaL_fileresult (lua_State *L, int stat, const char *fname) { 20876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman int en = errno; /* calls to Lua API may change this value */ 20976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman if (stat) { 21076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_pushboolean(L, 1); 21176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman return 1; 21276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman } 21376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman else { 21476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_pushnil(L); 21576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman if (fname) 21676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_pushfstring(L, "%s: %s", fname, strerror(en)); 21776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman else 21876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_pushstring(L, strerror(en)); 21976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_pushinteger(L, en); 22076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman return 3; 22176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman } 22276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman} 22376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 22476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 22576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman#if !defined(inspectstat) /* { */ 22676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 22776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman#if defined(LUA_USE_POSIX) 22876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 22976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman#include <sys/wait.h> 23076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 23176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman/* 23276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman** use appropriate macros to interpret 'pclose' return status 23376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman*/ 23476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman#define inspectstat(stat,what) \ 23576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman if (WIFEXITED(stat)) { stat = WEXITSTATUS(stat); } \ 23676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman else if (WIFSIGNALED(stat)) { stat = WTERMSIG(stat); what = "signal"; } 23776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 23876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman#else 23976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 24076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman#define inspectstat(stat,what) /* no op */ 24176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 24276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman#endif 24376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 24476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman#endif /* } */ 24576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 24676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 24776d05dc695b06c4e987bb8078f78032441e1430cGreg HartmanLUALIB_API int luaL_execresult (lua_State *L, int stat) { 24876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman const char *what = "exit"; /* type of termination */ 24976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman if (stat == -1) /* error? */ 25076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman return luaL_fileresult(L, 0, NULL); 25176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman else { 25276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman inspectstat(stat, what); /* interpret result */ 25376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman if (*what == 'e' && stat == 0) /* successful termination? */ 25476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_pushboolean(L, 1); 25576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman else 25676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_pushnil(L); 25776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_pushstring(L, what); 25876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_pushinteger(L, stat); 25976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman return 3; /* return true/nil,what,code */ 26076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman } 26176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman} 26276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 26376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman/* }====================================================== */ 26476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 26576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 26676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman/* 26776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman** {====================================================== 26876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman** Userdata's metatable manipulation 26976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman** ======================================================= 27076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman*/ 27176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 27276d05dc695b06c4e987bb8078f78032441e1430cGreg HartmanLUALIB_API int luaL_newmetatable (lua_State *L, const char *tname) { 27376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman luaL_getmetatable(L, tname); /* try to get metatable */ 27476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman if (!lua_isnil(L, -1)) /* name already in use? */ 27576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman return 0; /* leave previous value on top, but return 0 */ 27676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_pop(L, 1); 27776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_newtable(L); /* create metatable */ 27876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_pushvalue(L, -1); 27976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_setfield(L, LUA_REGISTRYINDEX, tname); /* registry.name = metatable */ 28076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman return 1; 28176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman} 28276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 28376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 28476d05dc695b06c4e987bb8078f78032441e1430cGreg HartmanLUALIB_API void luaL_setmetatable (lua_State *L, const char *tname) { 28576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman luaL_getmetatable(L, tname); 28676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_setmetatable(L, -2); 28776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman} 28876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 28976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 29076d05dc695b06c4e987bb8078f78032441e1430cGreg HartmanLUALIB_API void *luaL_testudata (lua_State *L, int ud, const char *tname) { 29176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman void *p = lua_touserdata(L, ud); 29276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman if (p != NULL) { /* value is a userdata? */ 29376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman if (lua_getmetatable(L, ud)) { /* does it have a metatable? */ 29476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman luaL_getmetatable(L, tname); /* get correct metatable */ 29576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman if (!lua_rawequal(L, -1, -2)) /* not the same? */ 29676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman p = NULL; /* value is a userdata with wrong metatable */ 29776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_pop(L, 2); /* remove both metatables */ 29876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman return p; 29976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman } 30076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman } 30176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman return NULL; /* value is not a userdata with a metatable */ 30276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman} 30376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 30476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 30576d05dc695b06c4e987bb8078f78032441e1430cGreg HartmanLUALIB_API void *luaL_checkudata (lua_State *L, int ud, const char *tname) { 30676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman void *p = luaL_testudata(L, ud, tname); 30776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman if (p == NULL) typeerror(L, ud, tname); 30876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman return p; 30976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman} 31076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 31176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman/* }====================================================== */ 31276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 31376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 31476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman/* 31576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman** {====================================================== 31676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman** Argument check functions 31776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman** ======================================================= 31876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman*/ 31976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 32076d05dc695b06c4e987bb8078f78032441e1430cGreg HartmanLUALIB_API int luaL_checkoption (lua_State *L, int narg, const char *def, 32176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman const char *const lst[]) { 32276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman const char *name = (def) ? luaL_optstring(L, narg, def) : 32376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman luaL_checkstring(L, narg); 32476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman int i; 32576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman for (i=0; lst[i]; i++) 32676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman if (strcmp(lst[i], name) == 0) 32776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman return i; 32876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman return luaL_argerror(L, narg, 32976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_pushfstring(L, "invalid option " LUA_QS, name)); 33076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman} 33176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 33276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 33376d05dc695b06c4e987bb8078f78032441e1430cGreg HartmanLUALIB_API void luaL_checkstack (lua_State *L, int space, const char *msg) { 33476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman /* keep some extra space to run error routines, if needed */ 33576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman const int extra = LUA_MINSTACK; 33676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman if (!lua_checkstack(L, space + extra)) { 33776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman if (msg) 33876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman luaL_error(L, "stack overflow (%s)", msg); 33976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman else 34076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman luaL_error(L, "stack overflow"); 34176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman } 34276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman} 34376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 34476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 34576d05dc695b06c4e987bb8078f78032441e1430cGreg HartmanLUALIB_API void luaL_checktype (lua_State *L, int narg, int t) { 34676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman if (lua_type(L, narg) != t) 34776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman tag_error(L, narg, t); 34876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman} 34976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 35076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 35176d05dc695b06c4e987bb8078f78032441e1430cGreg HartmanLUALIB_API void luaL_checkany (lua_State *L, int narg) { 35276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman if (lua_type(L, narg) == LUA_TNONE) 35376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman luaL_argerror(L, narg, "value expected"); 35476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman} 35576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 35676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 35776d05dc695b06c4e987bb8078f78032441e1430cGreg HartmanLUALIB_API const char *luaL_checklstring (lua_State *L, int narg, size_t *len) { 35876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman const char *s = lua_tolstring(L, narg, len); 35976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman if (!s) tag_error(L, narg, LUA_TSTRING); 36076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman return s; 36176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman} 36276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 36376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 36476d05dc695b06c4e987bb8078f78032441e1430cGreg HartmanLUALIB_API const char *luaL_optlstring (lua_State *L, int narg, 36576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman const char *def, size_t *len) { 36676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman if (lua_isnoneornil(L, narg)) { 36776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman if (len) 36876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman *len = (def ? strlen(def) : 0); 36976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman return def; 37076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman } 37176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman else return luaL_checklstring(L, narg, len); 37276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman} 37376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 37476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 37576d05dc695b06c4e987bb8078f78032441e1430cGreg HartmanLUALIB_API lua_Number luaL_checknumber (lua_State *L, int narg) { 37676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman int isnum; 37776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_Number d = lua_tonumberx(L, narg, &isnum); 37876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman if (!isnum) 37976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman tag_error(L, narg, LUA_TNUMBER); 38076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman return d; 38176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman} 38276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 38376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 38476d05dc695b06c4e987bb8078f78032441e1430cGreg HartmanLUALIB_API lua_Number luaL_optnumber (lua_State *L, int narg, lua_Number def) { 38576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman return luaL_opt(L, luaL_checknumber, narg, def); 38676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman} 38776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 38876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 38976d05dc695b06c4e987bb8078f78032441e1430cGreg HartmanLUALIB_API lua_Integer luaL_checkinteger (lua_State *L, int narg) { 39076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman int isnum; 39176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_Integer d = lua_tointegerx(L, narg, &isnum); 39276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman if (!isnum) 39376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman tag_error(L, narg, LUA_TNUMBER); 39476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman return d; 39576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman} 39676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 39776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 39876d05dc695b06c4e987bb8078f78032441e1430cGreg HartmanLUALIB_API lua_Unsigned luaL_checkunsigned (lua_State *L, int narg) { 39976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman int isnum; 40076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_Unsigned d = lua_tounsignedx(L, narg, &isnum); 40176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman if (!isnum) 40276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman tag_error(L, narg, LUA_TNUMBER); 40376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman return d; 40476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman} 40576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 40676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 40776d05dc695b06c4e987bb8078f78032441e1430cGreg HartmanLUALIB_API lua_Integer luaL_optinteger (lua_State *L, int narg, 40876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_Integer def) { 40976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman return luaL_opt(L, luaL_checkinteger, narg, def); 41076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman} 41176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 41276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 41376d05dc695b06c4e987bb8078f78032441e1430cGreg HartmanLUALIB_API lua_Unsigned luaL_optunsigned (lua_State *L, int narg, 41476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_Unsigned def) { 41576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman return luaL_opt(L, luaL_checkunsigned, narg, def); 41676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman} 41776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 41876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman/* }====================================================== */ 41976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 42076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 42176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman/* 42276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman** {====================================================== 42376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman** Generic Buffer manipulation 42476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman** ======================================================= 42576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman*/ 42676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 42776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman/* 42876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman** check whether buffer is using a userdata on the stack as a temporary 42976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman** buffer 43076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman*/ 43176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman#define buffonstack(B) ((B)->b != (B)->initb) 43276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 43376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 43476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman/* 43576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman** returns a pointer to a free area with at least 'sz' bytes 43676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman*/ 43776d05dc695b06c4e987bb8078f78032441e1430cGreg HartmanLUALIB_API char *luaL_prepbuffsize (luaL_Buffer *B, size_t sz) { 43876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_State *L = B->L; 43976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman if (B->size - B->n < sz) { /* not enough space? */ 44076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman char *newbuff; 44176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman size_t newsize = B->size * 2; /* double buffer size */ 44276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman if (newsize - B->n < sz) /* not big enough? */ 44376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman newsize = B->n + sz; 44476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman if (newsize < B->n || newsize - B->n < sz) 44576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman luaL_error(L, "buffer too large"); 44676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman /* create larger buffer */ 44776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman newbuff = (char *)lua_newuserdata(L, newsize * sizeof(char)); 44876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman /* move content to new buffer */ 44976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman memcpy(newbuff, B->b, B->n * sizeof(char)); 45076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman if (buffonstack(B)) 45176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_remove(L, -2); /* remove old buffer */ 45276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman B->b = newbuff; 45376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman B->size = newsize; 45476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman } 45576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman return &B->b[B->n]; 45676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman} 45776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 45876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 45976d05dc695b06c4e987bb8078f78032441e1430cGreg HartmanLUALIB_API void luaL_addlstring (luaL_Buffer *B, const char *s, size_t l) { 46076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman char *b = luaL_prepbuffsize(B, l); 46176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman memcpy(b, s, l * sizeof(char)); 46276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman luaL_addsize(B, l); 46376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman} 46476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 46576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 46676d05dc695b06c4e987bb8078f78032441e1430cGreg HartmanLUALIB_API void luaL_addstring (luaL_Buffer *B, const char *s) { 46776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman luaL_addlstring(B, s, strlen(s)); 46876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman} 46976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 47076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 47176d05dc695b06c4e987bb8078f78032441e1430cGreg HartmanLUALIB_API void luaL_pushresult (luaL_Buffer *B) { 47276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_State *L = B->L; 47376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_pushlstring(L, B->b, B->n); 47476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman if (buffonstack(B)) 47576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_remove(L, -2); /* remove old buffer */ 47676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman} 47776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 47876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 47976d05dc695b06c4e987bb8078f78032441e1430cGreg HartmanLUALIB_API void luaL_pushresultsize (luaL_Buffer *B, size_t sz) { 48076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman luaL_addsize(B, sz); 48176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman luaL_pushresult(B); 48276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman} 48376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 48476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 48576d05dc695b06c4e987bb8078f78032441e1430cGreg HartmanLUALIB_API void luaL_addvalue (luaL_Buffer *B) { 48676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_State *L = B->L; 48776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman size_t l; 48876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman const char *s = lua_tolstring(L, -1, &l); 48976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman if (buffonstack(B)) 49076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_insert(L, -2); /* put value below buffer */ 49176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman luaL_addlstring(B, s, l); 49276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_remove(L, (buffonstack(B)) ? -2 : -1); /* remove value */ 49376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman} 49476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 49576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 49676d05dc695b06c4e987bb8078f78032441e1430cGreg HartmanLUALIB_API void luaL_buffinit (lua_State *L, luaL_Buffer *B) { 49776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman B->L = L; 49876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman B->b = B->initb; 49976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman B->n = 0; 50076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman B->size = LUAL_BUFFERSIZE; 50176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman} 50276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 50376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 50476d05dc695b06c4e987bb8078f78032441e1430cGreg HartmanLUALIB_API char *luaL_buffinitsize (lua_State *L, luaL_Buffer *B, size_t sz) { 50576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman luaL_buffinit(L, B); 50676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman return luaL_prepbuffsize(B, sz); 50776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman} 50876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 50976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman/* }====================================================== */ 51076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 51176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 51276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman/* 51376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman** {====================================================== 51476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman** Reference system 51576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman** ======================================================= 51676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman*/ 51776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 51876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman/* index of free-list header */ 51976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman#define freelist 0 52076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 52176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 52276d05dc695b06c4e987bb8078f78032441e1430cGreg HartmanLUALIB_API int luaL_ref (lua_State *L, int t) { 52376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman int ref; 52476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman if (lua_isnil(L, -1)) { 52576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_pop(L, 1); /* remove from stack */ 52676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman return LUA_REFNIL; /* `nil' has a unique fixed reference */ 52776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman } 52876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman t = lua_absindex(L, t); 52976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_rawgeti(L, t, freelist); /* get first free element */ 53076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman ref = (int)lua_tointeger(L, -1); /* ref = t[freelist] */ 53176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_pop(L, 1); /* remove it from stack */ 53276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman if (ref != 0) { /* any free element? */ 53376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_rawgeti(L, t, ref); /* remove it from list */ 53476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_rawseti(L, t, freelist); /* (t[freelist] = t[ref]) */ 53576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman } 53676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman else /* no free elements */ 53776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman ref = (int)lua_rawlen(L, t) + 1; /* get a new reference */ 53876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_rawseti(L, t, ref); 53976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman return ref; 54076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman} 54176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 54276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 54376d05dc695b06c4e987bb8078f78032441e1430cGreg HartmanLUALIB_API void luaL_unref (lua_State *L, int t, int ref) { 54476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman if (ref >= 0) { 54576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman t = lua_absindex(L, t); 54676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_rawgeti(L, t, freelist); 54776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_rawseti(L, t, ref); /* t[ref] = t[freelist] */ 54876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_pushinteger(L, ref); 54976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_rawseti(L, t, freelist); /* t[freelist] = ref */ 55076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman } 55176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman} 55276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 55376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman/* }====================================================== */ 55476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 55576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 55676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman/* 55776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman** {====================================================== 55876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman** Load functions 55976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman** ======================================================= 56076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman*/ 56176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 56276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartmantypedef struct LoadF { 56376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman int n; /* number of pre-read characters */ 56476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman FILE *f; /* file being read */ 56576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman char buff[LUAL_BUFFERSIZE]; /* area for reading file */ 56676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman} LoadF; 56776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 56876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 56976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartmanstatic const char *getF (lua_State *L, void *ud, size_t *size) { 57076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman LoadF *lf = (LoadF *)ud; 57176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman (void)L; /* not used */ 57276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman if (lf->n > 0) { /* are there pre-read characters to be read? */ 57376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman *size = lf->n; /* return them (chars already in buffer) */ 57476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lf->n = 0; /* no more pre-read characters */ 57576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman } 57676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman else { /* read a block from file */ 57776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman /* 'fread' can return > 0 *and* set the EOF flag. If next call to 57876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 'getF' called 'fread', it might still wait for user input. 57976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman The next check avoids this problem. */ 58076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman if (feof(lf->f)) return NULL; 58176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman *size = fread(lf->buff, 1, sizeof(lf->buff), lf->f); /* read block */ 58276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman } 58376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman return lf->buff; 58476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman} 58576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 58676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 58776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartmanstatic int errfile (lua_State *L, const char *what, int fnameindex) { 58876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman const char *serr = strerror(errno); 58976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman const char *filename = lua_tostring(L, fnameindex) + 1; 59076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_pushfstring(L, "cannot %s %s: %s", what, filename, serr); 59176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_remove(L, fnameindex); 59276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman return LUA_ERRFILE; 59376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman} 59476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 59576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 59676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartmanstatic int skipBOM (LoadF *lf) { 59776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman const char *p = "\xEF\xBB\xBF"; /* Utf8 BOM mark */ 59876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman int c; 59976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lf->n = 0; 60076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman do { 60176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman c = getc(lf->f); 60276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman if (c == EOF || c != *(const unsigned char *)p++) return c; 60376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lf->buff[lf->n++] = c; /* to be read by the parser */ 60476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman } while (*p != '\0'); 60576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lf->n = 0; /* prefix matched; discard it */ 60676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman return getc(lf->f); /* return next character */ 60776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman} 60876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 60976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 61076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman/* 61176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman** reads the first character of file 'f' and skips an optional BOM mark 61276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman** in its beginning plus its first line if it starts with '#'. Returns 61376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman** true if it skipped the first line. In any case, '*cp' has the 61476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman** first "valid" character of the file (after the optional BOM and 61576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman** a first-line comment). 61676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman*/ 61776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartmanstatic int skipcomment (LoadF *lf, int *cp) { 61876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman int c = *cp = skipBOM(lf); 61976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman if (c == '#') { /* first line is a comment (Unix exec. file)? */ 62076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman do { /* skip first line */ 62176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman c = getc(lf->f); 62276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman } while (c != EOF && c != '\n') ; 62376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman *cp = getc(lf->f); /* skip end-of-line, if present */ 62476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman return 1; /* there was a comment */ 62576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman } 62676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman else return 0; /* no comment */ 62776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman} 62876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 62976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 63076d05dc695b06c4e987bb8078f78032441e1430cGreg HartmanLUALIB_API int luaL_loadfilex (lua_State *L, const char *filename, 63176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman const char *mode) { 63276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman LoadF lf; 63376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman int status, readstatus; 63476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman int c; 63576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman int fnameindex = lua_gettop(L) + 1; /* index of filename on the stack */ 63676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman if (filename == NULL) { 63776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_pushliteral(L, "=stdin"); 63876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lf.f = stdin; 63976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman } 64076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman else { 64176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_pushfstring(L, "@%s", filename); 64276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lf.f = fopen(filename, "r"); 64376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman if (lf.f == NULL) return errfile(L, "open", fnameindex); 64476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman } 64576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman if (skipcomment(&lf, &c)) /* read initial portion */ 64676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lf.buff[lf.n++] = '\n'; /* add line to correct line numbers */ 64776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman#ifndef SYSLINUX 64876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman if (c == LUA_SIGNATURE[0] && filename) { /* binary file? */ 64976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lf.f = freopen(filename, "rb", lf.f); /* reopen in binary mode */ 65076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman if (lf.f == NULL) return errfile(L, "reopen", fnameindex); 65176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman skipcomment(&lf, &c); /* re-read initial portion */ 65276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman } 65376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman#endif 65476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman if (c != EOF) 65576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lf.buff[lf.n++] = c; /* 'c' is the first character of the stream */ 65676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman status = lua_load(L, getF, &lf, lua_tostring(L, -1), mode); 65776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman readstatus = ferror(lf.f); 65876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman if (filename) fclose(lf.f); /* close file (even in case of errors) */ 65976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman if (readstatus) { 66076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_settop(L, fnameindex); /* ignore results from `lua_load' */ 66176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman return errfile(L, "read", fnameindex); 66276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman } 66376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_remove(L, fnameindex); 66476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman return status; 66576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman} 66676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 66776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 66876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartmantypedef struct LoadS { 66976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman const char *s; 67076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman size_t size; 67176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman} LoadS; 67276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 67376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 67476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartmanstatic const char *getS (lua_State *L, void *ud, size_t *size) { 67576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman LoadS *ls = (LoadS *)ud; 67676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman (void)L; /* not used */ 67776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman if (ls->size == 0) return NULL; 67876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman *size = ls->size; 67976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman ls->size = 0; 68076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman return ls->s; 68176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman} 68276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 68376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 68476d05dc695b06c4e987bb8078f78032441e1430cGreg HartmanLUALIB_API int luaL_loadbufferx (lua_State *L, const char *buff, size_t size, 68576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman const char *name, const char *mode) { 68676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman LoadS ls; 68776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman ls.s = buff; 68876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman ls.size = size; 68976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman return lua_load(L, getS, &ls, name, mode); 69076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman} 69176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 69276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 69376d05dc695b06c4e987bb8078f78032441e1430cGreg HartmanLUALIB_API int luaL_loadstring (lua_State *L, const char *s) { 69476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman return luaL_loadbuffer(L, s, strlen(s), s); 69576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman} 69676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 69776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman/* }====================================================== */ 69876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 69976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 70076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 70176d05dc695b06c4e987bb8078f78032441e1430cGreg HartmanLUALIB_API int luaL_getmetafield (lua_State *L, int obj, const char *event) { 70276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman if (!lua_getmetatable(L, obj)) /* no metatable? */ 70376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman return 0; 70476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_pushstring(L, event); 70576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_rawget(L, -2); 70676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman if (lua_isnil(L, -1)) { 70776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_pop(L, 2); /* remove metatable and metafield */ 70876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman return 0; 70976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman } 71076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman else { 71176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_remove(L, -2); /* remove only metatable */ 71276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman return 1; 71376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman } 71476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman} 71576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 71676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 71776d05dc695b06c4e987bb8078f78032441e1430cGreg HartmanLUALIB_API int luaL_callmeta (lua_State *L, int obj, const char *event) { 71876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman obj = lua_absindex(L, obj); 71976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman if (!luaL_getmetafield(L, obj, event)) /* no metafield? */ 72076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman return 0; 72176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_pushvalue(L, obj); 72276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_call(L, 1, 1); 72376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman return 1; 72476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman} 72576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 72676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 72776d05dc695b06c4e987bb8078f78032441e1430cGreg HartmanLUALIB_API int luaL_len (lua_State *L, int idx) { 72876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman int l; 72976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman int isnum; 73076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_len(L, idx); 73176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman l = (int)lua_tointegerx(L, -1, &isnum); 73276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman if (!isnum) 73376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman luaL_error(L, "object length is not a number"); 73476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_pop(L, 1); /* remove object */ 73576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman return l; 73676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman} 73776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 73876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 73976d05dc695b06c4e987bb8078f78032441e1430cGreg HartmanLUALIB_API const char *luaL_tolstring (lua_State *L, int idx, size_t *len) { 74076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman if (!luaL_callmeta(L, idx, "__tostring")) { /* no metafield? */ 74176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman switch (lua_type(L, idx)) { 74276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman case LUA_TNUMBER: 74376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman case LUA_TSTRING: 74476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_pushvalue(L, idx); 74576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman break; 74676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman case LUA_TBOOLEAN: 74776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_pushstring(L, (lua_toboolean(L, idx) ? "true" : "false")); 74876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman break; 74976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman case LUA_TNIL: 75076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_pushliteral(L, "nil"); 75176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman break; 75276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman default: 75376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_pushfstring(L, "%s: %p", luaL_typename(L, idx), 75476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_topointer(L, idx)); 75576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman break; 75676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman } 75776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman } 75876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman return lua_tolstring(L, -1, len); 75976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman} 76076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 76176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 76276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman/* 76376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman** {====================================================== 76476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman** Compatibility with 5.1 module functions 76576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman** ======================================================= 76676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman*/ 76776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman#if defined(LUA_COMPAT_MODULE) 76876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 76976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartmanstatic const char *luaL_findtable (lua_State *L, int idx, 77076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman const char *fname, int szhint) { 77176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman const char *e; 77276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman if (idx) lua_pushvalue(L, idx); 77376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman do { 77476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman e = strchr(fname, '.'); 77576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman if (e == NULL) e = fname + strlen(fname); 77676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_pushlstring(L, fname, e - fname); 77776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_rawget(L, -2); 77876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman if (lua_isnil(L, -1)) { /* no such field? */ 77976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_pop(L, 1); /* remove this nil */ 78076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_createtable(L, 0, (*e == '.' ? 1 : szhint)); /* new table for field */ 78176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_pushlstring(L, fname, e - fname); 78276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_pushvalue(L, -2); 78376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_settable(L, -4); /* set new table into field */ 78476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman } 78576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman else if (!lua_istable(L, -1)) { /* field has a non-table value? */ 78676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_pop(L, 2); /* remove table and value */ 78776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman return fname; /* return problematic part of the name */ 78876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman } 78976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_remove(L, -2); /* remove previous table */ 79076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman fname = e + 1; 79176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman } while (*e == '.'); 79276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman return NULL; 79376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman} 79476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 79576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 79676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman/* 79776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman** Count number of elements in a luaL_Reg list. 79876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman*/ 79976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartmanstatic int libsize (const luaL_Reg *l) { 80076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman int size = 0; 80176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman for (; l && l->name; l++) size++; 80276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman return size; 80376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman} 80476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 80576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 80676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman/* 80776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman** Find or create a module table with a given name. The function 80876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman** first looks at the _LOADED table and, if that fails, try a 80976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman** global variable with that name. In any case, leaves on the stack 81076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman** the module table. 81176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman*/ 81276d05dc695b06c4e987bb8078f78032441e1430cGreg HartmanLUALIB_API void luaL_pushmodule (lua_State *L, const char *modname, 81376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman int sizehint) { 81476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman luaL_findtable(L, LUA_REGISTRYINDEX, "_LOADED", 1); /* get _LOADED table */ 81576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_getfield(L, -1, modname); /* get _LOADED[modname] */ 81676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman if (!lua_istable(L, -1)) { /* not found? */ 81776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_pop(L, 1); /* remove previous result */ 81876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman /* try global variable (and create one if it does not exist) */ 81976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_pushglobaltable(L); 82076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman if (luaL_findtable(L, 0, modname, sizehint) != NULL) 82176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman luaL_error(L, "name conflict for module " LUA_QS, modname); 82276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_pushvalue(L, -1); 82376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_setfield(L, -3, modname); /* _LOADED[modname] = new table */ 82476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman } 82576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_remove(L, -2); /* remove _LOADED table */ 82676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman} 82776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 82876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 82976d05dc695b06c4e987bb8078f78032441e1430cGreg HartmanLUALIB_API void luaL_openlib (lua_State *L, const char *libname, 83076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman const luaL_Reg *l, int nup) { 83176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman luaL_checkversion(L); 83276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman if (libname) { 83376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman luaL_pushmodule(L, libname, libsize(l)); /* get/create library table */ 83476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_insert(L, -(nup + 1)); /* move library table to below upvalues */ 83576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman } 83676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman if (l) 83776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman luaL_setfuncs(L, l, nup); 83876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman else 83976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_pop(L, nup); /* remove upvalues */ 84076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman} 84176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 84276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman#endif 84376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman/* }====================================================== */ 84476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 84576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman/* 84676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman** set functions from list 'l' into table at top - 'nup'; each 84776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman** function gets the 'nup' elements at the top as upvalues. 84876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman** Returns with only the table at the stack. 84976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman*/ 85076d05dc695b06c4e987bb8078f78032441e1430cGreg HartmanLUALIB_API void luaL_setfuncs (lua_State *L, const luaL_Reg *l, int nup) { 85176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman luaL_checkversion(L); 85276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman luaL_checkstack(L, nup, "too many upvalues"); 85376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman for (; l->name != NULL; l++) { /* fill the table with given functions */ 85476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman int i; 85576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman for (i = 0; i < nup; i++) /* copy upvalues to the top */ 85676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_pushvalue(L, -nup); 85776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_pushcclosure(L, l->func, nup); /* closure with those upvalues */ 85876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_setfield(L, -(nup + 2), l->name); 85976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman } 86076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_pop(L, nup); /* remove upvalues */ 86176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman} 86276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 86376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 86476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman/* 86576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman** ensure that stack[idx][fname] has a table and push that table 86676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman** into the stack 86776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman*/ 86876d05dc695b06c4e987bb8078f78032441e1430cGreg HartmanLUALIB_API int luaL_getsubtable (lua_State *L, int idx, const char *fname) { 86976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_getfield(L, idx, fname); 87076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman if (lua_istable(L, -1)) return 1; /* table already there */ 87176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman else { 87276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_pop(L, 1); /* remove previous result */ 87376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman idx = lua_absindex(L, idx); 87476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_newtable(L); 87576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_pushvalue(L, -1); /* copy to be left at top */ 87676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_setfield(L, idx, fname); /* assign new table to field */ 87776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman return 0; /* false, because did not find table there */ 87876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman } 87976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman} 88076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 88176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 88276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman/* 88376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman** stripped-down 'require'. Calls 'openf' to open a module, 88476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman** registers the result in 'package.loaded' table and, if 'glb' 88576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman** is true, also registers the result in the global table. 88676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman** Leaves resulting module on the top. 88776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman*/ 88876d05dc695b06c4e987bb8078f78032441e1430cGreg HartmanLUALIB_API void luaL_requiref (lua_State *L, const char *modname, 88976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_CFunction openf, int glb) { 89076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_pushcfunction(L, openf); 89176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_pushstring(L, modname); /* argument to open function */ 89276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_call(L, 1, 1); /* open module */ 89376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman luaL_getsubtable(L, LUA_REGISTRYINDEX, "_LOADED"); 89476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_pushvalue(L, -2); /* make copy of module (call result) */ 89576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_setfield(L, -2, modname); /* _LOADED[modname] = module */ 89676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_pop(L, 1); /* remove _LOADED table */ 89776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman if (glb) { 89876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_pushvalue(L, -1); /* copy of 'mod' */ 89976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_setglobal(L, modname); /* _G[modname] = module */ 90076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman } 90176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman} 90276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 90376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 90476d05dc695b06c4e987bb8078f78032441e1430cGreg HartmanLUALIB_API const char *luaL_gsub (lua_State *L, const char *s, const char *p, 90576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman const char *r) { 90676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman const char *wild; 90776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman size_t l = strlen(p); 90876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman luaL_Buffer b; 90976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman luaL_buffinit(L, &b); 91076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman while ((wild = strstr(s, p)) != NULL) { 91176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman luaL_addlstring(&b, s, wild - s); /* push prefix */ 91276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman luaL_addstring(&b, r); /* push replacement in place of pattern */ 91376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman s = wild + l; /* continue after `p' */ 91476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman } 91576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman luaL_addstring(&b, s); /* push last suffix */ 91676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman luaL_pushresult(&b); 91776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman return lua_tostring(L, -1); 91876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman} 91976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 92076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 92176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartmanstatic void *l_alloc (void *ud, void *ptr, size_t osize, size_t nsize) { 92276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman (void)ud; (void)osize; /* not used */ 92376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman if (nsize == 0) { 92476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman free(ptr); 92576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman return NULL; 92676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman } 92776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman else 92876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman return realloc(ptr, nsize); 92976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman} 93076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 93176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 93276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartmanstatic int panic (lua_State *L) { 93376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman luai_writestringerror("PANIC: unprotected error in call to Lua API (%s)\n", 93476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_tostring(L, -1)); 93576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman return 0; /* return to Lua to abort */ 93676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman} 93776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 93876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 93976d05dc695b06c4e987bb8078f78032441e1430cGreg HartmanLUALIB_API lua_State *luaL_newstate (void) { 94076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_State *L = lua_newstate(l_alloc, NULL); 94176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman if (L) lua_atpanic(L, &panic); 94276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman return L; 94376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman} 94476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 94576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 94676d05dc695b06c4e987bb8078f78032441e1430cGreg HartmanLUALIB_API void luaL_checkversion_ (lua_State *L, lua_Number ver) { 94776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman const lua_Number *v = lua_version(L); 94876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman if (v != lua_version(NULL)) 94976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman luaL_error(L, "multiple Lua VMs detected"); 95076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman else if (*v != ver) 95176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman luaL_error(L, "version mismatch: app. needs %f, Lua core provides %f", 95276d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman ver, *v); 95376d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman /* check conversions number -> integer types */ 95476d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_pushnumber(L, -(lua_Number)0x1234); 95576d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman if (lua_tointeger(L, -1) != -0x1234 || 95676d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_tounsigned(L, -1) != (lua_Unsigned)-0x1234) 95776d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman luaL_error(L, "bad conversion number->int;" 95876d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman " must recompile Lua with proper settings"); 95976d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman lua_pop(L, 1); 96076d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman} 96176d05dc695b06c4e987bb8078f78032441e1430cGreg Hartman 962