/**
* Add non-existing key into the multimap.
*
* @tmap multimap.
* @key key
* @newcell prepared inserted value.
*
* @return 0 in success,
* -ENOMEM if no memory.
* -EEXIST if key already exists.
*/
static int multimap_add_newkey(
struct multimap *tmap, u64 key,
struct tree_cell *newcell, gfp_t gfp_mask)
{
int ret;
struct tree_cell_head *newhead;
/* Allocate and initialize new tree cell head. */
newhead = alloc_cell_head(tmap->mmgr, gfp_mask);
if (!newhead) {
LOGe("memory allocation failed.\n");
return -ENOMEM;
}
newhead->key = key;
INIT_HLIST_HEAD(&newhead->head);
hlist_add_head(&newcell->list, &newhead->head);
ASSERT(!hlist_empty(&newhead->head));
/* Add to the map. */
ret = map_add((struct map *)tmap, key, (unsigned long)newhead, gfp_mask);
if (ret != 0) {
free_cell_head(tmap->mmgr, newhead);
LOGe("map_add failed.\n");
ASSERT(ret != -EINVAL);
}
return ret;
}
/**
* Set oldest_lsid.
*
* @wdev walb dev.
* @ctl ioctl data.
* RETURN:
* 0 in success, or -EFAULT.
*/
static int ioctl_wdev_set_oldest_lsid(struct walb_dev *wdev, struct walb_ctl *ctl)
{
u64 lsid, oldest_lsid, written_lsid;
LOGn("WALB_IOCTL_SET_OLDEST_LSID_SET\n");
lsid = ctl->val_u64;
spin_lock(&wdev->lsid_lock);
written_lsid = wdev->lsids.written;
oldest_lsid = wdev->lsids.oldest;
spin_unlock(&wdev->lsid_lock);
if (!(lsid == written_lsid ||
(oldest_lsid <= lsid && lsid < written_lsid &&
walb_check_lsid_valid(wdev, lsid)))) {
LOGe("lsid %"PRIu64" is not valid.\n", lsid);
LOGe("You shoud specify valid logpack header lsid"
" (oldest_lsid (%"PRIu64") <= lsid <= written_lsid (%"PRIu64").\n",
oldest_lsid, written_lsid);
return -EFAULT;
}
spin_lock(&wdev->lsid_lock);
wdev->lsids.oldest = lsid;
spin_unlock(&wdev->lsid_lock);
if (!walb_sync_super_block(wdev)) {
LOGe("sync super block failed.\n");
return -EFAULT;
}
return 0;
}
bool Quests::loadFromXml()
{
xmlDocPtr doc = xmlParseFile(getFilePath(FileType::XML, "quests.xml").c_str());
if(!doc)
{
LOGe("[Quests::loadFromXml] Cannot load quests file: " << getLastXMLError());
return false;
}
xmlNodePtr p, root = xmlDocGetRootElement(doc);
if(xmlStrcmp(root->name,(const xmlChar*)"quests"))
{
LOGe("[Quests::loadFromXml] Malformed quests file.");
xmlFreeDoc(doc);
return false;
}
p = root->children;
while(p)
{
parseQuestNode(p, false);
p = p->next;
}
xmlFreeDoc(doc);
return true;
}
/**
* Read logpack header sector from log device.
*
* @fd log device fd opened.
* @super_sectp super sector.
* @lsid logpack lsid to read.
* @logh_sect buffer to store logpack header data.
* This allocated size must be sector size.
* @salt log checksum salt.
*
* RETURN:
* ture in success, or false.
*/
bool read_logpack_header_from_wldev(
int fd, const struct walb_super_sector* super_sectp,
u64 lsid, u32 salt, struct sector_data *logh_sect)
{
/* calc offset in the ring buffer */
u64 ring_buffer_offset = get_ring_buffer_offset_2(super_sectp);
u64 ring_buffer_size = super_sectp->ring_buffer_size;
u64 off = ring_buffer_offset + lsid % ring_buffer_size;
struct walb_logpack_header *logh = get_logpack_header(logh_sect);
/* read sector */
if (!sector_read(fd, off, logh_sect)) {
LOGe("read logpack header (lsid %"PRIu64") failed.\n", lsid);
return false;
}
/* check lsid */
if (lsid != logh->logpack_lsid) {
LOGe("lsid (given %"PRIu64" read %"PRIu64") is invalid.\n",
lsid, logh->logpack_lsid);
return false;
}
if (!is_valid_logpack_header_with_checksum(
logh, super_sectp->physical_bs, salt)) {
LOGe("check logpack header failed.\n");
return false;
}
return true;
}
Dispatcher::~Dispatcher() {
auto locked = _mutex.try_lock();
if (!locked) {
LOGe("Dispatcher deleted while in use.");
assert(locked);
_mutex.lock();
}
if (_state != State::STOPPED) {
LOGe("Dispatcher deleted but not yet stopped. Forgot to call waitUntilStopped()?");
assert(_state == State::STOPPED);
if (std::this_thread::get_id() != _thread.get_id()) {
if (_state == State::STARTED) {
stop();
}
waitUntilStopped();
}
else {
LOGe("Cannot delete the dispatcher from within the dispatcher thread.");
}
}
_mutex.unlock();
}
/**
* Invalidate lsid inside ring buffer.
*/
bool invalidate_lsid(struct walb_dev *wdev, u64 lsid)
{
struct sector_data *zero_sector;
struct walb_super_sector *super;
u64 off;
bool ret;
ASSERT(lsid != INVALID_LSID);
zero_sector = sector_alloc(
wdev->physical_bs, GFP_KERNEL | __GFP_ZERO);
if (!zero_sector) {
LOGe("sector allocation failed.\n");
return false;
}
spin_lock(&wdev->lsuper0_lock);
super = get_super_sector(wdev->lsuper0);
off = get_offset_of_lsid_2(super, lsid);
spin_unlock(&wdev->lsuper0_lock);
ret = sector_io(WRITE, wdev->ldev, off, zero_sector);
if (!ret) {
LOGe("sector write failed.\n");
iocore_set_readonly(wdev);
}
sector_free(zero_sector);
return ret;
}
/**
* Read super sector.
*
* Currently 2nd super sector is not read.
*
* RETURN:
* true in success, or false.
*/
bool read_super_sector(int fd, struct sector_data *sect)
{
u64 off0;
if (!is_valid_sector_data(sect)) {
LOGe("Sector data is not valid.\n");
return false;
}
ASSERT(sect->size <= PAGE_SIZE);
off0 = get_super_sector0_offset(sect->size);
if (!sector_read(fd, off0, sect)) {
LOGe("Read sector failed.\n");
return false;
}
if (checksum(sect->data, sect->size, 0) != 0) {
LOGe("Checksum invalid.\n");
return false;
}
if (!is_valid_super_sector(sect)) {
LOGe("Super sector invalid.\n");
return false;
}
return true;
}
/**
* Read a logpack data from a stream.
*
* @fd file descriptor (opened, seeked)
* @logh corresponding logpack header.
* @salt checksum salt.
* @sect_ary sector data array to be store data.
*
* RETURN:
* true in success, or false.
*/
bool read_logpack_data(
int fd,
const struct walb_logpack_header* logh, u32 salt,
struct sector_data_array *sect_ary)
{
unsigned int pbs;
u32 total_pb;
int i;
int n_req;
ASSERT(fd >= 0);
ASSERT(logh);
n_req = logh->n_records;
ASSERT_SECTOR_DATA_ARRAY(sect_ary);
pbs = sect_ary->sector_size;
ASSERT_PBS(pbs);
if (logh->total_io_size > sect_ary->size) {
LOGe("sect_ary size is not enough.\n");
return false;
}
total_pb = 0;
for (i = 0; i < n_req; i++) {
unsigned int idx_pb, log_lb, log_pb;
u32 csum;
const struct walb_log_record *rec = &logh->record[i];
if (test_bit_u32(LOG_RECORD_DISCARD, &rec->flags)) {
continue;
}
idx_pb = rec->lsid_local - 1;
log_lb = rec->io_size;
log_pb = capacity_pb(pbs, log_lb);
/* Read data of the log record. */
if (!sector_array_read(fd, sect_ary, idx_pb, log_pb)) {
LOGe("read log data failed.\n");
return false;
}
if (test_bit_u32(LOG_RECORD_PADDING, &rec->flags)) {
total_pb += log_pb;
continue;
}
/* Confirm checksum. */
csum = sector_array_checksum(
sect_ary,
idx_pb * pbs,
log_lb * LOGICAL_BLOCK_SIZE, salt);
if (csum != rec->checksum) {
LOGe("log record[%d] checksum is invalid. %08x %08x\n",
i, csum, rec->checksum);
return false;
}
total_pb += log_pb;
}
ASSERT(total_pb == logh->total_io_size);
return true;
}
/**
* Get two lsid values as a range from a walb ctl buffer.
* RETURN:
* true in success, or false.
*/
bool get_lsid_range_from_ctl(
u64 *lsid0, u64 *lsid1, const struct walb_ctl *ctl)
{
if (sizeof(u64) * 2 > ctl->u2k.buf_size) {
LOGe("Buffer is too small for u64 * 2.\n");
return false;
}
*lsid0 = ((const u64 *)ctl->u2k.kbuf)[0];
*lsid1 = ((const u64 *)ctl->u2k.kbuf)[1];
if (!is_lsid_range_valid(*lsid0, *lsid1)) {
LOGe("Specify valid lsid range.\n");
return false;
}
return true;
}
/**
* Set device name.
*
* @wdev walb device.
* @minor minor id. This will be used for default name.
* @name Name to set.
* If null or empty string is given and
* the preset name is empty,
* default name will be set using minor id.
*
* @return 0 in success, or -1.
*/
int walb_set_name(struct walb_dev *wdev,
unsigned int minor, const char *name)
{
int name_len;
char *dev_name;
ASSERT(wdev);
ASSERT(wdev->lsuper0);
dev_name = get_super_sector(wdev->lsuper0)->name;
if (name && *name) {
memset(dev_name, 0, DISK_NAME_LEN);
snprintf(dev_name, DISK_NAME_LEN, "%s", name);
} else if (*dev_name == 0) {
memset(dev_name, 0, DISK_NAME_LEN);
snprintf(dev_name, DISK_NAME_LEN, "%u", minor / 2);
}
LOGd("minor %u dev_name: %s\n", minor, dev_name);
name_len = strlen(dev_name);
ASSERT(name_len < DISK_NAME_LEN);
if (name_len > WALB_DEV_NAME_MAX_LEN) {
LOGe("Device name is too long: %s.\n", name);
return -1;
}
return 0;
}
static int __init test_init(void)
{
LOGe("BUILD_DATE %s\n", BUILD_DATE);
test_sizlist();
return -1;
}
bool Outfits::parseOutfitNode(xmlNodePtr p)
{
if(xmlStrcmp(p->name, (const xmlChar*)"outfit"))
return false;
int32_t intValue;
if(!readXMLInteger(p, "id", intValue))
{
LOGe("[Outfits::parseOutfitNode] Missing outfit id, skipping");
return false;
}
Outfit newOutfit;
newOutfit.outfitId = intValue;
std::string name, strValue;
if(readXMLString(p, "default", strValue))
newOutfit.isDefault = booleanString(strValue);
if(!readXMLString(p, "name", strValue))
{
std::stringstream ss;
ss << "Outfit #" << newOutfit.outfitId;
ss >> name;
}
/**
* Create a logpack.
*
* @logh_sectdp pointer to sector data pointer
* for logpack header (will be set).
* @logd_sect_aryp pointer to sector data array pointer
* for logpack data (will be set).
* @pbs physical block size [byte].
* @bufsize buffer size for log data [byte].
*
* RETURN:
* allocated logpack in success, or NULL.
*/
struct logpack *alloc_logpack(
unsigned int pbs, unsigned int n_sectors)
{
struct logpack *pack;
ASSERT(is_valid_pbs(pbs));
ASSERT(0 < n_sectors);
pack = (struct logpack *)malloc(sizeof(*pack));
if (!pack) { goto error1; }
memset(pack, 0, sizeof(*pack));
/* Buffer for logpack header. */
pack->sectd = sector_alloc(pbs);
if (!pack->sectd) { goto error1; }
pack->header = get_logpack_header(pack->sectd);
/* Buffer for logpack data. */
pack->sectd_ary = sector_array_alloc(pbs, n_sectors);
if (!pack->sectd_ary) { goto error1; }
return pack;
error1:
LOGe("Memory allocation failure.\n");
free_logpack(pack);
return NULL;
}
/**
* Resize disk.
*
* @gd disk.
* @new_size new size [logical block].
*
* RETURN:
* true in success, or false.
*/
bool resize_disk(struct gendisk *gd, u64 new_size)
{
struct block_device *bdev;
u64 old_size;
ASSERT(gd);
old_size = get_capacity(gd);
if (old_size == new_size) {
return true;
}
set_capacity(gd, new_size);
bdev = bdget_disk(gd, 0);
if (!bdev) {
LOGe("bdget_disk failed.\n");
return false;
}
mutex_lock(&bdev->bd_mutex);
if (old_size > new_size) {
LOGn("Shrink disk should discard block cache.\n");
check_disk_size_change(gd, bdev);
/* This should be implemented in check_disk_size_change(). */
bdev->bd_invalidated = 0;
} else {
i_size_write(bdev->bd_inode,
(loff_t)new_size * LOGICAL_BLOCK_SIZE);
}
mutex_unlock(&bdev->bd_mutex);
bdput(bdev);
return true;
}
void Connection::closeConnection() {
LOGt("Connection::closeConnection()");
boost::recursive_mutex::scoped_lock lock(m_connectionLock);
if(m_connectionState != CONNECTION_STATE_REQUEST_CLOSE)
{
LOGe("[Connection::closeConnection] m_connectionState = " << m_connectionState);
return;
}
if(m_protocol)
{
m_protocol->setConnection(Connection_ptr());
m_protocol->releaseProtocol();
m_protocol = nullptr;
}
m_connectionState = CONNECTION_STATE_CLOSING;
if(!m_pendingWrite || m_writeError)
{
closeSocket();
releaseConnection();
m_connectionState = CONNECTION_STATE_CLOSED;
}
}
ERR_CODE State::writeToStorage(uint8_t type, uint8_t* payload, uint8_t length, bool persistent) {
switch(type) {
// uint32_t variables
case STATE_RESET_COUNTER: {
if (length == 2) {
uint32_t value = ((uint32_t*) payload)[0];
if (value == 0) {
return set(type, payload, length);
}
} else {
LOGe(FMT_WRONG_PAYLOAD_LENGTH, length);
return ERR_WRONG_PAYLOAD_LENGTH;
}
break;
}
// variables with write disabled
case STATE_SWITCH_STATE:
case STATE_TEMPERATURE:
case STATE_FACTORY_RESET:
default:
LOGw(FMT_STATE_NOT_FOUND, type);
}
return ERR_WRITE_DISABLED;
}
static int __init test_init(void)
{
dev_t dev;
int err = 0;
struct block_device *bdev;
LOGe("BUILD_DATE %s\n", BUILD_DATE);
if (path_) {
bdev = blkdev_get_by_path(
path_, FMODE_READ|FMODE_WRITE|FMODE_EXCL, lock_);
if (IS_ERR(bdev)) {
err = PTR_ERR(bdev);
goto error0;
}
blkdev_put(bdev, FMODE_READ|FMODE_WRITE|FMODE_EXCL);
}
if (major_ != UINT_MAX && minor_ != UINT_MAX) {
dev = MKDEV(major_, minor_);
bdev = blkdev_get_by_dev(
dev, FMODE_READ|FMODE_WRITE|FMODE_EXCL, lock_);
if (IS_ERR(bdev)) {
err = PTR_ERR(bdev);
goto error0;
}
blkdev_put(bdev, FMODE_READ|FMODE_WRITE|FMODE_EXCL);
}
LOGn("succeeded.\n");
return -1;
error0:
LOGn("failed %d.\n", err);
return -1;
}
void TargetCallback::onTargetCombat(const CreatureP& creature, const CreatureP& target) const
{
//"onTargetCombat"(cid, target)
if(m_interface->reserveEnv())
{
ScriptEnviroment* env = m_interface->getEnv();
if(!env->setCallbackId(m_scriptId, m_interface))
return;
uint32_t cid = 0;
if(creature)
cid = env->addThing(creature);
m_interface->pushFunction(m_scriptId);
lua_State* L = m_interface->getState();
lua_pushnumber(L, cid);
lua_pushnumber(L, env->addThing(target));
int32_t size = lua_gettop(L);
if(lua_pcall(L, 2, 0 /*nReturnValues*/, 0) != 0)
LuaScriptInterface::error(nullptr, std::string(LuaScriptInterface::popString(L)));
if((lua_gettop(L) + 2 /*nParams*/ + 1) != size)
LuaScriptInterface::error(__FUNCTION__, "Stack size changed!");
env->resetCallback();
m_interface->releaseEnv();
}
else
{
LOGe("[TargetCallback::onTargetCombat] Call stack overflow.");
return;
}
}
void Dispatcher::waitUntilStopped() {
_mutex.lock();
if (_state == State::STARTED) {
LOGe("Cannot wait for dispatcher to stop because stopping wasn't requested.");
assert(_state != State::STARTED);
_mutex.unlock();
return;
}
if (_thread.get_id() == std::this_thread::get_id()) {
auto tasks = std::move(_tasks);
_mutex.unlock();
runTasks(tasks);
}
else {
if (_thread.joinable()) {
// TODO: race condition possible here?
_mutex.unlock();
_thread.join();
}
else {
_mutex.unlock();
}
}
}
/**
* Helper function for tasks.
*
* @data any data.
* @nr flag bit number.
* @flags_p pointer to flags data.
* @wq workqueue.
* @task task.
*
* RETURN:
* pack_work if really enqueued, or NULL.
*/
struct pack_work* enqueue_task_if_necessary(
void *data, int nr, unsigned long *flags_p,
struct workqueue_struct *wq, void (*task)(struct work_struct *))
{
struct pack_work *pwork = NULL;
int ret;
ASSERT(task);
ASSERT(wq);
retry:
if (!test_and_set_bit(nr, flags_p)) {
pwork = create_pack_work(data, GFP_NOIO);
if (!pwork) {
LOGn("memory allocation failed.\n");
clear_bit(nr, flags_p);
schedule();
goto retry;
}
LOG_("enqueue task for %d\n", nr);
INIT_WORK(&pwork->work, task);
ret = queue_work(wq, &pwork->work);
if (!ret) {
LOGe("work is already on the queue.\n");
}
}
return pwork;
}
void Storage::setUint32(uint32_t value, uint32_t& target) {
if (value == INT_MAX) {
LOGe("value %d too big, can only write max %d", value, INT_MAX-1);
} else {
target = value;
}
}
/**
* Redo logpack.
*
* @fd file descriptor of data device (opened).
* @logpack logpack header to be redo.
* @buf logpack data.
* (data size: logh->total_io_size * physical_bs)
*
* RETURN:
* true in success, or false.
*/
bool redo_logpack(
int fd,
const struct walb_logpack_header* logh,
const struct sector_data_array *sect_ary)
{
int i, n_req;
ASSERT(logh);
ASSERT_SECTOR_DATA_ARRAY(sect_ary);
n_req = logh->n_records;
for (i = 0; i < n_req; i++) {
unsigned int idx_lb, n_lb;
u64 off_lb;
const struct walb_log_record *rec = &logh->record[i];
if (test_bit_u32(LOG_RECORD_PADDING, &rec->flags)) {
continue;
}
off_lb = rec->offset;
idx_lb = addr_lb(sect_ary->sector_size, rec->lsid_local - 1);
n_lb = rec->io_size;
if (test_bit_u32(LOG_RECORD_DISCARD, &rec->flags)) {
/* If the data device supports discard request,
you must issue discard requests. */
/* now editing */
continue;
}
if (!sector_array_pwrite_lb(fd, off_lb, sect_ary, idx_lb, n_lb)) {
LOGe("write sectors failed.\n");
return false;
}
}
return true;
}
/**
* Resize walb device.
*
* @wdev walb dev.
* @ctl ioctl data.
* RETURN:
* 0 in success, or -EFAULT.
*/
static int ioctl_wdev_resize(struct walb_dev *wdev, struct walb_ctl *ctl)
{
u64 ddev_size;
u64 new_size;
u64 old_size;
LOGn("WALB_IOCTL_RESIZE.\n");
ASSERT(ctl->command == WALB_IOCTL_RESIZE);
old_size = get_capacity(wdev->gd);
new_size = ctl->val_u64;
ddev_size = wdev->ddev->bd_part->nr_sects;
if (new_size == 0) {
new_size = ddev_size;
}
if (new_size < old_size) {
LOGe("Shrink size from %"PRIu64" to %"PRIu64" is not supported.\n",
old_size, new_size);
return -EFAULT;
}
if (new_size > ddev_size) {
LOGe("new_size %"PRIu64" > data device capacity %"PRIu64".\n",
new_size, ddev_size);
return -EFAULT;
}
if (new_size == old_size) {
LOGn("No need to resize.\n");
return 0;
}
spin_lock(&wdev->size_lock);
wdev->size = new_size;
wdev->ddev_size = ddev_size;
spin_unlock(&wdev->size_lock);
if (!resize_disk(wdev->gd, new_size)) {
return -EFAULT;
}
/* Sync super block for super->device_size */
if (!walb_sync_super_block(wdev)) {
LOGe("superblock sync failed.\n");
return -EFAULT;
}
return 0;
}
void Storage::setString(std::string value, char* target) {
if (value.length() < MAX_STRING_SIZE) {
memset(target, 0, MAX_STRING_SIZE);
memcpy(target, value.c_str(), value.length());
} else {
LOGe("string too long!!");
}
}
bool Tracker::isTracking() {
if (!_stack) {
LOGe(STR_ERR_FORGOT_TO_ASSIGN_STACK);
return false;
}
return _tracking && _stack->isScanning();
}
double hzd_ln_eX_plus1(double X){
double sum,prod,denom,LOGRdxX,eX,Z,index;
int i,maxCalc;
if(X>LnLim.oneMinRdx && X<LnLim.maxOneSig)
return LOGe(ePOW(X)+ONE);
if(X>=LnLim.absMax || X>=(LnLim.two-LnLim.absMin))
return X;
if(X<=LnLim.absMin)
return ZERO;
if(X>LnLim.absMin && X<LnLim.oneMinRdx) {
eX = ePOW(X);
sum = eX;
prod = eX;
denom = ONE;
LOGRdxX = X/LnLim.fpRdx;
maxCalc = (int) ((LOGRdxX-DBL_MANT_DIG)/LOGRdxX);
for(i=2; i<=maxCalc; i++) {
denom = denom+ONE;
prod = -prod*eX;
sum = sum+(prod/denom);
}
return sum;
}
Z = ONE/(Machn.two*ePOW(X)+ONE);
prod = Machn.two*Z;
sum = X+prod;
LOGRdxX = LOGe(Z)/LnLim.fpRdx;
maxCalc = (int) ((LOGRdxX-DBL_MANT_DIG)/(LOGRdxX*2));
if(maxCalc<2)
return sum;
Z = Z*Z;
index = ONE;
for(i=2; i<=maxCalc; i++) {
prod = prod*Z;
index = index+ONE;
denom = (Machn.two*index)-ONE;
sum = sum+(prod/denom);
}
return sum;
}
/**
* Check logpack of the given lsid exists.
*
* @lsid lsid to check.
*
* @return Non-zero if valid, or 0.
*/
int walb_check_lsid_valid(struct walb_dev *wdev, u64 lsid)
{
struct sector_data *sect;
struct walb_logpack_header *logh;
u64 off;
ASSERT(wdev);
sect = sector_alloc(wdev->physical_bs, GFP_NOIO);
if (!sect) {
LOGe("walb_check_lsid_valid: alloc sector failed.\n");
goto error0;
}
ASSERT(is_same_size_sector(sect, wdev->lsuper0));
logh = get_logpack_header(sect);
spin_lock(&wdev->lsuper0_lock);
off = get_offset_of_lsid_2(get_super_sector(wdev->lsuper0), lsid);
spin_unlock(&wdev->lsuper0_lock);
if (!sector_io(READ, wdev->ldev, off, sect)) {
LOGe("walb_check_lsid_valid: read sector failed.\n");
goto error1;
}
/* Check valid logpack header. */
if (!is_valid_logpack_header_with_checksum(
logh, wdev->physical_bs, wdev->log_checksum_salt)) {
goto error1;
}
/* Check lsid. */
if (logh->logpack_lsid != lsid) {
goto error1;
}
sector_free(sect);
return 1;
error1:
sector_free(sect);
error0:
return 0;
}
bool Event::loadScript(const std::string& script, bool file)
{
if(!m_interface || m_scriptId != 0)
{
LOGe("[Event::loadScript] m_interface == nullptr, scriptId = " << m_scriptId);
return false;
}
bool result = false;
if(!file)
{
std::string buffer = script, function = "function " + getScriptEventName();
trimString(buffer);
if(buffer.find(function) == std::string::npos)
{
std::stringstream scriptstream;
scriptstream << function << "(" << getScriptEventParams() << ")" << std::endl << buffer << std::endl << "end";
buffer = scriptstream.str();
}
result = m_interface->loadBuffer(buffer);
}
else
result = m_interface->loadFile(script);
if(!result)
{
LOGe("[Event::loadScript] Cannot load script (" << script << "): " << m_interface->getLastError());
return false;
}
int32_t id = m_interface->getEvent(getScriptEventName());
if(id == -1)
{
LOGe("[Event::loadScript] Event " << getScriptEventName() << " not found (" << script << ")");
return false;
}
m_scripted = EVENT_SCRIPT_TRUE;
m_scriptId = id;
return true;
}
bool Event::loadBuffer(const std::string& buffer)
{
if(!m_interface || m_scriptData != "")
{
LOGe("[Event::loadScriptFile] m_interface == nullptr, scriptData != \"\"");
return false;
}
m_scripted = EVENT_SCRIPT_BUFFER;
m_scriptData = buffer;
return true;
}
bool CallBack::loadCallBack(LuaScriptInterface* _interface, std::string name)
{
if(!_interface)
{
LOGe("[CallBack::loadCallBack] m_interface == nullptr");
return false;
}
m_interface = _interface;
int32_t id = m_interface->getEvent(name);
if(id == -1)
{
LOGe("[CallBack::loadCallBack] Event " << name << " not found.");
return false;
}
m_callbackName = name;
m_scriptId = id;
m_loaded = true;
return true;
}
