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);
}
bool SettingsXML::OpenStorage(uint access, wchar_t (&szErr)[512])
{
bool bRc = false;
bool bNeedReopen = (mp_File == NULL);
LPCWSTR pszXmlFile;
HRESULT hr = S_OK;
VARIANT_BOOL bSuccess;
IXMLDOMParseError* pErr = NULL;
VARIANT vt; VariantInit(&vt);
bool bAllowCreate = (access & KEY_WRITE) == KEY_WRITE;
szErr[0] = 0;
if (m_Storage.pszFile && *m_Storage.pszFile)
{
pszXmlFile = m_Storage.pszFile;
}
else
{
// Must be already initialized
_ASSERTE(m_Storage.pszFile && *m_Storage.pszFile);
pszXmlFile = gpConEmu->ConEmuXml();
if (!pszXmlFile || !*pszXmlFile)
{
goto wrap;
}
}
m_Storage.pszFile = pszXmlFile;
// Changed access type?
if (bNeedReopen || (mn_access != access))
{
DWORD dwAccess = GENERIC_READ;
DWORD dwMode = OPEN_EXISTING;
if ((access & KEY_WRITE) == KEY_WRITE)
{
dwAccess |= GENERIC_WRITE;
dwMode = OPEN_ALWAYS;
}
HANDLE hFile = CreateFile(pszXmlFile, dwAccess, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, dwMode, 0, 0);
// XML-файл отсутсвует
if (!hFile || (hFile == INVALID_HANDLE_VALUE))
{
goto wrap;
}
else
{
BY_HANDLE_FILE_INFORMATION bfi = {0};
if (GetFileInformationByHandle(hFile, &bfi))
{
mb_Empty = (bfi.nFileSizeHigh == 0 && bfi.nFileSizeLow == 0);
if (!mb_Empty)
{
// UTF-8 BOM? Xml DOM does not allows BOM
if (bfi.nFileSizeHigh == 0 && bfi.nFileSizeLow == 3)
{
BYTE bom[3] = {}; DWORD nRead = 0;
if (ReadFile(hFile, bom, sizeof(bom), &nRead, NULL) && (nRead == sizeof(bom))
&& (bom[0]==0xEF && bom[1]==0xBB && bom[2]==0xBF))
{
mb_Empty = true;
}
}
}
}
CloseHandle(hFile); hFile = NULL;
if (mb_Empty && bAllowCreate)
{
bNeedReopen = true;
hFile = CreateFile(pszXmlFile, GENERIC_WRITE, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_ALWAYS, 0, 0);
if (!hFile || (hFile == INVALID_HANDLE_VALUE))
{
goto wrap;
}
else
{
LPCSTR pszDefault = "<?xml version=\"1.0\" encoding=\"utf-8\"?>\r\n"
"<key name=\"Software\">\r\n"
"\t<key name=\"ConEmu\">\r\n"
"\t</key>\r\n"
"</key>\r\n";
DWORD nLen = lstrlenA(pszDefault);
WriteFile(hFile, pszDefault, nLen, &nLen, NULL);
CloseHandle(hFile);
}
hFile = NULL;
}
}
}
if (!bNeedReopen)
{
bRc = true;
goto wrap;
}
if (mb_Empty && !bAllowCreate)
goto wrap;
CloseStorage();
SAFETRY
{
_ASSERTE(mp_File == NULL);
mp_File = CreateDomDocument(szErr, countof(szErr));
if (FAILED(hr) || !mp_File)
{
//Ошибка уже в szErr
//_wsprintf(szErr, SKIPLEN(countof(szErr)) L"Can't create IID_IXMLDOMDocument!\nErrCode=0x%08X", (DWORD)hr);
goto wrap;
}
hr = mp_File->put_preserveWhiteSpace(VARIANT_TRUE);
hr = mp_File->put_async(VARIANT_FALSE);
// Загрузить xml-ку
bSuccess = VARIANT_FALSE;
vt.vt = VT_BSTR; vt.bstrVal = ::SysAllocString(pszXmlFile);
hr = mp_File->load(vt, &bSuccess);
VariantClear(&vt);
if (hr == S_FALSE)
{
mb_Empty = true; // Файл пуст (может только заголовок?)
}
else if (FAILED(hr) || !bSuccess)
{
_wsprintf(szErr, SKIPLEN(countof(szErr)) L"Failed to load ConEmu.xml!\nHR=0x%08X\n", (DWORD)hr);
hr = mp_File->get_parseError(&pErr);
if (pErr)
{
long errorCode = 0; // Contains the error code of the last parse error. Read-only.
long line = 0; // Specifies the line number that contains the error. Read-only.
long linepos = 0; // Contains the character position within the line where the error occurred. Read-only.
hr = pErr->get_errorCode(&errorCode);
hr = pErr->get_line(&line);
hr = pErr->get_linepos(&linepos);
wsprintf(szErr+_tcslen(szErr), L"XmlErrCode=%i, Line=%i, Pos=%i", errorCode, line, linepos);
}
goto wrap;
}
mn_access = access;
bRc = true;
} SAFECATCH
{
lstrcpy(szErr, L"Exception in SettingsXML::OpenStorage");
bRc = false;
}
wrap:
SafeRelease(pErr);
if (!bRc)
CloseStorage();
return bRc;
}
bool SettingsXML::OpenKey(const wchar_t *regPath, uint access, BOOL abSilent /*= FALSE*/)
{
_ASSERTE(!gpConEmu->IsResetBasicSettings() || ((access & KEY_WRITE)!=KEY_WRITE));
bool lbRc = false;
HRESULT hr = S_OK;
wchar_t szErr[512]; szErr[0] = 0;
wchar_t szName[MAX_PATH];
const wchar_t* psz = NULL;
VARIANT_BOOL bSuccess;
IXMLDOMParseError* pErr = NULL;
//IXMLDOMNodeList* pList = NULL;
IXMLDOMNode* pKey = NULL;
IXMLDOMNode* pChild = NULL;
VARIANT vt; VariantInit(&vt);
bool bAllowCreate = (access & KEY_WRITE) == KEY_WRITE;
CloseKey(); // на всякий
if (!regPath || !*regPath)
{
return false;
}
HANDLE hFile = NULL;
DWORD dwAccess = GENERIC_READ;
if ((access & KEY_WRITE) == KEY_WRITE)
dwAccess |= GENERIC_WRITE;
LPCWSTR pszXmlFile;
if (m_Storage.pszFile && *m_Storage.pszFile)
{
pszXmlFile = m_Storage.pszFile;
}
else
{
_ASSERTE(m_Storage.pszFile && *m_Storage.pszFile);
m_Storage.pszFile = pszXmlFile = gpConEmu->ConEmuXml();
}
if (!pszXmlFile || !*pszXmlFile)
{
return false;
}
hFile = CreateFile(pszXmlFile, dwAccess, FILE_SHARE_READ|FILE_SHARE_WRITE,
NULL, OPEN_EXISTING, 0, 0);
// XML-файл отсутсвует
if (hFile == INVALID_HANDLE_VALUE)
{
return false;
}
else
{
BY_HANDLE_FILE_INFORMATION bfi = {0};
if (GetFileInformationByHandle(hFile, &bfi))
mb_Empty = (bfi.nFileSizeHigh == 0 && bfi.nFileSizeLow == 0);
CloseHandle(hFile); hFile = NULL;
if (mb_Empty && bAllowCreate)
{
hFile = CreateFile(pszXmlFile, GENERIC_WRITE, FILE_SHARE_READ|FILE_SHARE_WRITE,
NULL, OPEN_EXISTING, 0, 0);
if (hFile != INVALID_HANDLE_VALUE)
{
LPCSTR pszDefault = "<?xml version=\"1.0\" encoding=\"utf-8\"?>\r\n<key name=\"Software\">\r\n\t<key name=\"ConEmu\">\r\n\t</key>\r\n</key>\r\n";
DWORD nLen = lstrlenA(pszDefault);
WriteFile(hFile, pszDefault, nLen, &nLen, NULL);
CloseHandle(hFile);
}
hFile = NULL;
}
}
if (mb_Empty && !bAllowCreate)
return false;
SAFETRY
{
_ASSERTE(mp_File == NULL);
mp_File = CreateDomDocument(szErr, countof(szErr));
if (FAILED(hr) || !mp_File)
{
//Ошибка уже в szErr
//_wsprintf(szErr, SKIPLEN(countof(szErr)) L"Can't create IID_IXMLDOMDocument!\nErrCode=0x%08X", (DWORD)hr);
goto wrap;
}
hr = mp_File->put_preserveWhiteSpace(VARIANT_TRUE);
hr = mp_File->put_async(VARIANT_FALSE);
// Загрузить xml-ку
bSuccess = VARIANT_FALSE;
vt.vt = VT_BSTR; vt.bstrVal = ::SysAllocString(pszXmlFile);
hr = mp_File->load(vt, &bSuccess);
VariantClear(&vt);
if (hr == S_FALSE)
{
mb_Empty = true; // Файл пуст (может только заголовок?)
}
else if (FAILED(hr) || !bSuccess)
{
_wsprintf(szErr, SKIPLEN(countof(szErr)) L"Failed to load ConEmu.xml!\nHR=0x%08X\n", (DWORD)hr);
hr = mp_File->get_parseError(&pErr);
if (pErr)
{
long errorCode = 0; // Contains the error code of the last parse error. Read-only.
long line = 0; // Specifies the line number that contains the error. Read-only.
long linepos = 0; // Contains the character position within the line where the error occurred. Read-only.
hr = pErr->get_errorCode(&errorCode);
hr = pErr->get_line(&line);
hr = pErr->get_linepos(&linepos);
wsprintf(szErr+_tcslen(szErr), L"XmlErrCode=%i, Line=%i, Pos=%i", errorCode, line, linepos);
}
goto wrap;
}
hr = mp_File->QueryInterface(IID_IXMLDOMNode, (void **)&pKey);
if (FAILED(hr))
{
_wsprintf(szErr, SKIPLEN(countof(szErr)) L"XML: Root node not found!\nErrCode=0x%08X", (DWORD)hr);
goto wrap;
}
mi_Level = 0;
while(*regPath)
{
// Получить следующий токен
psz = wcschr(regPath, L'\\');
if (!psz) psz = regPath + _tcslen(regPath);
lstrcpyn(szName, regPath, psz-regPath+1);
// Найти в структуре XML
pChild = FindItem(pKey, L"key", szName, bAllowCreate);
pKey->Release();
pKey = pChild; pChild = NULL;
mi_Level++;
if (!pKey)
{
if (bAllowCreate)
{
_wsprintf(szErr, SKIPLEN(countof(szErr)) L"XML: Can't create key <%s>!", szName);
}
else
{
//_wsprintf(szErr, SKIPLEN(countof(szErr)) L"XML: key <%s> not found!", szName);
szErr[0] = 0; // ошибку не показывать - настройки по умолчанию
}
goto wrap;
}
if (*psz == L'\\')
{
regPath = psz + 1;
}
else
{
break;
}
}
// Нашли, запомнили
mp_Key = pKey; pKey = NULL;
if (mp_Key)
{
SYSTEMTIME st; wchar_t szTime[32];
GetLocalTime(&st);
_wsprintf(szTime, SKIPLEN(countof(szTime)) L"%04i-%02i-%02i %02i:%02i:%02i",
st.wYear, st.wMonth, st.wDay, st.wHour, st.wMinute, st.wSecond);
SetAttr(mp_Key, L"modified", szTime);
SetAttr(mp_Key, L"build", gpConEmu->ms_ConEmuBuild);
}
lbRc = true;
} SAFECATCH
{
lstrcpy(szErr, L"Exception in SettingsXML::OpenKey");
lbRc = false;
}
wrap:
if (pErr) { pErr->Release(); pErr = NULL; }
if (pChild) { pChild->Release(); pChild = NULL; }
if (pKey) { pKey->Release(); pKey = NULL; }
if (!lbRc && szErr[0] && !abSilent)
{
MBoxA(szErr);
}
return lbRc;
}
