API.xs - metacpan.org

#include "EXTERN.h"
#include "perl.h"
#include "XSUB.h"

#include <stdio.h>

#include "ppport.h"

#include <lua.h>
#include <lualib.h>
#include <lauxlib.h>

#if LUA_VERSION_NUM < 501

#error "This requires at least version 5.1 of Lua"

#endif

#include "const-c.inc"

#define MY_CXT_KEY "Lua::API::_guts" XS_VERSION

typedef struct {
    HV *OOB;
} my_cxt_t;

START_MY_CXT


/*-------------------------------------------------------------------*/
/* Support for out-of-band data

   Lua interfaces to C functions, not Perl ones, and they must be
   declared at compile time (can't create them on the fly) so we
   use trampoline C functions to call Perl.  Sometimes its possible
   to attach routing information (via Lua C closures) so that the
   trampoline knows which Perl function to call.  Sometimes its not.

   In the latter case, for certain classes of uses (such as hooks) we
   can deduce which Perl function to call based upon some extra piece
   of data needs to be stored somewhere.  This provides that facility.

   We keep track of the out-of-band data in a Perl hash, keyed off of
   a pointer address (like an inside-out object). We could
   have created a LuaInterpreter Object which contains both the
   lua_State pointer and any other instance specific data, but that
   makes using the automated XS calling of Lua functions much more
   messy.

*/

/* The OOB hash stores data keyed off of a pointer.  Its values are
   hashes */

static
HV* get_oob_entry( void *ptr )
{
    dMY_CXT;
    HV* oob;

    {
	SV ** svp = hv_fetch( MY_CXT.OOB, (const char*) &ptr, sizeof(ptr), 1 );
	if ( svp == NULL )
	    croak( "Perl Lua::API: error getting OOB hash\n" );

	/* if not defined, has not yet been created; do so */
	if ( ! SvOK( *svp) )
	{
	    HV *t_hv = newHV();
	    SV *t_rv = newRV_inc( (SV*) t_hv );
	    svp = hv_store( MY_CXT.OOB, (const char*) &ptr, sizeof(ptr), t_rv, 0);
	}

	oob = (HV*) SvRV(*svp);

	if ( SVt_PVHV != SvTYPE(oob) )
	    croak( "Perl Lua::API: OOB entry  %p is not a hash\n", (void *) ptr );
    }

    return oob;
}

static
SV * delete_oob_entry( void *ptr )
{
    dMY_CXT;

    return hv_delete( MY_CXT.OOB, (const char*) &ptr, sizeof(ptr), 0 );
}


/*-------------------------------------------------------------------*/
/* Mapping lua_State* to Lua::API::State objects

   When Lua calls the trampolines, its passes in a lua_State*.  Perl,
   however, wants a Lua::API::State object.  We could create them on the
   fly from the lua_State* (since there's nothing in the Lua::API::State
   object but a lua_State*), but then Lua::API::State::DESTROY would get
   called whenever the temporary objects are destroyed, which
   is not good.

   Instead, we keep track of the original Lua::API::State object in the OOB
   hash.
 */

static
SV* get_Perl_object( void *ptr )
{
    SV** svp = hv_fetch( get_oob_entry( ptr ), "object", 5, 0 );
    if ( svp == NULL )
	croak( "Perl Lua::API::get_Perl_object: error getting object\n" );

    return *svp;
}

static
void set_Perl_object( void *ptr, SV* object )
{
    HV* oob = get_oob_entry( ptr );

    /* store Perl Lua::API::State object keyed off of lua_State pointer */
    SV** svp = hv_fetch( oob, "object", 5, 1 );

    if ( svp == NULL )
	croak( "Perl Lua::API::set_Perl_object: error getting object\n" );

    sv_setsv( *svp, object );
}

#if 0

/*-------------------------------------------------------------------*/
/* panic function to catch errors thrown from Lua API calls.  This is
   used to turn them into Perl exceptions */

static
int set_panic( lua_State *L, jump_buf *env)
{
    HV* oob = get_oob_entry( L );
    SV** svp = hv_fetch(oob, "panic", 5, 1 );

    if ( svp == NULL )
	croak( "Perl Lua::API: error getting panic state\n" );

    if ( env )
    {
	sv_setpvn( *svp, env, sizeof(*env) );
    }

    else
    {
	hv_delete( oob, "panic", 4, G_DISCARD );
    }
}

