static void LoadHeader(LoadState* S)
{
char h[LUAC_HEADERSIZE];
char s[LUAC_HEADERSIZE];
luaU_header(h);
LoadBlock(S,s,LUAC_HEADERSIZE);
IF (memcmp(h,s,LUAC_HEADERSIZE)!=0, "bad header");
}
static void LoadHeader(LoadState* S)
{
char h[LUAC_HEADERSIZE];
char s[LUAC_HEADERSIZE];
luaU_header(h, '=');
LoadBlock(S,s,LUAC_HEADERSIZE);
S->swap=(s[6]!=h[6]); s[6]=h[6];
IF (memcmp(h,s,LUAC_HEADERSIZE)!=0, "bad header");
}
static void LoadMem (LoadState* S, void* b, int n, size_t size)
{
LoadBlock(S,b,n*size);
if (S->swap && b)
{
char* p=(char*) b;
char c;
switch (size)
{
case 1:
break;
case 2:
while (n--)
{
c=p[0];
p[0]=p[1];
p[1]=c;
p+=2;
}
break;
case 4:
while (n--)
{
c=p[0];
p[0]=p[3];
p[3]=c;
c=p[1];
p[1]=p[2];
p[2]=c;
p+=4;
}
break;
case 8:
while (n--)
{
c=p[0];
p[0]=p[7];
p[7]=c;
c=p[1];
p[1]=p[6];
p[6]=c;
c=p[2];
p[2]=p[5];
p[5]=c;
c=p[3];
p[3]=p[4];
p[4]=c;
p+=8;
}
break;
default:
IF(1, "bad size");
break;
}
}
}
BOOL XBaseProp::Load( LPCTSTR szFilename, XE::xtENCODING encode )
{
CToken token;
if( token.LoadFile( szFilename, XE::TXT_UTF16 ) == xFAIL )
{
XERROR( "%s 읽기 실패", szFilename );
return FALSE;
}
return LoadBlock( token, NULL, NULL );
}
void BufferManager::LoadTable(Table table){
string filename=table.name+".table";
fstream fin(filename.c_str(),ios::in);
for(int i=0;i<table.blockNum;i++)
if(IfinBuffer(filename,i)==-1){
int bufferID=GetEmptyBlockExcept(filename);
LoadBlock(filename,i,bufferID);
}
fin.close();
}
static void LoadHeader(LoadState* S)
{
char h[LUAC_HEADERSIZE];
char s[LUAC_HEADERSIZE];
luaU_header(h);
if ( h[8] > SIZE_T_PRECOMPILED_CHUNK )
h[8] = SIZE_T_PRECOMPILED_CHUNK;
LoadBlock(S,s,LUAC_HEADERSIZE);
IF (memcmp(h,s,LUAC_HEADERSIZE)!=0, "bad header");
}
static void LoadHeader(LoadState* S)
{
char h[LUAC_HEADERSIZE];
char s[LUAC_HEADERSIZE];
luaU_header(h);
LoadBlock(S,s,LUAC_HEADERSIZE);
S->flip = h[ENDIAN_OFFSET] != s[ENDIAN_OFFSET];
s[ENDIAN_OFFSET] = h[ENDIAN_OFFSET];
IF (memcmp(h,s,LUAC_HEADERSIZE)!=0, "bad header");
}
void SexeLoadCode(LoadState* S, Proto* f, sexe_stack_t *stack)
{
f->code=luaM_newvector(S->L, stack->size, Instruction);
f->sizecode = stack->size;
LoadBlock(S, f->code, stack->size * sizeof(Instruction));
VERBOSE("[CODE] x%d instrs @ %lu bytes each <%lu bytes>\n", stack->size, sizeof(Instruction), sizeof(sexe_stack_t) + (stack->size * sizeof(Instruction)));
}
static TString* LoadString(LoadState* S)
{
int32_t size;
LoadVar(S,size);
if (size==0)
return NULL;
else
{
char* s;
if (!luaZ_direct_mode(S->Z)) {
s = luaZ_openspace(S->L,S->b,size);
LoadBlock(S,s,size);
return luaS_newlstr(S->L,s,size-1); /* remove trailing zero */
} else {
s = (char*)luaZ_get_crt_address(S->Z);
LoadBlock(S,NULL,size);
return luaS_newrolstr(S->L,s,size-1);
}
}
}
static void LoadHeader(LoadState* S)
{
char h[LUAC_HEADERSIZE];
char s[LUAC_HEADERSIZE];
luaU_header(h);
LoadBlock(S,s,LUAC_HEADERSIZE);
#ifdef LUAC_SWAP_ON_LOAD
S->swap=(s[6]!=h[6]); s[6]=h[6];
#endif
IF (memcmp(h,s,LUAC_HEADERSIZE)!=0, "bad header");
}
static void LoadHeader(LoadState* S)
{
char h[LUAC_HEADERSIZE];
char s[LUAC_HEADERSIZE];
luaU_header(h);
LoadBlock(S,s,LUAC_HEADERSIZE);
if (memcmp(h,s,N0)==0) return;
if (memcmp(h,s,N1)!=0) error(S,"not a");
if (memcmp(h,s,N2)!=0) error(S,"version mismatch in");
if (memcmp(h,s,N3)!=0) error(S,"incompatible"); else error(S,"corrupted");
}
static TString* LoadString(LoadState* S)
{
int size=LoadInt(S);
if (size==0)
return NULL;
else
{
char* s=luaZ_openspace(S->L,S->b,size);
LoadBlock(S,s,size);
return luaS_newlstr(S->L,s,size-1); /* remove trailing '\0' */
}
}
static TString* LoadString (lua_State* L, ZIO* Z, int swap)
{
size_t size=LoadSize(L,Z,swap);
if (size==0)
return NULL;
else
{
char* s=luaO_openspace(L,size);
LoadBlock(L,s,size,Z,0);
return luaS_newlstr(L,s,size-1); /* remove trailing '\0' */
}
}
static void LoadDebug(LoadState* S, Proto* f)
{
int i,n;
n=LoadInt(S);
Align4(S);
#ifdef LUA_OPTIMIZE_DEBUG
if(n) {
if (!luaZ_direct_mode(S->Z)) {
f->packedlineinfo=luaM_newvector(S->L,n,unsigned char);
LoadBlock(S,f->packedlineinfo,n);
} else {
static void LoadHeader(LoadState* S)
{
lu_byte h[LUAC_HEADERSIZE];
lu_byte s[LUAC_HEADERSIZE];
luaU_header(h);
memcpy(s,h,sizeof(char)); /* first char already read */
LoadBlock(S,s+sizeof(char),LUAC_HEADERSIZE-sizeof(char));
if (memcmp(h,s,N0)==0) return;
if (memcmp(h,s,N1)!=0) error(S,"not a");
if (memcmp(h,s,N2)!=0) error(S,"version mismatch in");
if (memcmp(h,s,N3)!=0) error(S,"incompatible"); else error(S,"corrupted");
}
static void LoadHeader(LoadState* S)
{
char h[LUAC_HEADERSIZE];
char s[LUAC_HEADERSIZE];
int intck = (((lua_Number)0.5)==0); /* 0=float, 1=int */
luaU_header(h);
LoadBlock(S,s,LUAC_HEADERSIZE);
S->swap=(s[6]!=h[6]); s[6]=h[6]; /* Check if byte-swapping is needed */
S->numsize=h[10]=s[10]; /* length of lua_Number */
S->toflt=(s[11]>intck); /* check if conversion from int lua_Number to flt is needed */
if(S->toflt) s[11]=h[11];
IF (memcmp(h,s,LUAC_HEADERSIZE)!=0, "bad header");
}
static killa_TString* LoadString(LoadState* S)
{
size_t size;
LoadVar(S,size);
if (size==0)
return NULL;
else
{
char* s=killaZ_openspace(S->L,S->b,size);
LoadBlock(S,s,size*sizeof(char));
return killaS_newlstr(S->L,s,size-1); /* remove trailing '\0' */
}
}
static TString* LoadString(LoadState* S)
{
size_t size;
LoadVar(S,size);
if (size==0)
return nullptr;
else
{
char* s=luaZ_openspace(S->L,S->b,size);
LoadBlock(S,s,size);
return luaS_newlstr(S->L,s,size-1); /* remove trailing '\0' */
}
}
vector<Block> GetBlocks(const LocatorHashes& locators, const HashValue& hashStop) override {
vector<Block> r;
int idx = locators.FindIndexInMainChain();
EXT_LOCK (MtxSqlite) {
SqliteCommand cmd(EXT_STR("SELECT id, hash, data, txhashes FROM blocks WHERE id>" << idx << " ORDER BY id LIMIT " << 2000 + locators.DistanceBack), m_db);
for (DbDataReader dr = cmd.ExecuteReader(); dr.Read();) {
Block block = LoadBlock(dr);
r.push_back(block);
if (Hash(block) == hashStop)
break;
}
}
return r;
}
static void LoadHeader(LoadState* S)
{
char h[LUAC_HEADERSIZE];
char s[LUAC_HEADERSIZE];
LuaDumpConfig config;
config.endianness = (luaU_getHostOrder() == WWS_LUA_LITTLE_ENDIAN) ? 1 : 0;
config.sizeof_int = sizeof(int);
config.sizeof_size_t = sizeof(size_t);
config.sizeof_lua_Number = sizeof(lua_Number);
luaU_header(h, &config);
LoadBlock(S,s,LUAC_HEADERSIZE);
IF (memcmp(h,s,LUAC_HEADERSIZE)!=0, "bad header");
}
static TString* LoadString(LoadState* S)
{
size_t size = 0;
if ( sizeof(size_t) <= SIZE_T_PRECOMPILED_CHUNK )
LoadVar(S,size);
else
LoadMem(S,&size,1,SIZE_T_PRECOMPILED_CHUNK);
if (size==0)
return NULL;
else
{
char* s=luaZ_openspace(S->L,S->b,size);
LoadBlock(S,s,size);
return luaS_newlstr(S->L,s,size-1); /* remove trailing '\0' */
}
}
Area *XMLAreaLoader::LoadArea(tinyxml2::XMLElement *element, WorldGameState *world)
{
int width = atoi(element->Attribute("width"));
int height = atoi(element->Attribute("height"));
Area *result = new Area(Vec2(width, height), world);
// Get player start position/direction
auto startPosElement = element->FirstChildElement("startPos");
auto startDirElement = element->FirstChildElement("startDir");
if (startPosElement && startDirElement)
{
Vec2 startPos = LoadVec2(startPosElement);
DIR startDir = (DIR)atoi(startDirElement->GetText());
result->SetStartPosAndDir(startPos, startDir);
}
tinyxml2::XMLElement *blockElement = element->FirstChildElement("Blocks")->FirstChildElement("Block");
int iBlock = 0;
while (blockElement != NULL)
{
if (iBlock >= width*height)
throw std::exception();
LoadBlock(result->GetBlock(iBlock % width, iBlock / width), blockElement);
blockElement = blockElement->NextSiblingElement("Block");
iBlock++;
}
tinyxml2::XMLElement *entityElement = element->FirstChildElement("Entities")->FirstChildElement("Entity");
while (entityElement)
{
result->AddEntity(LoadEntity(entityElement));
entityElement = entityElement->NextSiblingElement("Entity");
}
return result;
}
static lua_Number LoadNumber (LoadState* S)
{
lua_Number x;
LoadBlock(S,&x,sizeof(x));
return x;
}
static size_t LoadSize (LoadState* S)
{
size_t x;
LoadBlock(S,&x,sizeof(x));
return x;
}
Block FindBlock(const HashValue& hash) override {
EXT_LOCK (MtxSqlite) {
DbDataReader dr = m_cmdFindBlock.Bind(1, ReducedBlockHash(hash)).ExecuteReader();
return dr.Read() ? LoadBlock(dr) : Block(nullptr);
}
}
static Number LoadNumber (lua_State* L, ZIO* Z, int swap)
{
Number x;
LoadBlock(L,&x,sizeof(x),Z,swap);
return x;
}
static size_t LoadSize (lua_State* L, ZIO* Z, int swap)
{
size_t x;
LoadBlock(L,&x,sizeof(x),Z,swap);
return x;
}
static int LoadInt (lua_State* L, ZIO* Z, int swap)
{
int x;
LoadBlock(L,&x,sizeof(x),Z,swap);
return x;
}
Block FindBlock(int height) override {
EXT_LOCK (MtxSqlite) {
DbDataReader dr = m_cmdFindBlockByOrd.Bind(1, height).ExecuteVector();
return LoadBlock(dr);
}
}
ret_ CXMLLoaderActions::LoadProcessBlock(CProgram &Program,
const DOMElement *pElement,
const CPDUInfo *pPDU)
{
#ifdef _DEBUG_
if (!pElement)
return (PARAMETER_NULL | PARAMETER_2);
#endif
DOMElement *pChild = (DOMElement *)pElement->getFirstChild();
if (!pChild)
return XML_LOADER_ERROR;
auto_xerces_str wsEmpty ("empty");
auto_xerces_str wsUnitaryCalculate ("unitary_calculate");
auto_xerces_str wsDualityCalculate ("duality_calculate");
auto_xerces_str wsConfigGroup ("config_group");
auto_xerces_str wsIf ("if");
auto_xerces_str wsWhile ("while");
auto_xerces_str wsContinue ("continue");
auto_xerces_str wsBlock ("block");
auto_xerces_str wsBreak ("break");
auto_xerces_str wsSend ("send");
auto_xerces_str wsReadFile ("read_file");
auto_xerces_str wsSaveFile ("save_file");
auto_xerces_str wsDeleteFile ("delete_file");
auto_xerces_str wsSplit ("split");
auto_xerces_str wsDie ("die");
auto_xerces_str wsShowWindow ("show_window");
auto_xerces_str wsWaitMessage ("wait_message");
auto_xerces_str wsAlert ("alert");
auto_xerces_str wsEnable ("enable");
auto_xerces_str wsAddItem ("add_item");
auto_xerces_str wsProgram ("program");
while (pChild)
{
if (0 == XMLString::compareString(pChild->getNodeName(),
wsEmpty))
{
if (SUCCESS != LoadEmpty(Program, pChild, pPDU))
return XML_LOADER_ERROR;
}
else if (0 == XMLString::compareString(pChild->getNodeName(),
wsUnitaryCalculate))
{
if (SUCCESS != LoadUnitaryCalculate(Program, pChild, pPDU))
return XML_LOADER_ERROR;
}
else if (0 == XMLString::compareString(pChild->getNodeName(),
wsDualityCalculate))
{
if (SUCCESS != LoadDualityCalculate(Program, pChild, pPDU))
return XML_LOADER_ERROR;
}
else if (0 == XMLString::compareString(pChild->getNodeName(),
wsConfigGroup))
{
if (SUCCESS != LoadConfigGroup(Program, pChild, pPDU))
return XML_LOADER_ERROR;
}
else if (0 == XMLString::compareString(pChild->getNodeName(),
wsIf))
{
if (SUCCESS != LoadIf(Program, pChild, pPDU))
return XML_LOADER_ERROR;
}
else if (0 == XMLString::compareString(pChild->getNodeName(),
wsWhile))
{
if (SUCCESS != LoadWhile(Program, pChild, pPDU))
return XML_LOADER_ERROR;
}
else if (0 == XMLString::compareString(pChild->getNodeName(),
wsContinue))
{
if (SUCCESS != LoadContinue(Program))
return XML_LOADER_ERROR;
}
else if (0 == XMLString::compareString(pChild->getNodeName(),
wsBlock))
{
if (SUCCESS != LoadBlock(Program))
return XML_LOADER_ERROR;
}
else if (0 == XMLString::compareString(pChild->getNodeName(),
wsBreak))
{
if (SUCCESS != LoadBreak(Program))
return XML_LOADER_ERROR;
}
else if (0 == XMLString::compareString(pChild->getNodeName(),
wsSend))
{
if (SUCCESS != LoadSend(Program, pChild, pPDU))
return XML_LOADER_ERROR;
}
else if (0 == XMLString::compareString(pChild->getNodeName(),
wsReadFile))
{
if (SUCCESS != LoadReadFile(Program, pChild, pPDU))
return XML_LOADER_ERROR;
}
else if (0 == XMLString::compareString(pChild->getNodeName(),
wsSaveFile))
{
if (SUCCESS != LoadSaveFile(Program, pChild, pPDU))
return XML_LOADER_ERROR;
}
else if (0 == XMLString::compareString(pChild->getNodeName(),
wsDeleteFile))
{
if (SUCCESS != LoadDeleteFile(Program, pChild, pPDU))
return XML_LOADER_ERROR;
}
else if (0 == XMLString::compareString(pChild->getNodeName(),
wsSplit))
{
if (SUCCESS != LoadSplit(Program, pChild, pPDU))
return XML_LOADER_ERROR;
}
else if (0 == XMLString::compareString(pChild->getNodeName(),
wsDie))
{
if (SUCCESS != LoadDie(Program))
return XML_LOADER_ERROR;
}
else if (0 == XMLString::compareString(pChild->getNodeName(),
wsShowWindow))
{
if (SUCCESS != LoadShowWindow(Program, pChild))
return XML_LOADER_ERROR;
}
else if (0 == XMLString::compareString(pChild->getNodeName(),
wsWaitMessage))
{
if (SUCCESS != LoadWaitMessage(Program, pChild))
return XML_LOADER_ERROR;
}
else if (0 == XMLString::compareString(pChild->getNodeName(),
wsAlert))
{
if (SUCCESS != LoadAlert(Program, pChild))
return XML_LOADER_ERROR;
}
else if (0 == XMLString::compareString(pChild->getNodeName(),
wsEnable))
{
if (SUCCESS != LoadEnable(Program, pChild))
return XML_LOADER_ERROR;
}
else if (0 == XMLString::compareString(pChild->getNodeName(),
wsAddItem))
{
if (SUCCESS != LoadAddItem(Program, pChild, pPDU))
return XML_LOADER_ERROR;
}
else if (0 == XMLString::compareString(pChild->getNodeName(),
wsProgram))
{
CProgram *pSubProgram = new CProgram();
if (SUCCESS != LoadProgram(&Program.Data(),
*pSubProgram,
pChild,
pPDU))
{
return XML_LOADER_ERROR;
}
if (false_v == Program.AddOperator(pSubProgram))
return XML_LOADER_ERROR;
}
pChild = (DOMElement *)pChild->getNextSibling();
}
return SUCCESS;
}
