bool CNtlXMLDoc::LoadXML( WCHAR* wszXMLBuffer )
{
if (false != m_bIsFileLoaded)
return false;
VARIANT_BOOL status;
HRESULT hResult = m_pXMLDocument->loadXML(wszXMLBuffer, &status);
if (FAILED(hResult))
{
return false;
}
if (VARIANT_FALSE == status)
{
IXMLDOMParseError* pXMLError = NULL;
m_pXMLDocument->get_parseError(&pXMLError);
BSTR bstrErrorReasonString;
pXMLError->get_reason(&bstrErrorReasonString);
::SysFreeString(bstrErrorReasonString);
pXMLError->Release();
return false;
}
m_bIsFileLoaded = true;
return true;
}
/**
* LoadXMLString
* initialize the document with a string containing the xml representation.
*
* @param [in] strXMLString: the xml representation in a string
* @return TRUE: on success
* FLASE: else
* @exception -
* @see
*/
BOOL CXMLDocument::LoadXMLString(const CString& strXMLString)
{
// HRESULT loadXML(BSTR bstrXML,VARIANT_BOOL * isSuccessful);
CComBSTR sString = strXMLString;
VARIANT_BOOL vbIsSuccessful = VARIANT_FALSE;
HRESULT hr = m_domDocument->loadXML(sString, &vbIsSuccessful);
if (hr != S_OK || (vbIsSuccessful==VARIANT_FALSE))
{
IXMLDOMParseError * pXMLError = NULL;
hr = m_domDocument->get_parseError(&pXMLError);
if(SUCCEEDED(hr))
{
long l=0,c=0;
BSTR bs;
pXMLError->get_line(&l);
pXMLError->get_linepos(&c);
hr = pXMLError->get_reason(&bs);
pXMLError->Release();
}
return FALSE;
}
else
{
return TRUE;
}
}
IXMLDOMDocument *XmlParser::_openFile(const LPWSTR file, XMLERRORDATA *error)
{
if(error)
{
error->errorCode = -1;
error->line = -1;
error->reason = NULL;
}
bool ok = false;
IXMLDOMDocument *x = createAndConfigureInterface();
if(x)
{
VARIANT_BOOL bl;
VARIANT str;
//Выделяем строку.
CWA(oleaut32, VariantInit)(&str);
str.vt = VT_BSTR;
str.bstrVal = CWA(oleaut32, SysAllocString)(file);
if(str.bstrVal != NULL)
{
//Загружаем файл.
if(x->load(str, &bl) == S_OK && bl == VARIANT_TRUE)ok = true;
//Получаем ошибку.
else if(error)
{
IXMLDOMParseError *ierror;
if(x->get_parseError(&ierror) == S_OK)
{
long l;
BSTR reason = NULL;
//Заполняем структуру.
if(ierror->get_errorCode(&l) == S_OK)error->errorCode = l;
if(ierror->get_line(&l) == S_OK)error->line = l;
if(ierror->get_reason(&reason) == S_OK)error->reason = reason;
ierror->Release();
}
}
CWA(oleaut32, VariantClear)(&str);
}
//Объект не создан, освобождаем интерфейс.
if(ok == false)
{
x->Release();
x = NULL;
}
}
return x;
}
IXMLDOMDocument *XmlParser::_openFile(const LPWSTR file, XMLERRORDATA *error)
{
if(error)
{
error->errorCode = -1;
error->line = -1;
error->reason = NULL;
}
bool ok = false;
IXMLDOMDocument *x = createAndConfigureInterface();
if(x)
{
VARIANT_BOOL bl;
VARIANT str;
//Select the line.
CWA(oleaut32, VariantInit)(&str);
str.vt = VT_BSTR;
str.bstrVal = CWA(oleaut32, SysAllocString)(file);
if(str.bstrVal != NULL)
{
//Load the file.
if(x->load(str, &bl) == S_OK && bl == VARIANT_TRUE)ok = true;
//Get an error.
else if(error)
{
IXMLDOMParseError *ierror;
if(x->get_parseError(&ierror) == S_OK)
{
long l;
BSTR reason = NULL;
//Fill in the structure.
if(ierror->get_errorCode(&l) == S_OK)error->errorCode = l;
if(ierror->get_line(&l) == S_OK)error->line = l;
if(ierror->get_reason(&reason) == S_OK)error->reason = reason;
ierror->Release();
}
}
CWA(oleaut32, VariantClear)(&str);
}
//The object is not created, we release interface.
if(ok == false)
{
x->Release();
x = NULL;
}
}
return x;
}
///////////////////////////////////////////////////////
// RADEventsXML::Populate
//
// Update the XML document on this object from the external
// persistent representation (a file). Then,
// for each RADEvent object extracted from the current XML document,
// insert it on the RADEventsList. Note: the list is not
// emptied or cleared prior to processing.
//
// Input/Output:
// rel - the RADEventsList instance that is populated from
// an XML document.
//
///////////////////////////////////////////////////////
void RADEventsXML::Populate(RADEventsList& rel)
{
/* using the path and file name,
find the XML file,
open it in memory,
get the event tree from it,
extract the n events on the event tree,
populate the local data structure with thr n events
*/
HRESULT hr;
IXMLDOMParseError * pObjError = NULL;
VARIANT_BOOL status;
_variant_t vSrc;
_bstr_t bstr;
_bstr_t filepath(m_fullpath);
DomFromCOM();
if (!m_pXMLDom) goto clean;
vSrc = m_fullpath;
hr = m_pXMLDom->load(vSrc, &status);
if(status!=VARIANT_TRUE)
{
hr = m_pXMLDom->get_parseError(&pObjError);
VARIANT varValue;
::VariantInit(&varValue);
hr = pObjError->get_reason( &(varValue.bstrVal));
dprintf("Failed to load DOM from %s. %S\n",m_fullpath, varValue.bstrVal);
::VariantClear(&varValue);
goto clean;
}
if (m_pIRNode)
m_pIRNode->Release();
m_pIRNode = NULL;
bstr = m_xirevspath;
HRCALL(m_pXMLDom->selectSingleNode(bstr, &m_pIRNode), "selectSingleNode");
if (m_pIRNode)
{
ProcessEvents(rel, true);
}
clean:
if (pObjError)
pObjError->Release();
}
// Helper function to display parse error.
// It returns error code of the parse error.
HRESULT XMLHelper::ReportParseError(IXMLDOMDocument *pDoc, char *szDesc)
{
HRESULT hr = S_OK;
HRESULT hrRet = E_FAIL; // Default error code if failed to get from parse error.
IXMLDOMParseError *pXMLErr = NULL;
BSTR bstrReason = NULL;
CHK_HR(pDoc->get_parseError(&pXMLErr));
CHK_HR(pXMLErr->get_errorCode(&hrRet));
CHK_HR(pXMLErr->get_reason(&bstrReason));
printf("%s\n%S\n", szDesc, bstrReason);
CleanUp:
SAFE_RELEASE(pXMLErr);
SysFreeString(bstrReason);
return hrRet;
}
int do_CheckXML(lua_State* L)
{
CString strXml = luaL_checkstring(L,1);
HRESULT hr;
IXMLDOMDocument * pXMLDoc;
//...
hr = CoInitialize(NULL);
// Check the return value, hr...
hr = CoCreateInstance(CLSID_DOMDocument30, NULL, CLSCTX_INPROC_SERVER,
IID_IXMLDOMDocument, (void**)&pXMLDoc);
// Check the return value, hr...
VARIANT_BOOL bSuccessful;
pXMLDoc->loadXML(strXml.AllocSysString(),&bSuccessful);
int irez = 0;
if(!bSuccessful)
{
IXMLDOMParseError *pIParseError = NULL;
pXMLDoc->get_parseError(&pIParseError);
long lineNum;
pIParseError->get_line(&lineNum);
long linePos;
pIParseError->get_linepos(&linePos);
BSTR reason;
pIParseError->get_reason(&reason);
lua_pushinteger(L, lineNum);
lua_pushinteger(L, linePos);
lua_pushstring(L, CString(reason));
pIParseError->Release();
pIParseError = NULL;
irez = 3;
}
pXMLDoc->Release();
return irez;
}
bool CNtlXMLDoc::Load(WCHAR* pwszFileName )
{
if (false != m_bIsFileLoaded)
return false;
VARIANT_BOOL status = VARIANT_FALSE;
HRESULT hResult = m_pXMLDocument->load((_variant_t)pwszFileName, &status);
if (FAILED(hResult))
{
return false;
}
if (VARIANT_FALSE == status)
{
IXMLDOMParseError* pXMLError = NULL;
m_pXMLDocument->get_parseError(&pXMLError);
BSTR bstrErrorReasonString;
LONG lLineNumber = 0;
BSTR bstrSrcText;
LONG lLinePosition = 0;
pXMLError->get_srcText(&bstrSrcText);
pXMLError->get_reason(&bstrErrorReasonString);
pXMLError->get_line(&lLineNumber);
pXMLError->get_linepos(&lLinePosition);
::SysFreeString(bstrErrorReasonString);
pXMLError->Release();
return false;
}
m_bIsFileLoaded = true;
return true;
}
// Load
bool COpcXmlDocument::Load(const COpcString& cFilePath)
{
HRESULT hResult = S_OK;
VARIANT varFile;
varFile.vt = VT_BSTR;
varFile.bstrVal = SysAllocString((LPCWSTR)cFilePath);
TRY
{
// create new document instance.
if (!Init())
{
THROW_(hResult, E_FAIL);
}
// load the file.
VARIANT_BOOL bResult = VARIANT_FALSE;
hResult = m_ipDocument->load(varFile, &bResult);
if (FAILED(hResult))
{
THROW();
}
if (!bResult)
{
IXMLDOMParseError* ipError = NULL;
hResult = m_ipDocument->get_parseError(&ipError);
if (FAILED(hResult))
{
THROW_(hResult, E_FAIL);
}
BSTR bstrReason = NULL;
hResult = ipError->get_reason(&bstrReason);
if (SUCCEEDED(hResult))
{
SysFreeString(bstrReason);
}
ipError->Release();
}
// update default path.
if (!cFilePath.IsEmpty()) m_cFilePath = cFilePath;
}
CATCH
{
Clear();
}
FINALLY
{
OpcVariantClear(&varFile);
}
return SUCCEEDED(hResult);
}