static
int panic( Lua_State *L )
{
    HV* oob = get_oob_entry( L );
    SV** svp = hv_fetch(oob, "panic", 5, 1 );

    if ( svp == NULL )
	croak( "Perl Lua::API: error getting panic state\n" );



}
#endif

/*-------------------------------------------------------------------*/
/* Support for hooks */


static
void set_hook( lua_State *L, SV* func )
{
    HV* oob = get_oob_entry( L );
    SV** svp = hv_fetch( oob, "hook", 4, 1 );

    if ( svp == NULL )
	croak( "Perl Lua::API: error getting hook\n" );

    if ( SvOK(func) )
    {
	sv_setsv( *svp, func );
    }

    else
    {
	hv_delete( oob, "hook", 4, G_DISCARD );
    }
}

/* trampoline */
static
void l2p_hook( lua_State *L, lua_Debug *ar )
{
    char *error = NULL;
    STRLEN error_len;
    SV** svp;
    HV* oob = get_oob_entry( L );
    SV* hook;
    dSP;

    svp = hv_fetch( oob, "hook", 4, 0 );
    if ( svp == NULL )
	croak( "Perl Lua::API: error getting hook\n" );
    hook = *svp;

    ENTER;
    SAVETMPS;

    PUSHMARK(SP);

    XPUSHs(get_Perl_object(L));
    XPUSHs(get_Perl_object(ar));

    PUTBACK;

    call_sv( hook, G_EVAL | G_DISCARD );

    SPAGAIN;

    /* catch exceptions */
    if (SvTRUE(ERRSV))
    {
       POPs;

       error = SvPV( ERRSV, error_len );
       /* If this is an exception thrown by Lua::API::State::error(),
          everything is already on the Lua stack and nothing further
          needs to be done.  If not, need to set up stack.
        */
       if ( ! sv_isa( ERRSV, "Lua::API::State::Error" ) )
	  lua_pushstring( L, error );
    }

    PUTBACK;
    FREETMPS;
    LEAVE;

    if ( error )
       lua_error( L );
}


/*-------------------------------------------------------------------*/
/* Support for pushcfunction and pushcclosure.
 *
 * The SV pointer is stored as the *last* upvalue for the trampoline
 * routine.  Perl routines which use lua_Debug.nups to get the number
 * of upvalues must decrement it by one to get their true upvalue
 * count.
 *
 */

static
int l2p_closure( lua_State *L )
{
    dSP;
    SV *func;
    char *error = NULL;
    STRLEN error_len;
    int count;
    lua_Debug ar;

    lua_getstack( L, 0, &ar );

    lua_getinfo( L, "u", &ar );

    func = (SV*) lua_touserdata( L, lua_upvalueindex( ar.nups ) );

    ENTER;
    SAVETMPS;
    PUSHMARK(SP);

    XPUSHs(get_Perl_object(L));

    PUTBACK;

    count = call_sv( func, G_EVAL | G_SCALAR);

    /* catch exceptions */
    if (SvTRUE(ERRSV))
    {
       POPs;

       error = SvPV( ERRSV, error_len );
       /* If this is an exception thrown by Lua::API::State::error(),
          everything is already on the Lua stack and nothing further
          needs to be done.  If not, need to set up stack.
        */
       if ( ! sv_isa( ERRSV, "Lua::API::State::Error" ) )
	  lua_pushstring( L, error );
    }

    PUTBACK;
    FREETMPS;
    LEAVE;

    if ( error )
       lua_error( L );


    return count;
}

/*-------------------------------------------------------------------*/
/* Support for lua_cpcall.
 *
 * lua_cpcall calls a C function directly with a lightuserdata value
 * on the stack. We can't use a closure to wrap the Perl SV, so, we
 * wrap it explicitly in a structure.  This is the trampoline routine
 * which unwraps it and calls the Perl routine
 *
 */

typedef struct {
    SV *sv;    /* Perl function to call */
    void *ud;  /* user data pointer */
} CPCallData;

