virtual int __fun_call(Executor& ewsl,int pm)
{
if (pm == 0)
{
this_logger().PrintLn("usage: help(function_name[,level]);");
return 0;
}
int lv=0;
if(pm>=2)
{
lv=variant_cast<int>(ewsl.ci0.nbx[2]);
}
DataPtrT<CallableData> _kp=ewsl.ci0.nbx[1].kptr();
HelpData* _hd=_kp ? _kp->__get_helpdata() : NULL;
String _sHelp;
if (_hd)
{
_hd->ToValue(_sHelp, 0);
}
else
{
_sHelp = "no_help";
}
this_logger().PrintLn(_sHelp);
return 0;
}
virtual int __fun_call(Executor& ewsl,int pm)
{
if(pm==1)
{
String *p=ewsl.ci0.nbx[1].ptr<String>();
if(p)
{
ewsl.ci0.nbx[1].reset(Translate(*p));
}
else
{
this_logger().LogTrace("not string");
}
return 1;
}
else if(pm==2)
{
String *p=ewsl.ci0.nbx[1].ptr<String>();
String *d=ewsl.ci0.nbx[2].ptr<String>();
if(p && d)
{
ewsl.ci0.nbx[1].reset(Translate(*p,*d));
}
else
{
this_logger().LogTrace("not string");
}
return 1;
}
ewsl.kerror("invalid param count");
return 1;
}
bool CmdLineParser::parse(int argc, char** argv)
{
arr_1t<String> vargv;
if(argc<0)
{
this_logger().PrintLn("argc<0");
return false;
}
else if(argc==0)
{
return true;
}
for(int i=0;i<argc;i++)
{
if(argv[i]==0)
{
this_logger().PrintLn("empty option");
return false;
}
vargv.push_back(IConv::from_ansi(argv[i]));
}
return parse(vargv);
}
bool XmlParser::parse_document()
{
xmldoc.DeleteChildren();
xmldoc.DeleteAttributes();
pcur=pbeg;
pend=pcur+size;
nodes.clear();
nodes.push_back(&xmldoc);
try
{
parse_subnodes();
}
catch(std::exception& e)
{
this_logger().LogError(e.what());
nodes.clear();
return false;
}
nodes.clear();
return true;
}
virtual int __fun_call(Executor& ewsl,int pm)
{
ewsl.check_pmc(this,pm,1);
String *p=ewsl.ci0.nbx[1].ptr<String>();
if(p)
{
}
else
{
this_logger().LogTrace("not string");
}
return 1;
}
void Session::ep_ctl(int f)
{
if(state.get()!=STATE_OK)
{
return;
}
int _def_ctl=EPOLLERR|EPOLLHUP|EPOLLET;//|EPOLLONESHOT;
int _tmp_ctl=_def_ctl;//|EPOLLONESHOT;//|EPOLLONESHOT;//m_nLastEpoll_def.val();
if(m_nPendingSend.get()>0)
{
_tmp_ctl=_tmp_ctl|EPOLLOUT;
}
if(m_nPendingRecv.get()>0)
{
_tmp_ctl=_tmp_ctl|EPOLLIN;
}
if(_tmp_ctl==_def_ctl)
{
return;
}
m_nLastEpoll_ctl=_tmp_ctl;
struct epoll_event ev;
ev.data.ptr=this;
ev.events=_tmp_ctl;
int bRet=epoll_ctl(hiocp->native_handle(),EPOLL_CTL_MOD,sk_local.sock.native_handle(),&ev);
if(bRet<0)
{
this_logger().LogError("epoll_ctl failed: %s",strerror(errno));
Disconnect();
}
}
bool CodeGen::parse(TNode_statement_list* q)
{
stmt_list.reset(q);
TNodeVisitorCG_Analyzer vis_phase1(*this);
TNodeVisitorCG_Generator vis_phase2(*this);
try
{
vis_phase1.parse(q);
vis_phase2.parse(q);
}
catch(std::exception& e)
{
this_logger().LogError(e.what());
return false;
}
return true;
}
virtual int __fun_call(Executor& ewsl,int)
{
this_logger().LogCommand("clc");
return 0;
}
void IOCPPool::HandleRecv(Session& ikey)
{
if(ikey.m_nPendingRecv.get()==0)
{
return;
}
for(;;)
{
TempOlapPtr q=ikey.lkfq_recv.getq();
if(!q)
{
break;
}
if(q->type==MyOverLapped::ACTION_WAIT_RECV)
{
ikey.m_nPendingRecv--;
ikey.OnRecvReady();
break;
}
if(q->type==MyOverLapped::ACTION_UDP_RECV)
{
int bRet=ikey.sk_local.sock.recv(q->dbuf[0].buf,q->dbuf[0].len,q->peer);
if(bRet>0)
{
q->size=bRet;
accounter.nRecvBytes.fetch_add(bRet);
accounter.nSendCount++;
ikey.m_nPendingRecv--;
ikey.OnRecvCompleted(q);
break;
}
else if(bRet<0)
{
ikey.m_nPendingRecv--;
ikey.Disconnect();
break;
}
else
{
ikey.m_nPendingRecv--;
this_logger().LogMessage("recv udp failed");
}
break;
}
q->size=0;
for(;;)
{
int bRet=ikey.sk_local.sock.recv(q->dbuf[0].buf+q->size,q->dbuf[0].len-q->size);
if(bRet<0)
{
if(errno==EAGAIN)
{
break;
}
if(errno==EINTR)
{
continue;
}
ikey.Disconnect();
break;
}
else if(bRet==0)
{
break;
}
q->size+=bRet;
break;
}
if(q->size>0)
{
accounter.nRecvCount++;
accounter.nRecvBytes.fetch_add(q->size);
ikey.m_nPendingRecv--;
ikey.OnRecvCompleted(q);
}
else
{
ikey.m_nPendingRecv--;
}
break;
}
}
bool CmdLineParser::parse(const arr_1t<String>& argv)
{
typedef bst_map<String, OptionType>::iterator iterator;
m_aParams.clear();
m_aSwitchs.clear();
m_aOptions=m_aOptionsDefault;
int argc=argv.size();
int nParamCount=m_aCmdLineOptions[""].tags;
for (int i = 1; i < argc; i++)
{
const char* pa = argv[i].c_str();
if (pa[0] == '-')
{
if (pa[1] == 0)
{
this_logger().PrintLn("empty option");
return false;
}
String ps = pa + 1;
iterator it = m_aCmdLineOptions.find(ps);
if (it == m_aCmdLineOptions.end())
{
this_logger().PrintLn("unknown option or switch");
return false;
}
OptionType opt((*it).second);
if (opt.type == CMDLINE_SWITCH)
{
m_aSwitchs.insert(ps);
}
else if (opt.type == CMDLINE_OPTION)
{
if (++i == argc)
{
this_logger().PrintLn("option value expected");
return false;
}
m_aOptions[ps] = argv[i];
m_aSwitchs.insert(ps);
}
else
{
this_logger().PrintLn("unknown option type");
return false;
}
}
else
{
m_aParams.push_back(pa);
}
}
if(nParamCount>=0 && (int)m_aParams.size()!=nParamCount)
{
if (nParamCount == 0)
{
this_logger().PrintLn("no_param_allown");
}
else
{
this_logger().PrintLn("invalid_param_count:%d needed",nParamCount);
}
return false;
}
return true;
}
LoggerSwap::~LoggerSwap()
{
swap(this_logger());
}
LoggerSwap::LoggerSwap(Logger& logger):Logger(logger)
{
swap(this_logger());
}
LoggerSwap::LoggerSwap()
{
reset(new LogNull);
swap(this_logger());
}
bool CmdProc::DoExecId(ICmdParam& cmd)
{
Logger& logger(this_logger());
if (cmd.param1 == CP_LOAD_FILE)
{
if(!DoLoad(cmd.extra1))
{
logger.LogError(_hT("failed_to_load_file %s!"),cmd.extra1);
return false;
}
return true;
}
else if (cmd.param1 == CP_SAVE_FILE)
{
return DoSave(cmd.extra1);
}
else if (cmd.param1 == CP_INIT)
{
if (cmd.extra1 != "")
{
}
else if (!TestId(CmdProc::CP_SAVEAS, cmd.extra1))
{
return false;
}
//if (cmd.extra1 == "")
//{
// return true;
//}
cmd.param1 = CP_LOAD_FILE;
if (!DoExecId(cmd)) return false;
return true;
}
else if (cmd.param1 == CP_LOAD)
{
if (cmd.extra1 != "")
{
}
else if (!TestId(CmdProc::CP_SAVEAS, cmd.extra1))
{
return false;
}
if (cmd.extra1 == "")
{
String exts;
TestId(CP_FILEEXT, exts);
if (Wrapper::FileDialog(cmd.extra1, IDefs::FD_OPEN, "", exts) == IDefs::BTN_CANCEL)
{
return false;
}
}
cmd.param1 = CP_LOAD_FILE;
if (!DoExecId(cmd)) return false;
return true;
}
else if(cmd.param1==CP_SAVE_TEMP)
{
if (cmd.extra1 != "")
{
}
else if (cmd.extra2 == "")
{
return false;
}
else
{
cmd.extra1 = cmd.extra2 + ".temp";
}
cmd.param1 = CP_SAVE_FILE;
return DoExecId(cmd);
}
else if(cmd.param1==CP_SAVE_POST)
{
if (cmd.extra1 == ""||cmd.extra2=="")
{
return false;
}
if (cmd.extra1 != cmd.extra2)
{
if (!FSObject::current().Rename(cmd.extra1, cmd.extra2, 1))
{
logger.LogError(_hT("failed_to_save_file %s!"),cmd.extra2);
return false;
}
}
fn.SetFilename(cmd.extra2);
return true;
}
else if(cmd.param1==CP_SAVE||cmd.param1==CP_SAVEAS)
{
if(!TestId(CmdProc::CP_SAVEAS,cmd.extra1))
{
cmd.param2 = -1;
return false;
}
if(cmd.extra1==""||cmd.param1==CP_SAVEAS)
{
String exts;
TestId(CP_FILEEXT,exts);
if (Wrapper::FileDialog(cmd.extra1, IDefs::FD_SAVE | IDefs::FD_OVERWRITE_PROMPT, "", exts) == IDefs::BTN_CANCEL)
{
cmd.param2 = -2;
return false;
}
}
if (!FSObject::current().FileExists(cmd.extra1))
{
cmd.extra2 = cmd.extra1;
}
else
{
std::swap(cmd.extra1,cmd.extra2);
}
cmd.param2 = 0;
cmd.param1=CP_SAVE_TEMP;
if(!DoExecId(cmd))
{
logger.LogError(_hT("failed_to_save_file %s!"),cmd.extra2);
return false;
}
cmd.param1=CP_SAVE_POST;
if(!DoExecId(cmd)) return false;
return true;
}
else
{
return false;
}
}
