namespace internal
{
// Runs a cache check for the given repository
int check_cache(lua_State *L)
{
bool force = false;
if (lua_gettop(L) != 1 && lua_gettop(L) != 2) {
return LuaHelpers::pushError(L, "Invalid number of arguments (1 or 2 expected)");
}
if (lua_gettop(L) > 1) {
force = lua_type(L, 0) != LUA_TNIL;
lua_pop(L, 1);
}
Repository *repo = LuaHelpers::popl<Repository>(L);
AbstractCache *cache = dynamic_cast<AbstractCache *>(repo->backend());
if (cache == NULL) {
return LuaHelpers::pushError(L, "No active cache found");
}
try {
cache->check(force);
} catch (const PepperException &ex) {
return LuaHelpers::pushError(L, str::printf("Error checking cache: %s: %s", ex.where(), ex.what()));
} catch (const std::exception &ex) {
return LuaHelpers::pushError(L, str::printf("Error checking cache: %s", ex.what()));
}
return LuaHelpers::pushNil(L);
}
// Lua wrapper for sys::datetime::Watch
class Watch : public sys::datetime::Watch
{
public:
Watch(lua_State *) : sys::datetime::Watch() { }
int start(lua_State *) { sys::datetime::Watch::start(); return 0; }
int elapsed(lua_State *L) { return LuaHelpers::push(L, sys::datetime::Watch::elapsed()); }
int elapsedMSecs(lua_State *L) { return LuaHelpers::push(L, sys::datetime::Watch::elapsedMSecs()); }
static const char className[];
static Lunar<Watch>::RegType methods[];
};
const char Watch::className[] = "watch";
Lunar<Watch>::RegType Watch::methods[] = {
LUNAR_DECLARE_METHOD(Watch, start),
LUNAR_DECLARE_METHOD(Watch, elapsed),
LUNAR_DECLARE_METHOD(Watch, elapsedMSecs),
{0,0}
};
// Function table of internal functions
const struct luaL_reg table[] = {
{"check_cache", check_cache},
{NULL, NULL}
};
} // namespace internal
inline int32 CLuaAbility::setRange(lua_State *L)
{
DSP_DEBUG_BREAK_IF(m_PLuaAbility == nullptr);
DSP_DEBUG_BREAK_IF(lua_isnil(L, -1) || !lua_isnumber(L, -1));
m_PLuaAbility->setRange(lua_tointeger(L, -1));
return 0;
}
/************************************************************************
* *
* Инициализация методов в lua *
* *
************************************************************************/
const int8 CLuaAbility::className[] = "CAbility";
Lunar<CLuaAbility>::Register_t CLuaAbility::methods[] =
{
LUNAR_DECLARE_METHOD(CLuaAbility,getID),
LUNAR_DECLARE_METHOD(CLuaAbility,getRecast),
LUNAR_DECLARE_METHOD(CLuaAbility,getRange),
LUNAR_DECLARE_METHOD(CLuaAbility,setMsg),
LUNAR_DECLARE_METHOD(CLuaAbility,setAnimation),
LUNAR_DECLARE_METHOD(CLuaAbility,setRecast),
LUNAR_DECLARE_METHOD(CLuaAbility,setCE),
LUNAR_DECLARE_METHOD(CLuaAbility,setVE),
LUNAR_DECLARE_METHOD(CLuaAbility,setRange),
{nullptr,nullptr}
};
{
DSP_DEBUG_BREAK_IF(m_PLuaAbility == NULL);
DSP_DEBUG_BREAK_IF(lua_isnil(L,-1) || !lua_isnumber(L,-1));
m_PLuaAbility->setAnimationID(lua_tointeger(L,-1));
return 0;
}
inline int32 CLuaAbility::getID(lua_State *L)
{
DSP_DEBUG_BREAK_IF(m_PLuaAbility == NULL);
lua_pushinteger(L, m_PLuaAbility->getID());
return 1;
}
/************************************************************************
* *
* Инициализация методов в lua *
* *
************************************************************************/
const int8 CLuaAbility::className[] = "CAbility";
Lunar<CLuaAbility>::Register_t CLuaAbility::methods[] =
{
LUNAR_DECLARE_METHOD(CLuaAbility,setMsg),
LUNAR_DECLARE_METHOD(CLuaAbility,setAnimation),
LUNAR_DECLARE_METHOD(CLuaAbility,getID),
{NULL,NULL}
};
{
if (!lua_isnil(L, 1) && lua_isnumber(L, 1))
{
uint8 slotID = (uint8)lua_tonumber(L, 1);
uint8 amount = -1;
if (lua_isnumber(L, 2))
{
amount = (uint8)lua_tonumber(L, 2);
}
m_pMyTradeContainer->setConfirmedStatus(slotID, amount);
}
}
return 0;
}
//======================================================//
const int8 CLuaTradeContainer::className[] = "TradeContainer";
Lunar<CLuaTradeContainer>::Register_t CLuaTradeContainer::methods[] =
{
LUNAR_DECLARE_METHOD(CLuaTradeContainer,getGil),
LUNAR_DECLARE_METHOD(CLuaTradeContainer,getItem),
LUNAR_DECLARE_METHOD(CLuaTradeContainer,getItemSubId),
LUNAR_DECLARE_METHOD(CLuaTradeContainer,getItemCount),
LUNAR_DECLARE_METHOD(CLuaTradeContainer,getSlotCount),
LUNAR_DECLARE_METHOD(CLuaTradeContainer,getItemQty),
LUNAR_DECLARE_METHOD(CLuaTradeContainer,getSlotQty),
LUNAR_DECLARE_METHOD(CLuaTradeContainer,hasItemQty),
LUNAR_DECLARE_METHOD(CLuaTradeContainer,confirmItem),
{nullptr,nullptr}
};
uint16 augmentid = unpackBitsBE((uint8*)(&augment), 0, 11);
uint8 augmentVal = unpackBitsBE((uint8*)(&augment), 11, 5);
lua_pushinteger(L, augmentid);
lua_pushinteger(L, augmentVal);
return 2;
}
//==========================================================//
const int8 CLuaItem::className[] = "CItem";
Lunar<CLuaItem>::Register_t CLuaItem::methods[] =
{
LUNAR_DECLARE_METHOD(CLuaItem,getID),
LUNAR_DECLARE_METHOD(CLuaItem,getSubID),
LUNAR_DECLARE_METHOD(CLuaItem,getFlag),
LUNAR_DECLARE_METHOD(CLuaItem,getAHCat),
LUNAR_DECLARE_METHOD(CLuaItem,getQuantity),
LUNAR_DECLARE_METHOD(CLuaItem,getLocationID),
LUNAR_DECLARE_METHOD(CLuaItem,getSlotID),
LUNAR_DECLARE_METHOD(CLuaItem,getWornItem),
LUNAR_DECLARE_METHOD(CLuaItem,isType),
LUNAR_DECLARE_METHOD(CLuaItem,isSubType),
LUNAR_DECLARE_METHOD(CLuaItem,getName),
LUNAR_DECLARE_METHOD(CLuaItem,getMod),
LUNAR_DECLARE_METHOD(CLuaItem,addMod),
LUNAR_DECLARE_METHOD(CLuaItem,delMod),
LUNAR_DECLARE_METHOD(CLuaItem,getAugment),
{nullptr,nullptr}
*/
#include <stdio.h>
#include "lua_script.h"
#include "lua_cube.h"
#include "lua_system.h"
#include "lodepng.h"
#include "color.h"
#include "svmmemory.h"
#include "cubeslots.h"
#include "ostime.h"
const char LuaCube::className[] = "Cube";
Lunar<LuaCube>::RegType LuaCube::methods[] = {
LUNAR_DECLARE_METHOD(LuaCube, reset),
LUNAR_DECLARE_METHOD(LuaCube, isDebugging),
LUNAR_DECLARE_METHOD(LuaCube, lcdFrameCount),
LUNAR_DECLARE_METHOD(LuaCube, lcdPixelCount),
LUNAR_DECLARE_METHOD(LuaCube, exceptionCount),
LUNAR_DECLARE_METHOD(LuaCube, getNeighborID),
LUNAR_DECLARE_METHOD(LuaCube, getRadioAddress),
LUNAR_DECLARE_METHOD(LuaCube, handleRadioPacket),
LUNAR_DECLARE_METHOD(LuaCube, saveScreenshot),
LUNAR_DECLARE_METHOD(LuaCube, testScreenshot),
LUNAR_DECLARE_METHOD(LuaCube, testSetEnabled),
LUNAR_DECLARE_METHOD(LuaCube, testGetACK),
LUNAR_DECLARE_METHOD(LuaCube, testWrite),
LUNAR_DECLARE_METHOD(LuaCube, xbPoke),
LUNAR_DECLARE_METHOD(LuaCube, xwPoke),
LUNAR_DECLARE_METHOD(LuaCube, xbPeek),
inline int32 CLuaStatusEffect::addMod(lua_State* L)
{
DSP_DEBUG_BREAK_IF(m_PLuaStatusEffect == NULL);
DSP_DEBUG_BREAK_IF(lua_isnil(L,1) || !lua_isnumber(L,1));
DSP_DEBUG_BREAK_IF(lua_isnil(L,2) || !lua_isnumber(L,2));
m_PLuaStatusEffect->addMod( lua_tointeger(L,1), lua_tointeger(L,2) );
return 1;
}
//======================================================//
const int8 CLuaStatusEffect::className[] = "CLuaStatusEffect";
Lunar<CLuaStatusEffect>::Register_t CLuaStatusEffect::methods[] =
{
LUNAR_DECLARE_METHOD(CLuaStatusEffect,getType),
LUNAR_DECLARE_METHOD(CLuaStatusEffect,getSubType),
LUNAR_DECLARE_METHOD(CLuaStatusEffect,setIcon),
LUNAR_DECLARE_METHOD(CLuaStatusEffect,getPower),
LUNAR_DECLARE_METHOD(CLuaStatusEffect,setPower),
LUNAR_DECLARE_METHOD(CLuaStatusEffect,getDuration),
LUNAR_DECLARE_METHOD(CLuaStatusEffect,setDuration),
LUNAR_DECLARE_METHOD(CLuaStatusEffect,getStartTime),
LUNAR_DECLARE_METHOD(CLuaStatusEffect,getLastTick),
LUNAR_DECLARE_METHOD(CLuaStatusEffect,getTickCount),
LUNAR_DECLARE_METHOD(CLuaStatusEffect,resetStartTime),
LUNAR_DECLARE_METHOD(CLuaStatusEffect,addMod),
{NULL,NULL}
};
/************************************************************************
* *
* *
* *
************************************************************************/
inline int32 CLuaRegion::DelCount(lua_State *L)
{
DSP_DEBUG_BREAK_IF(m_PLuaRegion == NULL);
DSP_DEBUG_BREAK_IF(lua_isnil(L,-1) || !lua_isnumber(L,-1));
lua_pushinteger(L, m_PLuaRegion->DelCount(lua_tointeger(L,-1)));
return 1;
}
/************************************************************************
* *
* Инициализация методов в lua *
* *
************************************************************************/
const int8 CLuaRegion::className[] = "CRegion";
Lunar<CLuaRegion>::Register_t CLuaRegion::methods[] =
{
LUNAR_DECLARE_METHOD(CLuaRegion,GetRegionID),
LUNAR_DECLARE_METHOD(CLuaRegion,GetCount),
LUNAR_DECLARE_METHOD(CLuaRegion,AddCount),
LUNAR_DECLARE_METHOD(CLuaRegion,DelCount),
{NULL,NULL}
};
}
void LuaCar::setSelf(Car *self, CarControl *control)
{
this->self = self;
this->control = control;
}
Car *LuaCar::getSelf()
{
return this->self;
}
const char LuaCar::className[] = "LuaCar";
Lunar<LuaCar>::RegType LuaCar::methods[] = {
LUNAR_DECLARE_METHOD(LuaCar, getPosition),
LUNAR_DECLARE_METHOD(LuaCar, getLane),
LUNAR_DECLARE_METHOD(LuaCar, getSpeed),
LUNAR_DECLARE_METHOD(LuaCar, getType),
LUNAR_DECLARE_METHOD(LuaCar, getGeometry),
LUNAR_DECLARE_METHOD(LuaCar, isTracked),
LUNAR_DECLARE_METHOD(LuaCar, isLeftAllowed),
LUNAR_DECLARE_METHOD(LuaCar, isRightAllowed),
LUNAR_DECLARE_METHOD(LuaCar, nextTrafficLight),
LUNAR_DECLARE_METHOD(LuaCar, setAcceleration),
LUNAR_DECLARE_METHOD(LuaCar, setSpeed),
LUNAR_DECLARE_METHOD(LuaCar, setLaneChange),
LUNAR_DECLARE_METHOD(LuaCar, getDestination),
{0,0}
};
inline int32 CLuaMobSkill::getTP(lua_State* L)
{
DSP_DEBUG_BREAK_IF(m_PLuaMobSkill == NULL);
lua_pushnumber( L, m_PLuaMobSkill->getTP() );
return 1;
}
/************************************************************************
* *
* declare lua function *
* *
************************************************************************/
const int8 CLuaMobSkill::className[] = "CMobSkill";
Lunar<CLuaMobSkill>::Register_t CLuaMobSkill::methods[] =
{
LUNAR_DECLARE_METHOD(CLuaMobSkill,setMsg),
LUNAR_DECLARE_METHOD(CLuaMobSkill,getMsg),
LUNAR_DECLARE_METHOD(CLuaMobSkill,hasMissMsg),
LUNAR_DECLARE_METHOD(CLuaMobSkill,isAoE),
LUNAR_DECLARE_METHOD(CLuaMobSkill,isConal),
LUNAR_DECLARE_METHOD(CLuaMobSkill,isSingle),
LUNAR_DECLARE_METHOD(CLuaMobSkill,getParam),
LUNAR_DECLARE_METHOD(CLuaMobSkill,getID),
LUNAR_DECLARE_METHOD(CLuaMobSkill,getTotalTargets),
LUNAR_DECLARE_METHOD(CLuaMobSkill,getTP),
LUNAR_DECLARE_METHOD(CLuaMobSkill,setSkillchain),
{NULL,NULL}
};
return 0;
}
inline int32 CLuaAction::setAdditionalEffect(lua_State* L)
{
DSP_DEBUG_BREAK_IF(m_PLuaAction == nullptr);
m_PLuaAction->additionalEffect = static_cast<SUBEFFECT>(lua_tointeger(L, -1));
return 0;
}
inline int32 CLuaAction::setAddEffectParam(lua_State* L)
{
DSP_DEBUG_BREAK_IF(m_PLuaAction == nullptr);
m_PLuaAction->addEffectParam = lua_tointeger(L, -1);
return 0;
}
// Initialize Lua Methods
const int8 CLuaAction::className[] = "CAction";
Lunar<CLuaAction>::Register_t CLuaAction::methods[] =
{
LUNAR_DECLARE_METHOD(CLuaAction, setParam),
LUNAR_DECLARE_METHOD(CLuaAction, setMessageID),
LUNAR_DECLARE_METHOD(CLuaAction, setAddEffectParam),
LUNAR_DECLARE_METHOD(CLuaAction, setAdditionalEffect),
{nullptr,nullptr}
};
DSP_DEBUG_BREAK_IF(m_PLuaInstance == NULL);
lua_pushstring( L, m_PLuaInstance->m_FastestName.c_str() );
return 1;
}
inline int32 CLuaInstance::setAsFastest(lua_State* L){
DSP_DEBUG_BREAK_IF(m_PLuaInstance == NULL);
lua_pushinteger( L, 0 );
return 1;
}
/************************************************************************
* *
* declare lua function *
* *
************************************************************************/
const int8 CLuaInstance::className[] = "CInstance";
Lunar<CLuaInstance>::Register_t CLuaInstance::methods[] =
{
LUNAR_DECLARE_METHOD(CLuaInstance,getInstanceNumber),
LUNAR_DECLARE_METHOD(CLuaInstance,getBcnmID),
LUNAR_DECLARE_METHOD(CLuaInstance,getTimeLimit),
LUNAR_DECLARE_METHOD(CLuaInstance,getTimeInside),
LUNAR_DECLARE_METHOD(CLuaInstance,getFastestTime),
LUNAR_DECLARE_METHOD(CLuaInstance,getFastestPlayer),
{NULL,NULL}
};
#include "flash_device.h"
#include "flash_blockcache.h"
#include "flash_volume.h"
#include "flash_volumeheader.h"
#include "flash_lfs.h"
#include "flash_stack.h"
#include "flash_recycler.h"
#include "flash_syslfs.h"
#include "elfprogram.h"
const char LuaFilesystem::className[] = "Filesystem";
const char LuaFilesystem::callbackHostField[] = "__filesystem_callbackHost";
bool LuaFilesystem::callbacksEnabled;
Lunar<LuaFilesystem>::RegType LuaFilesystem::methods[] = {
LUNAR_DECLARE_METHOD(LuaFilesystem, newVolume),
LUNAR_DECLARE_METHOD(LuaFilesystem, listVolumes),
LUNAR_DECLARE_METHOD(LuaFilesystem, deleteVolume),
LUNAR_DECLARE_METHOD(LuaFilesystem, volumeType),
LUNAR_DECLARE_METHOD(LuaFilesystem, volumeParent),
LUNAR_DECLARE_METHOD(LuaFilesystem, volumeMap),
LUNAR_DECLARE_METHOD(LuaFilesystem, volumeEraseCounts),
LUNAR_DECLARE_METHOD(LuaFilesystem, volumePayload),
LUNAR_DECLARE_METHOD(LuaFilesystem, simulatedBlockEraseCounts),
LUNAR_DECLARE_METHOD(LuaFilesystem, rawRead),
LUNAR_DECLARE_METHOD(LuaFilesystem, rawWrite),
LUNAR_DECLARE_METHOD(LuaFilesystem, rawErase),
LUNAR_DECLARE_METHOD(LuaFilesystem, invalidateCache),
LUNAR_DECLARE_METHOD(LuaFilesystem, setCallbacksEnabled),
LUNAR_DECLARE_METHOD(LuaFilesystem, onRawRead),
LUNAR_DECLARE_METHOD(LuaFilesystem, onRawWrite),
if (buffer.empty()) {
return false;
}
in >> stat.cadd >> stat.ladd >> stat.cdel >> stat.ldel;
m_stats[buffer] = stat;
}
return true;
}
/*
* Lua binding
*/
const char Diffstat::className[] = "diffstat";
Lunar<Diffstat>::RegType Diffstat::methods[] = {
LUNAR_DECLARE_METHOD(Diffstat, files),
LUNAR_DECLARE_METHOD(Diffstat, lines_added),
LUNAR_DECLARE_METHOD(Diffstat, bytes_added),
LUNAR_DECLARE_METHOD(Diffstat, lines_removed),
LUNAR_DECLARE_METHOD(Diffstat, bytes_removed),
{0,0}
};
Diffstat::Diffstat(lua_State *L) {
Diffstat *other = Lunar<Diffstat>::check(L, 1);
if (other == NULL) {
return;
}
m_stats = other->m_stats;
}
{
DSP_DEBUG_BREAK_IF(m_PLuaBattlefield == nullptr);
m_PLuaBattlefield->win();
return 0;
}
/************************************************************************
* *
* declare lua function *
* *
************************************************************************/
const int8 CLuaBattlefield::className[] = "CBattlefield";
Lunar<CLuaBattlefield>::Register_t CLuaBattlefield::methods[] =
{
LUNAR_DECLARE_METHOD(CLuaBattlefield,getBattlefieldNumber),
LUNAR_DECLARE_METHOD(CLuaBattlefield,getBcnmID),
LUNAR_DECLARE_METHOD(CLuaBattlefield,getTimeLimit),
LUNAR_DECLARE_METHOD(CLuaBattlefield,getTimeInside),
LUNAR_DECLARE_METHOD(CLuaBattlefield,getFastestTime),
LUNAR_DECLARE_METHOD(CLuaBattlefield,getFastestPlayer),
LUNAR_DECLARE_METHOD(CLuaBattlefield,getEntrance),
LUNAR_DECLARE_METHOD(CLuaBattlefield,setEntrance),
LUNAR_DECLARE_METHOD(CLuaBattlefield,insertAlly),
LUNAR_DECLARE_METHOD(CLuaBattlefield,getAllies),
LUNAR_DECLARE_METHOD(CLuaBattlefield,lose),
LUNAR_DECLARE_METHOD(CLuaBattlefield,win),
{nullptr,nullptr}
};
lua_pushinteger(L, m_pLuaZone->GetID());
return 1;
}
inline int32 CLuaZone::getRegionID(lua_State* L)
{
DSP_DEBUG_BREAK_IF(m_pLuaZone == nullptr);
lua_pushinteger(L, m_pLuaZone->GetRegionID());
return 1;
}
/************************************************************************
* *
* Инициализация методов в lua *
* *
************************************************************************/
const int8 CLuaZone::className[] = "CZone";
Lunar<CLuaZone>::Register_t CLuaZone::methods[] =
{
LUNAR_DECLARE_METHOD(CLuaZone,levelRestriction),
LUNAR_DECLARE_METHOD(CLuaZone,registerRegion),
LUNAR_DECLARE_METHOD(CLuaZone,getPlayers),
LUNAR_DECLARE_METHOD(CLuaZone,getID),
LUNAR_DECLARE_METHOD(CLuaZone,getRegionID),
{nullptr,nullptr}
};
}
/************************************************************************
* *
* Устанавливаем ограничение уровня для зоны *
* *
************************************************************************/
inline int32 CLuaZone::levelRestriction(lua_State *L)
{
if( m_pLuaZone != NULL)
{
}
lua_pushnil(L);
return 1;
}
/************************************************************************
* *
* Инициализация методов в lua *
* *
************************************************************************/
const int8 CLuaZone::className[] = "CZone";
Lunar<CLuaZone>::Register_t CLuaZone::methods[] =
{
LUNAR_DECLARE_METHOD(CLuaZone,levelRestriction),
LUNAR_DECLARE_METHOD(CLuaZone,registerRegion),
{NULL,NULL}
};
actionList.actionTargets[0].addEffectMessage = lua_tointeger(L, 2);
return 0;
}
else
{
lua_pushinteger(L, actionList.actionTargets[0].addEffectMessage);
return 1;
}
}
}
return 0;
}
// Initialize Lua Methods
const int8 CLuaAction::className[] = "CAction";
Lunar<CLuaAction>::Register_t CLuaAction::methods[] =
{
LUNAR_DECLARE_METHOD(CLuaAction, recast),
LUNAR_DECLARE_METHOD(CLuaAction, actionID),
LUNAR_DECLARE_METHOD(CLuaAction, param),
LUNAR_DECLARE_METHOD(CLuaAction, messageID),
LUNAR_DECLARE_METHOD(CLuaAction, animation),
LUNAR_DECLARE_METHOD(CLuaAction, speceffect),
LUNAR_DECLARE_METHOD(CLuaAction, reaction),
LUNAR_DECLARE_METHOD(CLuaAction, additionalEffect),
LUNAR_DECLARE_METHOD(CLuaAction, addEffectParam),
LUNAR_DECLARE_METHOD(CLuaAction, addEffectMessage),
{nullptr,nullptr}
};
inline int32 CLuaSpell::getFlag(lua_State *L)
{
DSP_DEBUG_BREAK_IF(m_PLuaSpell == NULL);
lua_pushinteger(L, m_PLuaSpell->getFlag());
return 1;
}
/************************************************************************
* *
* Инициализация методов в lua *
* *
************************************************************************/
const int8 CLuaSpell::className[] = "CSpell";
Lunar<CLuaSpell>::Register_t CLuaSpell::methods[] =
{
LUNAR_DECLARE_METHOD(CLuaSpell,setMsg),
LUNAR_DECLARE_METHOD(CLuaSpell,setAoE),
LUNAR_DECLARE_METHOD(CLuaSpell,setFlag),
LUNAR_DECLARE_METHOD(CLuaSpell,setRadius),
LUNAR_DECLARE_METHOD(CLuaSpell,setAnimation),
LUNAR_DECLARE_METHOD(CLuaSpell,setMPCost),
LUNAR_DECLARE_METHOD(CLuaSpell,isAoE),
LUNAR_DECLARE_METHOD(CLuaSpell,getMagicBurstMessage),
LUNAR_DECLARE_METHOD(CLuaSpell,getElement),
LUNAR_DECLARE_METHOD(CLuaSpell,getTotalTargets),
LUNAR_DECLARE_METHOD(CLuaSpell,getID),
LUNAR_DECLARE_METHOD(CLuaSpell,getSpellGroup),
LUNAR_DECLARE_METHOD(CLuaSpell,getFlag),
{NULL,NULL}
};
// Converts from UNIX to Gnuplot epoch
static inline int64_t convepoch(int64_t t)
{
return t - 946684800;
}
// Gnuplot arguments (-persist only works with the X11 or wxt terminal)
static const char *gp_args[] = {NULL};
static const char *gp_args_persist[] = {"-persist", NULL};
// Static variables for the lua bindings
const char Plot::className[] = "gnuplot";
Lunar<Plot>::RegType Plot::methods[] = {
LUNAR_DECLARE_METHOD(Plot, cmd),
LUNAR_DECLARE_METHOD(Plot, set_output),
LUNAR_DECLARE_METHOD(Plot, set_title),
LUNAR_DECLARE_METHOD(Plot, set_xrange),
LUNAR_DECLARE_METHOD(Plot, set_xrange_time),
LUNAR_DECLARE_METHOD(Plot, plot_series),
LUNAR_DECLARE_METHOD(Plot, plot_multi_series),
LUNAR_DECLARE_METHOD(Plot, plot_histogram),
LUNAR_DECLARE_METHOD(Plot, plot_pie),
LUNAR_DECLARE_METHOD(Plot, flush),
{0,0}
};
bool Plot::s_hasX11Term = false;
bool Plot::s_detectTerminals = true;