static
int l2p_cpcall( lua_State *L ) {
    dSP;
    int count;
    char *error = NULL;
    STRLEN error_len;
    CPCallData *data;


    /* grab our structure... */
    data = (CPCallData *) lua_touserdata( L, -1 );

    /* ...remove it from the stack */
    lua_pop( L, 1 );

    /* ...and replace it with the user data */
    lua_pushlightuserdata( L, data->ud );

    ENTER;
    SAVETMPS;
    PUSHMARK(SP);

    XPUSHs(get_Perl_object(L));
    PUTBACK;

    count = call_sv( (SV*) data->sv, G_EVAL | G_DISCARD);

    SPAGAIN;

    /* catch exceptions */
    if (SvTRUE(ERRSV))
    {
       POPs;

       error = SvPV( ERRSV, error_len );
       /* If this is an exception thrown by Lua::API::State::error(),
          everything is already on the Lua stack and nothing further
          needs to be done.  If not, need to set up stack.
        */
       if ( ! sv_isa( ERRSV, "Lua::API::State::Error" ) )
	  lua_pushstring( L, error );
    }


    PUTBACK;
    FREETMPS;
    LEAVE;

    if ( error )
       lua_error( L );

    return count;
}

/*-------------------------------------------------------------------*/

/* put Lua error object on stack using lua_error. call only from XS
routines.  */

static int
call_lua_error( lua_State *L )
{
  return lua_error( L );
}

static void
throw_lua_error( lua_State *L, char *error )
{
   lua_pushcfunction( L, &call_lua_error );
   lua_pushstring(L, error );
   lua_pcall( L, 1, 0, 0 ); 
}

/* based on code in lauxlib.c */
static void
throw_luaL_error( lua_State *L, const char *fmt, ... )
{
   lua_pushcfunction( L, &call_lua_error );
   va_list argp;
   va_start(argp, fmt);
   luaL_where(L, 1);
   lua_pushvfstring(L, fmt, argp);
   va_end(argp);
   lua_concat(L, 2);
   lua_pcall( L, 1, 0, 0 ); 
}


/*-------------------------------------------------------------------*/


#include "wrap.h"


/*-------------------------------------------------------------------*/

MODULE = Lua::API		PACKAGE = Lua::API

INCLUDE: const-xs.inc

BOOT:
{
    MY_CXT_INIT;
    MY_CXT.OOB = newHV();
}

 # oh, ick

const char *
RELEASE( )
      CODE:
        RETVAL = LUA_RELEASE;
      OUTPUT:
        RETVAL

const char *
COPYRIGHT( )
      CODE :
        RETVAL = LUA_COPYRIGHT;
      OUTPUT:
        RETVAL

MODULE = Lua::API		PACKAGE = Lua::API::State		PREFIX = lua_

lua_CFunction
lua_atpanic(L, panicf)
	lua_State *	L
	lua_CFunction	panicf

void
lua_call(L, nargs, nresults)
	lua_State *	L
	int	nargs
	int	nresults

 # call either lua_checkstack or luaL_checkstack based upon the number
 # of parameters
void
lua_checkstack(L, sz, ...)
	lua_State *	L
	int	  sz
	PPCODE:
	  /* call lua_checkstack */
	  if ( items == 2 )
	  {
	    int status = lua_checkstack( L, sz );
            EXTEND(SP, 1);
            PUSHs(sv_2mortal(newSViv(status)));
	  }
	  /* emulate luaL_checkstack */
	  else if ( items == 3 )
	  {
	    const char *msg = (const char*) SvPV_nolen(ST(2));
	    if ( !lua_checkstack( L, sz ) )
	    {
	       throw_luaL_error( L, "stack overflow (%s)", msg );
	       SV *rv = newSV(0);
	       SV *sv = newSVrv( rv, "Lua::API::State::Error" );
	       sv_setsv((SV*) get_sv("@", GV_ADD), rv);
	       croak(NULL);
	    }
	  }
	  else
	  {
	    croak_xs_usage( cv, "L,sz,[msg]" );
	  }

 # void
 # lua_close(L)
 # 	lua_State *	L


void
lua_concat(L, n)
	lua_State *	L
	int	n

int
lua_cpcall(L, func, ud)
	lua_State *	L
	SV *func
	SV *ud
      PREINIT:
	CPCallData data = { func, ud };
      CODE:
	RETVAL = lua_cpcall( L, l2p_cpcall, &data );
      OUTPUT:
	RETVAL

void
lua_createtable(L, narr, nrec)
	lua_State *	L
	int	narr
	int	nrec

 # No support for lua_Writer

 # int
 # lua_dump(L, writer, data)
 # 	lua_State *	L
 # 	lua_Writer	writer
 # 	void *	data
 #

