bool ParseMarkupXml(const char *xml, MarkupParserCallback *cb)
{
ParserState *state = new ParserState(xml, cb);
bool ok = ParseXml(state);
delete state;
return ok;
}
int main()
{
std::string strXml;
//CreateXml(strXml);
ReadXml(strXml);
ParseXml(strXml);
return 0;
}
Node *
ReadFile
(
const char * fileName
)
{
IStream * pStream;
IXmlReader * pReader;
HANDLE fileHandle = CreateFile(fileName, FILE_GENERIC_READ, FILE_SHARE_READ, nullptr, OPEN_EXISTING, 0, nullptr);
if (fileHandle == INVALID_HANDLE_VALUE)
{
Fatal("Cannot open XML file %s", fileName);
}
if (FAILED(CreateStreamOnHandle(fileHandle, &pStream)))
{
Fatal("Cannot create stream from file");
}
if (FAILED(CreateXmlReader(__uuidof(IXmlReader), (void**) &pReader, nullptr)))
{
Fatal("Cannot create XML reader");
}
if (FAILED(pReader->SetProperty(XmlReaderProperty_DtdProcessing, DtdProcessing_Prohibit)))
{
Fatal("Cannot prohibit DTD processing");
}
if (FAILED(pReader->SetInput(pStream)))
{
Fatal("Cannot set XML reader input");
}
Node * topNode;
if (FAILED(ParseXml(pReader, &topNode)))
{
unsigned int line, linePos;
pReader->GetLineNumber(&line);
pReader->GetLinePosition(&linePos);
fprintf(
stderr,
"Error on line %d, position %d in \"%s\".\n",
line,
linePos,
fileName);
Fatal("Error parsing XML");
}
SAFERELEASE(pReader);
SAFERELEASE(pStream);
CloseHandle(fileHandle);
return topNode;
}
bool BilibiliParser::ParseFileSource(const wchar_t* filePath) {
std::ifstream file;
file.open(filePath, std::ios::in || std::ios::binary || std::ios::ate);
if (file.fail())
return false;
file.seekg(0, std::ios::end);
size_t length = static_cast<size_t>(file.tellg());
std::string buffer;
buffer.reserve(length + 1);
buffer.resize(length);
file.seekg(0, std::ios::beg);
file.read(&buffer[0], length);
file.close();
return ParseXml(buffer.c_str(), true);
}
void ClientSocket::OnReceive(int nErrorCode)
{
// TODO: 在此添加专用代码和/或调用基类
char *pData = NULL;
//pData = new char[10240];
//memset(pData, 0, sizeof(char)*10240);
External_Mag_Head msgHead;
int msgLen = sizeof(External_Mag_Head);
UINT leng = 0;
CString strDoc;
pData = new char[msgLen];
memset(pData, 0, sizeof(char)*msgLen);
SetTimeOut(3000);
leng = Receive(pData, msgLen, 0);
KillTimeOut();
AsyncSelect(FD_READ);
memcpy(&msgHead, pData, msgLen);
free(pData);
pData = new char[msgHead.load_len + 1];
memset(pData, 0, sizeof(char)*msgHead.load_len + 1);
SetTimeOut(3000);
leng = Receive(pData, msgHead.load_len, 0);
KillTimeOut();
AsyncSelect(FD_READ);
//char *p_msgBody = (char*)malloc(sizeof(char)*msgHead.load_len);
//memset(p_msgBody, 0, sizeof(char)*msgHead.load_len);
//memcpy(p_msgBody, pData + msgLen, sizeof(char)*msgHead.load_len);
strDoc = StringConvertor::Utf8ToWide(pData);
m_xml.SetDoc(strDoc);
ParseXml(m_xml);
/*DWORD *pParams = new DWORD[2];
pParams[0] = (DWORD)this;
pParams[1] = (DWORD)pData;
m_hThread = ::CreateThread(NULL, NULL, ParseXml, (LPVOID*)(pParams), NULL, NULL);*/
delete pData;
CSocket::OnReceive(nErrorCode);
}
bool BilibiliParser::ParseFileSource(const char* filePath) {
file<> xmlFile(filePath);
return ParseXml(xmlFile.data(), true);
}
bool BilibiliParser::ParseStringSource(const char* str) {
return ParseXml(str);
}
void FPackage::SetData(
const uint8*& BinaryBuffer,
const int32 BinaryBufferSize,
const FString& FilePath)
{
// save the sbsar
LinkData.reset(
new Details::LinkDataAssembly(
BinaryBuffer,
BinaryBufferSize));
{
int32 Err = 0;
// grab the xmls using the linker
SubstanceLinkerContext *context;
SubstanceLinkerContextInitEnum mode = Substance_Linker_Context_Init_NonMobile;
#if IPHONE
mode = Substance_Linker_Context_Init_Mobile;
#endif
Err = Substance::gAPI->SubstanceLinkerContextInit(&context, mode);
if (Err)
{
GWarn->Log((*FString::Printf(TEXT("Substance: error while initializing the linker context(%d)"), Err)));
return;
}
Err = Substance::gAPI->SubstanceLinkerContextSetXMLCallback(context, (void*)linkerCallbackArchiveXml);
if (Err)
{
GWarn->Log((*FString::Printf(TEXT("Substance: linker error (%d)"), Err)));
return;
}
if (Err)
{
GWarn->Log((*FString::Printf(TEXT("Substance: linker error (%d)"), Err)));
return;
}
SubstanceLinkerHandle *handle;
Err = Substance::gAPI->SubstanceLinkerHandleInit(&handle,context, 0);
if (Err)
{
GWarn->Log((*FString::Printf(TEXT("Substance: linker error (%d)"), Err)));
return;
}
linkerArchiveXmlContent.Empty();
Err = Substance::gAPI->SubstanceLinkerPushMemory(
handle,
(const char*)BinaryBuffer,
BinaryBufferSize);
if (Err)
{
GWarn->Log(TEXT("Substance: invalid assembly, cannot import file."));
return;
}
// Release
Err = Substance::gAPI->SubstanceLinkerRelease(handle, context);
if (Err)
{
GWarn->Log((*FString::Printf(TEXT("Substance: linker error (%d)"), Err)));
return;
}
}
// try to parse the xml file
if (false == ParseXml(linkerArchiveXmlContent))
{
// abort if invalid
GWarn->Log( TEXT("Substance: error while parsing xml companion file."));
return;
}
Substance::List<graph_desc_t*>::TIterator itG(Graphs.itfront());
for (; itG ; ++itG)
{
(*itG)->Parent = this;
Substance::List<output_desc_t>::TIterator itO((*itG)->OutputDescs.itfront());
for (; itO ; ++itO)
{
Details::LinkDataAssembly *linkdata =
(Details::LinkDataAssembly *)LinkData.get();
linkdata->setOutputFormat(
(*itO).Uid,
(*itO).Format);
}
}
SourceFilePath = FilePath;
SourceFileTimestamp = IFileManager::Get().GetTimeStamp( *FilePath ).ToString();
}
INT32 CInvUpload::CommunicationProc(void* pDataIn, void* pDataOut, string &strErr)
{
INT32 res = 0;
NoteData_Para noteData;
noteData.m_appType = NET_FPSC; //此处设置业务类型
DataOutType dataOut(g_Xml_OutBuf_Inv, PROTOCOL_OUT_BUFF_LEN);
res = BuildXml(pDataIn, &dataOut, ¬eData, strErr);
DBG_PRINT(("res = %u", res));
if (res != SUCCESS)
{
return res;
}
DBG_PRINT(("outLen = %d", dataOut.outLen));
//////////////////////////////////////////////////////////////////////////
//此处为处理流程，将上面组织的数据发送给库SSL接口，接收到的数据放入g_Xml_OutBuf_Inv中。
//////////////////////////////////////////////////////////////////////////
#if SSL_USE_TYPE == 1
int rec_len = PROTOCOL_OUT_BUFF_LEN;
CTechnologyMsg pTechMsg;
string strTechMsg("");
pTechMsg.m_nsrsbh = g_gNetArg->m_nsrsbh;
pTechMsg.m_servIP = g_gNetArg->m_servIP;
pTechMsg.m_servPort = g_gNetArg->m_servPort;
pTechMsg.m_passWord = g_gNetArg->m_strzskl;
pTechMsg.m_certPwd = g_gNetArg->m_strzskl;
pTechMsg.m_servId = TECH_MSG_SERV_ID_INV;
if(g_gNetArg->m_servId != "")
{
pTechMsg.m_servId = g_gNetArg->m_servId;
}
GetTechMsgStr(&pTechMsg, strTechMsg);
UINT8 errBuf[1024];
memset(errBuf, 0, sizeof(errBuf));
// printf("------------------------send-------------------------------------\n");
// DBG_PRINT(("dataOut.outLen = %d", dataOut.outLen));
// printf("%s\n", g_Xml_OutBuf_Inv);
// printf("\n----------------------send---------------------------------------\n");
int retval = 0;
#if NET_LOCK_FLAG == 1
CJSKInfoFunc::MutexLock();
#endif
retval=aisino_ssl_transfer_call(SSL_AUTH_CODE,(char*)strTechMsg.c_str(),strTechMsg.size(),
(unsigned char*)g_Xml_OutBuf_Inv,dataOut.outLen,(unsigned char*)g_Xml_ExchangeBuf_Inv,&rec_len,errBuf);
#if NET_LOCK_FLAG == 1
CJSKInfoFunc::MutexUnlock();
#endif
DBG_PRINT(("retval = %d", retval));
if( retval != 0)
{
DBG_PRINT(("errBuf = %s", errBuf));
//strErr = (INT8 *)errBuf;
strErr = "网络通信错误!";
return retval;
}
DBG_PRINT(("rec_len = %d", rec_len));
dataOut.fill(g_Xml_ExchangeBuf_Inv, rec_len);
memset(g_Xml_ExchangeBuf_Inv, 0, PROTOCOL_OUT_BUFF_LEN);
#ifdef XML_DEBUG_OUT
printf("--------------------------CInvUpload rec begin-----------------------------------\n");
DBG_PRINT(("rec_len = %d", rec_len));
printf("%s\n", g_Xml_OutBuf_Inv);
printf("\n------------------------CInvUpload rec end-------------------------------------\n");
#endif
#endif
res = ParseXml(pDataOut, &dataOut, ¬eData, strErr);
DBG_PRINT(("res = %d", res));
if (res != SUCCESS)
{
return res;
}
return SUCCESS;
}
void GlobalHiScoreDb::HandleResponseFromServer(const std::string& response)
{
HiScoreVec vec;
PXml xml = ParseXml(response.c_str());
/*
Example response:
<hiscores>
<hi>
<score>200</score>
<nick>Jay</nick>
<level>2</level>
<depth>3</depth>
<pos>
<x>12</x> <y>34</y> <z>56</z>
</pos>
</hi>
</hiscores>
*/
xml = xml.getChildNode("hiscores");
if (!xml.isEmpty())
{
int n = xml.nChildNode();
for (int i = 0; i < n; i++)
{
PXml xhi = xml.getChildNode(i);
if (!xhi.isEmpty())
{
PXml xscore = xhi.getChildNode("score");
if (!xscore.isEmpty())
{
int score = ToInt(xscore.getText());
PXml xnick = xhi.getChildNode("nick");
if (!xnick.isEmpty())
{
std::string nick = xnick.getText();
PXml xlevel = xhi.getChildNode("level");
if (!xlevel.isEmpty())
{
int level = ToInt(xlevel.getText());
PXml xdepth = xhi.getChildNode("depth");
if (!xdepth.isEmpty())
{
int depth = ToInt(xdepth.getText());
PXml xpos = xhi.getChildNode("pos");
if (!xpos.isEmpty())
{
PXml xx = xpos.getChildNode("x");
PXml xy = xpos.getChildNode("y");
PXml xz = xpos.getChildNode("z");
if (!xx.isEmpty() && !xy.isEmpty() && !xz.isEmpty())
{
Vec3f pos(ToFloat(xx.getText()), ToFloat(xy.getText()), ToFloat(xz.getText()));
// Nickname is stored encoded in server DB
Hi hi(score, level, depth, DecodeStr(nick), pos);
vec.push_back(hi);
continue;
}
}
}
}
}
}
}
#ifdef _DEBUG
std::cout << "ERROR (1) parsing hi scores XML from server!\n";
#endif
return;
}
}
else
{
#ifdef _DEBUG
std::cout << "ERROR (2) parsing hi scores XML from server!\n";
#endif
return;
}
m_global.SetVec(vec);
// Save locally so we can show something if we lose connectivity later
m_global.Save(FILENAME_GLOBAL);
// Remove local hi scores which are in the response
for (const Hi& hi : vec)
{
m_local.RemoveHiScore(hi);
}
m_local.Save(FILENAME_LOCAL);
}
UINT CUpdateMgr::MyCheckUpdateThreadProc()
{
if (true == DownLoadServerUpdateXmlFile())
{
string ServerXml = m_SingleDownLoad.GetMemBuf();
g_Logger.Debug(__FILE__,__LINE__,"解析服务器端xml文件 %s",ServerXml.c_str());
ParseXml(ServerXml,SERVER,PARSE_TYPE_MEMORY);
}
#ifdef _UNICODE
USES_CONVERSION;
ParseXml(W2A(LOCALXMLCONFIG),LOCAL,PARSE_TYPE_FILE);
#else
ParseXml(LOCALXMLCONFIG,LOCAL,PARSE_TYPE_FILE);
#endif
map<string,SERVER_XML_INFO*>::iterator ServerIter;
map<string,LOCAL_XML_INFO*>::iterator LocalIter;
BOOL bAppendLst=FALSE;
CString strCurDirectory;
ClearLocalXml_Tmp();
g_Logger.Debug(__FILE__,__LINE__,"m_MapServerXmlInfo Count %d",m_MapServerXmlInfo.size());
g_Logger.Debug(__FILE__,__LINE__,"m_MapLocalXmlInfo Count %d",m_MapLocalXmlInfo.size());
for(ServerIter = m_MapServerXmlInfo.begin(); ServerIter != m_MapServerXmlInfo.end(); ServerIter++)
{
SERVER_XML_INFO* lpSerXmlInfo =(SERVER_XML_INFO*)ServerIter->second;
LOCAL_XML_INFO* lpLocalXmlInfo =NULL;
LocalIter = m_MapLocalXmlInfo.find(ServerIter->first);
if (LocalIter != m_MapLocalXmlInfo.end())
{
//找到
lpLocalXmlInfo = (LOCAL_XML_INFO*)LocalIter->second;
if(strcmp(lpSerXmlInfo->md5.c_str(),lpLocalXmlInfo->md5.c_str())!=0)
{
bAppendLst = TRUE;
}
else
{
g_Logger.Debug(__FILE__,__LINE__,"md5 值一致不需要加入更新列表 %s",lpLocalXmlInfo->fileName.c_str());
}
}
else
{
//说明没找到,添加到更新列表中
//m_UpdateList.push_back(ServerIter->second);
bAppendLst = TRUE;
}
if (bAppendLst)
{
USES_CONVERSION;
//说明md5不一致,需要更新,添加到更新列表中
//SERVER_XML_INFO* lpServerXmlInfo = (SERVER_XML_INFO*)ServerIter->second;
LPMULTI_DOWNLOAD_INFO lpMultiDownLoad = new MULTI_DOWNLOAD_INFO;
memset(lpMultiDownLoad,0,sizeof(MULTI_DOWNLOAD_INFO));
wstring wsCurDirectory;
CEnvironment::Env_GetCurrentDirectory(wsCurDirectory);
strCurDirectory.Format(_T("%s\\%s%s\\"),wsCurDirectory.c_str(),UPDATEFOLDER, s2ws(m_serverUpdateTime).c_str());
#ifdef _UNICODE
_tcscpy(lpMultiDownLoad->filename,A2W(lpSerXmlInfo->fileName.c_str()));
//_tcscpy((lpMultiDownLoad->url).c_str(),A2W(lpSerXmlInfo->url.c_str()));
strcpy(lpMultiDownLoad->url,lpSerXmlInfo->url.c_str());
_tcscpy(lpMultiDownLoad->fileSavePath,strCurDirectory.GetBuffer(0));
#else
_tcscpy(lpMultiDownLoad->filename,(lpSerXmlInfo->fileName.c_str()));
_tcscpy(lpMultiDownLoad->url,(lpSerXmlInfo->url.c_str()));
_tcscpy(lpMultiDownLoad->fileSavePath,strCurDirectory.GetBuffer(0));
#endif
LOCAL_XML_INFO* lpNewLocalXmlInfo = new LOCAL_XML_INFO;
memset(lpNewLocalXmlInfo,0,sizeof(LOCAL_XML_INFO));
lpNewLocalXmlInfo->fileName =lpSerXmlInfo->fileName;
lpNewLocalXmlInfo->lastVersion=lpSerXmlInfo->lastVersion;
lpNewLocalXmlInfo->md5=lpSerXmlInfo->md5;
lpNewLocalXmlInfo->size=lpSerXmlInfo->size;
g_Logger.Debug(__FILE__,__LINE__,"加入更新列表,%s",lpNewLocalXmlInfo->fileName);
m_LocalXmlTmpList.push_back(lpNewLocalXmlInfo);
m_UpdateList.push_back(lpMultiDownLoad);
bAppendLst=FALSE;
}
}
if (m_UpdateList.size()>0)
{
BOOL bRet = MakeSureDirectoryPathExists(W2A(strCurDirectory.GetBuffer(0)));
if (!bRet)
{
DWORD dwErr = GetLastError();
string strMsg;
CGlobalFunction::AfxFormatMessageA(dwErr,strMsg);
g_Logger.Debug(__FILE__,__LINE__,"创建更新目录 失败 dwErr=%ld,Msg=%s,strCurDirectory=%s",dwErr,strMsg.c_str(), W2A(strCurDirectory.GetBuffer()));
}
else
{
g_Logger.Debug(__FILE__,__LINE__,"创建更新目录 成功 %s", W2A(strCurDirectory.GetBuffer()));
}
return SendMessage(AfxGetMainWnd()->m_hWnd, UM_UPDATE,NULL,NULL);
}
else
{
//没有需要更新的文件,程序退出
return SendMessage(AfxGetMainWnd()->m_hWnd,WM_CLOSE,NULL,NULL);
}
//return DO_NOT_NEEDUPDATE;
}
void Ve1Req::HandleResult()
{
m_errorStr.clear();
bool success = false;
const HttpResult& res = GetResult();
if (res.GetSuccess())
{
const std::string& str = res.GetString();
m_xml = ParseXml(str.c_str());
// For all responses, Child 0 is current server time
PXml p = m_xml.getChildNode(0);
if (SafeStrCmp(p.getName(), "now"))
{
m_timestamp = p.getText();
// TODO More checking
success = true;
}
else
{
// TODO Get HTTP code
m_errorStr = m_name + ": Didn't get time stamp in result: " + str;
}
if (m_xml.nChildNode() > 1)
{
p = m_xml.getChildNode(1);
if (SafeStrCmp(p.getName(), "error"))
{
m_errorStr = p.getText();
success = false;
}
m_errorCode = "";
// Check for <errorcode>
if (m_xml.nChildNode() > 2)
{
p = m_xml.getChildNode(1);
if (SafeStrCmp(p.getName(), "errorcode"))
{
m_errorCode = p.getText();
}
}
}
}
else
{
//m_errorStr = res.GetErrorString();
m_errorStr = "I don't seem to be able to go online. Is your internet connection working?";
}
if (success)
{
OnSuccess();
}
else
{
OnFailure();
}
}
