forked from metin2/server
Add project files.
This commit is contained in:
988
quest/src/qc.cc
Normal file
988
quest/src/qc.cc
Normal file
@ -0,0 +1,988 @@
|
||||
#if !defined(_MSC_VER) && defined(__cplusplus)
|
||||
extern "C" {
|
||||
#endif
|
||||
#include <lua.h>
|
||||
#include <lauxlib.h>
|
||||
#include <lualib.h>
|
||||
#include "../../../liblua/src/lzio.h"
|
||||
#include "../../../liblua/src/llex.h"
|
||||
#include "../../../liblua/src/lstring.h"
|
||||
#if !defined(_MSC_VER) && defined(__cplusplus)
|
||||
}
|
||||
#endif
|
||||
|
||||
#include <algorithm>
|
||||
#include <iostream>
|
||||
#include <set>
|
||||
#include <map>
|
||||
#include <fstream>
|
||||
#include <string>
|
||||
#include <sstream>
|
||||
#include <utility>
|
||||
#include <vector>
|
||||
|
||||
#ifndef __WIN32__
|
||||
#include <unistd.h>
|
||||
#else
|
||||
#include <boost/typeof/typeof.hpp>
|
||||
#define typeof(t) BOOST_TYPEOF(t)
|
||||
#include <direct.h>
|
||||
#define mkdir(path, mode) _mkdir(path)
|
||||
#endif
|
||||
#include <sys/types.h>
|
||||
#include <sys/stat.h>
|
||||
#include <errno.h>
|
||||
|
||||
#include "crc32.h"
|
||||
|
||||
#define OUTPUT_FOLDER "object"
|
||||
|
||||
using namespace std;
|
||||
|
||||
lua_State* L;
|
||||
|
||||
typedef struct LoadF {
|
||||
FILE *f;
|
||||
char buff[LUAL_BUFFERSIZE];
|
||||
} LoadF;
|
||||
|
||||
char * g_filename;
|
||||
|
||||
unsigned int get_string_crc(const std::string & str)
|
||||
{
|
||||
const unsigned char * s = (const unsigned char*) str.c_str();
|
||||
const unsigned char * end = s + str.size();
|
||||
unsigned int h = 0;
|
||||
|
||||
while (s < end)
|
||||
{
|
||||
h *= 16777619;
|
||||
h ^= (unsigned char) *(unsigned char *) (s++);
|
||||
}
|
||||
|
||||
return h;
|
||||
}
|
||||
|
||||
|
||||
static const char *getF (lua_State *L, void *ud, size_t *size) {
|
||||
LoadF *lf = (LoadF *)ud;
|
||||
|
||||
if (feof(lf->f))
|
||||
return NULL;
|
||||
|
||||
*size = fread(lf->buff, 1, LUAL_BUFFERSIZE, lf->f);
|
||||
return (*size > 0) ? lf->buff : NULL;
|
||||
}
|
||||
|
||||
static void next (LexState * ls)
|
||||
{
|
||||
ls->lastline = ls->linenumber;
|
||||
|
||||
if (ls->lookahead.token != TK_EOS)
|
||||
{
|
||||
/* is there a look-ahead token? */
|
||||
ls->t = ls->lookahead; /* use this one */
|
||||
ls->lookahead.token = TK_EOS; /* and discharge it */
|
||||
}
|
||||
else
|
||||
ls->t.token = luaX_lex(ls, &ls->t.seminfo); /* read next token */
|
||||
}
|
||||
|
||||
static bool testnext (LexState * ls, int c)
|
||||
{
|
||||
if (ls->t.token == c)
|
||||
{
|
||||
next(ls);
|
||||
return true;
|
||||
}
|
||||
else
|
||||
return false;
|
||||
}
|
||||
|
||||
static void lookahead (LexState * ls)
|
||||
{
|
||||
lua_assert(ls->lookahead.token == TK_EOS);
|
||||
ls->lookahead.token = luaX_lex(ls, &ls->lookahead.seminfo);
|
||||
}
|
||||
|
||||
enum parse_state
|
||||
{
|
||||
ST_START,
|
||||
ST_QUEST,
|
||||
ST_QUEST_WITH_OR_BEGIN,
|
||||
ST_STATELIST,
|
||||
ST_STATE_NAME,
|
||||
ST_STATE_BEGIN,
|
||||
ST_WHENLIST_OR_FUNCTION,
|
||||
ST_WHEN_NAME,
|
||||
ST_WHEN_WITH_OR_BEGIN,
|
||||
ST_WHEN_BODY,
|
||||
ST_FUNCTION_NAME,
|
||||
ST_FUNCTION_ARG,
|
||||
ST_FUNCTION_BODY,
|
||||
};
|
||||
|
||||
//#define t2obj(tok) ((tok.token == TK_NAME || tok.token == TK_STRING)?getstr(tok.seminfo.ts):((tok.token==TK_NUMBER)?lexstate.t.seminfo.r:luaX_token2str(&lexstate,tok.token)))
|
||||
|
||||
struct LexState * pls = 0;
|
||||
void errorline(int line , const char * str)
|
||||
{
|
||||
cout.flush();
|
||||
if (g_filename)
|
||||
cerr << g_filename <<":";
|
||||
cerr << line<< ':';
|
||||
cerr << str << endl;
|
||||
abort();
|
||||
}
|
||||
void error(const char * str)
|
||||
{
|
||||
cout.flush();
|
||||
if (g_filename)
|
||||
cout << g_filename <<":";
|
||||
if (pls)
|
||||
{
|
||||
cout << pls->linenumber << ':';
|
||||
}
|
||||
cerr << str << endl;
|
||||
abort();
|
||||
}
|
||||
|
||||
#define assert(exp) if (!(exp)) error("assertion failure : " #exp)
|
||||
#define assert_msg(exp,msg) if (!(exp)) error(msg " : " #exp)
|
||||
|
||||
ostream & operator << (ostream & ostr, const Token& tok)
|
||||
{
|
||||
if (tok.token == TK_NAME)
|
||||
ostr << getstr(tok.seminfo.ts);
|
||||
else if (tok.token == TK_NUMBER)
|
||||
ostr << tok.seminfo.r;
|
||||
else if (tok.token == TK_STRING)
|
||||
ostr << '"' << getstr(tok.seminfo.ts) <<'"';
|
||||
else
|
||||
ostr << luaX_token2str(pls,tok.token);
|
||||
return ostr;
|
||||
}
|
||||
|
||||
bool check_syntax(const string& str, const string& module)
|
||||
{
|
||||
int ret = luaL_loadbuffer(L, str.c_str(), str.size(), module.c_str());
|
||||
|
||||
if (ret)
|
||||
{
|
||||
cerr << str << endl;
|
||||
error((string("syntax error : ")+lua_tostring(L,-1) ).c_str());
|
||||
return false;
|
||||
}
|
||||
|
||||
lua_pop(L,1);
|
||||
return true;
|
||||
}
|
||||
|
||||
int none_c_function(lua_State* L)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
set<string> function_defs;
|
||||
set<string> function_calls;
|
||||
|
||||
void RegisterDefFunction(const string& fname)
|
||||
{
|
||||
function_defs.insert(fname);
|
||||
}
|
||||
|
||||
void RegisterUsedFunction(const string& fname)
|
||||
{
|
||||
function_calls.insert(fname);
|
||||
}
|
||||
|
||||
void CheckUsedFunction()
|
||||
{
|
||||
bool hasError = false;
|
||||
set<string> error_func;
|
||||
|
||||
for (typeof(function_calls.begin()) it = function_calls.begin(); it != function_calls.end(); ++it)
|
||||
{
|
||||
if (function_defs.find(*it) == function_defs.end())
|
||||
{
|
||||
hasError = true;
|
||||
error_func.insert(*it);
|
||||
}
|
||||
//cout << "Used : " << *it << endl;
|
||||
}
|
||||
|
||||
if (hasError)
|
||||
{
|
||||
cout << "Calls undeclared function! : " << endl;
|
||||
for (typeof(error_func.begin()) it = error_func.begin(); it != error_func.end(); ++it)
|
||||
{
|
||||
cout << *it << endl;
|
||||
}
|
||||
abort();
|
||||
}
|
||||
}
|
||||
|
||||
void load_quest_function_list(const char* filename)
|
||||
{
|
||||
ifstream inf(filename);
|
||||
string s;
|
||||
|
||||
while (!inf.eof())
|
||||
{
|
||||
inf >> s;
|
||||
if (inf.fail())
|
||||
break;
|
||||
|
||||
RegisterDefFunction(s);
|
||||
}
|
||||
}
|
||||
|
||||
struct AScript
|
||||
{
|
||||
string when_condition;
|
||||
string when_argument;
|
||||
string script;
|
||||
|
||||
AScript(string a, string b, string c) :
|
||||
when_condition(a),
|
||||
when_argument(b),
|
||||
script(c)
|
||||
{}
|
||||
|
||||
AScript() {}
|
||||
};
|
||||
|
||||
void parse(char * filename)
|
||||
{
|
||||
ifstream inf(filename);
|
||||
LoadF lf;
|
||||
lf.f = fopen(filename,"r");
|
||||
ZIO z;
|
||||
luaZ_init(&z, getF,&lf,"quest");
|
||||
Mbuffer b;
|
||||
struct LexState lexstate;
|
||||
pls = &lexstate;
|
||||
luaZ_initbuffer(L,&b);
|
||||
lexstate.buff = &b;
|
||||
luaX_setinput(L, &lexstate, &z, luaS_new(L, zname(&z)));
|
||||
|
||||
parse_state ps = ST_START;
|
||||
|
||||
int nested = 0;
|
||||
|
||||
string quest_name;
|
||||
string start_condition;
|
||||
|
||||
string current_state_name;
|
||||
string current_when_name;
|
||||
string current_when_condition;
|
||||
|
||||
string current_when_argument;
|
||||
|
||||
set<string> define_state_name_set;
|
||||
map<int,string> used_state_name_map;
|
||||
|
||||
map<string, map<string, string> > state_script_map;
|
||||
map<string, map<string, vector<AScript> > > state_arg_script_map;
|
||||
|
||||
vector<pair<string, string> > when_name_arg_vector;
|
||||
|
||||
string current_function_name;
|
||||
string current_function_arg;
|
||||
string all_functions;
|
||||
|
||||
load_quest_function_list("quest_functions");
|
||||
|
||||
while (1)
|
||||
{
|
||||
next(&lexstate);
|
||||
|
||||
/*/
|
||||
cout << luaX_token2str(&lexstate,lexstate.t.token);
|
||||
if (lexstate.t.token == TK_NAME)
|
||||
cout << '\t' << getstr(lexstate.t.seminfo.ts);
|
||||
else if (lexstate.t.token == TK_NUMBER)
|
||||
cout << '\t' << lexstate.t.seminfo.r;
|
||||
else if (lexstate.t.token == TK_STRING)
|
||||
cout << '\t' << '"' << getstr(lexstate.t.seminfo.ts) <<'"';
|
||||
cout << endl;
|
||||
//*/
|
||||
|
||||
if (lexstate.t.token == TK_EOS) break;
|
||||
|
||||
Token& t= lexstate.t;
|
||||
|
||||
switch(ps)
|
||||
{
|
||||
case ST_START:
|
||||
{
|
||||
assert(nested==0);
|
||||
if (t.token == TK_QUEST)
|
||||
ps = ST_QUEST;
|
||||
else
|
||||
error("must start with 'quest'");
|
||||
}
|
||||
break;
|
||||
case ST_QUEST:
|
||||
{
|
||||
assert(nested==0);
|
||||
if (t.token == TK_NAME || t.token == TK_STRING)
|
||||
{
|
||||
quest_name = getstr(lexstate.t.seminfo.ts);
|
||||
cout << "QUEST : " << quest_name << endl;
|
||||
ps = ST_QUEST_WITH_OR_BEGIN;
|
||||
}
|
||||
else
|
||||
error("quest name must be given");
|
||||
}
|
||||
break;
|
||||
case ST_QUEST_WITH_OR_BEGIN:
|
||||
assert(nested==0);
|
||||
if (t.token == TK_WITH)
|
||||
{
|
||||
assert(nested==0);
|
||||
next(&lexstate);
|
||||
ostringstream os;
|
||||
os << (lexstate.t);
|
||||
//cout << (lexstate.t);
|
||||
next(&lexstate);
|
||||
while (lexstate.t.token!=TK_DO)
|
||||
{
|
||||
os << " " <<(lexstate.t);
|
||||
//cout << TK_DO<<lexstate.t.token << " " <<(lexstate.t) <<endl;
|
||||
next(&lexstate);
|
||||
}
|
||||
start_condition = os.str();
|
||||
check_syntax("if "+start_condition+" then end", quest_name);
|
||||
cout << "\twith ";
|
||||
cout << start_condition;
|
||||
cout << endl;
|
||||
t = lexstate.t;
|
||||
}
|
||||
if (t.token == TK_DO)
|
||||
{
|
||||
ps = ST_STATELIST;
|
||||
nested++;
|
||||
}
|
||||
else
|
||||
{
|
||||
ostringstream os;
|
||||
os << "quest doesn't have begin-end clause. (" << t << ")";
|
||||
error(os.str().c_str());
|
||||
}
|
||||
break;
|
||||
case ST_STATELIST:
|
||||
{
|
||||
assert(nested==1);
|
||||
if (t.token == TK_STATE)
|
||||
{
|
||||
ps = ST_STATE_NAME;
|
||||
}
|
||||
else if (t.token == TK_END)
|
||||
{
|
||||
nested --;
|
||||
ps = ST_START;
|
||||
}
|
||||
else
|
||||
{
|
||||
error("expecting 'state'");
|
||||
}
|
||||
}
|
||||
break;
|
||||
case ST_STATE_NAME:
|
||||
{
|
||||
assert(nested==1);
|
||||
if (t.token == TK_NAME || t.token == TK_STRING)
|
||||
{
|
||||
current_state_name = getstr(t.seminfo.ts);
|
||||
define_state_name_set.insert(current_state_name);
|
||||
cout << "STATE : " << current_state_name << endl;
|
||||
ps = ST_STATE_BEGIN;
|
||||
}
|
||||
else
|
||||
{
|
||||
error("state name must be given");
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
case ST_STATE_BEGIN:
|
||||
{
|
||||
assert(nested==1);
|
||||
|
||||
if (t.token == TK_DO)
|
||||
{
|
||||
nested ++;
|
||||
ps = ST_WHENLIST_OR_FUNCTION;
|
||||
}
|
||||
else
|
||||
{
|
||||
error("state doesn't have begin-end clause.");
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
case ST_WHENLIST_OR_FUNCTION:
|
||||
{
|
||||
assert(nested==2);
|
||||
|
||||
if (t.token == TK_WHEN)
|
||||
{
|
||||
ps = ST_WHEN_NAME;
|
||||
|
||||
when_name_arg_vector.clear();
|
||||
}
|
||||
else if (t.token == TK_END)
|
||||
{
|
||||
nested--;
|
||||
ps = ST_STATELIST;
|
||||
}
|
||||
else if (t.token == TK_FUNCTION)
|
||||
{
|
||||
ps = ST_FUNCTION_NAME;
|
||||
}
|
||||
else
|
||||
{
|
||||
error("expecting 'when' or 'function'");
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
case ST_WHEN_NAME:
|
||||
{
|
||||
assert(nested==2);
|
||||
if (t.token == TK_NAME || t.token == TK_STRING || t.token == TK_NUMBER)
|
||||
{
|
||||
if (t.token == TK_NUMBER)
|
||||
{
|
||||
ostringstream os;
|
||||
os << (unsigned int)t.seminfo.r;
|
||||
current_when_name = os.str();
|
||||
lexstate.lookahead.token = '.';
|
||||
}
|
||||
else
|
||||
{
|
||||
current_when_name = getstr(t.seminfo.ts);
|
||||
lookahead(&lexstate);
|
||||
}
|
||||
ps = ST_WHEN_WITH_OR_BEGIN;
|
||||
current_when_argument = "";
|
||||
if (lexstate.lookahead.token == '.')
|
||||
{
|
||||
next(&lexstate);
|
||||
current_when_name += '.';
|
||||
next(&lexstate);
|
||||
ostringstream os;
|
||||
t = lexstate.t;
|
||||
os << t;
|
||||
if (os.str() == "target")
|
||||
{
|
||||
current_when_argument = "." + current_when_name;
|
||||
current_when_argument.resize(current_when_argument.size()-1);
|
||||
current_when_name = "target";
|
||||
}
|
||||
else
|
||||
{
|
||||
current_when_name += os.str();
|
||||
}
|
||||
lookahead(&lexstate);
|
||||
}
|
||||
|
||||
{
|
||||
// make when argument
|
||||
ostringstream os;
|
||||
while (lexstate.lookahead.token == '.')
|
||||
{
|
||||
next(&lexstate);
|
||||
os << '.';
|
||||
next(&lexstate);
|
||||
t = lexstate.t;
|
||||
//if (t.token == TK_STRING)
|
||||
//t.token = TK_NAME;
|
||||
os << t;
|
||||
lookahead(&lexstate);
|
||||
}
|
||||
current_when_argument += os.str();
|
||||
}
|
||||
cout << "WHEN : " << current_when_name ;
|
||||
if (!current_when_argument.empty())
|
||||
{
|
||||
cout << " (";
|
||||
cout << current_when_argument.substr(1);
|
||||
cout << ")";
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
error("when name must be given");
|
||||
}
|
||||
|
||||
if (lexstate.lookahead.token == TK_OR)
|
||||
{
|
||||
// <20><><EFBFBD><EFBFBD> when name
|
||||
// push to somewhere -.-
|
||||
ps = ST_WHEN_NAME;
|
||||
when_name_arg_vector.push_back(make_pair(current_when_name, current_when_argument));
|
||||
|
||||
next(&lexstate);
|
||||
cout << " or" << endl;
|
||||
}
|
||||
else
|
||||
{
|
||||
cout <<endl;
|
||||
}
|
||||
}
|
||||
break;
|
||||
case ST_WHEN_WITH_OR_BEGIN:
|
||||
{
|
||||
assert(nested==2);
|
||||
current_when_condition = "";
|
||||
if (t.token == TK_WITH)
|
||||
{
|
||||
// here comes <20><><EFBFBD>ǽ<EFBFBD>
|
||||
next(&lexstate);
|
||||
ostringstream os;
|
||||
os << (lexstate.t);
|
||||
//cout << (lexstate.t);
|
||||
next(&lexstate);
|
||||
while (lexstate.t.token!=TK_DO)
|
||||
{
|
||||
os << " " <<(lexstate.t);
|
||||
//cout << TK_DO<<lexstate.t.token << " " <<(lexstate.t) <<endl;
|
||||
next(&lexstate);
|
||||
}
|
||||
current_when_condition = os.str();
|
||||
check_syntax("if "+current_when_condition+" then end", current_state_name+current_when_condition);
|
||||
cout << "\twith ";
|
||||
cout << current_when_condition;
|
||||
cout << endl;
|
||||
t = lexstate.t;
|
||||
}
|
||||
if (t.token == TK_DO)
|
||||
{
|
||||
ps = ST_WHEN_BODY;
|
||||
nested++;
|
||||
}
|
||||
else
|
||||
{
|
||||
//error("when doesn't have begin-end clause.");
|
||||
ostringstream os;
|
||||
os << "when doesn't have begin-end clause. (" << t << ")";
|
||||
error(os.str().c_str());
|
||||
}
|
||||
|
||||
}
|
||||
break;
|
||||
case ST_WHEN_BODY:
|
||||
{
|
||||
assert(nested==3);
|
||||
|
||||
// output
|
||||
ostringstream os;
|
||||
int state_check = 0;
|
||||
typeof(lexstate) prev = lexstate;
|
||||
string callname;
|
||||
bool registered = false;
|
||||
if (prev.t.token == '.')
|
||||
prev.t.token == TK_DO; // any token
|
||||
while (1)
|
||||
{
|
||||
if (lexstate.t.token == TK_DO || lexstate.t.token == TK_IF /*|| lexstate.t.token == TK_FOR*/ || lexstate.t.token == TK_BEGIN || lexstate.t.token == TK_FUNCTION)
|
||||
{
|
||||
//cout << ">>>" << endl;
|
||||
nested++;
|
||||
}
|
||||
else if (lexstate.t.token == TK_END)
|
||||
{
|
||||
//cout << "<<<" << endl;
|
||||
nested--;
|
||||
}
|
||||
|
||||
if (!callname.empty())
|
||||
{
|
||||
lookahead(&lexstate);
|
||||
if (lexstate.lookahead.token == '(')
|
||||
{
|
||||
RegisterUsedFunction(callname);
|
||||
registered = true;
|
||||
}
|
||||
callname.clear();
|
||||
}
|
||||
else if (lexstate.t.token == '(')
|
||||
{
|
||||
if (!registered && prev.t.token == TK_NAME)
|
||||
RegisterUsedFunction(getstr(prev.t.seminfo.ts));
|
||||
registered = false;
|
||||
}
|
||||
|
||||
if (lexstate.t.token == '.')
|
||||
{
|
||||
ostringstream fname;
|
||||
lookahead(&lexstate);
|
||||
fname << prev.t << '.' << lexstate.lookahead;
|
||||
callname = fname.str();
|
||||
}
|
||||
|
||||
if (state_check)
|
||||
{
|
||||
state_check--;
|
||||
if (!state_check)
|
||||
{
|
||||
if (lexstate.t.token == TK_NAME || lexstate.t.token == TK_STRING)
|
||||
{
|
||||
used_state_name_map[lexstate.linenumber] = (getstr(lexstate.t.seminfo.ts));
|
||||
lexstate.t.token = TK_STRING;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (lexstate.t.token == TK_NAME && ((strcmp(getstr(lexstate.t.seminfo.ts),"set_state")==0) || (strcmp(getstr(lexstate.t.seminfo.ts),"newstate")==0) || (strcmp(getstr(lexstate.t.seminfo.ts),"setstate")==0)))
|
||||
{
|
||||
state_check = 2;
|
||||
}
|
||||
if (nested==2) break;
|
||||
os << lexstate.t << ' ';
|
||||
prev = lexstate;
|
||||
next(&lexstate);
|
||||
if (lexstate.linenumber != lexstate.lastline)
|
||||
os << endl;
|
||||
}
|
||||
|
||||
|
||||
//cout << os.str() << endl;
|
||||
|
||||
check_syntax(os.str(), current_state_name+current_when_condition);
|
||||
reverse(when_name_arg_vector.begin(), when_name_arg_vector.end());
|
||||
while (1)
|
||||
{
|
||||
if (current_when_argument.empty())
|
||||
{
|
||||
if (current_when_condition.empty())
|
||||
state_script_map[current_when_name][current_state_name]+=os.str();
|
||||
else
|
||||
state_script_map[current_when_name][current_state_name]+="if "+current_when_condition+" then "+os.str()+" return end ";
|
||||
}
|
||||
else
|
||||
{
|
||||
state_arg_script_map[current_when_name][current_state_name].push_back(AScript(current_when_condition, current_when_argument, os.str()));
|
||||
}
|
||||
|
||||
if (!when_name_arg_vector.empty())
|
||||
{
|
||||
current_when_name = when_name_arg_vector.back().first;
|
||||
current_when_argument = when_name_arg_vector.back().second;
|
||||
when_name_arg_vector.pop_back();
|
||||
}
|
||||
else
|
||||
break;
|
||||
}
|
||||
|
||||
ps = ST_WHENLIST_OR_FUNCTION;
|
||||
}
|
||||
break;
|
||||
case ST_FUNCTION_NAME:
|
||||
if (t.token == TK_NAME)
|
||||
{
|
||||
current_function_name = getstr(t.seminfo.ts);
|
||||
RegisterDefFunction(quest_name+"."+current_function_name);
|
||||
ps = ST_FUNCTION_ARG;
|
||||
}
|
||||
break;
|
||||
case ST_FUNCTION_ARG:
|
||||
{
|
||||
assert(t.token == '(');
|
||||
next(&lexstate);
|
||||
current_function_arg = '(';
|
||||
if (t.token != ')')
|
||||
{
|
||||
do
|
||||
{
|
||||
if (t.token == TK_NAME)
|
||||
{
|
||||
current_function_arg += getstr(t.seminfo.ts);
|
||||
next(&lexstate);
|
||||
if (t.token != ')')
|
||||
current_function_arg += ',';
|
||||
}
|
||||
else
|
||||
{
|
||||
ostringstream os;
|
||||
os << "invalud argument name " << getstr(t.seminfo.ts) << " for function " << current_function_name;
|
||||
error(os.str().c_str());
|
||||
}
|
||||
} while (testnext(&lexstate, ','));
|
||||
}
|
||||
current_function_arg += ')';
|
||||
ps = ST_FUNCTION_BODY;
|
||||
nested ++;
|
||||
}
|
||||
break;
|
||||
|
||||
case ST_FUNCTION_BODY:
|
||||
{
|
||||
assert(nested == 3);
|
||||
ostringstream os;
|
||||
typeof(lexstate) prev = lexstate;
|
||||
bool registered = false;
|
||||
if (prev.t.token == '.')
|
||||
prev.t.token = TK_DO;
|
||||
string callname;
|
||||
while (nested >= 3)
|
||||
{
|
||||
if (lexstate.t.token == TK_DO || lexstate.t.token == TK_IF /*|| lexstate.t.token == TK_FOR*/ || lexstate.t.token == TK_BEGIN || lexstate.t.token == TK_FUNCTION)
|
||||
{
|
||||
//cout << ">>>" << endl;
|
||||
nested++;
|
||||
}
|
||||
else if (lexstate.t.token == TK_END)
|
||||
{
|
||||
//cout << "<<<" << endl;
|
||||
nested--;
|
||||
}
|
||||
|
||||
if (!callname.empty())
|
||||
{
|
||||
lookahead(&lexstate);
|
||||
if (lexstate.lookahead.token == '(')
|
||||
{
|
||||
RegisterUsedFunction(callname);
|
||||
registered = true;
|
||||
}
|
||||
callname.clear();
|
||||
}
|
||||
else if (lexstate.t.token == '(')
|
||||
{
|
||||
if (!registered && prev.t.token == TK_NAME)
|
||||
RegisterUsedFunction(getstr(prev.t.seminfo.ts));
|
||||
registered = false;
|
||||
}
|
||||
|
||||
if (lexstate.t.token == '.')
|
||||
{
|
||||
ostringstream fname;
|
||||
lookahead(&lexstate);
|
||||
fname << prev.t << '.' << lexstate.lookahead;
|
||||
callname = fname.str();
|
||||
}
|
||||
|
||||
os << lexstate.t << ' ';
|
||||
if (nested == 2)
|
||||
break;
|
||||
prev = lexstate;
|
||||
next(&lexstate);
|
||||
//cout << lexstate.t << ' ' << lexstate.linenumber << ' ' << lexstate.lastline << endl;
|
||||
if (lexstate.linenumber != lexstate.lastline)
|
||||
os << endl;
|
||||
|
||||
}
|
||||
ps = ST_WHENLIST_OR_FUNCTION;
|
||||
all_functions += ',';
|
||||
all_functions += current_function_name;
|
||||
all_functions += "= function ";
|
||||
all_functions += current_function_arg;
|
||||
all_functions += os.str();
|
||||
cout << "FUNCTION " << current_function_name << current_function_arg << endl;
|
||||
}
|
||||
break;
|
||||
|
||||
} // end of switch
|
||||
|
||||
}
|
||||
assert(nested==0);
|
||||
for (map<int,string>::iterator it = used_state_name_map.begin();it!=used_state_name_map.end();++it)
|
||||
{
|
||||
if (define_state_name_set.find(it->second)==define_state_name_set.end())
|
||||
{
|
||||
errorline(it->first,("state name not found : "+it->second).c_str());
|
||||
}
|
||||
}
|
||||
|
||||
if (!define_state_name_set.empty())
|
||||
{
|
||||
if (0 != mkdir(OUTPUT_FOLDER "/state", S_IRWXU))
|
||||
{
|
||||
if (errno != EEXIST)
|
||||
{
|
||||
perror("cannot create directory");
|
||||
exit(1);
|
||||
}
|
||||
}
|
||||
|
||||
ofstream ouf((string(OUTPUT_FOLDER "/state/")+quest_name).c_str());
|
||||
ouf << quest_name << "={[\"start\"]=0";
|
||||
set<string> :: iterator it;
|
||||
|
||||
map<string, int> state_crc;
|
||||
set<int> crc_set;
|
||||
|
||||
state_crc["start"] = 0;
|
||||
for (it = define_state_name_set.begin(); it != define_state_name_set.end(); ++it)
|
||||
{
|
||||
int crc = (int) CRC32((*it).c_str());
|
||||
|
||||
if (crc_set.find(crc) == crc_set.end())
|
||||
{
|
||||
crc_set.insert(crc);
|
||||
}
|
||||
else
|
||||
{
|
||||
++crc;
|
||||
|
||||
while (crc_set.find(crc) != crc_set.end())
|
||||
++crc;
|
||||
|
||||
printf("WARN: state CRC conflict occur! state index may differ in next compile time.\n");
|
||||
crc_set.insert(crc);
|
||||
}
|
||||
state_crc.insert(make_pair(*it, crc));
|
||||
}
|
||||
|
||||
int idx = 1;
|
||||
|
||||
for (it = define_state_name_set.begin(); it!=define_state_name_set.end(); ++it)
|
||||
{
|
||||
if (*it != "start")
|
||||
{
|
||||
ouf << ",[\"" << *it << "\"]=" <<state_crc[*it];
|
||||
++idx;
|
||||
}
|
||||
}
|
||||
|
||||
// quest function<6F><6E><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
|
||||
ouf << all_functions;
|
||||
|
||||
ouf << "}";
|
||||
}
|
||||
|
||||
if (!start_condition.empty())
|
||||
{
|
||||
if (0 != mkdir(OUTPUT_FOLDER "/begin_condition", S_IRWXU))
|
||||
{
|
||||
if (errno != EEXIST)
|
||||
{
|
||||
perror("cannot create directory");
|
||||
exit(1);
|
||||
}
|
||||
}
|
||||
|
||||
ofstream ouf((string(OUTPUT_FOLDER "/begin_condition/")+quest_name).c_str());
|
||||
|
||||
ouf << "return " <<start_condition;
|
||||
ouf.close();
|
||||
}
|
||||
|
||||
{
|
||||
map<string, map<string, vector<AScript> > >::iterator it;
|
||||
|
||||
for (it = state_arg_script_map.begin(); it != state_arg_script_map.end(); ++it)
|
||||
{
|
||||
string second_name;
|
||||
string path;
|
||||
|
||||
if (it->first.find('.')==it->first.npos)
|
||||
{
|
||||
// one like login
|
||||
string s(it->first);
|
||||
transform(s.begin(),s.end(),s.begin(),::tolower);
|
||||
mkdir(OUTPUT_FOLDER "/notarget",0755);
|
||||
mkdir((OUTPUT_FOLDER "/notarget/"+s).c_str(),0755);
|
||||
path = OUTPUT_FOLDER "/notarget/"+s+"/";
|
||||
second_name = s;
|
||||
}
|
||||
else
|
||||
{
|
||||
// two like [WHO].Kill
|
||||
string s = it->first;
|
||||
transform(s.begin(),s.end(),s.begin(),::tolower);
|
||||
int i = s.find('.');
|
||||
mkdir((OUTPUT_FOLDER "/"+it->first.substr(0,i)).c_str(),0755);
|
||||
mkdir((OUTPUT_FOLDER "/"+it->first.substr(0,i)+"/"+s.substr(i+1,s.npos)).c_str(),0755);
|
||||
path = OUTPUT_FOLDER "/" + it->first.substr(0,i) + "/"+s.substr(i+1,s.npos)+"/";
|
||||
second_name = s.substr(i+1,s.npos);
|
||||
}
|
||||
|
||||
map<string,vector<AScript> >::iterator it2;
|
||||
for (it2 = it->second.begin(); it2 != it->second.end(); ++it2)
|
||||
{
|
||||
for (int i = 0; i < it2->second.size(); ++i)
|
||||
{
|
||||
ostringstream os;
|
||||
os << i;
|
||||
{
|
||||
ofstream ouf((path+quest_name+"."+it2->first+"."+os.str()+"."+"script").c_str());
|
||||
copy(it2->second[i].script.begin(),it2->second[i].script.end(), ostreambuf_iterator<char>(ouf));
|
||||
}
|
||||
{
|
||||
ofstream ouf((path+quest_name+"."+it2->first+"."+os.str()+"."+"when").c_str());
|
||||
if (!it2->second[i].when_condition.empty())
|
||||
{
|
||||
ouf << "return ";
|
||||
copy(it2->second[i].when_condition.begin(),it2->second[i].when_condition.end(), ostreambuf_iterator<char>(ouf));
|
||||
}
|
||||
}
|
||||
{
|
||||
ofstream ouf((path+quest_name+"."+it2->first+"."+os.str()+"."+"arg").c_str());
|
||||
copy(it2->second[i].when_argument.begin()+1,it2->second[i].when_argument.end(), ostreambuf_iterator<char>(ouf));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
{
|
||||
map<string,map<string,string> >::iterator it;
|
||||
|
||||
for (it = state_script_map.begin();it!=state_script_map.end();++it)
|
||||
{
|
||||
string path;
|
||||
if (it->first.find('.')==it->first.npos)
|
||||
{
|
||||
// one
|
||||
string s = it->first;
|
||||
transform(s.begin(),s.end(),s.begin(),::tolower);
|
||||
mkdir(OUTPUT_FOLDER "/notarget",0755);
|
||||
mkdir((OUTPUT_FOLDER "/notarget/"+s).c_str(),0755);
|
||||
path = OUTPUT_FOLDER "/notarget/"+s+"/";
|
||||
}
|
||||
else
|
||||
{
|
||||
// two like [WHO].Kill
|
||||
string s = it->first;
|
||||
transform(s.begin(),s.end(),s.begin(),::tolower);
|
||||
int i = s.find('.');
|
||||
mkdir((OUTPUT_FOLDER "/"+it->first.substr(0,i)).c_str(),0755);
|
||||
mkdir((OUTPUT_FOLDER "/"+it->first.substr(0,i)+"/"+s.substr(i+1,s.npos)).c_str(),0755);
|
||||
path = OUTPUT_FOLDER "/" + it->first.substr(0,i) + "/"+s.substr(i+1,s.npos)+"/";
|
||||
}
|
||||
|
||||
map<string,string>::iterator it2;
|
||||
for (it2 = it->second.begin();it2!=it->second.end();++it2)
|
||||
{
|
||||
ofstream ouf((path+quest_name+"."+it2->first).c_str());
|
||||
copy(it2->second.begin(),it2->second.end(), ostreambuf_iterator<char>(ouf));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
CheckUsedFunction();
|
||||
}
|
||||
|
||||
int main(int argc, char* argv[])
|
||||
{
|
||||
mkdir(OUTPUT_FOLDER, 0700);
|
||||
L = lua_open();
|
||||
luaX_init(L);
|
||||
|
||||
if (argc > 1)
|
||||
{
|
||||
for (int i = 1; i < argc; ++i)
|
||||
{
|
||||
g_filename = argv[i];
|
||||
parse(argv[i]);
|
||||
}
|
||||
}
|
||||
|
||||
lua_close(L);
|
||||
return 0;
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user