int
lua_equal(L, idx1, idx2)
	lua_State *	L
	int	idx1
	int	idx2

int
lua_gc(L, what, data)
	lua_State *	L
	int	what
	int	data

lua_Alloc
lua_getallocf(L, ud)
	lua_State *	L
	void **	ud

void
lua_getfenv(L, idx)
	lua_State *	L
	int	idx

void
lua_getfield(L, idx, k)
	lua_State *	L
	int	idx
	const char *	k

int
lua_getgccount(L)
	lua_State *	L

void
lua_getglobal(L, name)
	lua_State *	L
	const char *	name

lua_Hook
lua_gethook(L)
	lua_State *	L

int
lua_gethookcount(L)
	lua_State *	L

int
lua_gethookmask(L)
	lua_State *	L

int
lua_getinfo(L, what, ar)
	lua_State *	L
	const char *	what
	lua_Debug *	ar

const char *
lua_getlocal(L, ar, n)
	lua_State *	L
	const lua_Debug *	ar
	int	n

void
lua_getmetatable(L, ...)
	lua_State *	L
      PPCODE:
	if ( items != 1 )
	    croak_xs_usage( cv, "L,(objindex|name)" );
	if ( looks_like_number( ST(1) ) )
	{
	    int	objindex = (int)SvIV(ST(1));
	    int RETVAL = lua_getmetatable(L, objindex);
	    EXTEND(SP,1);
	    PUSHs(sv_2mortal(newSViv(RETVAL)));
	}
        else
	{
	    const char *n = (const char *)SvPV_nolen(ST(1));
	    luaL_getmetatable(L, n);
	    XSRETURN_EMPTY;
	}

void
lua_getregistry(L)
	lua_State *	L

int
lua_getstack(L, level, ar)
	lua_State *	L
	int	level
	lua_Debug *	ar

void
lua_gettable(L, idx)
	lua_State *	L
	int	idx

int
lua_gettop(L)
	lua_State *	L

const char *
lua_getupvalue(L, funcindex, n)
	lua_State *	L
	int	funcindex
	int	n

void
lua_insert(L, idx)
	lua_State *	L
	int	idx

int
lua_isboolean(L, index)
	lua_State *	L
	int	index

int
lua_iscfunction(L, idx)
	lua_State *	L
	int	idx

int
lua_isfunction(L, index)
	lua_State *	L
	int	index

int
lua_islightuserdata(L, index)
	lua_State *	L
	int	index

int
lua_isnil(L, index)
	lua_State *	L
	int	index

int
lua_isnone(L, index)
	lua_State *	L
	int	index

int
lua_isnoneornil(L, index)
	lua_State *	L
	int	index

int
lua_isnumber(L, idx)
	lua_State *	L
	int	idx

int
lua_isstring(L, idx)
	lua_State *	L
	int	idx

int
lua_istable(L, index)
	lua_State *	L
	int	index

int
lua_isthread(L, index)
	lua_State *	L
	int	index

int
lua_isuserdata(L, idx)
	lua_State *	L
	int	idx

int
lua_lessthan(L, idx1, idx2)
	lua_State *	L
	int	idx1
	int	idx2

 # No support for lua_Reader

 # int
 # lua_load(L, reader, dt, chunkname)
 # 	lua_State *	L
 # 	lua_Reader	reader
 # 	void *	dt
 # 	const char *	chunkname


 # There is currently no support for setting another allocator.
 # luaL_newstate() is used instead.  If an allocator is ever
 # supported, then newstate() should be written to accept either no
 # arguments (and use luaL_newstate) or two (and use lua_newstate).

 # lua_State *
 # lua_newstate(f, ud)
 #         lua_Alloc       f
 #         void *  ud

void
lua_newtable(L)
	lua_State *	L

lua_State *
lua_newthread(L)
	lua_State *	L

void *
lua_newuserdata(L, sz)
	lua_State *	L
	size_t	sz

int
lua_next(L, idx)
	lua_State *	L
	int	idx

size_t
lua_objlen(L, idx)
	lua_State *	L
	int	idx


int
lua_pcall(L, nargs, nresults, errfunc)
	lua_State *	L
	int	nargs
	int	nresults
	int	errfunc

void
lua_pop(L, index)
	lua_State *	L
	int	index

void
lua_pushboolean(L, b)
	lua_State *	L
	int	b

void
lua_pushcclosure(L, fn, n)
	lua_State *	L
	SV *	fn
	int	n
	PREINIT:
	SV *sv_c = newSVsv(fn);
        CODE:
        lua_pushlightuserdata(L, sv_c );
        lua_pushcclosure(L, l2p_closure, n+1 );

void
lua_pushcfunction(L, f)
	lua_State *	L
	SV *f
	PREINIT:
	SV *sv_c = newSVsv(f);
        CODE:
        lua_pushlightuserdata(L, sv_c );
        lua_pushcclosure(L, l2p_closure, 1 );


 # This is (temporarily) in API.pm
 # const char *
 # lua_pushfstring(L, fmt, ...)
 # 	lua_State *	L
 #	const char *	fmt

void
lua_pushinteger(L, n)
	lua_State *	L
	lua_Integer	n

void
lua_pushlightuserdata(L, p)
	lua_State *	L
	void *	p

void
lua_pushlstring(L, s, l)
	lua_State *	L
	const char *	s
	size_t	l

void
lua_pushliteral(L, s)
	lua_State *	L
	const char *	s
       CODE:
         lua_pushlstring(L,s,strlen(s));

void
lua_pushnil(L)
	lua_State *	L

void
lua_pushnumber(L, n)
	lua_State *	L
	lua_Number	n

void
lua_pushstring(L, s)
	lua_State *	L
	const char *	s

int
lua_pushthread(L)
	lua_State *	L

void
lua_pushvalue(L, idx)
	lua_State *	L
	int	idx

 # This is (temporarily) in Lua/API.pm
 # const char *
 # lua_pushvfstring(L, fmt, argp)
 # 	lua_State *	L
 # 	const char *	fmt
 # 	va_list	argp

int
lua_rawequal(L, idx1, idx2)
	lua_State *	L
	int	idx1
	int	idx2

void
lua_rawget(L, idx)
	lua_State *	L
	int	idx

void
lua_rawgeti(L, idx, n)
	lua_State *	L
	int	idx
	int	n

void
lua_rawset(L, idx)
	lua_State *	L
	int	idx

void
lua_rawseti(L, idx, n)
	lua_State *	L
	int	idx
	int	n


void
lua_remove(L, idx)
	lua_State *	L
	int	idx

void
lua_replace(L, idx)
	lua_State *	L
	int	idx

int
lua_resume(L, narg)
	lua_State *	L
	int	narg

 # There is currently no support for setting another allocator.

 # void
 # lua_setallocf(L, f, ud)
 # 	lua_State *	L
 # 	lua_Alloc	f
 # 	void *	ud

int
lua_setfenv(L, idx)
	lua_State *	L
	int	idx

void
lua_setfield(L, idx, k)
	lua_State *	L
	int	idx
	const char *	k

void
lua_setglobal(L, s)
	lua_State *	L
	const char *	s

int
lua_sethook(L, func, mask, count)
	lua_State *	L
	SV	*func
	int	mask
	int	count
     CODE:
        set_hook( L, func );
	RETVAL = lua_sethook( L, SvOK(func) ? l2p_hook : NULL, mask, count );

void
lua_setlevel(from, to)
	lua_State *	from
	lua_State *	to

const char *
lua_setlocal(L, ar, n)
	lua_State *	L
	const lua_Debug *	ar
	int	n

int
lua_setmetatable(L, objindex)
	lua_State *	L
	int	objindex

void
lua_settable(L, idx)
	lua_State *	L
	int	idx

void
lua_settop(L, idx)
	lua_State *	L
	int	idx

const char *
lua_setupvalue(L, funcindex, n)
	lua_State *	L
	int	funcindex
	int	n

int
lua_status(L)
	lua_State *	L

size_t
lua_strlen(L, index)
	lua_State *	L
	int	index

int
lua_toboolean(L, idx)
	lua_State *	L
	int	idx

lua_CFunction
lua_tocfunction(L, idx)
	lua_State *	L
	int	idx

lua_Integer
lua_tointeger(L, idx)
	lua_State *	L
	int	idx

const char *
lua_tolstring(L, idx, len)
	lua_State *	L
	int	idx
	size_t &len

lua_Number
lua_tonumber(L, idx)
	lua_State *	L
	int	idx

const void *
lua_topointer(L, idx)
	lua_State *	L
	int	idx

const char *
lua_tostring(L, index)
	lua_State *	L
	int	index

lua_State *
lua_tothread(L, idx)
	lua_State *	L
	int	idx

SV *
lua_touserdata(L, idx)
	lua_State *	L
	int	idx

int
lua_type(L, idx)
	lua_State *	L
	int	idx

const char *
lua_typename(L, tp)
	lua_State *	L
	int	tp

void
lua_xmove(from, to, n)
	lua_State *	from
	lua_State *	to
	int	n

int
lua_yield(L, nresults)
	lua_State *	L
	int	nresults

int
luaopen_base(L)
	lua_State *	L

int
luaopen_debug(L)
	lua_State *	L

int
luaopen_io(L)
	lua_State *	L

int
luaopen_math(L)
	lua_State *	L

int
luaopen_os(L)
	lua_State *	L

int
luaopen_package(L)
	lua_State *	L

int
luaopen_string(L)
	lua_State *	L

int
luaopen_table(L)
	lua_State *	L



MODULE = Lua::API		PACKAGE = Lua::API::State		PREFIX = luaL_

INCLUDE: xs.h

void
luaL_openlibs(L)
	lua_State *	L

void
luaL_buffinit(L, B)
	lua_State *	L
	luaL_Buffer *	B

int
luaL_callmeta(L, obj, e)
	lua_State *	L
	int	obj
	const char *	e

int
luaL_dofile(L, fn)
	lua_State *	L
	const char *	fn

int
luaL_dostring(L, s)
	lua_State *	L
	const char *	s

 # implemented in Lua/API.pm
 # int
 # luaL_error(L, fmt, ...)
 # 	lua_State *	L
 # 	const char *	fmt

const char *
luaL_findtable(L, idx, fname, szhint)
	lua_State *	L
	int	idx
	const char *	fname
	int	szhint

int
luaL_getmetafield(L, obj, e)
	lua_State *	L
	int	obj
	const char *	e

const char *
luaL_gsub(L, s, p, r)
	lua_State *	L
	const char *	s
	const char *	p
	const char *	r

int
luaL_loadbuffer(L, buff, sz, name)
	lua_State *	L
	const char *	buff
	size_t	sz
	const char *	name

int
luaL_loadfile(L, filename)
	lua_State *	L
	const char *	filename

int
luaL_loadstring(L, s)
	lua_State *	L
	const char *	s

int
luaL_newmetatable(L, tname)
	lua_State *	L
	const char *	tname

lua_State *
luaL_newstate(CLASS)
	char *CLASS = NO_INIT
    PROTOTYPE: $
    ALIAS:
	open = 1
	new = 2
    PPCODE:
        RETVAL = luaL_newstate();
	ST(0) = sv_newmortal();
        sv_setref_iv(ST(0), "Lua::API::State", PTR2IV(RETVAL));
	set_Perl_object( RETVAL, ST(0) );
        XSRETURN(1);


int
luaL_ref(L, t)
	lua_State *	L
	int	t

 # implemented in Lua/API.pm
 # void
 # luaL_register(L, libname, l)
 # 	lua_State *	L
 # 	const char *	libname
 # 	const luaL_Reg *	l

void
luaL_unref(L, t, ref)
	lua_State *	L
	int	t
	int	ref

void
luaL_where(L, lvl)
	lua_State *	L
	int	lvl


MODULE = Lua::API		PACKAGE = Lua::API::State

void
DESTROY( lua_State * L )
     ALIAS:
       close = 1
     CODE:
 	if ( NULL != delete_oob_entry( L ) )
	    lua_close( L );


  # These functions are wrapped in Lua/API.pm, which calls them
  # explicitly, so don't remove the prefix

int
lua_error(L)
	lua_State *	L

void
lua_register(L, name, f)
	lua_State *	L
	const char *	name
 	SV *	f
	PREINIT:
	SV *sv_c = newSVsv(f);
        CODE:
        lua_pushlightuserdata(L, sv_c );
        lua_pushcclosure(L, l2p_closure, 1 );
	lua_setglobal(L, name );

int
lua_getmetatable(L, index)
	lua_State *	L
	int             index

void
luaL_getmetatable(L, n)
	lua_State *	L
	const char *	n

const char *
lua_typename(L, tp)
	lua_State *	L
	int	tp

const char *
luaL_typename(L, i)
	lua_State *	L
	int	i

MODULE = Lua::API		PACKAGE = Lua::API::Debug

lua_Debug *
new(CLASS)
	char *CLASS = NO_INIT
    PROTOTYPE: $
    PPCODE:
        Newxz( RETVAL, 1, lua_Debug );
	ST(0) = sv_newmortal();
        sv_setref_iv(ST(0), "Lua::API::Debug", PTR2IV(RETVAL));
	set_Perl_object( RETVAL, ST(0) );
        XSRETURN(1);

void
DESTROY(THIS)
	lua_Debug * THIS;
    CODE:
        delete_oob_entry( THIS );
        Safefree(THIS);

int
event(THIS)
	lua_Debug * THIS
    PROTOTYPE: $
    CODE:
	RETVAL = THIS->event;
    OUTPUT:
	RETVAL

const char *
name(THIS)
	lua_Debug * THIS
    PROTOTYPE: $
    CODE:
	RETVAL = THIS->name;
    OUTPUT:
	RETVAL

const char *
namewhat(THIS)
	lua_Debug * THIS
    PROTOTYPE: $
    CODE:
	RETVAL = THIS->namewhat;
    OUTPUT:
	RETVAL

const char *
what(THIS)
	lua_Debug * THIS
    PROTOTYPE: $
    CODE:
	RETVAL = THIS->what;
    OUTPUT:
	RETVAL

const char *
source(THIS)
	lua_Debug * THIS
    PROTOTYPE: $
    CODE:
	RETVAL = THIS->source;
    OUTPUT:
	RETVAL

int
currentline(THIS)
	lua_Debug * THIS
    PROTOTYPE: $
    CODE:
	RETVAL = THIS->currentline;
    OUTPUT:
	RETVAL

int
nups(THIS)
	lua_Debug * THIS
    PROTOTYPE: $
    CODE:
	RETVAL = THIS->nups;
    OUTPUT:
	RETVAL

int
linedefined(THIS)
	lua_Debug * THIS
    PROTOTYPE: $
    CODE:
	RETVAL = THIS->linedefined;
    OUTPUT:
	RETVAL

int
lastlinedefined(THIS)
	lua_Debug * THIS
    PROTOTYPE: $
    CODE:
	RETVAL = THIS->lastlinedefined;
    OUTPUT:
	RETVAL

char *
short_src(THIS)
	lua_Debug * THIS
    PROTOTYPE: $
    CODE:
	RETVAL = THIS->short_src;
    OUTPUT:
	RETVAL

MODULE = Lua::API		PACKAGE = Lua::API::Buffer		PREFIX = luaL_

luaL_Buffer *
new(CLASS)
	char *CLASS = NO_INIT
    PROTOTYPE: $
    PPCODE:
        Newxz( RETVAL, 1, luaL_Buffer );
	ST(0) = sv_newmortal();
        sv_setref_iv(ST(0), "Lua::API::Buffer", PTR2IV(RETVAL));
	set_Perl_object( RETVAL, ST(0) );
        XSRETURN(1);

void
DESTROY(THIS)
	luaL_Buffer * THIS;
    CODE:
        delete_oob_entry( THIS );
        Safefree(THIS);


void
luaL_addchar(B, c)
	luaL_Buffer *	B
	char	c

void
luaL_addlstring(B, s, l)
	luaL_Buffer *	B
	const char *	s
	size_t	l

void
luaL_addsize(B, n)
	luaL_Buffer *	B
	size_t	n

void
luaL_addstring(B, s)
	luaL_Buffer *	B
	const char *	s

void
luaL_addvalue(B)
	luaL_Buffer *	B

char *
luaL_prepbuffer(B)
	luaL_Buffer *	B

void
luaL_pushresult(B)
	luaL_Buffer *	B
	Global
`s`	Focus search bar
`?`	Bring up this help dialog
	GitHub
`g` `p`	Go to pull requests
`g` `i`	go to github issues (only if github is preferred repository)
	POD
`g` `a`	Go to author
`g` `c`	Go to changes
`g` `i`	Go to issues
`g` `d`	Go to dist
`g` `r`	Go to repository/SCM
`g` `s`	Go to source
`g` `b`	Go to file browse
	Search terms
module: (e.g. module:Plugin)
distribution: (e.g. distribution:Dancer auth)
author: (e.g. author:SONGMU Redis)
version: (e.g. version:1.00)