From 837be8df532198e24b6672eb9e0bd14a5c0fed3c Mon Sep 17 00:00:00 2001 From: George Hazan Date: Tue, 12 Feb 2019 18:17:38 +0300 Subject: UserInfoEx: old xml driver removed & replaced with new tinyxml2 --- include/m_xml.h | 5 + .../src/ex_import/classExImContactBase.h | 2 - .../src/ex_import/classExImContactXML.cpp | 96 +- .../UserInfoEx/src/ex_import/classExImContactXML.h | 15 +- plugins/UserInfoEx/src/ex_import/svc_ExImXML.cpp | 13 +- plugins/UserInfoEx/src/ex_import/tinystr.cpp | 131 -- plugins/UserInfoEx/src/ex_import/tinystr.h | 312 ---- plugins/UserInfoEx/src/ex_import/tinyxml.cpp | 1934 -------------------- plugins/UserInfoEx/src/ex_import/tinyxml.h | 1554 ---------------- plugins/UserInfoEx/src/ex_import/tinyxmlerror.cpp | 61 - plugins/UserInfoEx/src/ex_import/tinyxmlparser.cpp | 1440 --------------- plugins/UserInfoEx/src/stdafx.h | 2 - plugins/UserInfoEx/src/version.h | 2 +- 13 files changed, 59 insertions(+), 5508 deletions(-) delete mode 100644 plugins/UserInfoEx/src/ex_import/tinystr.cpp delete mode 100644 plugins/UserInfoEx/src/ex_import/tinystr.h delete mode 100644 plugins/UserInfoEx/src/ex_import/tinyxml.cpp delete mode 100644 plugins/UserInfoEx/src/ex_import/tinyxml.h delete mode 100644 plugins/UserInfoEx/src/ex_import/tinyxmlerror.cpp delete mode 100644 plugins/UserInfoEx/src/ex_import/tinyxmlparser.cpp diff --git a/include/m_xml.h b/include/m_xml.h index a35997c7f4..1c8dffc1f5 100644 --- a/include/m_xml.h +++ b/include/m_xml.h @@ -39,6 +39,11 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. #include "../src/mir_core/src/tinyxml2.h" +typedef tinyxml2::XMLNode TiXmlNode; +typedef tinyxml2::XMLText TiXmlText; +typedef tinyxml2::XMLElement TiXmlElement; +typedef tinyxml2::XMLDocument TiXmlDocument; + ///////////////////////////////////////////////////////////////////////////////////////// // old API to be removed once diff --git a/plugins/UserInfoEx/src/ex_import/classExImContactBase.h b/plugins/UserInfoEx/src/ex_import/classExImContactBase.h index e34d77d338..4894d09bae 100644 --- a/plugins/UserInfoEx/src/ex_import/classExImContactBase.h +++ b/plugins/UserInfoEx/src/ex_import/classExImContactBase.h @@ -21,8 +21,6 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. #pragma once -HANDLE CListFindGroup(LPCSTR pszGroup); - class CExImContactBase { BYTE compareUID(DBVARIANT *dbv); diff --git a/plugins/UserInfoEx/src/ex_import/classExImContactXML.cpp b/plugins/UserInfoEx/src/ex_import/classExImContactXML.cpp index b349ab7b71..d30973d337 100644 --- a/plugins/UserInfoEx/src/ex_import/classExImContactXML.cpp +++ b/plugins/UserInfoEx/src/ex_import/classExImContactXML.cpp @@ -96,7 +96,7 @@ BYTE CExImContactXML::IsContactInfo(LPCSTR pszKey) /** * name: CreateXmlNode * class: CExImContactXML -* desc: creates a new TiXmlElement representing the contact +* desc: creates a _xmlDoc.NewElement representing the contact * whose information are stored in this class * param: none * return: pointer to the newly created TiXmlElement @@ -106,34 +106,31 @@ TiXmlElement* CExImContactXML::CreateXmlElement() { if (_hContact) { if (_pszProto) { - _xmlNode = new TiXmlElement(XKEY_CONTACT); + _xmlDoc.InsertEndChild(_xmlNode = _xmlDoc.NewElement(XKEY_CONTACT)); - if (_xmlNode) { - LPSTR pszUID = uid2String(TRUE); - _xmlNode->SetAttribute("ampro", _pszAMPro); - _xmlNode->SetAttribute("proto", _pszProto); + LPSTR pszUID = uid2String(TRUE); + _xmlNode->SetAttribute("ampro", _pszAMPro); + _xmlNode->SetAttribute("proto", _pszProto); - if (_pszDisp) _xmlNode->SetAttribute("disp", _pszDisp); - if (_pszNick) _xmlNode->SetAttribute("nick", _pszNick); - if (_pszGroup) _xmlNode->SetAttribute("group", _pszGroup); + if (_pszDisp) _xmlNode->SetAttribute("disp", _pszDisp); + if (_pszNick) _xmlNode->SetAttribute("nick", _pszNick); + if (_pszGroup) _xmlNode->SetAttribute("group", _pszGroup); - if (pszUID) { - - if (_pszUIDKey) { - _xmlNode->SetAttribute("uidk", _pszUIDKey); - _xmlNode->SetAttribute("uidv", pszUID); - } - else { - _xmlNode->SetAttribute("uidk", "#NV"); - _xmlNode->SetAttribute("uidv", "UNLOADED"); - } - mir_free(pszUID); + if (pszUID) { + if (_pszUIDKey) { + _xmlNode->SetAttribute("uidk", _pszUIDKey); + _xmlNode->SetAttribute("uidv", pszUID); } + else { + _xmlNode->SetAttribute("uidk", "#NV"); + _xmlNode->SetAttribute("uidv", "UNLOADED"); + } + mir_free(pszUID); } } else _xmlNode = nullptr; } - else _xmlNode = new TiXmlElement(XKEY_OWNER); + else _xmlDoc.InsertEndChild(_xmlNode = _xmlDoc.NewElement(XKEY_OWNER)); return _xmlNode; } @@ -184,7 +181,6 @@ int CExImContactXML::ExportSubContact(CExImContactXML *vMetaContact, DB::CEnumLi if (!_xmlNode->NoChildren() && vMetaContact->_xmlNode->LinkEndChild(_xmlNode)) return ERROR_OK; - delete _xmlNode; return ERROR_NOT_ADDED; } @@ -232,15 +228,17 @@ int CExImContactXML::Export(FILE *xmlfile, DB::CEnumList* pModules) // add xContact to document if (_xmlNode->NoChildren()) { - delete _xmlNode; _xmlNode = nullptr; + _xmlDoc.Clear(); return ERROR_NOT_ADDED; } - _xmlNode->Print(xmlfile, 1); + + tinyxml2::XMLPrinter printer(xmlfile, false); + _xmlDoc.Print(&printer); fputc('\n', xmlfile); - delete _xmlNode; _xmlNode = nullptr; + _xmlDoc.Clear(); return ERROR_OK; } @@ -260,7 +258,7 @@ int CExImContactXML::ExportModule(LPCSTR pszModule) return ERROR_INVALID_PARAMS; if (!Settings.EnumSettings(_hContact, pszModule)) { - TiXmlElement *xmod = new TiXmlElement(XKEY_MOD); + TiXmlElement *xmod = _xmlDoc.NewElement(XKEY_MOD); if (!xmod) return ERROR_MEMORY_ALLOC; @@ -270,8 +268,6 @@ int CExImContactXML::ExportModule(LPCSTR pszModule) if (!xmod->NoChildren() && _xmlNode->LinkEndChild(xmod)) return ERROR_OK; - - delete xmod; } return ERROR_EMPTY_MODULE; @@ -302,17 +298,17 @@ int CExImContactXML::ExportSetting(TiXmlElement *xmlModule, LPCSTR pszModule, LP case DBVT_BYTE: //'b' bVal and cVal are valid buf[0] = 'b'; _ultoa(dbv.bVal, buf + 1, 10); - xmlValue = new TiXmlText(buf); + xmlValue = _xmlDoc.NewText(buf); break; case DBVT_WORD: //'w' wVal and sVal are valid buf[0] = 'w'; _ultoa(dbv.wVal, buf + 1, 10); - xmlValue = new TiXmlText(buf); + xmlValue = _xmlDoc.NewText(buf); break; case DBVT_DWORD: //'d' dVal and lVal are valid buf[0] = 'd'; _ultoa(dbv.dVal, buf + 1, 10); - xmlValue = new TiXmlText(buf); + xmlValue = _xmlDoc.NewText(buf); break; case DBVT_ASCIIZ: //'s' pszVal is valid if (mir_IsEmptyA(dbv.pszVal)) break; @@ -320,7 +316,7 @@ int CExImContactXML::ExportSetting(TiXmlElement *xmlModule, LPCSTR pszModule, LP if (str = (LPSTR)mir_alloc(mir_strlen(dbv.pszVal) + 2)) { str[0] = 's'; mir_strcpy(&str[1], dbv.pszVal); - xmlValue = new TiXmlText(str); + xmlValue = _xmlDoc.NewText(str); mir_free(str); } break; @@ -329,7 +325,7 @@ int CExImContactXML::ExportSetting(TiXmlElement *xmlModule, LPCSTR pszModule, LP if (str = (LPSTR)mir_alloc(mir_strlen(dbv.pszVal) + 2)) { str[0] = 'u'; mir_strcpy(&str[1], dbv.pszVal); - xmlValue = new TiXmlText(str); + xmlValue = _xmlDoc.NewText(str); mir_free(str); } break; @@ -339,7 +335,7 @@ int CExImContactXML::ExportSetting(TiXmlElement *xmlModule, LPCSTR pszModule, LP if (str = (LPSTR)mir_alloc(mir_strlen(dbv.pszVal) + 2)) { str[0] = 'u'; mir_strcpy(&str[1], dbv.pszVal); - xmlValue = new TiXmlText(str); + xmlValue = _xmlDoc.NewText(str); mir_free(str); } break; @@ -353,7 +349,7 @@ int CExImContactXML::ExportSetting(TiXmlElement *xmlModule, LPCSTR pszModule, LP if (mir_base64_encodebuf(dbv.pbVal, dbv.cpbVal, str+1, baselen)) { str[baselen+1] = 0; str[0] = 'n'; - xmlValue = new TiXmlText(str); + xmlValue = _xmlDoc.NewText(str); } mir_free(str); } @@ -367,14 +363,12 @@ int CExImContactXML::ExportSetting(TiXmlElement *xmlModule, LPCSTR pszModule, LP } db_free(&dbv); if (xmlValue) { - xmlEntry = new TiXmlElement(XKEY_SET); + xmlEntry = _xmlDoc.NewElement(XKEY_SET); if (xmlEntry) { xmlEntry->SetAttribute("key", pszSetting); if (xmlEntry->LinkEndChild(xmlValue) && xmlModule->LinkEndChild(xmlEntry)) return ERROR_OK; - delete xmlEntry; } - delete xmlValue; } return ERROR_MEMORY_ALLOC; } @@ -404,13 +398,13 @@ BYTE CExImContactXML::ExportEvents() // encode data LPSTR pBase64Data = mir_base64_encode(dbei.pBlob, dbei.cbBlob); if (pBase64Data) { - TiXmlElement *xmlEvent = new TiXmlElement("evt"); + TiXmlElement *xmlEvent = _xmlDoc.NewElement("evt"); if (xmlEvent) { xmlEvent->SetAttribute("type", dbei.eventType); - xmlEvent->SetAttribute("time", dbei.timestamp); - xmlEvent->SetAttribute("flag", dbei.flags); + xmlEvent->SetAttribute("time", (int)dbei.timestamp); + xmlEvent->SetAttribute("flag", (int)dbei.flags); - TiXmlText *xmlText = new TiXmlText(pBase64Data); + TiXmlText *xmlText = _xmlDoc.NewText(pBase64Data); xmlEvent->LinkEndChild(xmlText); // find module @@ -421,7 +415,7 @@ BYTE CExImContactXML::ExportEvents() // create new module if (!xmlModule) { - xmlModule = _xmlNode->InsertEndChild(TiXmlElement(XKEY_MOD)); + xmlModule = _xmlNode->InsertEndChild(_xmlDoc.NewElement(XKEY_MOD)); if (!xmlModule) break; ((TiXmlElement*)xmlModule)->SetAttribute("key", dbei.szModule); @@ -452,9 +446,7 @@ void CExImContactXML::CountKeys(DWORD &numSettings, DWORD &numEvents) { numSettings = numEvents = 0; - for (TiXmlNode *xmod = _xmlNode->FirstChild(); - xmod != nullptr; - xmod = xmod->NextSibling(XKEY_MOD)) { + for (TiXmlNode *xmod = _xmlNode->FirstChild(); xmod != nullptr; xmod = xmod->NextSiblingElement(XKEY_MOD)) { for (TiXmlNode *xkey = xmod->FirstChild(); xkey != nullptr; xkey = xkey->NextSibling()) { @@ -592,7 +584,7 @@ int CExImContactXML::ImportContact() _pXmlFile->_numEventsTodo += numEvents; // import all modules - for (TiXmlNode *xmod = _xmlNode->FirstChild(); xmod != nullptr; xmod = xmod->NextSibling(XKEY_MOD)) { + for (TiXmlNode *xmod = _xmlNode->FirstChild(); xmod != nullptr; xmod = xmod->NextSiblingElement(XKEY_MOD)) { // import module if (ImportModule(xmod) == ERROR_ABORTED) { // ask to delete new incomplete contact @@ -854,7 +846,7 @@ int CExImContactXML::ImportSetting(LPCSTR pszModule, TiXmlElement *xmlEntry) // validate value TiXmlText* xval = (TiXmlText*)xmlEntry->FirstChild(); - if (!xval || xval->Type() != TiXmlText::TEXT) + if (!xval || xval->ToText() == nullptr) return ERROR_INVALID_VALUE; LPCSTR value = xval->Value(); @@ -935,12 +927,12 @@ int CExImContactXML::ImportEvent(LPCSTR pszModule, TiXmlElement *xmlEvent) // timestamp must be valid DBEVENTINFO dbei = {}; - xmlEvent->Attribute("time", (LPINT)&dbei.timestamp); + xmlEvent->SetAttribute("time", (LPINT)&dbei.timestamp); if (dbei.timestamp == 0) return ERROR_INVALID_TIMESTAMP; TiXmlText *xmlValue = (TiXmlText*)xmlEvent->FirstChild(); - if (!xmlValue || xmlValue->Type() != TiXmlText::TEXT) + if (!xmlValue || xmlValue->ToText() == nullptr) return ERROR_INVALID_VALUE; LPCSTR tmp = xmlValue->Value(); @@ -955,8 +947,8 @@ int CExImContactXML::ImportEvent(LPCSTR pszModule, TiXmlElement *xmlEvent) dbei.cbBlob = (WORD)baselen; dbei.szModule = (LPSTR)pszModule; - xmlEvent->Attribute("type", (LPINT)&dbei.eventType); - xmlEvent->Attribute("flag", (LPINT)&dbei.flags); + xmlEvent->SetAttribute("type", (LPINT)&dbei.eventType); + xmlEvent->SetAttribute("flag", (LPINT)&dbei.flags); if (dbei.flags == 0) dbei.flags = DBEF_READ; diff --git a/plugins/UserInfoEx/src/ex_import/classExImContactXML.h b/plugins/UserInfoEx/src/ex_import/classExImContactXML.h index 7b2a255929..29c92a3e6e 100644 --- a/plugins/UserInfoEx/src/ex_import/classExImContactXML.h +++ b/plugins/UserInfoEx/src/ex_import/classExImContactXML.h @@ -45,11 +45,12 @@ enum EError { ERROR_EMPTY_MODULE = 13 }; -class CExImContactXML : public CExImContactBase { - - CFileXml *_pXmlFile; // the xmlfile - TiXmlElement *_xmlNode; // xmlnode with contact information - MEVENT _hEvent; +class CExImContactXML : public CExImContactBase +{ + CFileXml *_pXmlFile; // the xmlfile + TiXmlDocument _xmlDoc; + TiXmlElement *_xmlNode; // xmlnode with contact information + MEVENT _hEvent; BYTE IsContactInfo(LPCSTR pszKey); @@ -60,12 +61,12 @@ class CExImContactXML : public CExImContactBase { int ImportContact(); int ImportNormalContact(); int ImportMetaSubContact(CExImContactXML * pMetaContact); - void CountKeys(DWORD &numSettings, DWORD &numEvents); + void CountKeys(DWORD &numSettings, DWORD &numEvents); // private exporting methods int ExportModule(LPCSTR pszModule); int ExportSetting(TiXmlElement *xmlModule, LPCSTR pszModule, LPCSTR pszSetting); - BYTE ExportEvents(); + BYTE ExportEvents(); int ExportContact(DB::CEnumList* pModules); int ExportSubContact(CExImContactXML *vMetaContact, DB::CEnumList* pModules); diff --git a/plugins/UserInfoEx/src/ex_import/svc_ExImXML.cpp b/plugins/UserInfoEx/src/ex_import/svc_ExImXML.cpp index 067210b013..390af4034f 100644 --- a/plugins/UserInfoEx/src/ex_import/svc_ExImXML.cpp +++ b/plugins/UserInfoEx/src/ex_import/svc_ExImXML.cpp @@ -346,7 +346,7 @@ int CFileXml::Import(MCONTACT hContact, LPCSTR pszFileName) TiXmlDocument doc; if (!doc.LoadFile(pszFileName)) { MsgErr(nullptr, LPGENW("Parser is unable to load XMLCard \"%s\"\nError: %d\nDescription: %s"), - pszFileName, doc.ErrorId(), doc.ErrorDesc()); + pszFileName, doc.ErrorID(), doc.Error()); return 1; } // is xmlfile a XMLCard ? @@ -384,12 +384,6 @@ int CFileXml::Import(MCONTACT hContact, LPCSTR pszFileName) } } else { -#ifdef _DEBUG - LARGE_INTEGER freq, t1, t2; - - QueryPerformanceFrequency(&freq); - QueryPerformanceCounter(&t1); -#endif // count contacts in file for progress bar _numContactsTodo = CountContacts(xmlCard); if (_numContactsTodo > 0) { @@ -404,11 +398,6 @@ int CFileXml::Import(MCONTACT hContact, LPCSTR pszFileName) // finally hide the progress dialog _progress.Hide(); -#ifdef _DEBUG - QueryPerformanceCounter(&t2); - MsgErr(nullptr, LPGENW("Import took %f ms"), - (long double)(t2.QuadPart - t1.QuadPart) / freq.QuadPart * 1000.); -#endif // show results MsgBox(nullptr, MB_ICONINFORMATION, LPGENW("Import complete"), LPGENW("Some basic statistics"), LPGENW("added contacts: %u / %u\nadded settings: %u / %u\nadded events %u / %u\nduplicated events: %u"), diff --git a/plugins/UserInfoEx/src/ex_import/tinystr.cpp b/plugins/UserInfoEx/src/ex_import/tinystr.cpp deleted file mode 100644 index 5414a2d95f..0000000000 --- a/plugins/UserInfoEx/src/ex_import/tinystr.cpp +++ /dev/null @@ -1,131 +0,0 @@ -/* -www.sourceforge.net/projects/tinyxml -Original file by Yves Berquin. - -This software is provided 'as-is', without any express or implied -warranty. In no event will the authors be held liable for any -damages arising from the use of this software. - -Permission is granted to anyone to use this software for any -purpose, including commercial applications, and to alter it and -redistribute it freely, subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must -not claim that you wrote the original software. If you use this -software in a product, an acknowledgment in the product documentation -would be appreciated but is not required. - -2. Altered source versions must be plainly marked as such, and -must not be misrepresented as being the original software. - -3. This notice may not be removed or altered from any source -distribution. -*/ - -/* - * THIS FILE WAS ALTERED BY Tyge Lovset, 7. April 2005. - * - * - completely rewritten. compact, clean, and fast implementation. - * - sizeof(TiXmlString) = pointer size (4 bytes on 32-bit systems) - * - fixed reserve() to work as per specification. - * - fixed buggy compares operator==(), operator<(), and operator>() - * - fixed operator+=() to take a const ref argument, following spec. - * - added "copy" constructor with length, and most compare operators. - * - added swap(), clear(), size(), capacity(), operator+(). - -=============================================================================== - -UserinfoEx plugin for Miranda IM - -Copyright: -© 2006-2010 DeathAxe, Yasnovidyashii, Merlin, K. Romanov, Kreol -=============================================================================== - */ - -#include "../stdafx.h" - -#ifndef TIXML_USE_STL - - -// Error value for find primitive -const TiXmlString::size_type TiXmlString::npos = static_cast< size_type >(-1); - -// Null rep. -TiXmlString::Rep TiXmlString::nullrep_ = { 0, 0, '\0' }; - - -void TiXmlString::reserve (size_type cap) -{ - if (cap > capacity()) - { - TiXmlString tmp; - tmp.init(length(), cap); - memcpy(tmp.start(), data(), length()); - swap(tmp); - } -} - - -TiXmlString& TiXmlString::assign(const char* str, size_type len) -{ - size_type cap = capacity(); - if (len > cap || cap > 3*(len + 8)) - { - TiXmlString tmp; - tmp.init(len); - memcpy(tmp.start(), str, len); - swap(tmp); - } - else - { - memmove(start(), str, len); - set_size(len); - } - return *this; -} - - -TiXmlString& TiXmlString::append(const char* str, size_type len) -{ - size_type newsize = length() + len; - if (newsize > capacity()) - { - reserve (newsize + capacity()); - } - memmove(finish(), str, len); - set_size(newsize); - return *this; -} - - -TiXmlString operator + (const TiXmlString & a, const TiXmlString & b) -{ - TiXmlString tmp; - tmp.reserve(a.length() + b.length()); - tmp += a; - tmp += b; - return tmp; -} - -TiXmlString operator + (const TiXmlString & a, const char* b) -{ - TiXmlString tmp; - TiXmlString::size_type b_len = static_cast(mir_strlen(b)); - tmp.reserve(a.length() + b_len); - tmp += a; - tmp.append(b, b_len); - return tmp; -} - -TiXmlString operator + (const char* a, const TiXmlString & b) -{ - TiXmlString tmp; - TiXmlString::size_type a_len = static_cast(mir_strlen(a)); - tmp.reserve(a_len + b.length()); - tmp.append(a, a_len); - tmp += b; - return tmp; -} - - -#endif // TIXML_USE_STL diff --git a/plugins/UserInfoEx/src/ex_import/tinystr.h b/plugins/UserInfoEx/src/ex_import/tinystr.h deleted file mode 100644 index 3f5dbf9308..0000000000 --- a/plugins/UserInfoEx/src/ex_import/tinystr.h +++ /dev/null @@ -1,312 +0,0 @@ -/* -www.sourceforge.net/projects/tinyxml -Original file by Yves Berquin. - -This software is provided 'as-is', without any express or implied -warranty. In no event will the authors be held liable for any -damages arising from the use of this software. - -Permission is granted to anyone to use this software for any -purpose, including commercial applications, and to alter it and -redistribute it freely, subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must -not claim that you wrote the original software. If you use this -software in a product, an acknowledgment in the product documentation -would be appreciated but is not required. - -2. Altered source versions must be plainly marked as such, and -must not be misrepresented as being the original software. - -3. This notice may not be removed or altered from any source -distribution. -*/ - -/* - * THIS FILE WAS ALTERED BY Tyge Lovset, 7. April 2005. - * - * - completely rewritten. compact, clean, and fast implementation. - * - sizeof(TiXmlString) = pointer size (4 bytes on 32-bit systems) - * - fixed reserve() to work as per specification. - * - fixed buggy compares operator==(), operator<(), and operator>() - * - fixed operator+=() to take a const ref argument, following spec. - * - added "copy" constructor with length, and most compare operators. - * - added swap(), clear(), size(), capacity(), operator+(). - -=============================================================================== - -UserinfoEx plugin for Miranda IM - -Copyright: -© 2006-2010 DeathAxe, Yasnovidyashii, Merlin, K. Romanov, Kreol -=============================================================================== - */ - -#ifndef TIXML_USE_STL - -#ifndef TIXML_STRING_INCLUDED -#define TIXML_STRING_INCLUDED - - -#define TIXML_EXPLICIT explicit - -/* - TiXmlString is an emulation of a subset of the std::string template. - Its purpose is to allow compiling TinyXML on compilers with no or poor STL support. - Only the member functions relevant to the TinyXML project have been implemented. - The buffer allocation is made by a simplistic power of 2 like mechanism : if we increase - a string and there's no more room, we allocate a buffer twice as big as we need. -*/ -class TiXmlString -{ - public : - // The size type used - typedef size_t size_type; - - // Error value for find primitive - static const size_type npos; // = -1; - - - // TiXmlString empty constructor - TiXmlString () : rep_(&nullrep_) - { - } - - // TiXmlString copy constructor - TiXmlString (const TiXmlString & copy) - { - init(copy.length()); - memcpy(start(), copy.data(), length()); - } - - // TiXmlString constructor, based on a string - TIXML_EXPLICIT TiXmlString (const char * copy) - { - init(static_cast(mir_strlen(copy))); - memcpy(start(), copy, length()); - } - - // TiXmlString constructor, based on a string - TIXML_EXPLICIT TiXmlString (const char * str, size_type len) - { - init(len); - memcpy(start(), str, len); - } - - // TiXmlString destructor - ~TiXmlString () - { - quit(); - } - - // = operator - TiXmlString& operator=(const char * copy) - { - return assign(copy, (size_type)mir_strlen(copy)); - } - - // = operator - TiXmlString& operator=(const TiXmlString & copy) - { - return assign(copy.start(), copy.length()); - } - - - // += operator. Maps to append - TiXmlString& operator+=(const char * suffix) - { - return append(suffix, static_cast(mir_strlen(suffix))); - } - - // += operator. Maps to append - TiXmlString& operator+=(char single) - { - return append(&single, 1); - } - - // += operator. Maps to append - TiXmlString& operator+=(const TiXmlString & suffix) - { - return append(suffix.data(), suffix.length()); - } - - - // Convert a TiXmlString into a null-terminated char * - const char * c_str () const { return rep_->str; } - - // Convert a TiXmlString into a char * (need not be null terminated). - const char * data () const { return rep_->str; } - - // Return the length of a TiXmlString - size_type length () const { return rep_->size; } - - // Alias for length() - size_type size () const { return rep_->size; } - - // Checks if a TiXmlString is empty - bool empty () const { return rep_->size == 0; } - - // Return capacity of string - size_type capacity () const { return rep_->capacity; } - - - // single char extraction - const char& at (size_type index) const - { - assert(index < length()); - return rep_->str[ index ]; - } - - // [] operator - char& operator [] (size_type index) const - { - assert(index < length()); - return rep_->str[ index ]; - } - - // find a char in a string. Return TiXmlString::npos if not found - size_type find (char lookup) const - { - return find(lookup, 0); - } - - // find a char in a string from an offset. Return TiXmlString::npos if not found - size_type find (char tofind, size_type offset) const - { - if (offset >= length()) return npos; - - for (const char* p = c_str() + offset; *p != '\0'; ++p) - { - if (*p == tofind) return static_cast< size_type >(p - c_str()); - } - return npos; - } - - void clear () - { - //Lee: - //The original was just too strange, though correct: - // TiXmlString().swap(*this); - //Instead use the quit & re-init: - quit(); - init(0,0); - } - - /* Function to reserve a big amount of data when we know we'll need it. Be aware that this - function DOES NOT clear the content of the TiXmlString if any exists. - */ - void reserve (size_type cap); - - TiXmlString& assign (const char* str, size_type len); - - TiXmlString& append (const char* str, size_type len); - - void swap (TiXmlString& other) - { - Rep* r = rep_; - rep_ = other.rep_; - other.rep_ = r; - } - - private: - - void init(size_type sz) { init(sz, sz); } - void set_size(size_type sz) { rep_->str[ rep_->size = sz ] = '\0'; } - char* start() const { return rep_->str; } - char* finish() const { return rep_->str + rep_->size; } - - struct Rep - { - size_type size, capacity; - char str[1]; - }; - - void init(size_type sz, size_type cap) - { - if (cap) - { - // Lee: the original form: - // rep_ = static_cast(operator new(sizeof(Rep) + cap)); - // doesn't work in some cases of new being overloaded. Switching - // to the normal allocation, although use an 'int' for systems - // that are overly picky about structure alignment. - const size_type bytesNeeded = sizeof(Rep) + cap; - const size_type intsNeeded = (bytesNeeded + sizeof(int) - 1) / sizeof(int); - rep_ = reinterpret_cast(new int[ intsNeeded ]); - - rep_->str[ rep_->size = sz ] = '\0'; - rep_->capacity = cap; - } - else - { - rep_ = &nullrep_; - } - } - - void quit() - { - if (rep_ != &nullrep_) - { - // The rep_ is really an array of ints. (see the allocator, above). - // Cast it back before delete, so the compiler won't incorrectly call destructors. - delete [] (reinterpret_cast(rep_)); - } - } - - Rep * rep_; - static Rep nullrep_; - -} ; - - -inline bool operator == (const TiXmlString & a, const TiXmlString & b) -{ - return (a.length() == b.length()) // optimization on some platforms - && (mir_strcmp(a.c_str(), b.c_str()) == 0); // actual compare -} -inline bool operator < (const TiXmlString & a, const TiXmlString & b) -{ - return mir_strcmp(a.c_str(), b.c_str()) < 0; -} - -inline bool operator != (const TiXmlString & a, const TiXmlString & b) { return !(a == b); } -inline bool operator > (const TiXmlString & a, const TiXmlString & b) { return b < a; } -inline bool operator <= (const TiXmlString & a, const TiXmlString & b) { return !(b < a); } -inline bool operator >= (const TiXmlString & a, const TiXmlString & b) { return !(a < b); } - -inline bool operator == (const TiXmlString & a, const char* b) { return mir_strcmp(a.c_str(), b) == 0; } -inline bool operator == (const char* a, const TiXmlString & b) { return b == a; } -inline bool operator != (const TiXmlString & a, const char* b) { return !(a == b); } -inline bool operator != (const char* a, const TiXmlString & b) { return !(b == a); } - -TiXmlString operator + (const TiXmlString & a, const TiXmlString & b); -TiXmlString operator + (const TiXmlString & a, const char* b); -TiXmlString operator + (const char* a, const TiXmlString & b); - - -/* - TiXmlOutStream is an emulation of std::ostream. It is based on TiXmlString. - Only the operators that we need for TinyXML have been developped. -*/ -class TiXmlOutStream : public TiXmlString -{ -public : - - // TiXmlOutStream << operator. - TiXmlOutStream & operator << (const TiXmlString & in) - { - *this += in; - return *this; - } - - // TiXmlOutStream << operator. - TiXmlOutStream & operator << (const char * in) - { - *this += in; - return *this; - } - -} ; - -#endif // TIXML_STRING_INCLUDED -#endif // TIXML_USE_STL diff --git a/plugins/UserInfoEx/src/ex_import/tinyxml.cpp b/plugins/UserInfoEx/src/ex_import/tinyxml.cpp deleted file mode 100644 index bfd6707659..0000000000 --- a/plugins/UserInfoEx/src/ex_import/tinyxml.cpp +++ /dev/null @@ -1,1934 +0,0 @@ -/* -www.sourceforge.net/projects/tinyxml -Original code (2.0 and earlier)copyright (c) 2000-2002 Lee Thomason (www.grinninglizard.com) - -This software is provided 'as-is', without any express or implied -warranty. In no event will the authors be held liable for any -damages arising from the use of this software. - -Permission is granted to anyone to use this software for any -purpose, including commercial applications, and to alter it and -redistribute it freely, subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must -not claim that you wrote the original software. If you use this -software in a product, an acknowledgment in the product documentation -would be appreciated but is not required. - -2. Altered source versions must be plainly marked as such, and -must not be misrepresented as being the original software. - -3. This notice may not be removed or altered from any source -distribution. - -=============================================================================== - -UserinfoEx plugin for Miranda IM - -Copyright: -© 2006-2010 DeathAxe, Yasnovidyashii, Merlin, K. Romanov, Kreol -=============================================================================== - */ - -#include "../stdafx.h" - -bool TiXmlBase::condenseWhiteSpace = true; - -void TiXmlBase::StreamDepth(TIXML_OSTREAM* stream, int depth) const -{ - for (int i = 0; i < depth; ++i) - { - (*stream) << " "; - } -} - -void TiXmlBase::PutString(const TIXML_STRING& str, TIXML_OSTREAM* stream) -{ - TIXML_STRING buffer; - PutString(str, &buffer); - (*stream) << buffer; -} - -void TiXmlBase::PutString(const TIXML_STRING& str, TIXML_STRING* outString) -{ - int i=0; - - while (i<(int)str.length()) - { - unsigned char c = (unsigned char) str[i]; - - if ( c == '&' - && i < ((int)str.length() - 2) - && str[i+1] == '#' - && str[i+2] == 'x') - { - // Hexadecimal character reference. - // Pass through unchanged. - // © -- copyright symbol, for example. - // - // The -1 is a bug fix from Rob Laveaux. It keeps - // an overflow from happening if there is no ';'. - // There are actually 2 ways to exit this loop - - // while fails (error case) and break (semicolon found). - // However, there is no mechanism (currently) for - // this function to return an error. - while (i<(int)str.length()-1) - { - outString->append(str.c_str() + i, 1); - ++i; - if (str[i] == ';') - break; - } - } - else if (c == '&') - { - outString->append(entity[0].str, entity[0].strLength); - ++i; - } - else if (c == '<') - { - outString->append(entity[1].str, entity[1].strLength); - ++i; - } - else if (c == '>') - { - outString->append(entity[2].str, entity[2].strLength); - ++i; - } - else if (c == '\"') - { - outString->append(entity[3].str, entity[3].strLength); - ++i; - } - else if (c == '\'') - { - outString->append(entity[4].str, entity[4].strLength); - ++i; - } - else if (c < 32) - { - // Easy pass at non-alpha/numeric/symbol - // Below 32 is symbolic. - char buf[32]; - mir_snprintf(buf, "&#x%02X;", (unsigned) (c & 0xff)); - - //*ME: warning C4267: convert 'size_t' to 'int' - //*ME: Int-Cast to make compiler happy ... - outString->append(buf, (int)mir_strlen(buf)); - ++i; - } - else - { - //char realc = (char) c; - //outString->append(&realc, 1); - *outString += (char) c; // somewhat more efficient function call. - ++i; - } - } -} - - -// <-- Strange class for a bug fix. Search for STL_STRING_BUG -TiXmlBase::StringToBuffer::StringToBuffer(const TIXML_STRING& str) -{ - buffer = new char[ str.length()+1 ]; - if (buffer) - { - mir_strcpy(buffer, str.c_str()); - } -} - - -TiXmlBase::StringToBuffer::~StringToBuffer() -{ - delete [] buffer; -} -// End strange bug fix. --> - - -TiXmlNode::TiXmlNode(NodeType _type) : TiXmlBase() -{ - parent = nullptr; - type = _type; - firstChild = nullptr; - lastChild = nullptr; - prev = nullptr; - next = nullptr; -} - - -TiXmlNode::~TiXmlNode() -{ - TiXmlNode* node = firstChild; - TiXmlNode* temp = nullptr; - - while (node) - { - temp = node; - node = node->next; - - delete temp; - } -} - - -void TiXmlNode::CopyTo(TiXmlNode* target) const -{ - target->SetValue (value.c_str()); - target->userData = userData; -} - - -void TiXmlNode::Clear() -{ - TiXmlNode* node = firstChild; - TiXmlNode* temp = nullptr; - - while (node) - { - temp = node; - node = node->next; - delete temp; - } - - firstChild = nullptr; - lastChild = nullptr; -} - - -TiXmlNode* TiXmlNode::LinkEndChild(TiXmlNode* node) -{ - assert(node->parent == nullptr || node->parent == this); - assert(node->GetDocument() == nullptr || node->GetDocument() == this->GetDocument()); - - if (node->Type() == TiXmlNode::DOCUMENT) - { - delete node; - if (GetDocument()) GetDocument()->SetError(TIXML_ERROR_DOCUMENT_TOP_ONLY, nullptr, nullptr, TIXML_ENCODING_UNKNOWN); - return nullptr; - } - - node->parent = this; - - node->prev = lastChild; - node->next = nullptr; - - if (lastChild) - lastChild->next = node; - else - firstChild = node; // it was an empty list. - - lastChild = node; - return node; -} - - -TiXmlNode* TiXmlNode::InsertEndChild(const TiXmlNode& addThis) -{ - if (addThis.Type() == TiXmlNode::DOCUMENT) - { - if (GetDocument()) GetDocument()->SetError(TIXML_ERROR_DOCUMENT_TOP_ONLY, nullptr, nullptr, TIXML_ENCODING_UNKNOWN); - return nullptr; - } - TiXmlNode* node = addThis.Clone(); - if (!node) - return nullptr; - - return LinkEndChild(node); -} - - -TiXmlNode* TiXmlNode::InsertBeforeChild(TiXmlNode* beforeThis, const TiXmlNode& addThis) -{ - if (!beforeThis || beforeThis->parent != this) { - return nullptr; - } - if (addThis.Type() == TiXmlNode::DOCUMENT) - { - if (GetDocument()) GetDocument()->SetError(TIXML_ERROR_DOCUMENT_TOP_ONLY, nullptr, nullptr, TIXML_ENCODING_UNKNOWN); - return nullptr; - } - - TiXmlNode* node = addThis.Clone(); - if (!node) - return nullptr; - node->parent = this; - - node->next = beforeThis; - node->prev = beforeThis->prev; - if (beforeThis->prev) - { - beforeThis->prev->next = node; - } - else - { - assert(firstChild == beforeThis); - firstChild = node; - } - beforeThis->prev = node; - return node; -} - - -TiXmlNode* TiXmlNode::InsertAfterChild(TiXmlNode* afterThis, const TiXmlNode& addThis) -{ - if (!afterThis || afterThis->parent != this) { - return nullptr; - } - if (addThis.Type() == TiXmlNode::DOCUMENT) - { - if (GetDocument()) GetDocument()->SetError(TIXML_ERROR_DOCUMENT_TOP_ONLY, nullptr, nullptr, TIXML_ENCODING_UNKNOWN); - return nullptr; - } - - TiXmlNode* node = addThis.Clone(); - if (!node) - return nullptr; - node->parent = this; - - node->prev = afterThis; - node->next = afterThis->next; - if (afterThis->next) - { - afterThis->next->prev = node; - } - else - { - assert(lastChild == afterThis); - lastChild = node; - } - afterThis->next = node; - return node; -} - - -TiXmlNode* TiXmlNode::ReplaceChild(TiXmlNode* replaceThis, const TiXmlNode& withThis) -{ - if (replaceThis->parent != this) - return nullptr; - - TiXmlNode* node = withThis.Clone(); - if (!node) - return nullptr; - - node->next = replaceThis->next; - node->prev = replaceThis->prev; - - if (replaceThis->next) - replaceThis->next->prev = node; - else - lastChild = node; - - if (replaceThis->prev) - replaceThis->prev->next = node; - else - firstChild = node; - - delete replaceThis; - node->parent = this; - return node; -} - - -bool TiXmlNode::RemoveChild(TiXmlNode* removeThis) -{ - if (removeThis->parent != this) - { - assert(0); - return false; - } - - if (removeThis->next) - removeThis->next->prev = removeThis->prev; - else - lastChild = removeThis->prev; - - if (removeThis->prev) - removeThis->prev->next = removeThis->next; - else - firstChild = removeThis->next; - - delete removeThis; - return true; -} - -const TiXmlNode* TiXmlNode::FirstChild(const char * _value) const -{ - const TiXmlNode* node; - for (node = firstChild; node; node = node->next) - { - if (mir_strcmp(node->Value(), _value) == 0) - return node; - } - return nullptr; -} - - -TiXmlNode* TiXmlNode::FirstChild(const char * _value) -{ - TiXmlNode* node; - for (node = firstChild; node; node = node->next) - { - if (mir_strcmp(node->Value(), _value) == 0) - return node; - } - return nullptr; -} - - -const TiXmlNode* TiXmlNode::LastChild(const char * _value) const -{ - const TiXmlNode* node; - for (node = lastChild; node; node = node->prev) - { - if (mir_strcmp(node->Value(), _value) == 0) - return node; - } - return nullptr; -} - -TiXmlNode* TiXmlNode::LastChild(const char * _value) -{ - TiXmlNode* node; - for (node = lastChild; node; node = node->prev) - { - if (mir_strcmp(node->Value(), _value) == 0) - return node; - } - return nullptr; -} - -const TiXmlNode* TiXmlNode::IterateChildren(const TiXmlNode* previous) const -{ - if (!previous) - { - return FirstChild(); - } - else - { - assert(previous->parent == this); - return previous->NextSibling(); - } -} - -TiXmlNode* TiXmlNode::IterateChildren(TiXmlNode* previous) -{ - if (!previous) - { - return FirstChild(); - } - else - { - assert(previous->parent == this); - return previous->NextSibling(); - } -} - -const TiXmlNode* TiXmlNode::IterateChildren(const char * val, const TiXmlNode* previous) const -{ - if (!previous) - { - return FirstChild(val); - } - else - { - assert(previous->parent == this); - return previous->NextSibling(val); - } -} - -TiXmlNode* TiXmlNode::IterateChildren(const char * val, TiXmlNode* previous) -{ - if (!previous) - { - return FirstChild(val); - } - else - { - assert(previous->parent == this); - return previous->NextSibling(val); - } -} - -const TiXmlNode* TiXmlNode::NextSibling(const char * _value) const -{ - const TiXmlNode* node; - for (node = next; node; node = node->next) - { - if (mir_strcmp(node->Value(), _value) == 0) - return node; - } - return nullptr; -} - -TiXmlNode* TiXmlNode::NextSibling(const char * _value) -{ - TiXmlNode* node; - for (node = next; node; node = node->next) - { - if (mir_strcmp(node->Value(), _value) == 0) - return node; - } - return nullptr; -} - -const TiXmlNode* TiXmlNode::PreviousSibling(const char * _value) const -{ - const TiXmlNode* node; - for (node = prev; node; node = node->prev) - { - if (mir_strcmp(node->Value(), _value) == 0) - return node; - } - return nullptr; -} - -TiXmlNode* TiXmlNode::PreviousSibling(const char * _value) -{ - TiXmlNode* node; - for (node = prev; node; node = node->prev) - { - if (mir_strcmp(node->Value(), _value) == 0) - return node; - } - return nullptr; -} - -void TiXmlElement::RemoveAttribute(const char * name) -{ - TIXML_STRING str(name); - TiXmlAttribute* node = attributeSet.Find(str); - if (node) - { - attributeSet.Remove(node); - delete node; - } -} - -const TiXmlElement* TiXmlNode::FirstChildElement() const -{ - const TiXmlNode* node; - - for ( node = FirstChild(); - node; - node = node->NextSibling()) - { - if (node->ToElement()) - return node->ToElement(); - } - return nullptr; -} - -TiXmlElement* TiXmlNode::FirstChildElement() -{ - TiXmlNode* node; - - for ( node = FirstChild(); - node; - node = node->NextSibling()) - { - if (node->ToElement()) - return node->ToElement(); - } - return nullptr; -} - -const TiXmlElement* TiXmlNode::FirstChildElement(const char * _value) const -{ - const TiXmlNode* node; - - for ( node = FirstChild(_value); - node; - node = node->NextSibling(_value)) - { - if (node->ToElement()) - return node->ToElement(); - } - return nullptr; -} - -TiXmlElement* TiXmlNode::FirstChildElement(const char * _value) -{ - TiXmlNode* node; - - for ( node = FirstChild(_value); - node; - node = node->NextSibling(_value)) - { - if (node->ToElement()) - return node->ToElement(); - } - return nullptr; -} - -const TiXmlElement* TiXmlNode::NextSiblingElement() const -{ - const TiXmlNode* node; - - for ( node = NextSibling(); - node; - node = node->NextSibling()) - { - if (node->ToElement()) - return node->ToElement(); - } - return nullptr; -} - -TiXmlElement* TiXmlNode::NextSiblingElement() -{ - TiXmlNode* node; - - for ( node = NextSibling(); - node; - node = node->NextSibling()) - { - if (node->ToElement()) - return node->ToElement(); - } - return nullptr; -} - -const TiXmlElement* TiXmlNode::NextSiblingElement(const char * _value) const -{ - const TiXmlNode* node; - - for ( node = NextSibling(_value); - node; - node = node->NextSibling(_value)) - { - if (node->ToElement()) - return node->ToElement(); - } - return nullptr; -} - -TiXmlElement* TiXmlNode::NextSiblingElement(const char * _value) -{ - TiXmlNode* node; - - for ( node = NextSibling(_value); - node; - node = node->NextSibling(_value)) - { - if (node->ToElement()) - return node->ToElement(); - } - return nullptr; -} - - -const TiXmlDocument* TiXmlNode::GetDocument() const -{ - const TiXmlNode* node; - - for (node = this; node; node = node->parent) - { - if (node->ToDocument()) - return node->ToDocument(); - } - return nullptr; -} - -TiXmlDocument* TiXmlNode::GetDocument() -{ - TiXmlNode* node; - - for (node = this; node; node = node->parent) - { - if (node->ToDocument()) - return node->ToDocument(); - } - return nullptr; -} - -TiXmlElement::TiXmlElement (const char * _value) - : TiXmlNode(TiXmlNode::ELEMENT) -{ - firstChild = lastChild = nullptr; - value = _value; -} - - -#ifdef TIXML_USE_STL -TiXmlElement::TiXmlElement(const std::string& _value) - : TiXmlNode(TiXmlNode::ELEMENT) -{ - firstChild = lastChild = 0; - value = _value; -} -#endif - - -TiXmlElement::TiXmlElement(const TiXmlElement& copy) - : TiXmlNode(TiXmlNode::ELEMENT) -{ - firstChild = lastChild = nullptr; - copy.CopyTo(this); -} - - -void TiXmlElement::operator=(const TiXmlElement& base) -{ - ClearThis(); - base.CopyTo(this); -} - - -TiXmlElement::~TiXmlElement() -{ - ClearThis(); -} - - -void TiXmlElement::ClearThis() -{ - Clear(); - while (attributeSet.First()) - { - TiXmlAttribute* node = attributeSet.First(); - attributeSet.Remove(node); - delete node; - } -} - - -const char * TiXmlElement::Attribute(const char * name) const -{ - TIXML_STRING str(name); - const TiXmlAttribute* node = attributeSet.Find(str); - - if (node) - return node->Value(); - - return nullptr; -} - - -const char * TiXmlElement::Attribute(const char * name, int* i) const -{ - const char * s = Attribute(name); - if (i) - { - if (s) - *i = (int)_atoi64(s); - else - *i = 0; - } - return s; -} - - -const char * TiXmlElement::Attribute(const char * name, double* d) const -{ - const char * s = Attribute(name); - if (d) - { - if (s) - *d = atof(s); - else - *d = 0; - } - return s; -} - - -int TiXmlElement::QueryIntAttribute(const char* name, int* ival) const -{ - TIXML_STRING str(name); - const TiXmlAttribute* node = attributeSet.Find(str); - if (!node) - return TIXML_NO_ATTRIBUTE; - - return node->QueryIntValue(ival); -} - - -int TiXmlElement::QueryDoubleAttribute(const char* name, double* dval) const -{ - TIXML_STRING str(name); - const TiXmlAttribute* node = attributeSet.Find(str); - if (!node) - return TIXML_NO_ATTRIBUTE; - - return node->QueryDoubleValue(dval); -} - - -void TiXmlElement::SetAttribute(const char * name, int val) -{ - char buf[64]; - mir_snprintf(buf, "%d", val); - SetAttribute(name, buf); -} - - -#ifdef TIXML_USE_STL -void TiXmlElement::SetAttribute(const std::string& name, int val) -{ - std::ostringstream oss; - oss << val; - SetAttribute(name, oss.str()); -} -#endif - - -void TiXmlElement::SetDoubleAttribute(const char * name, double val) -{ - char buf[256]; - mir_snprintf(buf, "%f", val); - SetAttribute(name, buf); -} - - -void TiXmlElement::SetAttribute(const char * cname, const char * cvalue) -{ - TIXML_STRING _name(cname); - TIXML_STRING _value(cvalue); - - TiXmlAttribute* node = attributeSet.Find(_name); - if (node) - { - node->SetValue(cvalue); - return; - } - - TiXmlAttribute* attrib = new TiXmlAttribute(cname, cvalue); - if (attrib) - { - attributeSet.Add(attrib); - } - else - { - TiXmlDocument* document = GetDocument(); - if (document) document->SetError(TIXML_ERROR_OUT_OF_MEMORY, nullptr, nullptr, TIXML_ENCODING_UNKNOWN); - } -} - - -#ifdef TIXML_USE_STL -void TiXmlElement::SetAttribute(const std::string& name, const std::string& _value) -{ - TiXmlAttribute* node = attributeSet.Find(name); - if (node) - { - node->SetValue(_value); - return; - } - - TiXmlAttribute* attrib = new TiXmlAttribute(name, _value); - if (attrib) - { - attributeSet.Add(attrib); - } - else - { - TiXmlDocument* document = GetDocument(); - if (document) document->SetError(TIXML_ERROR_OUT_OF_MEMORY, 0, 0, TIXML_ENCODING_UNKNOWN); - } -} -#endif - - -void TiXmlElement::Print(FILE* cfile, int depth) const -{ - int i; - for (i=0; iNext()) - { - fprintf(cfile, " "); - attrib->Print(cfile, depth); - } - - // There are 3 different formatting approaches: - // 1) An element without children is printed as a node - // 2) An element with only a text child is printed as text - // 3) An element with children is printed on multiple lines. - TiXmlNode* node; - if (!firstChild) - { - fprintf(cfile, " />"); - } - else if (firstChild == lastChild && firstChild->ToText()) - { - fprintf(cfile, ">"); - firstChild->Print(cfile, depth + 1); - fprintf(cfile, "", value.c_str()); - } - else - { - fprintf(cfile, ">"); - - for (node = firstChild; node; node=node->NextSibling()) - { - if (!node->ToText()) - { - fprintf(cfile, "\n"); - } - node->Print(cfile, depth+1); - } - fprintf(cfile, "\n"); - for (i=0; i", value.c_str()); - } -} - -void TiXmlElement::StreamOut(TIXML_OSTREAM * stream) const -{ - (*stream) << "<" << value; - - const TiXmlAttribute* attrib; - for (attrib = attributeSet.First(); attrib; attrib = attrib->Next()) - { - (*stream) << " "; - attrib->StreamOut(stream); - } - - // If this node has children, give it a closing tag. Else - // make it an empty tag. - TiXmlNode* node; - if (firstChild) - { - (*stream) << ">"; - - for (node = firstChild; node; node=node->NextSibling()) - { - node->StreamOut(stream); - } - (*stream) << ""; - } - else - { - (*stream) << " />"; - } -} - -void TiXmlElement::FormattedStreamOut(TIXML_OSTREAM * stream, int depth) const -{ - // Adding tabs to get the proper tree format - int oldDepth = depth; - StreamDepth(stream, depth); - - // Element name - (*stream) << "<" << value; - - // Attributes - const TiXmlAttribute* attrib; - for (attrib = attributeSet.First(); attrib; attrib = attrib->Next()) - { - (*stream) << " "; - attrib->StreamOut(stream); - } - - // There are 3 different formatting approaches: - // 1) An element without children is printed as a node - // 2) An element with only a text child is printed as text - // 3) An element with children is printed on multiple lines. - TiXmlNode* node; - if (!firstChild) - { - (*stream) << " />" << TIXML_ENDL; - } - else if (firstChild == lastChild && firstChild->ToText()) - { - (*stream) << ">"; - firstChild->FormattedStreamOut(stream, depth + 1); - (*stream) << "" << TIXML_ENDL; - } - else - { - (*stream) << ">" << TIXML_ENDL; - - // Children - depth++; - for (node = firstChild; node; node=node->NextSibling()) - { - node->FormattedStreamOut(stream, depth); - } - StreamDepth(stream, oldDepth); - (*stream) << "" << TIXML_ENDL; - } -} - -void TiXmlElement::CopyTo(TiXmlElement* target) const -{ - // superclass: - TiXmlNode::CopyTo(target); - - // Element class: - // Clone the attributes, then clone the children. - const TiXmlAttribute* attribute = nullptr; - for ( attribute = attributeSet.First(); - attribute; - attribute = attribute->Next()) - { - target->SetAttribute(attribute->Name(), attribute->Value()); - } - - TiXmlNode* node = nullptr; - for (node = firstChild; node; node = node->NextSibling()) - { - target->LinkEndChild(node->Clone()); - } -} - - -TiXmlNode* TiXmlElement::Clone() const -{ - TiXmlElement* clone = new TiXmlElement(Value()); - if (!clone) - return nullptr; - - CopyTo(clone); - return clone; -} - - -const char* TiXmlElement::GetText() const -{ - const TiXmlNode* child = this->FirstChild(); - if (child) { - const TiXmlText* childText = child->ToText(); - if (childText) { - return childText->Value(); - } - } - return nullptr; -} - - -TiXmlDocument::TiXmlDocument() : TiXmlNode(TiXmlNode::DOCUMENT) -{ - tabsize = 4; - useMicrosoftBOM = false; - ClearError(); -} - -TiXmlDocument::TiXmlDocument(const char * documentName) : TiXmlNode(TiXmlNode::DOCUMENT) -{ - tabsize = 4; - useMicrosoftBOM = false; - value = documentName; - ClearError(); -} - - -#ifdef TIXML_USE_STL -TiXmlDocument::TiXmlDocument(const std::string& documentName) : TiXmlNode(TiXmlNode::DOCUMENT) -{ - tabsize = 4; - useMicrosoftBOM = false; - value = documentName; - ClearError(); -} -#endif - - -TiXmlDocument::TiXmlDocument(const TiXmlDocument& copy) : TiXmlNode(TiXmlNode::DOCUMENT) -{ - copy.CopyTo(this); -} - - -void TiXmlDocument::operator=(const TiXmlDocument& copy) -{ - Clear(); - copy.CopyTo(this); -} - - -bool TiXmlDocument::LoadFile(TiXmlEncoding encoding) -{ - // See STL_STRING_BUG below. - StringToBuffer buf(value); - - if (buf.buffer && LoadFile(buf.buffer, encoding)) - return true; - - return false; -} - - -bool TiXmlDocument::SaveFile() const -{ - // See STL_STRING_BUG below. - StringToBuffer buf(value); - - if (buf.buffer && SaveFile(buf.buffer)) - return true; - - return false; -} - -#ifdef TIXML_USE_STL -std::string TiXmlDocument::GetAsString() -{ - std::stringstream out; - FormattedStreamOut(&out, 0); - return out.str(); -} -#endif - -bool TiXmlDocument::GetAsCharBuffer(char* buffer, size_t bufferSize) -{ - #ifdef TIXML_USE_STL - std::string data = GetAsString(); - #else - TIXML_OSTREAM data; - FormattedStreamOut(&data, 0); - #endif - - if (bufferSize < data.length()) - { - return false; - } - else - { - mir_strcpy(buffer, data.c_str()); - return true; - } -} - -bool TiXmlDocument::LoadFile(const char* filename, TiXmlEncoding encoding) -{ - // There was a really terrifying little bug here. The code: - // value = filename - // in the STL case, cause the assignment method of the std::string to - // be called. What is strange, is that the std::string had the same - // address as it's c_str() method, and so bad things happen. Looks - // like a bug in the Microsoft STL implementation. - // See STL_STRING_BUG above. - // Fixed with the StringToBuffer class. - value = filename; - - // reading in binary mode so that tinyxml can normalize the EOL - FILE* file = fopen(value.c_str (), "rb"); - - if (file) - { - bool result = LoadFile(file, encoding); - fclose(file); - return result; - } - else - { - SetError(TIXML_ERROR_OPENING_FILE, nullptr, nullptr, TIXML_ENCODING_UNKNOWN); - return false; - } -} - -bool TiXmlDocument::LoadFile(FILE* file, TiXmlEncoding encoding) -{ - if (!file) - { - SetError(TIXML_ERROR_OPENING_FILE, nullptr, nullptr, TIXML_ENCODING_UNKNOWN); - return false; - } - - // Delete the existing data: - Clear(); - location.Clear(); - - // Get the file size, so we can pre-allocate the string. HUGE speed impact. - long length = 0; - fseek(file, 0, SEEK_END); - length = ftell(file); - fseek(file, 0, SEEK_SET); - - // Strange case, but good to handle up front. - if (length == 0) - { - SetError(TIXML_ERROR_DOCUMENT_EMPTY, nullptr, nullptr, TIXML_ENCODING_UNKNOWN); - return false; - } - - // If we have a file, assume it is all one big XML file, and read it in. - // The document parser may decide the document ends sooner than the entire file, however. - TIXML_STRING data; - data.reserve(length); - - // Subtle bug here. TinyXml did use fgets. But from the XML spec: - // 2.11 End-of-Line Handling - // - // - // ...the XML processor MUST behave as if it normalized all line breaks in external - // parsed entities (including the document entity) on input, before parsing, by translating - // both the two-character sequence #xD #xA and any #xD that is not followed by #xA to - // a single #xA character. - // - // - // It is not clear fgets does that, and certainly isn't clear it works cross platform. - // Generally, you expect fgets to translate from the convention of the OS to the c/unix - // convention, and not work generally. - - /* - while (fgets(buf, sizeof(buf), file)) - { - data += buf; - } - */ - - char* buf = new char[ length+1 ]; - buf[0] = 0; - - if (fread(buf, length, 1, file) != 1) { - delete [] buf; - SetError(TIXML_ERROR_OPENING_FILE, nullptr, nullptr, TIXML_ENCODING_UNKNOWN); - return false; - } - - const char* lastPos = buf; - const char* p = buf; - - buf[length] = 0; - while (*p) { - assert(p < (buf+length)); - if (*p == 0xa) { - // Newline character. No special rules for this. Append all the characters - // since the last string, and include the newline. - data.append(lastPos, (p-lastPos+1)); // append, include the newline - ++p; // move past the newline - lastPos = p; // and point to the new buffer (may be 0) - assert(p <= (buf+length)); - } - else if (*p == 0xd) { - // Carriage return. Append what we have so far, then - // handle moving forward in the buffer. - if ((p-lastPos) > 0) { - data.append(lastPos, p-lastPos); // do not add the CR - } - data += (char)0xa; // a proper newline - - if (*(p+1) == 0xa) { - // Carriage return - new line sequence - p += 2; - lastPos = p; - assert(p <= (buf+length)); - } - else { - // it was followed by something else...that is presumably characters again. - ++p; - lastPos = p; - assert(p <= (buf+length)); - } - } - else { - ++p; - } - } - // Handle any left over characters. - if (p-lastPos) { - data.append(lastPos, p-lastPos); - } - delete [] buf; - buf = nullptr; - - Parse(data.c_str(), nullptr, encoding); - - if ( Error()) - return false; - else - return true; -} - - -bool TiXmlDocument::SaveFile(const char * filename) const -{ - // The old c stuff lives on... - FILE* fp = fopen(filename, "w"); - if (fp) - { - bool result = SaveFile(fp); - fclose(fp); - return result; - } - return false; -} - - -bool TiXmlDocument::SaveFile(FILE* fp) const -{ - if (useMicrosoftBOM) - { - const unsigned char TIXML_UTF_LEAD_0 = 0xefU; - const unsigned char TIXML_UTF_LEAD_1 = 0xbbU; - const unsigned char TIXML_UTF_LEAD_2 = 0xbfU; - - fputc(TIXML_UTF_LEAD_0, fp); - fputc(TIXML_UTF_LEAD_1, fp); - fputc(TIXML_UTF_LEAD_2, fp); - } - Print(fp, 0); - return true; -} - - -void TiXmlDocument::CopyTo(TiXmlDocument* target) const -{ - TiXmlNode::CopyTo(target); - - target->error = error; - target->errorDesc = errorDesc.c_str (); - - TiXmlNode* node = nullptr; - for (node = firstChild; node; node = node->NextSibling()) - { - target->LinkEndChild(node->Clone()); - } -} - - -TiXmlNode* TiXmlDocument::Clone() const -{ - TiXmlDocument* clone = new TiXmlDocument(); - if (!clone) - return nullptr; - - CopyTo(clone); - return clone; -} - - -void TiXmlDocument::Print(FILE* cfile, int depth) const -{ - const TiXmlNode* node; - for (node=FirstChild(); node; node=node->NextSibling()) - { - node->Print(cfile, depth); - fprintf(cfile, "\n"); - } -} - -void TiXmlDocument::StreamOut(TIXML_OSTREAM * out) const -{ - const TiXmlNode* node; - for (node=FirstChild(); node; node=node->NextSibling()) - { - node->StreamOut(out); - - // Special rule for streams: stop after the root element. - // The stream in code will only read one element, so don't - // write more than one. - if (node->ToElement()) - break; - } -} - -void TiXmlDocument::FormattedStreamOut(TIXML_OSTREAM * out, int depth) const -{ - const TiXmlNode* node; - for (node=FirstChild(); node; node=node->NextSibling()) - { - node->FormattedStreamOut(out, depth); - - // Special rule for streams: stop after the root element. - // The stream in code will only read one element, so don't - // write more than one. - if (node->ToElement()) - break; - } -} - -const TiXmlAttribute* TiXmlAttribute::Next() const -{ - // We are using knowledge of the sentinel. The sentinel - // have a value or name. - if (next->value.empty() && next->name.empty()) - return nullptr; - return next; -} - -TiXmlAttribute* TiXmlAttribute::Next() -{ - // We are using knowledge of the sentinel. The sentinel - // have a value or name. - if (next->value.empty() && next->name.empty()) - return nullptr; - return next; -} - -const TiXmlAttribute* TiXmlAttribute::Previous() const -{ - // We are using knowledge of the sentinel. The sentinel - // have a value or name. - if (prev->value.empty() && prev->name.empty()) - return nullptr; - return prev; -} - -TiXmlAttribute* TiXmlAttribute::Previous() -{ - // We are using knowledge of the sentinel. The sentinel - // have a value or name. - if (prev->value.empty() && prev->name.empty()) - return nullptr; - return prev; -} - -void TiXmlAttribute::Print(FILE* cfile, int /*depth*/) const -{ - TIXML_STRING n, v; - - PutString(name, &n); - PutString(value, &v); - - if (value.find ('\"') == TIXML_STRING::npos) - fprintf (cfile, "%s=\"%s\"", n.c_str(), v.c_str()); - else - fprintf (cfile, "%s='%s'", n.c_str(), v.c_str()); -} - - -void TiXmlAttribute::StreamOut(TIXML_OSTREAM * stream) const -{ - if (value.find('\"') != TIXML_STRING::npos) - { - PutString(name, stream); - (*stream) << "=" << "'"; - PutString(value, stream); - (*stream) << "'"; - } - else - { - PutString(name, stream); - (*stream) << "=" << "\""; - PutString(value, stream); - (*stream) << "\""; - } -} - -int TiXmlAttribute::QueryIntValue(int* ival) const -{ - if (sscanf(value.c_str(), "%d", ival) == 1) - return TIXML_SUCCESS; - return TIXML_WRONG_TYPE; -} - -int TiXmlAttribute::QueryDoubleValue(double* dval) const -{ - if (sscanf(value.c_str(), "%lf", dval) == 1) - return TIXML_SUCCESS; - return TIXML_WRONG_TYPE; -} - -void TiXmlAttribute::SetIntValue(int _value) -{ - char buf[64]; - mir_snprintf(buf, "%d", _value); - SetValue(buf); -} - -void TiXmlAttribute::SetDoubleValue(double _value) -{ - char buf[256]; - mir_snprintf(buf, "%lf", _value); - SetValue(buf); -} - -int TiXmlAttribute::IntValue() const -{ - return (int)_atoi64(value.c_str ()); -} - -double TiXmlAttribute::DoubleValue() const -{ - return atof (value.c_str ()); -} - - -TiXmlComment::TiXmlComment(const TiXmlComment& copy) : TiXmlNode(TiXmlNode::COMMENT) -{ - copy.CopyTo(this); -} - - -void TiXmlComment::operator=(const TiXmlComment& base) -{ - Clear(); - base.CopyTo(this); -} - - -void TiXmlComment::Print(FILE* cfile, int depth) const -{ - for (int i=0; i", value.c_str()); -} - -void TiXmlComment::StreamOut(TIXML_OSTREAM * stream) const -{ - (*stream) << ""; -} - -void TiXmlComment::FormattedStreamOut(TIXML_OSTREAM * stream, int depth) const -{ - StreamDepth(stream, depth); - - StreamOut(stream); - - (*stream) << TIXML_ENDL; -} - -void TiXmlComment::CopyTo(TiXmlComment* target) const -{ - TiXmlNode::CopyTo(target); -} - - -TiXmlNode* TiXmlComment::Clone() const -{ - TiXmlComment* clone = new TiXmlComment(); - - if (!clone) - return nullptr; - - CopyTo(clone); - return clone; -} - - -void TiXmlText::Print(FILE* cfile, int depth) const -{ - if (cdata) - { - int i; - fprintf(cfile, "\n"); - for (i=0; i\n"); - } - else - { - TIXML_STRING buffer; - PutString(value, &buffer); - fprintf(cfile, "%s", buffer.c_str()); - } -} - - -void TiXmlText::StreamOut(TIXML_OSTREAM * stream) const -{ - if (cdata) - { - (*stream) << ""; - } - else - { - PutString(value, stream); - } -} - -void TiXmlText::FormattedStreamOut(TIXML_OSTREAM * stream, int depth) const -{ - if (cdata) - { - (*stream) << TIXML_ENDL; - StreamDepth(stream, depth); - (*stream) << "" << TIXML_ENDL; - } - else - { - PutString(value, stream); - } -} - -void TiXmlText::CopyTo(TiXmlText* target) const -{ - TiXmlNode::CopyTo(target); - target->cdata = cdata; -} - - -TiXmlNode* TiXmlText::Clone() const -{ - TiXmlText* clone = nullptr; - clone = new TiXmlText(""); - - if (!clone) - return nullptr; - - CopyTo(clone); - return clone; -} - - -TiXmlDeclaration::TiXmlDeclaration(const char * _version, - const char * _encoding, - const char * _standalone) - : TiXmlNode(TiXmlNode::DECLARATION) -{ - version = _version; - encoding = _encoding; - standalone = _standalone; -} - - -#ifdef TIXML_USE_STL -TiXmlDeclaration::TiXmlDeclaration( const std::string& _version, - const std::string& _encoding, - const std::string& _standalone) - : TiXmlNode(TiXmlNode::DECLARATION) -{ - version = _version; - encoding = _encoding; - standalone = _standalone; -} -#endif - - -TiXmlDeclaration::TiXmlDeclaration(const TiXmlDeclaration& copy) - : TiXmlNode(TiXmlNode::DECLARATION) -{ - copy.CopyTo(this); -} - - -void TiXmlDeclaration::operator=(const TiXmlDeclaration& copy) -{ - Clear(); - copy.CopyTo(this); -} - - -void TiXmlDeclaration::Print(FILE* cfile, int /*depth*/) const -{ - fprintf (cfile, ""); -} - -void TiXmlDeclaration::StreamOut(TIXML_OSTREAM * stream) const -{ - (*stream) << ""; -} - -void TiXmlDeclaration::FormattedStreamOut(TIXML_OSTREAM * stream, int depth) const -{ - StreamDepth(stream, depth); - StreamOut(stream); - (*stream) << TIXML_ENDL; -} - -void TiXmlDeclaration::CopyTo(TiXmlDeclaration* target) const -{ - TiXmlNode::CopyTo(target); - - target->version = version; - target->encoding = encoding; - target->standalone = standalone; -} - - -TiXmlNode* TiXmlDeclaration::Clone() const -{ - TiXmlDeclaration* clone = new TiXmlDeclaration(); - - if (!clone) - return nullptr; - - CopyTo(clone); - return clone; -} - - -void TiXmlUnknown::Print(FILE* cfile, int depth) const -{ - for (int i=0; i", value.c_str()); -} - - -void TiXmlUnknown::StreamOut(TIXML_OSTREAM * stream) const -{ - (*stream) << "<" << value << ">"; // Don't use entities here! It is unknown. -} - -void TiXmlUnknown::FormattedStreamOut(TIXML_OSTREAM * stream, int depth) const -{ - StreamDepth(stream, depth); - (*stream) << "<" << value << ">" << TIXML_ENDL; // Don't use entities here! It is unknown. -} - -void TiXmlUnknown::CopyTo(TiXmlUnknown* target) const -{ - TiXmlNode::CopyTo(target); -} - - -TiXmlNode* TiXmlUnknown::Clone() const -{ - TiXmlUnknown* clone = new TiXmlUnknown(); - - if (!clone) - return nullptr; - - CopyTo(clone); - return clone; -} - - -TiXmlAttributeSet::TiXmlAttributeSet() -{ - sentinel.next = &sentinel; - sentinel.prev = &sentinel; -} - - -TiXmlAttributeSet::~TiXmlAttributeSet() -{ - assert(sentinel.next == &sentinel); - assert(sentinel.prev == &sentinel); -} - - -void TiXmlAttributeSet::Add(TiXmlAttribute* addMe) -{ - assert(!Find(TIXML_STRING(addMe->Name()))); // Shouldn't be multiply adding to the set. - - addMe->next = &sentinel; - addMe->prev = sentinel.prev; - - sentinel.prev->next = addMe; - sentinel.prev = addMe; -} - -void TiXmlAttributeSet::Remove(TiXmlAttribute* removeMe) -{ - TiXmlAttribute* node; - - for (node = sentinel.next; node != &sentinel; node = node->next) - { - if (node == removeMe) - { - node->prev->next = node->next; - node->next->prev = node->prev; - node->next = nullptr; - node->prev = nullptr; - return; - } - } - assert(0); // we tried to remove a non-linked attribute. -} - -const TiXmlAttribute* TiXmlAttributeSet::Find(const TIXML_STRING& name) const -{ - const TiXmlAttribute* node; - - for (node = sentinel.next; node != &sentinel; node = node->next) - { - if (node->name == name) - return node; - } - return nullptr; -} - -TiXmlAttribute* TiXmlAttributeSet::Find(const TIXML_STRING& name) -{ - TiXmlAttribute* node; - - for (node = sentinel.next; node != &sentinel; node = node->next) - { - if (node->name == name) - return node; - } - return nullptr; -} - -#ifdef TIXML_USE_STL -TIXML_ISTREAM & operator >> (TIXML_ISTREAM & in, TiXmlNode & base) -{ - TIXML_STRING tag; - tag.reserve(8 * 1000); - base.StreamIn(&in, &tag); - - base.Parse(tag.c_str(), 0, TIXML_DEFAULT_ENCODING); - return in; -} -#endif - - -TIXML_OSTREAM & operator<< (TIXML_OSTREAM & out, const TiXmlNode & base) -{ - base.StreamOut (& out); - return out; -} - - -#ifdef TIXML_USE_STL -std::string & operator<< (std::string& out, const TiXmlNode& base) -{ - std::ostringstream os_stream(std::ostringstream::out); - base.StreamOut(&os_stream); - - out.append(os_stream.str()); - return out; -} -#endif - - -TiXmlHandle TiXmlHandle::FirstChild() const -{ - if (node) - { - TiXmlNode* child = node->FirstChild(); - if (child) - return TiXmlHandle(child); - } - return TiXmlHandle(nullptr); -} - - -TiXmlHandle TiXmlHandle::FirstChild(const char * value) const -{ - if (node) - { - TiXmlNode* child = node->FirstChild(value); - if (child) - return TiXmlHandle(child); - } - return TiXmlHandle(nullptr); -} - - -TiXmlHandle TiXmlHandle::FirstChildElement() const -{ - if (node) - { - TiXmlElement* child = node->FirstChildElement(); - if (child) - return TiXmlHandle(child); - } - return TiXmlHandle(nullptr); -} - - -TiXmlHandle TiXmlHandle::FirstChildElement(const char * value) const -{ - if (node) - { - TiXmlElement* child = node->FirstChildElement(value); - if (child) - return TiXmlHandle(child); - } - return TiXmlHandle(nullptr); -} - - -TiXmlHandle TiXmlHandle::Child(int count) const -{ - if (node) - { - int i; - TiXmlNode* child = node->FirstChild(); - for ( i=0; - child && iNextSibling(), ++i) - { - // nothing - } - if (child) - return TiXmlHandle(child); - } - return TiXmlHandle(nullptr); -} - - -TiXmlHandle TiXmlHandle::Child(const char* value, int count) const -{ - if (node) - { - int i; - TiXmlNode* child = node->FirstChild(value); - for ( i=0; - child && iNextSibling(value), ++i) - { - // nothing - } - if (child) - return TiXmlHandle(child); - } - return TiXmlHandle(nullptr); -} - - -TiXmlHandle TiXmlHandle::ChildElement(int count) const -{ - if (node) - { - int i; - TiXmlElement* child = node->FirstChildElement(); - for ( i=0; - child && iNextSiblingElement(), ++i) - { - // nothing - } - if (child) - return TiXmlHandle(child); - } - return TiXmlHandle(nullptr); -} - - -TiXmlHandle TiXmlHandle::ChildElement(const char* value, int count) const -{ - if (node) - { - int i; - TiXmlElement* child = node->FirstChildElement(value); - for ( i=0; - child && iNextSiblingElement(value), ++i) - { - // nothing - } - if (child) - return TiXmlHandle(child); - } - return TiXmlHandle(nullptr); -} diff --git a/plugins/UserInfoEx/src/ex_import/tinyxml.h b/plugins/UserInfoEx/src/ex_import/tinyxml.h deleted file mode 100644 index bf3732a862..0000000000 --- a/plugins/UserInfoEx/src/ex_import/tinyxml.h +++ /dev/null @@ -1,1554 +0,0 @@ -/* -www.sourceforge.net/projects/tinyxml -Original code (2.0 and earlier)copyright (c) 2000-2002 Lee Thomason (www.grinninglizard.com) - -This software is provided 'as-is', without any express or implied -warranty. In no event will the authors be held liable for any -damages arising from the use of this software. - -Permission is granted to anyone to use this software for any -purpose, including commercial applications, and to alter it and -redistribute it freely, subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must -not claim that you wrote the original software. If you use this -software in a product, an acknowledgment in the product documentation -would be appreciated but is not required. - -2. Altered source versions must be plainly marked as such, and -must not be misrepresented as being the original software. - -3. This notice may not be removed or altered from any source -distribution. - -=============================================================================== - -UserinfoEx plugin for Miranda IM - -Copyright: -© 2006-2010 DeathAxe, Yasnovidyashii, Merlin, K. Romanov, Kreol -=============================================================================== -*/ - - -#ifndef TINYXML_INCLUDED -#define TINYXML_INCLUDED - -// Help out windows: -#if defined(_DEBUG) && !defined(DEBUG) -#define DEBUG -#endif - -#ifdef TIXML_USE_TICPP - #ifndef TIXML_USE_STL - #define TIXML_USE_STL - #endif -#endif - -#ifdef TIXML_USE_STL - #include - #include - #include - #define TIXML_STRING std::string - #define TIXML_ISTREAM std::istream - #define TIXML_OSTREAM std::ostream - #define TIXML_ENDL std::endl -#else - #define TIXML_STRING TiXmlString - #define TIXML_OSTREAM TiXmlOutStream - #define TIXML_ENDL "\n" -#endif - -// Deprecated library function hell. Compilers want to use the -// new safe versions. This probably doesn't fully address the problem, -// but it gets closer. There are too many compilers for me to fully -// test. If you get compilation troubles, undefine TIXML_SAFE - -#define TIXML_SAFE // TinyXml isn't fully buffer overrun protected, safe code. This is work in progress. -#ifdef TIXML_SAFE - #if defined(_MSC_VER) && (_MSC_VER >= 1400) - // Microsoft visual studio, version 2005 and higher. - #define TIXML_SNSCANF _snscanf_s - #elif defined(_MSC_VER) && (_MSC_VER >= 1200) - // Microsoft visual studio, version 6 and higher. - //#pragma message("Using _sn* functions.") - #define TIXML_SNSCANF _snscanf - #elif defined(__GNUC__) && (__GNUC__ >= 3) - // GCC version 3 and higher.s - //#warning("Using sn* functions.") - #define TIXML_SNSCANF snscanf - #endif -#endif - -class TiXmlDocument; -class TiXmlElement; -class TiXmlComment; -class TiXmlUnknown; -class TiXmlAttribute; -class TiXmlText; -class TiXmlDeclaration; -class TiXmlParsingData; - -const int TIXML_MAJOR_VERSION = 2; -const int TIXML_MINOR_VERSION = 4; -const int TIXML_PATCH_VERSION = 3; - -/* Internal structure for tracking location of items - in the XML file. -*/ -struct TiXmlCursor -{ - TiXmlCursor() { Clear(); } - void Clear() { row = col = -1; } - - int row; // 0 based. - int col; // 0 based. -}; - - -// Only used by Attribute::Query functions -enum -{ - TIXML_SUCCESS, - TIXML_NO_ATTRIBUTE, - TIXML_WRONG_TYPE -}; - - -// Used by the parsing routines. -enum TiXmlEncoding -{ - TIXML_ENCODING_UNKNOWN, - TIXML_ENCODING_UTF8, - TIXML_ENCODING_LEGACY -}; - -const TiXmlEncoding TIXML_DEFAULT_ENCODING = TIXML_ENCODING_UNKNOWN; - -/** TiXmlBase is a base class for every class in TinyXml. - It does little except to establish that TinyXml classes - can be printed and provide some utility functions. - - In XML, the document and elements can contain - other elements and other types of nodes. - - @verbatim - A Document can contain: Element (container or leaf) - Comment (leaf) - Unknown (leaf) - Declaration(leaf) - - An Element can contain: Element (container or leaf) - Text (leaf) - Attributes (not on tree) - Comment (leaf) - Unknown (leaf) - - A Decleration contains: Attributes (not on tree) - @endverbatim -*/ -#ifdef TIXML_USE_TICPP -#include "ticpprc.h" -class TiXmlBase : public TiCppRC -#else -class TiXmlBase : private MNonCopyable -#endif -{ - friend class TiXmlNode; - friend class TiXmlElement; - friend class TiXmlDocument; - -public: - TiXmlBase() : userData(0) {} - virtual ~TiXmlBase() {} - - /** All TinyXml classes can print themselves to a filestream. - This is a formatted print, and will insert tabs and newlines. - - (For an unformatted stream, use the << operator.) - */ - virtual void Print(FILE* cfile, int depth) const = 0; - - /** The world does not agree on whether white space should be kept or - not. In order to make everyone happy, these global, static functions - are provided to set whether or not TinyXml will condense all white space - into a single space or not. The default is to condense. Note changing this - values is not thread safe. - */ - static void SetCondenseWhiteSpace(bool condense) { condenseWhiteSpace = condense; } - - /// Return the current white space setting. - static bool IsWhiteSpaceCondensed() { return condenseWhiteSpace; } - - /** Return the position, in the original source file, of this node or attribute. - The row and column are 1-based. (That is the first row and first column is - 1,1). If the returns values are 0 or less, then the parser does not have - a row and column value. - - Generally, the row and column value will be set when the TiXmlDocument::Load(void), - TiXmlDocument::LoadFile(), or any TiXmlNode::Parse() is called. It will NOT be set - when the DOM was created from operator>>. - - The values reflect the initial load. Once the DOM is modified programmatically - (by adding or changing nodes and attributes) the new values will NOT update to - reflect changes in the document. - - There is a minor performance cost to computing the row and column. Computation - can be disabled if TiXmlDocument::SetTabSize() is called with 0 as the value. - - @sa TiXmlDocument::SetTabSize() - */ - int Row() const { return location.row + 1; } - int Column() const { return location.col + 1; } ///< See Row() - - void _SetUserData(void* user) { userData = user; } - void* _GetUserData() { return userData; } - - // Table that returs, for a given lead byte, the total number of bytes - // in the UTF-8 sequence. - static const int utf8ByteTable[256]; - - virtual const char* Parse( const char* p, - TiXmlParsingData* data, - TiXmlEncoding encoding /*= TIXML_ENCODING_UNKNOWN */) = 0; - - enum - { - TIXML_NO_ERROR = 0, - TIXML_ERROR, - TIXML_ERROR_OPENING_FILE, - TIXML_ERROR_OUT_OF_MEMORY, - TIXML_ERROR_PARSING_ELEMENT, - TIXML_ERROR_FAILED_TO_READ_ELEMENT_NAME, - TIXML_ERROR_READING_ELEMENT_VALUE, - TIXML_ERROR_READING_ATTRIBUTES, - TIXML_ERROR_PARSING_EMPTY, - TIXML_ERROR_READING_END_TAG, - TIXML_ERROR_PARSING_UNKNOWN, - TIXML_ERROR_PARSING_COMMENT, - TIXML_ERROR_PARSING_DECLARATION, - TIXML_ERROR_DOCUMENT_EMPTY, - TIXML_ERROR_EMBEDDED_NULL, - TIXML_ERROR_PARSING_CDATA, - TIXML_ERROR_DOCUMENT_TOP_ONLY, - - TIXML_ERROR_STRING_COUNT - }; - -protected: - - void StreamDepth(TIXML_OSTREAM* stream, int depth) const; - - // See STL_STRING_BUG - // Utility class to overcome a bug. - class StringToBuffer - { - public: - StringToBuffer(const TIXML_STRING& str); - ~StringToBuffer(); - char* buffer; - }; - - static const char* SkipWhiteSpace(const char*, TiXmlEncoding encoding); - inline static bool IsWhiteSpace(char c) - { - return (isspace((unsigned char) c) || c == '\n' || c == '\r'); - } - inline static bool IsWhiteSpace(int c) - { - if (c < 256) - return IsWhiteSpace((char) c); - return false; // Again, only truly correct for English/Latin...but usually works. - } - - virtual void StreamOut (TIXML_OSTREAM *) const = 0; - virtual void FormattedStreamOut(TIXML_OSTREAM * stream, int depth) const = 0; - - #ifdef TIXML_USE_STL - static bool StreamWhiteSpace(TIXML_ISTREAM * in, TIXML_STRING * tag); - static bool StreamTo(TIXML_ISTREAM * in, int character, TIXML_STRING * tag); - #endif - - /* Reads an XML name into the string provided. Returns - a pointer just past the last character of the name, - or 0 if the function has an error. - */ - static const char* ReadName(const char* p, TIXML_STRING* name, TiXmlEncoding encoding); - - /* Reads text. Returns a pointer past the given end tag. - Wickedly complex options, but it keeps the (sensitive) code in one place. - */ - static const char* ReadText( const char* in, // where to start - TIXML_STRING* text, // the string read - bool ignoreWhiteSpace, // whether to keep the white space - const char* endTag, // what ends this text - bool ignoreCase, // whether to ignore case in the end tag - TiXmlEncoding encoding); // the current encoding - - // If an entity has been found, transform it into a character. - static const char* GetEntity(const char* in, char* value, int* length, TiXmlEncoding encoding); - - // Get a character, while interpreting entities. - // The length can be from 0 to 4 bytes. - inline static const char* GetChar(const char* p, char* _value, int* length, TiXmlEncoding encoding) - { - assert(p); - if (encoding == TIXML_ENCODING_UTF8) - { - *length = utf8ByteTable[ *((unsigned char*)p) ]; - assert(*length >= 0 && *length < 5); - } - else - { - *length = 1; - } - - if (*length == 1) - { - if (*p == '&') - return GetEntity(p, _value, length, encoding); - *_value = *p; - return p+1; - } - else if (*length) - { - //strncpy(_value, p, *length); // lots of compilers don't like this function (unsafe), - // and the null terminator isn't needed - for (int i=0; p[i] && i<*length; ++i) { - _value[i] = p[i]; - } - return p + (*length); - } - else - { - // Not valid text. - return 0; - } - } - - // Puts a string to a stream, expanding entities as it goes. - // Note this should not contian the '<', '>', etc, or they will be transformed into entities! - static void PutString(const TIXML_STRING& str, TIXML_OSTREAM* out); - - static void PutString(const TIXML_STRING& str, TIXML_STRING* out); - - // Return true if the next characters in the stream are any of the endTag sequences. - // Ignore case only works for english, and should only be relied on when comparing - // to English words: StringEqual(p, "version", true) is fine. - static bool StringEqual( const char* p, - const char* endTag, - bool ignoreCase, - TiXmlEncoding encoding); - - static const char* errorString[ TIXML_ERROR_STRING_COUNT ]; - - TiXmlCursor location; - - /// Field containing a generic user pointer - void* userData; - - // None of these methods are reliable for any language except English. - // Good for approximation, not great for accuracy. - static int IsAlpha(unsigned char anyByte, TiXmlEncoding encoding); - static int IsAlphaNum(unsigned char anyByte, TiXmlEncoding encoding); - inline static int ToLower(int v, TiXmlEncoding encoding) - { - if (encoding == TIXML_ENCODING_UTF8) - { - if (v < 128) return tolower(v); - return v; - } - else - { - return tolower(v); - } - } - static void ConvertUTF32ToUTF8(unsigned long input, char* output, int* length); - -private: - struct Entity - { - const char* str; - unsigned int strLength; - char chr; - }; - enum - { - NUM_ENTITY = 5, - MAX_ENTITY_LENGTH = 6 - - }; - static Entity entity[ NUM_ENTITY ]; - static bool condenseWhiteSpace; -}; - - -/** The parent class for everything in the Document Object Model. - (Except for attributes). - Nodes have siblings, a parent, and children. A node can be - in a document, or stand on its own. The type of a TiXmlNode - can be queried, and it can be cast to its more defined type. -*/ -class TiXmlNode : public TiXmlBase -{ - friend class TiXmlDocument; - friend class TiXmlElement; - -public: - #ifdef TIXML_USE_STL - - /** An input stream operator, for every class. Tolerant of newlines and - formatting, but doesn't expect them. - */ - friend std::istream& operator >> (std::istream& in, TiXmlNode& base); - - /** An output stream operator, for every class. Note that this outputs - without any newlines or formatting, as opposed to Print(), which - includes tabs and new lines. - - The operator<< and operator>> are not completely symmetric. Writing - a node to a stream is very well defined. You'll get a nice stream - of output, without any extra whitespace or newlines. - - But reading is not as well defined. (As it always is.) If you create - a TiXmlElement (for example) and read that from an input stream, - the text needs to define an element or junk will result. This is - true of all input streams, but it's worth keeping in mind. - - A TiXmlDocument will read nodes until it reads a root element, and - all the children of that root element. - */ - friend std::ostream& operator<< (std::ostream& out, const TiXmlNode& base); - - /// Appends the XML node or attribute to a std::string. - friend std::string& operator<< (std::string& out, const TiXmlNode& base); - - #else - // Used internally, not part of the public API. - friend TIXML_OSTREAM& operator<< (TIXML_OSTREAM& out, const TiXmlNode& base); - #endif - - /** The types of XML nodes supported by TinyXml. (All the - unsupported types are picked up by UNKNOWN.) - */ - enum NodeType - { - DOCUMENT, - ELEMENT, - COMMENT, - UNKNOWN, - TEXT, - DECLARATION, - TYPECOUNT - }; - - virtual ~TiXmlNode(); - - /** The meaning of 'value' changes for the specific type of - TiXmlNode. - @verbatim - Document: filename of the xml file - Element: name of the element - Comment: the comment text - Unknown: the tag contents - Text: the text string - @endverbatim - - The subclasses will wrap this function. - */ - const char *Value() const { return value.c_str (); } - - #ifdef TIXML_USE_STL - /** Return Value() as a std::string. If you only use STL, - this is more efficient than calling Value(). - Only available in STL mode. - */ - const std::string& ValueStr() const { return value; } - #endif - - /** Changes the value of the node. Defined as: - @verbatim - Document: filename of the xml file - Element: name of the element - Comment: the comment text - Unknown: the tag contents - Text: the text string - @endverbatim - */ - void SetValue(const char * _value) { value = _value;} - - #ifdef TIXML_USE_STL - /// STL std::string form. - void SetValue(const std::string& _value) { value = _value; } - #endif - - /// Delete all the children of this node. Does not affect 'this'. - void Clear(); - - /// One step up the DOM. - TiXmlNode* Parent() { return parent; } - const TiXmlNode* Parent() const { return parent; } - - const TiXmlNode* FirstChild() const { return firstChild; } ///< The first child of this node. Will be null if there are no children. - TiXmlNode* FirstChild() { return firstChild; } - const TiXmlNode* FirstChild(const char * value) const; ///< The first child of this node with the matching 'value'. Will be null if none found. - TiXmlNode* FirstChild(const char * value); ///< The first child of this node with the matching 'value'. Will be null if none found. - - const TiXmlNode* LastChild() const { return lastChild; } /// The last child of this node. Will be null if there are no children. - TiXmlNode* LastChild() { return lastChild; } - const TiXmlNode* LastChild(const char * value) const; /// The last child of this node matching 'value'. Will be null if there are no children. - TiXmlNode* LastChild(const char * value); - - #ifdef TIXML_USE_STL - const TiXmlNode* FirstChild(const std::string& _value) const { return FirstChild (_value.c_str ()); } ///< STL std::string form. - TiXmlNode* FirstChild(const std::string& _value) { return FirstChild (_value.c_str ()); } ///< STL std::string form. - const TiXmlNode* LastChild(const std::string& _value) const { return LastChild (_value.c_str ()); } ///< STL std::string form. - TiXmlNode* LastChild(const std::string& _value) { return LastChild (_value.c_str ()); } ///< STL std::string form. - #endif - - /** An alternate way to walk the children of a node. - One way to iterate over nodes is: - @verbatim - for (child = parent->FirstChild(); child; child = child->NextSibling()) - @endverbatim - - IterateChildren does the same thing with the syntax: - @verbatim - child = 0; - while (child = parent->IterateChildren(child)) - @endverbatim - - IterateChildren takes the previous child as input and finds - the next one. If the previous child is null, it returns the - first. IterateChildren will return null when done. - */ - const TiXmlNode* IterateChildren(const TiXmlNode* previous) const; - TiXmlNode* IterateChildren(TiXmlNode* previous); - - /// This flavor of IterateChildren searches for children with a particular 'value' - const TiXmlNode* IterateChildren(const char * value, const TiXmlNode* previous) const; - TiXmlNode* IterateChildren(const char * value, TiXmlNode* previous); - - #ifdef TIXML_USE_STL - const TiXmlNode* IterateChildren(const std::string& _value, const TiXmlNode* previous) const { return IterateChildren (_value.c_str (), previous); } ///< STL std::string form. - TiXmlNode* IterateChildren(const std::string& _value, TiXmlNode* previous) { return IterateChildren (_value.c_str (), previous); } ///< STL std::string form. - #endif - - /** Add a new node related to this. Adds a child past the LastChild. - Returns a pointer to the new object or NULL if an error occured. - */ - TiXmlNode* InsertEndChild(const TiXmlNode& addThis); - - - /** Add a new node related to this. Adds a child past the LastChild. - - NOTE: the node to be added is passed by pointer, and will be - henceforth owned (and deleted) by tinyXml. This method is efficient - and avoids an extra copy, but should be used with care as it - uses a different memory model than the other insert functions. - - @sa InsertEndChild - */ - TiXmlNode* LinkEndChild(TiXmlNode* addThis); - - /** Add a new node related to this. Adds a child before the specified child. - Returns a pointer to the new object or NULL if an error occured. - */ - TiXmlNode* InsertBeforeChild(TiXmlNode* beforeThis, const TiXmlNode& addThis); - - /** Add a new node related to this. Adds a child after the specified child. - Returns a pointer to the new object or NULL if an error occured. - */ - TiXmlNode* InsertAfterChild( TiXmlNode* afterThis, const TiXmlNode& addThis); - - /** Replace a child of this node. - Returns a pointer to the new object or NULL if an error occured. - */ - TiXmlNode* ReplaceChild(TiXmlNode* replaceThis, const TiXmlNode& withThis); - - /// Delete a child of this node. - bool RemoveChild(TiXmlNode* removeThis); - - /// Navigate to a sibling node. - const TiXmlNode* PreviousSibling() const { return prev; } - TiXmlNode* PreviousSibling() { return prev; } - - /// Navigate to a sibling node. - const TiXmlNode* PreviousSibling(const char *) const; - TiXmlNode* PreviousSibling(const char *); - - #ifdef TIXML_USE_STL - const TiXmlNode* PreviousSibling(const std::string& _value) const { return PreviousSibling (_value.c_str ()); } ///< STL std::string form. - TiXmlNode* PreviousSibling(const std::string& _value) { return PreviousSibling (_value.c_str ()); } ///< STL std::string form. - const TiXmlNode* NextSibling(const std::string& _value) const { return NextSibling (_value.c_str ()); } ///< STL std::string form. - TiXmlNode* NextSibling(const std::string& _value) { return NextSibling (_value.c_str ()); } ///< STL std::string form. - #endif - - /// Navigate to a sibling node. - const TiXmlNode* NextSibling() const { return next; } - TiXmlNode* NextSibling() { return next; } - - /// Navigate to a sibling node with the given 'value'. - const TiXmlNode* NextSibling(const char *) const; - TiXmlNode* NextSibling(const char *); - - /** Convenience function to get through elements. - Calls NextSibling and ToElement. Will skip all non-Element - nodes. Returns 0 if there is not another element. - */ - const TiXmlElement* NextSiblingElement() const; - TiXmlElement* NextSiblingElement(); - - /** Convenience function to get through elements. - Calls NextSibling and ToElement. Will skip all non-Element - nodes. Returns 0 if there is not another element. - */ - const TiXmlElement* NextSiblingElement(const char *) const; - TiXmlElement* NextSiblingElement(const char *); - - #ifdef TIXML_USE_STL - const TiXmlElement* NextSiblingElement(const std::string& _value) const { return NextSiblingElement (_value.c_str ()); } ///< STL std::string form. - TiXmlElement* NextSiblingElement(const std::string& _value) { return NextSiblingElement (_value.c_str ()); } ///< STL std::string form. - #endif - - /// Convenience function to get through elements. - const TiXmlElement* FirstChildElement() const; - TiXmlElement* FirstChildElement(); - - /// Convenience function to get through elements. - const TiXmlElement* FirstChildElement(const char * value) const; - TiXmlElement* FirstChildElement(const char * value); - - #ifdef TIXML_USE_STL - const TiXmlElement* FirstChildElement(const std::string& _value) const { return FirstChildElement (_value.c_str ()); } ///< STL std::string form. - TiXmlElement* FirstChildElement(const std::string& _value) { return FirstChildElement (_value.c_str ()); } ///< STL std::string form. - #endif - - /** Query the type (as an enumerated value, above) of this node. - The possible types are: DOCUMENT, ELEMENT, COMMENT, - UNKNOWN, TEXT, and DECLARATION. - */ - int Type() const { return type; } - - /** Return a pointer to the Document this node lives in. - Returns null if not in a document. - */ - const TiXmlDocument* GetDocument() const; - TiXmlDocument* GetDocument(); - - /// Returns true if this node has no children. - bool NoChildren() const { return !firstChild; } - - virtual const TiXmlDocument* ToDocument() const { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type. - virtual const TiXmlElement* ToElement() const { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type. - virtual const TiXmlComment* ToComment() const { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type. - virtual const TiXmlUnknown* ToUnknown() const { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type. - virtual const TiXmlText* ToText() const { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type. - virtual const TiXmlDeclaration* ToDeclaration() const { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type. - - virtual TiXmlDocument* ToDocument() { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type. - virtual TiXmlElement* ToElement() { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type. - virtual TiXmlComment* ToComment() { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type. - virtual TiXmlUnknown* ToUnknown() { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type. - virtual TiXmlText* ToText() { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type. - virtual TiXmlDeclaration* ToDeclaration() { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type. - - /** Create an exact duplicate of this node and return it. The memory must be deleted - by the caller. - */ - virtual TiXmlNode* Clone() const = 0; - -protected: - TiXmlNode(NodeType _type); - - // Copy to the allocated object. Shared functionality between Clone, Copy constructor, - // and the assignment operator. - void CopyTo(TiXmlNode* target) const; - - #ifdef TIXML_USE_STL - // The real work of the input operator. - virtual void StreamIn(TIXML_ISTREAM* in, TIXML_STRING* tag) = 0; - #endif - - // Figure out what is at *p, and parse it. Returns null if it is not an xml node. - TiXmlNode* Identify(const char* start, TiXmlEncoding encoding); - - TiXmlNode* parent; - NodeType type; - - TiXmlNode* firstChild; - TiXmlNode* lastChild; - - TIXML_STRING value; - - TiXmlNode* prev; - TiXmlNode* next; -}; - -/** An attribute is a name-value pair. Elements have an arbitrary - number of attributes, each with a unique name. - - @note The attributes are not TiXmlNodes, since they are not - part of the tinyXML document object model. There are other - suggested ways to look at this problem. -*/ -class TiXmlAttribute : public TiXmlBase -{ - friend class TiXmlAttributeSet; - -public: - /// Construct an empty attribute. - TiXmlAttribute() : TiXmlBase() - { - document = 0; - prev = next = 0; - } - - #ifdef TIXML_USE_STL - /// std::string constructor. - TiXmlAttribute(const std::string& _name, const std::string& _value) - { - name = _name; - value = _value; - document = 0; - prev = next = 0; - } - #endif - - /// Construct an attribute with a name and value. - TiXmlAttribute(const char * _name, const char * _value) - { - name = _name; - value = _value; - document = 0; - prev = next = 0; - } - - const char* Name() const { return name.c_str(); } ///< Return the name of this attribute. - const char* Value() const { return value.c_str(); } ///< Return the value of this attribute. - #ifdef TIXML_USE_STL - const std::string& ValueStr() const { return value; } ///< Return the value of this attribute. - #endif - int IntValue() const; ///< Return the value of this attribute, converted to an integer. - double DoubleValue() const; ///< Return the value of this attribute, converted to a double. - - // Get the tinyxml string representation - const TIXML_STRING& NameTStr() const { return name; } - - /** QueryIntValue examines the value string. It is an alternative to the - IntValue() method with richer error checking. - If the value is an integer, it is stored in 'value' and - the call returns TIXML_SUCCESS. If it is not - an integer, it returns TIXML_WRONG_TYPE. - - A specialized but useful call. Note that for success it returns 0, - which is the opposite of almost all other TinyXml calls. - */ - int QueryIntValue(int* _value) const; - /// QueryDoubleValue examines the value string. See QueryIntValue(). - int QueryDoubleValue(double* _value) const; - - void SetName(const char* _name) { name = _name; } ///< Set the name of this attribute. - void SetValue(const char* _value) { value = _value; } ///< Set the value. - - void SetIntValue(int _value); ///< Set the value from an integer. - void SetDoubleValue(double _value); ///< Set the value from a double. - - #ifdef TIXML_USE_STL - /// STL std::string form. - void SetName(const std::string& _name) { name = _name; } - /// STL std::string form. - void SetValue(const std::string& _value) { value = _value; } - #endif - - /// Get the next sibling attribute in the DOM. Returns null at end. - const TiXmlAttribute* Next() const; - TiXmlAttribute* Next(); - /// Get the previous sibling attribute in the DOM. Returns null at beginning. - const TiXmlAttribute* Previous() const; - TiXmlAttribute* Previous(); - - bool operator==(const TiXmlAttribute& rhs) const { return rhs.name == name; } - bool operator<(const TiXmlAttribute& rhs) const { return name < rhs.name; } - bool operator>(const TiXmlAttribute& rhs) const { return name > rhs.name; } - - /* Attribute parsing starts: first letter of the name - returns: the next char after the value end quote - */ - virtual const char* Parse(const char* p, TiXmlParsingData* data, TiXmlEncoding encoding); - - // Prints this Attribute to a FILE stream. - virtual void Print(FILE* cfile, int depth) const; - - virtual void StreamOut(TIXML_OSTREAM * out) const; - virtual void FormattedStreamOut(TIXML_OSTREAM *, int) const {} - - // [internal use] - // Set the document pointer so the attribute can report errors. - void SetDocument(TiXmlDocument* doc) { document = doc; } - -private: - TiXmlDocument* document; // A pointer back to a document, for error reporting. - TIXML_STRING name; - TIXML_STRING value; - TiXmlAttribute* prev; - TiXmlAttribute* next; -}; - - -/* A class used to manage a group of attributes. - It is only used internally, both by the ELEMENT and the DECLARATION. - - The set can be changed transparent to the Element and Declaration - classes that use it, but NOT transparent to the Attribute - which has to implement a next() and previous() method. Which makes - it a bit problematic and prevents the use of STL. - - This version is implemented with circular lists because: - - I like circular lists - - it demonstrates some independence from the (typical) doubly linked list. -*/ -class TiXmlAttributeSet : private MNonCopyable -{ -public: - TiXmlAttributeSet(); - ~TiXmlAttributeSet(); - - void Add(TiXmlAttribute* attribute); - void Remove(TiXmlAttribute* attribute); - - const TiXmlAttribute* First() const { return (sentinel.next == &sentinel) ? 0 : sentinel.next; } - TiXmlAttribute* First() { return (sentinel.next == &sentinel) ? 0 : sentinel.next; } - const TiXmlAttribute* Last() const { return (sentinel.prev == &sentinel) ? 0 : sentinel.prev; } - TiXmlAttribute* Last() { return (sentinel.prev == &sentinel) ? 0 : sentinel.prev; } - - const TiXmlAttribute* Find(const TIXML_STRING& name) const; - TiXmlAttribute* Find(const TIXML_STRING& name); - -private: - TiXmlAttribute sentinel; -}; - - -/** The element is a container class. It has a value, the element name, - and can contain other elements, text, comments, and unknowns. - Elements also contain an arbitrary number of attributes. -*/ -class TiXmlElement : public TiXmlNode -{ -public: - /// Construct an element. - TiXmlElement (const char * in_value); - - #ifdef TIXML_USE_STL - /// std::string constructor. - TiXmlElement(const std::string& _value); - #endif - - TiXmlElement(const TiXmlElement&); - - void operator=(const TiXmlElement& base); - - virtual ~TiXmlElement(); - - /** Given an attribute name, Attribute() returns the value - for the attribute of that name, or null if none exists. - */ - const char* Attribute(const char* name) const; - - /** Given an attribute name, Attribute() returns the value - for the attribute of that name, or null if none exists. - If the attribute exists and can be converted to an integer, - the integer value will be put in the return 'i', if 'i' - is non-null. - */ - const char* Attribute(const char* name, int* i) const; - - /** Given an attribute name, Attribute() returns the value - for the attribute of that name, or null if none exists. - If the attribute exists and can be converted to an double, - the double value will be put in the return 'd', if 'd' - is non-null. - */ - const char* Attribute(const char* name, double* d) const; - - /** QueryIntAttribute examines the attribute - it is an alternative to the - Attribute() method with richer error checking. - If the attribute is an integer, it is stored in 'value' and - the call returns TIXML_SUCCESS. If it is not - an integer, it returns TIXML_WRONG_TYPE. If the attribute - does not exist, then TIXML_NO_ATTRIBUTE is returned. - */ - int QueryIntAttribute(const char* name, int* _value) const; - /// QueryDoubleAttribute examines the attribute - see QueryIntAttribute(). - int QueryDoubleAttribute(const char* name, double* _value) const; - /// QueryFloatAttribute examines the attribute - see QueryIntAttribute(). - int QueryFloatAttribute(const char* name, float* _value) const { - double d; - int result = QueryDoubleAttribute(name, &d); - if (result == TIXML_SUCCESS) { - *_value = (float)d; - } - return result; - } - #ifdef TIXML_USE_STL - /** Template form of the attribute query which will try to read the - attribute into the specified type. Very easy, very powerful, but - be careful to make sure to call this with the correct type. - - @return TIXML_SUCCESS, TIXML_WRONG_TYPE, or TIXML_NO_ATTRIBUTE - */ - template< typename T > int QueryValueAttribute(const std::string& name, T* outValue) const - { - const TiXmlAttribute* node = attributeSet.Find(name); - if (!node) - return TIXML_NO_ATTRIBUTE; - - std::stringstream sstream(node->ValueStr()); - sstream >> *outValue; - if (!sstream.fail()) - return TIXML_SUCCESS; - return TIXML_WRONG_TYPE; - } - #endif - - /** Sets an attribute of name to a given value. The attribute - will be created if it does not exist, or changed if it does. - */ - void SetAttribute(const char* name, const char * _value); - - #ifdef TIXML_USE_STL - const char* Attribute(const std::string& name) const { return Attribute(name.c_str()); } - const char* Attribute(const std::string& name, int* i) const { return Attribute(name.c_str(), i); } - const char* Attribute(const std::string& name, double* d) const { return Attribute(name.c_str(), d); } - int QueryIntAttribute(const std::string& name, int* _value) const { return QueryIntAttribute(name.c_str(), _value); } - int QueryDoubleAttribute(const std::string& name, double* _value) const { return QueryDoubleAttribute(name.c_str(), _value); } - - /// STL std::string form. - void SetAttribute(const std::string& name, const std::string& _value); - ///< STL std::string form. - void SetAttribute(const std::string& name, int _value); - #endif - - /** Sets an attribute of name to a given value. The attribute - will be created if it does not exist, or changed if it does. - */ - void SetAttribute(const char * name, int value); - - /** Sets an attribute of name to a given value. The attribute - will be created if it does not exist, or changed if it does. - */ - void SetDoubleAttribute(const char * name, double value); - - /** Deletes an attribute with the given name. - */ - void RemoveAttribute(const char * name); - #ifdef TIXML_USE_STL - void RemoveAttribute(const std::string& name) { RemoveAttribute (name.c_str ()); } ///< STL std::string form. - #endif - - const TiXmlAttribute* FirstAttribute() const { return attributeSet.First(); } ///< Access the first attribute in this element. - TiXmlAttribute* FirstAttribute() { return attributeSet.First(); } - const TiXmlAttribute* LastAttribute() const { return attributeSet.Last(); } ///< Access the last attribute in this element. - TiXmlAttribute* LastAttribute() { return attributeSet.Last(); } - - /** Convenience function for easy access to the text inside an element. Although easy - and concise, GetText() is limited compared to getting the TiXmlText child - and accessing it directly. - - If the first child of 'this' is a TiXmlText, the GetText() - returns the character string of the Text node, else null is returned. - - This is a convenient method for getting the text of simple contained text: - @verbatim - This is text - const char* str = fooElement->GetText(); - @endverbatim - - 'str' will be a pointer to "This is text". - - Note that this function can be misleading. If the element foo was created from - this XML: - @verbatim - This is text - @endverbatim - - then the value of str would be null. The first child node isn't a text node, it is - another element. From this XML: - @verbatim - This is text - @endverbatim - GetText() will return "This is ". - - WARNING: GetText() accesses a child node - don't become confused with the - similarly named TiXmlHandle::Text() and TiXmlNode::ToText() which are - safe type casts on the referenced node. - */ - const char* GetText() const; - - /// Creates a new Element and returns it - the returned element is a copy. - virtual TiXmlNode* Clone() const; - // Print the Element to a FILE stream. - virtual void Print(FILE* cfile, int depth) const; - - /* Attribtue parsing starts: next char past '<' - returns: next char past '>' - */ - virtual const char* Parse(const char* p, TiXmlParsingData* data, TiXmlEncoding encoding); - - virtual const TiXmlElement* ToElement() const { return this; } ///< Cast to a more defined type. Will return null not of the requested type. - virtual TiXmlElement* ToElement() { return this; } ///< Cast to a more defined type. Will return null not of the requested type. - -protected: - - void CopyTo(TiXmlElement* target) const; - void ClearThis(); // like clear, but initializes 'this' object as well - - // Used to be public [internal use] - #ifdef TIXML_USE_STL - virtual void StreamIn(TIXML_ISTREAM * in, TIXML_STRING * tag); - #endif - virtual void StreamOut(TIXML_OSTREAM * out) const; - virtual void FormattedStreamOut(TIXML_OSTREAM * stream, int depth) const; - - /* [internal use] - Reads the "value" of the element -- another element, or text. - This should terminate with the current end tag. - */ - const char* ReadValue(const char* in, TiXmlParsingData* prevData, TiXmlEncoding encoding); - -private: - - TiXmlAttributeSet attributeSet; -}; - - -/** An XML comment. -*/ -class TiXmlComment : public TiXmlNode -{ -public: - /// Constructs an empty comment. - TiXmlComment() : TiXmlNode(TiXmlNode::COMMENT) {} - TiXmlComment(const TiXmlComment&); - void operator=(const TiXmlComment& base); - - virtual ~TiXmlComment() {} - - /// Returns a copy of this Comment. - virtual TiXmlNode* Clone() const; - /// Write this Comment to a FILE stream. - virtual void Print(FILE* cfile, int depth) const; - - /* Attribtue parsing starts: at the ! of the !-- - returns: next char past '>' - */ - virtual const char* Parse(const char* p, TiXmlParsingData* data, TiXmlEncoding encoding); - - virtual const TiXmlComment* ToComment() const { return this; } ///< Cast to a more defined type. Will return null not of the requested type. - virtual TiXmlComment* ToComment() { return this; } ///< Cast to a more defined type. Will return null not of the requested type. - -protected: - void CopyTo(TiXmlComment* target) const; - - // used to be public - #ifdef TIXML_USE_STL - virtual void StreamIn(TIXML_ISTREAM * in, TIXML_STRING * tag); - #endif - virtual void StreamOut(TIXML_OSTREAM * out) const; - virtual void FormattedStreamOut(TIXML_OSTREAM * stream, int depth) const; - -private: - -}; - - -/** XML text. A text node can have 2 ways to output the next. "normal" output - and CDATA. It will default to the mode it was parsed from the XML file and - you generally want to leave it alone, but you can change the output mode with - SetCDATA() and query it with CDATA(). -*/ -class TiXmlText : public TiXmlNode -{ - friend class TiXmlElement; -public: - /** Constructor for text element. By default, it is treated as - normal, encoded text. If you want it be output as a CDATA text - element, set the parameter _cdata to 'true' - */ - TiXmlText (const char * initValue) : TiXmlNode (TiXmlNode::TEXT) - { - SetValue(initValue); - cdata = false; - } - virtual ~TiXmlText() {} - - #ifdef TIXML_USE_STL - /// Constructor. - TiXmlText(const std::string& initValue) : TiXmlNode (TiXmlNode::TEXT) - { - SetValue(initValue); - cdata = false; - } - #endif - - TiXmlText(const TiXmlText& copy) : TiXmlNode(TiXmlNode::TEXT) { copy.CopyTo(this); } - void operator=(const TiXmlText& base) { base.CopyTo(this); } - - /// Write this text object to a FILE stream. - virtual void Print(FILE* cfile, int depth) const; - - /// Queries whether this represents text using a CDATA section. - bool CDATA() { return cdata; } - /// Turns on or off a CDATA representation of text. - void SetCDATA(bool _cdata) { cdata = _cdata; } - - virtual const char* Parse(const char* p, TiXmlParsingData* data, TiXmlEncoding encoding); - - virtual const TiXmlText* ToText() const { return this; } ///< Cast to a more defined type. Will return null not of the requested type. - virtual TiXmlText* ToText() { return this; } ///< Cast to a more defined type. Will return null not of the requested type. - -protected : - /// [internal use] Creates a new Element and returns it. - virtual TiXmlNode* Clone() const; - void CopyTo(TiXmlText* target) const; - - virtual void StreamOut (TIXML_OSTREAM * out) const; - virtual void FormattedStreamOut(TIXML_OSTREAM * stream, int depth) const; - - bool Blank() const; // returns true if all white space and new lines - // [internal use] - #ifdef TIXML_USE_STL - virtual void StreamIn(TIXML_ISTREAM * in, TIXML_STRING * tag); - #endif - -private: - bool cdata; // true if this should be input and output as a CDATA style text element -}; - - -/** In correct XML the declaration is the first entry in the file. - @verbatim - - @endverbatim - - TinyXml will happily read or write files without a declaration, - however. There are 3 possible attributes to the declaration: - version, encoding, and standalone. - - Note: In this version of the code, the attributes are - handled as special cases, not generic attributes, simply - because there can only be at most 3 and they are always the same. -*/ -class TiXmlDeclaration : public TiXmlNode -{ -public: - /// Construct an empty declaration. - TiXmlDeclaration() : TiXmlNode(TiXmlNode::DECLARATION) {} - -#ifdef TIXML_USE_STL - /// Constructor. - TiXmlDeclaration( const std::string& _version, - const std::string& _encoding, - const std::string& _standalone); -#endif - - /// Construct. - TiXmlDeclaration( const char* _version, - const char* _encoding, - const char* _standalone); - - TiXmlDeclaration(const TiXmlDeclaration& copy); - void operator=(const TiXmlDeclaration& copy); - - virtual ~TiXmlDeclaration() {} - - /// Version. Will return an empty string if none was found. - const char *Version() const { return version.c_str (); } - /// Encoding. Will return an empty string if none was found. - const char *Encoding() const { return encoding.c_str (); } - /// Is this a standalone document? - const char *Standalone() const { return standalone.c_str (); } - - /// Creates a copy of this Declaration and returns it. - virtual TiXmlNode* Clone() const; - /// Print this declaration to a FILE stream. - virtual void Print(FILE* cfile, int depth) const; - - virtual const char* Parse(const char* p, TiXmlParsingData* data, TiXmlEncoding encoding); - - virtual const TiXmlDeclaration* ToDeclaration() const { return this; } ///< Cast to a more defined type. Will return null not of the requested type. - virtual TiXmlDeclaration* ToDeclaration() { return this; } ///< Cast to a more defined type. Will return null not of the requested type. - -protected: - void CopyTo(TiXmlDeclaration* target) const; - // used to be public - #ifdef TIXML_USE_STL - virtual void StreamIn(TIXML_ISTREAM * in, TIXML_STRING * tag); - #endif - virtual void StreamOut (TIXML_OSTREAM * out) const; - virtual void FormattedStreamOut(TIXML_OSTREAM * stream, int depth) const; - -private: - - TIXML_STRING version; - TIXML_STRING encoding; - TIXML_STRING standalone; -}; - - -/** Any tag that tinyXml doesn't recognize is saved as an - unknown. It is a tag of text, but should not be modified. - It will be written back to the XML, unchanged, when the file - is saved. - - DTD tags get thrown into TiXmlUnknowns. -*/ -class TiXmlUnknown : public TiXmlNode -{ -public: - TiXmlUnknown() : TiXmlNode(TiXmlNode::UNKNOWN) {} - virtual ~TiXmlUnknown() {} - - TiXmlUnknown(const TiXmlUnknown& copy) : TiXmlNode(TiXmlNode::UNKNOWN) { copy.CopyTo(this); } - void operator=(const TiXmlUnknown& copy) { copy.CopyTo(this); } - - /// Creates a copy of this Unknown and returns it. - virtual TiXmlNode* Clone() const; - /// Print this Unknown to a FILE stream. - virtual void Print(FILE* cfile, int depth) const; - - virtual const char* Parse(const char* p, TiXmlParsingData* data, TiXmlEncoding encoding); - - virtual const TiXmlUnknown* ToUnknown() const { return this; } ///< Cast to a more defined type. Will return null not of the requested type. - virtual TiXmlUnknown* ToUnknown() { return this; } ///< Cast to a more defined type. Will return null not of the requested type. - -protected: - void CopyTo(TiXmlUnknown* target) const; - - #ifdef TIXML_USE_STL - virtual void StreamIn(TIXML_ISTREAM * in, TIXML_STRING * tag); - #endif - virtual void StreamOut (TIXML_OSTREAM * out) const; - virtual void FormattedStreamOut(TIXML_OSTREAM * stream, int depth) const; - -private: - -}; - - -/** Always the top level node. A document binds together all the - XML pieces. It can be saved, loaded, and printed to the screen. - The 'value' of a document node is the xml file name. -*/ -class TiXmlDocument : public TiXmlNode -{ -public: - /// Create an empty document, that has no name. - TiXmlDocument(); - /// Create a document with a name. The name of the document is also the filename of the xml. - TiXmlDocument(const char * documentName); - - #ifdef TIXML_USE_STL - /// Constructor. - TiXmlDocument(const std::string& documentName); - #endif - - TiXmlDocument(const TiXmlDocument& copy); - void operator=(const TiXmlDocument& copy); - - virtual ~TiXmlDocument() {} - - /** Load a file using the current document value. - Returns true if successful. Will delete any existing - document data before loading. - */ - bool LoadFile(TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING); - /// Save a file using the current document value. Returns true if successful. - bool SaveFile() const; - /// Load a file using the given filename. Returns true if successful. - bool LoadFile(const char * filename, TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING); - /// Save a file using the given filename. Returns true if successful. - bool SaveFile(const char * filename) const; - /** Load a file using the given FILE*. Returns true if successful. Note that this method - doesn't stream - the entire object pointed at by the FILE* - will be interpreted as an XML file. TinyXML doesn't stream in XML from the current - file location. Streaming may be added in the future. - */ - bool LoadFile(FILE*, TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING); - /// Save a file using the given FILE*. Returns true if successful. - bool SaveFile(FILE*) const; - - #ifdef TIXML_USE_STL - bool LoadFile(const std::string& filename, TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING) ///< STL std::string version. - { - StringToBuffer f(filename); - return (f.buffer && LoadFile(f.buffer, encoding)); - } - bool SaveFile(const std::string& filename) const ///< STL std::string version. - { - StringToBuffer f(filename); - return (f.buffer && SaveFile(f.buffer)); - } - /** Write the document to a string using formatted printing ("pretty print"). - @return the document as a formatted standard string. - */ - std::string GetAsString(); - #endif - - /** Write the document to a string using formatted printing ("pretty print"). - @param buffer A character buffer that should be big enough to hold your document. - @param bufferSize The size of @p buffer. - - @return True if the document could be copied into @p buffer, else false. - */ - bool GetAsCharBuffer(char* buffer, size_t bufferSize); - - /** Parse the given null terminated block of xml data. Passing in an encoding to this - method (either TIXML_ENCODING_LEGACY or TIXML_ENCODING_UTF8 will force TinyXml - to use that encoding, regardless of what TinyXml might otherwise try to detect. - */ - virtual const char* Parse(const char* p, TiXmlParsingData* data = 0, TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING); - - /** Get the root element -- the only top level element -- of the document. - In well formed XML, there should only be one. TinyXml is tolerant of - multiple elements at the document level. - */ - const TiXmlElement* RootElement() const { return FirstChildElement(); } - TiXmlElement* RootElement() { return FirstChildElement(); } - - /** If an error occurs, Error will be set to true. Also, - - The ErrorId() will contain the integer identifier of the error (not generally useful) - - The ErrorDesc() method will return the name of the error. (very useful) - - The ErrorRow() and ErrorCol() will return the location of the error (if known) - */ - bool Error() const { return error; } - - /// Contains a textual (english) description of the error if one occurs. - const char * ErrorDesc() const { return errorDesc.c_str (); } - - /** Generally, you probably want the error string (ErrorDesc()). But if you - prefer the ErrorId, this function will fetch it. - */ - int ErrorId() const { return errorId; } - - /** Returns the location (if known) of the error. The first column is column 1, - and the first row is row 1. A value of 0 means the row and column wasn't applicable - (memory errors, for example, have no row/column) or the parser lost the error. (An - error in the error reporting, in that case.) - - @sa SetTabSize, Row, Column - */ - int ErrorRow() { return errorLocation.row+1; } - int ErrorCol() { return errorLocation.col+1; } ///< The column where the error occured. See ErrorRow() - - /** SetTabSize() allows the error reporting functions (ErrorRow() and ErrorCol()) - to report the correct values for row and column. It does not change the output - or input in any way. - - By calling this method, with a tab size - greater than 0, the row and column of each node and attribute is stored - when the file is loaded. Very useful for tracking the DOM back in to - the source file. - - The tab size is required for calculating the location of nodes. If not - set, the default of 4 is used. The tabsize is set per document. Setting - the tabsize to 0 disables row/column tracking. - - Note that row and column tracking is not supported when using operator>>. - - The tab size needs to be enabled before the parse or load. Correct usage: - @verbatim - TiXmlDocument doc; - doc.SetTabSize(8); - doc.Load("myfile.xml"); - @endverbatim - - @sa Row, Column - */ - void SetTabSize(int _tabsize) { tabsize = _tabsize; } - - int TabSize() const { return tabsize; } - - /** If you have handled the error, it can be reset with this call. The error - state is automatically cleared if you Parse a new XML block. - */ - void ClearError() { error = false; - errorId = 0; - errorDesc = ""; - errorLocation.row = errorLocation.col = 0; - //errorLocation.last = 0; - } - - /** Dump the document to standard out. */ - void Print() const { Print(stdout, 0); } - - /// Print this Document to a FILE stream. - virtual void Print(FILE* cfile, int depth = 0) const; - // [internal use] - void SetError(int err, const char* errorLocation, TiXmlParsingData* prevData, TiXmlEncoding encoding); - - virtual const TiXmlDocument* ToDocument() const { return this; } ///< Cast to a more defined type. Will return null not of the requested type. - virtual TiXmlDocument* ToDocument() { return this; } ///< Cast to a more defined type. Will return null not of the requested type. - -protected : - virtual void StreamOut (TIXML_OSTREAM * out) const; - virtual void FormattedStreamOut(TIXML_OSTREAM * stream, int depth) const; - // [internal use] - virtual TiXmlNode* Clone() const; - #ifdef TIXML_USE_STL - virtual void StreamIn(TIXML_ISTREAM * in, TIXML_STRING * tag); - #endif - -private: - void CopyTo(TiXmlDocument* target) const; - - bool error; - int errorId; - TIXML_STRING errorDesc; - int tabsize; - TiXmlCursor errorLocation; - bool useMicrosoftBOM; // the UTF-8 BOM were found when read. Note this, and try to write. -}; - - -/** - A TiXmlHandle is a class that wraps a node pointer with null checks; this is - an incredibly useful thing. Note that TiXmlHandle is not part of the TinyXml - DOM structure. It is a separate utility class. - - Take an example: - @verbatim - - - - - - - @endverbatim - - Assuming you want the value of "attributeB" in the 2nd "Child" element, it's very - easy to write a *lot* of code that looks like: - - @verbatim - TiXmlElement* root = document.FirstChildElement("Document"); - if (root) - { - TiXmlElement* element = root->FirstChildElement("Element"); - if (element) - { - TiXmlElement* child = element->FirstChildElement("Child"); - if (child) - { - TiXmlElement* child2 = child->NextSiblingElement("Child"); - if (child2) - { - // Finally do something useful. - @endverbatim - - And that doesn't even cover "else" cases. TiXmlHandle addresses the verbosity - of such code. A TiXmlHandle checks for null pointers so it is perfectly safe - and correct to use: - - @verbatim - TiXmlHandle docHandle(&document); - TiXmlElement* child2 = docHandle.FirstChild("Document").FirstChild("Element").Child("Child", 1).Element(); - if (child2) - { - // do something useful - @endverbatim - - Which is MUCH more concise and useful. - - It is also safe to copy handles - internally they are nothing more than node pointers. - @verbatim - TiXmlHandle handleCopy = handle; - @endverbatim - - What they should not be used for is iteration: - - @verbatim - int i=0; - while (true) - { - TiXmlElement* child = docHandle.FirstChild("Document").FirstChild("Element").Child("Child", i).Element(); - if (!child) - break; - // do something - ++i; - } - @endverbatim - - It seems reasonable, but it is in fact two embedded while loops. The Child method is - a linear walk to find the element, so this code would iterate much more than it needs - to. Instead, prefer: - - @verbatim - TiXmlElement* child = docHandle.FirstChild("Document").FirstChild("Element").FirstChild("Child").Element(); - - for (child; child; child=child->NextSiblingElement()) - { - // do something - } - @endverbatim -*/ -class TiXmlHandle -{ -public: - /// Create a handle from any node (at any depth of the tree.) This can be a null pointer. - TiXmlHandle(TiXmlNode* _node) { this->node = _node; } - /// Copy constructor - TiXmlHandle(const TiXmlHandle& ref) { this->node = ref.node; } - TiXmlHandle operator=(const TiXmlHandle& ref) { this->node = ref.node; return *this; } - - /// Return a handle to the first child node. - TiXmlHandle FirstChild() const; - /// Return a handle to the first child node with the given name. - TiXmlHandle FirstChild(const char * value) const; - /// Return a handle to the first child element. - TiXmlHandle FirstChildElement() const; - /// Return a handle to the first child element with the given name. - TiXmlHandle FirstChildElement(const char * value) const; - - /** Return a handle to the "index" child with the given name. - The first child is 0, the second 1, etc. - */ - TiXmlHandle Child(const char* value, int index) const; - /** Return a handle to the "index" child. - The first child is 0, the second 1, etc. - */ - TiXmlHandle Child(int index) const; - /** Return a handle to the "index" child element with the given name. - The first child element is 0, the second 1, etc. Note that only TiXmlElements - are indexed: other types are not counted. - */ - TiXmlHandle ChildElement(const char* value, int index) const; - /** Return a handle to the "index" child element. - The first child element is 0, the second 1, etc. Note that only TiXmlElements - are indexed: other types are not counted. - */ - TiXmlHandle ChildElement(int index) const; - - #ifdef TIXML_USE_STL - TiXmlHandle FirstChild(const std::string& _value) const { return FirstChild(_value.c_str()); } - TiXmlHandle FirstChildElement(const std::string& _value) const { return FirstChildElement(_value.c_str()); } - - TiXmlHandle Child(const std::string& _value, int index) const { return Child(_value.c_str(), index); } - TiXmlHandle ChildElement(const std::string& _value, int index) const { return ChildElement(_value.c_str(), index); } - #endif - - /// Return the handle as a TiXmlNode. This may return null. - TiXmlNode* Node() const { return node; } - /// Return the handle as a TiXmlElement. This may return null. - TiXmlElement* Element() const { return ((node && node->ToElement()) ? node->ToElement() : 0); } - /// Return the handle as a TiXmlText. This may return null. - TiXmlText* Text() const { return ((node && node->ToText()) ? node->ToText() : 0); } - /// Return the handle as a TiXmlUnknown. This may return null; - TiXmlUnknown* Unknown() const { return ((node && node->ToUnknown()) ? node->ToUnknown() : 0); } - -private: - TiXmlNode* node; -}; - -#endif - diff --git a/plugins/UserInfoEx/src/ex_import/tinyxmlerror.cpp b/plugins/UserInfoEx/src/ex_import/tinyxmlerror.cpp deleted file mode 100644 index d84be9bfc4..0000000000 --- a/plugins/UserInfoEx/src/ex_import/tinyxmlerror.cpp +++ /dev/null @@ -1,61 +0,0 @@ -/* -www.sourceforge.net/projects/tinyxml -Original code (2.0 and earlier)copyright (c) 2000-2002 Lee Thomason (www.grinninglizard.com) - -This software is provided 'as-is', without any express or implied -warranty. In no event will the authors be held liable for any -damages arising from the use of this software. - -Permission is granted to anyone to use this software for any -purpose, including commercial applications, and to alter it and -redistribute it freely, subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must -not claim that you wrote the original software. If you use this -software in a product, an acknowledgment in the product documentation -would be appreciated but is not required. - -2. Altered source versions must be plainly marked as such, and -must not be misrepresented as being the original software. - -3. This notice may not be removed or altered from any source -distribution. - -=============================================================================== - -UserinfoEx plugin for Miranda IM - -Copyright: -© 2006-2010 DeathAxe, Yasnovidyashii, Merlin, K. Romanov, Kreol -=============================================================================== -*/ - -#include "../stdafx.h" - -// The goal of the seperate error file is to make the first -// step towards localization. tinyxml (currently) only supports -// english error messages, but the could now be translated. -// -// It also cleans up the code a bit. -// - -const char* TiXmlBase::errorString[ TIXML_ERROR_STRING_COUNT ] = -{ - "No error", - "Error", - "Failed to open file", - "Memory allocation failed.", - "Error parsing Element.", - "Failed to read Element name", - "Error reading Element value.", - "Error reading Attributes.", - "Error: empty tag.", - "Error reading end tag.", - "Error parsing Unknown.", - "Error parsing Comment.", - "Error parsing Declaration.", - "Error document empty.", - "Error null (0) or unexpected EOF found in input stream.", - "Error parsing CDATA.", - "Error when TiXmlDocument added to document, because TiXmlDocument can only be at the root.", -}; diff --git a/plugins/UserInfoEx/src/ex_import/tinyxmlparser.cpp b/plugins/UserInfoEx/src/ex_import/tinyxmlparser.cpp deleted file mode 100644 index f6e1df72b0..0000000000 --- a/plugins/UserInfoEx/src/ex_import/tinyxmlparser.cpp +++ /dev/null @@ -1,1440 +0,0 @@ -/* -www.sourceforge.net/projects/tinyxml -Original code (2.0 and earlier)copyright (c) 2000-2002 Lee Thomason (www.grinninglizard.com) - -This software is provided 'as-is', without any express or implied -warranty. In no event will the authors be held liable for any -damages arising from the use of this software. - -Permission is granted to anyone to use this software for any -purpose, including commercial applications, and to alter it and -redistribute it freely, subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must -not claim that you wrote the original software. If you use this -software in a product, an acknowledgment in the product documentation -would be appreciated but is not required. - -2. Altered source versions must be plainly marked as such, and -must not be misrepresented as being the original software. - -3. This notice may not be removed or altered from any source -distribution. - -=============================================================================== - -UserinfoEx plugin for Miranda IM - -Copyright: -© 2006-2010 DeathAxe, Yasnovidyashii, Merlin, K. Romanov, Kreol -=============================================================================== -*/ - -#include "../stdafx.h" - -// Note tha "PutString" hardcodes the same list. This -// is less flexible than it appears. Changing the entries -// or order will break putstring. -TiXmlBase::Entity TiXmlBase::entity[ NUM_ENTITY ] = -{ - { "&", 5, '&' }, - { "<", 4, '<' }, - { ">", 4, '>' }, - { """, 6, '\"' }, - { "'", 6, '\'' } -}; - -// Bunch of unicode info at: -// http://www.unicode.org/faq/utf_bom.html -// Including the basic of this table, which determines the #bytes in the -// sequence from the lead byte. 1 placed for invalid sequences -- -// although the result will be junk, pass it through as much as possible. -// Beware of the non-characters in UTF-8: -// ef bb bf (Microsoft "lead bytes") -// ef bf be -// ef bf bf - -const unsigned char TIXML_UTF_LEAD_0 = 0xefU; -const unsigned char TIXML_UTF_LEAD_1 = 0xbbU; -const unsigned char TIXML_UTF_LEAD_2 = 0xbfU; - -const int TiXmlBase::utf8ByteTable[256] = -{ - // 0 1 2 3 4 5 6 7 8 9 a b c d e f - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x00 - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x10 - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x20 - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x30 - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x40 - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x50 - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x60 - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x70 End of ASCII range - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x80 0x80 to 0xc1 invalid - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x90 - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0xa0 - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0xb0 - 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, // 0xc0 0xc2 to 0xdf 2 byte - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, // 0xd0 - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // 0xe0 0xe0 to 0xef 3 byte - 4, 4, 4, 4, 4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 // 0xf0 0xf0 to 0xf4 4 byte, 0xf5 and higher invalid -}; - - -void TiXmlBase::ConvertUTF32ToUTF8(unsigned long input, char* output, int* length) -{ - const unsigned long BYTE_MASK = 0xBF; - const unsigned long BYTE_MARK = 0x80; - const unsigned long FIRST_BYTE_MARK[7] = { 0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC }; - - if (input < 0x80) - *length = 1; - else if (input < 0x800) - *length = 2; - else if (input < 0x10000) - *length = 3; - else if (input < 0x200000) - *length = 4; - else { - *length = 0; return; - } // This code won't covert this correctly anyway. - - output += *length; - - // Scary scary fall throughs. - switch (*length) { - case 4: - --output; - *output = (char)((input | BYTE_MARK) & BYTE_MASK); - input >>= 6; - case 3: - --output; - *output = (char)((input | BYTE_MARK) & BYTE_MASK); - input >>= 6; - case 2: - --output; - *output = (char)((input | BYTE_MARK) & BYTE_MASK); - input >>= 6; - case 1: - --output; - *output = (char)(input | FIRST_BYTE_MARK[*length]); - } -} - - -/*static*/ int TiXmlBase::IsAlpha(unsigned char anyByte, TiXmlEncoding /*encoding*/) -{ - // This will only work for low-ascii, everything else is assumed to be a valid - // letter. I'm not sure this is the best approach, but it is quite tricky trying - // to figure out alhabetical vs. not across encoding. So take a very - // conservative approach. - -// if (encoding == TIXML_ENCODING_UTF8) -// { - if (anyByte < 127) - return isalpha(anyByte); - else - return 1; // What else to do? The unicode set is huge...get the english ones right. -// } -// else -// { -// return isalpha(anyByte); -// } -} - - -/*static*/ int TiXmlBase::IsAlphaNum(unsigned char anyByte, TiXmlEncoding /*encoding*/) -{ - // This will only work for low-ascii, everything else is assumed to be a valid - // letter. I'm not sure this is the best approach, but it is quite tricky trying - // to figure out alhabetical vs. not across encoding. So take a very - // conservative approach. - -// if (encoding == TIXML_ENCODING_UTF8) -// { - if (anyByte < 127) - return isalnum(anyByte); - else - return 1; // What else to do? The unicode set is huge...get the english ones right. -// } -// else -// { -// return isalnum(anyByte); -// } -} - - -class TiXmlParsingData -{ - friend class TiXmlDocument; -public: - void Stamp(const char* now, TiXmlEncoding encoding); - - const TiXmlCursor& Cursor() { return cursor; } - -private: - // Only used by the document! - TiXmlParsingData(const char* start, int _tabsize, int row, int col) - { - assert(start); - stamp = start; - tabsize = _tabsize; - cursor.row = row; - cursor.col = col; - } - - TiXmlCursor cursor; - const char* stamp; - int tabsize; -}; - - -void TiXmlParsingData::Stamp(const char* now, TiXmlEncoding encoding) -{ - assert(now); - - // Do nothing if the tabsize is 0. - if (tabsize < 1) { - return; - } - - // Get the current row, column. - int row = cursor.row; - int col = cursor.col; - const char* p = stamp; - assert(p); - - while (p < now) { - // Treat p as unsigned, so we have a happy compiler. - const unsigned char* pU = (const unsigned char*)p; - - // Code contributed by Fletcher Dunn: (modified by lee) - switch (*pU) { - case 0: - // We *should* never get here, but in case we do, don't - // advance past the terminating null character, ever - return; - - case '\r': - // bump down to the next line - ++row; - col = 0; - // Eat the character - ++p; - - // Check for \r\n sequence, and treat this as a single character - if (*p == '\n') { - ++p; - } - break; - - case '\n': - // bump down to the next line - ++row; - col = 0; - - // Eat the character - ++p; - - // Check for \n\r sequence, and treat this as a single - // character. (Yes, this bizarre thing does occur still - // on some arcane platforms...) - if (*p == '\r') { - ++p; - } - break; - - case '\t': - // Eat the character - ++p; - - // Skip to next tab stop - col = (col / tabsize + 1) * tabsize; - break; - - case TIXML_UTF_LEAD_0: - if (encoding == TIXML_ENCODING_UTF8) { - if (*(p + 1) && *(p + 2)) { - // In these cases, don't advance the column. These are - // 0-width spaces. - if (*(pU + 1) == TIXML_UTF_LEAD_1 && *(pU + 2) == TIXML_UTF_LEAD_2) - p += 3; - else if (*(pU + 1) == 0xbfU && *(pU + 2) == 0xbeU) - p += 3; - else if (*(pU + 1) == 0xbfU && *(pU + 2) == 0xbfU) - p += 3; - else { - p += 3; ++col; - } // A normal character. - } - } - else { - ++p; - ++col; - } - break; - - default: - if (encoding == TIXML_ENCODING_UTF8) { - // Eat the 1 to 4 byte utf8 character. - int step = TiXmlBase::utf8ByteTable[*((unsigned char*)p)]; - if (step == 0) - step = 1; // Error case from bad encoding, but handle gracefully. - p += step; - - // Just advance one column, of course. - ++col; - } - else { - ++p; - ++col; - } - break; - } - } - cursor.row = row; - cursor.col = col; - assert(cursor.row >= -1); - assert(cursor.col >= -1); - stamp = p; - assert(stamp); -} - - -const char* TiXmlBase::SkipWhiteSpace(const char* p, TiXmlEncoding encoding) -{ - if (!p || !*p) { - return nullptr; - } - if (encoding == TIXML_ENCODING_UTF8) { - while (*p) { - const unsigned char* pU = (const unsigned char*)p; - - // Skip the stupid Microsoft UTF-8 Byte order marks - if (*(pU + 0) == TIXML_UTF_LEAD_0 - && *(pU + 1) == TIXML_UTF_LEAD_1 - && *(pU + 2) == TIXML_UTF_LEAD_2) { - p += 3; - continue; - } - else if (*(pU + 0) == TIXML_UTF_LEAD_0 - && *(pU + 1) == 0xbfU - && *(pU + 2) == 0xbeU) { - p += 3; - continue; - } - else if (*(pU + 0) == TIXML_UTF_LEAD_0 - && *(pU + 1) == 0xbfU - && *(pU + 2) == 0xbfU) { - p += 3; - continue; - } - - if (IsWhiteSpace(*p) || *p == '\n' || *p == '\r') // Still using old rules for white space. - ++p; - else - break; - } - } - else { - while (*p && IsWhiteSpace(*p) || *p == '\n' || *p == '\r') - ++p; - } - - return p; -} - -#ifdef TIXML_USE_STL -/*static*/ bool TiXmlBase::StreamWhiteSpace(TIXML_ISTREAM * in, TIXML_STRING * tag) -{ - for (;;) { - if (!in->good()) return false; - - int c = in->peek(); - // At this scope, we can't get to a document. So fail silently. - if (!IsWhiteSpace(c) || c <= 0) - return true; - - *tag += (char)in->get(); - } -} - -/*static*/ bool TiXmlBase::StreamTo(TIXML_ISTREAM * in, int character, TIXML_STRING * tag) -{ - //assert(character > 0 && character < 128); // else it won't work in utf-8 - while (in->good()) { - int c = in->peek(); - if (c == character) - return true; - if (c <= 0) // Silent failure: can't get document at this scope - return false; - - in->get(); - *tag += (char)c; - } - return false; -} -#endif - -const char* TiXmlBase::ReadName(const char* p, TIXML_STRING * name, TiXmlEncoding encoding) -{ - *name = ""; - assert(p); - - // Names start with letters or underscores. - // Of course, in unicode, tinyxml has no idea what a letter *is*. The - // algorithm is generous. - // - // After that, they can be letters, underscores, numbers, - // hyphens, or colons. (Colons are valid ony for namespaces, - // but tinyxml can't tell namespaces from names.) - if (p && *p - && (IsAlpha((unsigned char)*p, encoding) || *p == '_')) { - while (p && *p - && (IsAlphaNum((unsigned char)*p, encoding) - || *p == '_' - || *p == '-' - || *p == '.' - || *p == ':')) { - (*name) += *p; - ++p; - } - return p; - } - return nullptr; -} - -const char* TiXmlBase::GetEntity(const char* p, char* value, int* length, TiXmlEncoding encoding) -{ - // Presume an entity, and pull it out. - TIXML_STRING ent; - int i; - *length = 0; - - if (*(p + 1) && *(p + 1) == '#' && *(p + 2)) { - unsigned long ucs = 0; - ptrdiff_t delta = 0; - unsigned mult = 1; - - if (*(p + 2) == 'x') { - // Hexadecimal. - if (!*(p + 3)) return nullptr; - - const char* q = p + 3; - q = strchr(q, ';'); - - if (!q || !*q) return nullptr; - - delta = q - p; - --q; - - while (*q != 'x') { - if (*q >= '0' && *q <= '9') - ucs += mult * (*q - '0'); - else if (*q >= 'a' && *q <= 'f') - ucs += mult * (*q - 'a' + 10); - else if (*q >= 'A' && *q <= 'F') - ucs += mult * (*q - 'A' + 10); - else - return nullptr; - mult *= 16; - --q; - } - } - else { - // Decimal. - if (!*(p + 2)) return nullptr; - - const char* q = p + 2; - q = strchr(q, ';'); - - if (!q || !*q) return nullptr; - - delta = q - p; - --q; - - while (*q != '#') { - if (*q >= '0' && *q <= '9') - ucs += mult * (*q - '0'); - else - return nullptr; - mult *= 10; - --q; - } - } - if (encoding == TIXML_ENCODING_UTF8) { - // convert the UCS to UTF-8 - ConvertUTF32ToUTF8(ucs, value, length); - } - else { - *value = (char)ucs; - *length = 1; - } - return p + delta + 1; - } - - // Now try to match it. - for (i = 0; i < NUM_ENTITY; ++i) { - if (strncmp(entity[i].str, p, entity[i].strLength) == 0) { - assert(mir_strlen(entity[i].str) == entity[i].strLength); - *value = entity[i].chr; - *length = 1; - return (p + entity[i].strLength); - } - } - - // So it wasn't an entity, its unrecognized, or something like that. - *value = *p; // Don't put back the last one, since we return it! - //*length = 1; // Leave unrecognized entities - this doesn't really work. - // Just writes strange XML. - return p + 1; -} - - -bool TiXmlBase::StringEqual(const char* p, - const char* tag, - bool ignoreCase, - TiXmlEncoding encoding) -{ - assert(p); - assert(tag); - if (!p || !*p) { - assert(0); - return false; - } - - const char* q = p; - - if (ignoreCase) { - while (*q && *tag && ToLower(*q, encoding) == ToLower(*tag, encoding)) { - ++q; - ++tag; - } - - if (*tag == 0) - return true; - } - else { - while (*q && *tag && *q == *tag) { - ++q; - ++tag; - } - - if (*tag == 0) // Have we found the end of the tag, and everything equal? - return true; - } - return false; -} - -const char* TiXmlBase::ReadText(const char* p, - TIXML_STRING * text, - bool trimWhiteSpace, - const char* endTag, - bool caseInsensitive, - TiXmlEncoding encoding) -{ - *text = ""; - if (!trimWhiteSpace // certain tags always keep whitespace - || !condenseWhiteSpace) // if true, whitespace is always kept - { - // Keep all the white space. - while (p && *p - && !StringEqual(p, endTag, caseInsensitive, encoding) - ) { - int len; - char cArr[4] = { 0, 0, 0, 0 }; - p = GetChar(p, cArr, &len, encoding); - text->append(cArr, len); - } - } - else { - bool whitespace = false; - - // Remove leading white space: - p = SkipWhiteSpace(p, encoding); - while (p && *p - && !StringEqual(p, endTag, caseInsensitive, encoding)) { - if (*p == '\r' || *p == '\n') { - whitespace = true; - ++p; - } - else if (IsWhiteSpace(*p)) { - whitespace = true; - ++p; - } - else { - // If we've found whitespace, add it before the - // new character. Any whitespace just becomes a space. - if (whitespace) { - (*text) += ' '; - whitespace = false; - } - int len; - char cArr[4] = { 0, 0, 0, 0 }; - p = GetChar(p, cArr, &len, encoding); - if (len == 1) - (*text) += cArr[0]; // more efficient - else - text->append(cArr, len); - } - } - } - return p + mir_strlen(endTag); -} - -#ifdef TIXML_USE_STL - -void TiXmlDocument::StreamIn(TIXML_ISTREAM * in, TIXML_STRING * tag) -{ - // The basic issue with a document is that we don't know what we're - // streaming. Read something presumed to be a tag (and hope), then - // identify it, and call the appropriate stream method on the tag. - // - // This "pre-streaming" will never read the closing ">" so the - // sub-tag can orient itself. - - if (!StreamTo(in, '<', tag)) { - SetError(TIXML_ERROR_PARSING_EMPTY, 0, 0, TIXML_ENCODING_UNKNOWN); - return; - } - - while (in->good()) { - int tagIndex = (int)tag->length(); - while (in->good() && in->peek() != '>') { - int c = in->get(); - if (c <= 0) { - SetError(TIXML_ERROR_EMBEDDED_NULL, 0, 0, TIXML_ENCODING_UNKNOWN); - break; - } - (*tag) += (char)c; - } - - if (in->good()) { - // We now have something we presume to be a node of - // some sort. Identify it, and call the node to - // continue streaming. - TiXmlNode* node = Identify(tag->c_str() + tagIndex, TIXML_DEFAULT_ENCODING); - - if (node) { - node->StreamIn(in, tag); - bool isElement = node->ToElement() != 0; - delete node; - node = 0; - - // If this is the root element, we're done. Parsing will be - // done by the >> operator. - if (isElement) { - return; - } - } - else { - SetError(TIXML_ERROR, 0, 0, TIXML_ENCODING_UNKNOWN); - return; - } - } - } - // We should have returned sooner. - SetError(TIXML_ERROR, 0, 0, TIXML_ENCODING_UNKNOWN); -} - -#endif - -const char* TiXmlDocument::Parse(const char* p, TiXmlParsingData* prevData, TiXmlEncoding encoding) -{ - ClearError(); - - // Parse away, at the document level. Since a document - // contains nothing but other tags, most of what happens - // here is skipping white space. - if (!p || !*p) { - SetError(TIXML_ERROR_DOCUMENT_EMPTY, nullptr, nullptr, TIXML_ENCODING_UNKNOWN); - return nullptr; - } - - // Note that, for a document, this needs to come - // before the while space skip, so that parsing - // starts from the pointer we are given. - location.Clear(); - if (prevData) { - location.row = prevData->cursor.row; - location.col = prevData->cursor.col; - } - else { - location.row = 0; - location.col = 0; - } - TiXmlParsingData data(p, TabSize(), location.row, location.col); - location = data.Cursor(); - - if (encoding == TIXML_ENCODING_UNKNOWN) { - // Check for the Microsoft UTF-8 lead bytes. - const unsigned char* pU = (const unsigned char*)p; - if (*(pU + 0) && *(pU + 0) == TIXML_UTF_LEAD_0 - && *(pU + 1) && *(pU + 1) == TIXML_UTF_LEAD_1 - && *(pU + 2) && *(pU + 2) == TIXML_UTF_LEAD_2) { - encoding = TIXML_ENCODING_UTF8; - useMicrosoftBOM = true; - } - } - - p = SkipWhiteSpace(p, encoding); - if (!p) { - SetError(TIXML_ERROR_DOCUMENT_EMPTY, nullptr, nullptr, TIXML_ENCODING_UNKNOWN); - return nullptr; - } - - while (p && *p) { - TiXmlNode* node = Identify(p, encoding); - if (node) { - p = node->Parse(p, &data, encoding); - LinkEndChild(node); - } - else { - break; - } - - // Did we get encoding info? - if (encoding == TIXML_ENCODING_UNKNOWN - && node->ToDeclaration()) { - TiXmlDeclaration* dec = node->ToDeclaration(); - const char* enc = dec->Encoding(); - assert(enc); - - if (*enc == 0) - encoding = TIXML_ENCODING_UTF8; - else if (StringEqual(enc, "UTF-8", true, TIXML_ENCODING_UNKNOWN)) - encoding = TIXML_ENCODING_UTF8; - else if (StringEqual(enc, "UTF8", true, TIXML_ENCODING_UNKNOWN)) - encoding = TIXML_ENCODING_UTF8; // incorrect, but be nice - else - encoding = TIXML_ENCODING_LEGACY; - } - - p = SkipWhiteSpace(p, encoding); - } - - // Was this empty? - if (!firstChild) { - SetError(TIXML_ERROR_DOCUMENT_EMPTY, nullptr, nullptr, encoding); - return nullptr; - } - - // All is well. - return p; -} - -void TiXmlDocument::SetError(int err, const char* pError, TiXmlParsingData* data, TiXmlEncoding encoding) -{ - // The first error in a chain is more accurate - don't set again! - if (error) - return; - - assert(err > 0 && err < TIXML_ERROR_STRING_COUNT); - error = true; - errorId = err; - errorDesc = errorString[errorId]; - - errorLocation.Clear(); - if (pError && data) { - data->Stamp(pError, encoding); - errorLocation = data->Cursor(); - } -} - - -TiXmlNode* TiXmlNode::Identify(const char* p, TiXmlEncoding encoding) -{ - TiXmlNode* returnNode = nullptr; - - p = SkipWhiteSpace(p, encoding); - if (!p || !*p || *p != '<') { - return nullptr; - } - - TiXmlDocument* doc = GetDocument(); - p = SkipWhiteSpace(p, encoding); - - if (!p || !*p) { - return nullptr; - } - - // What is this thing? - // - Elements start with a letter or underscore, but xml is reserved. - // - Comments: "; - - if (!StringEqual(p, startTag, false, encoding)) { - document->SetError(TIXML_ERROR_PARSING_COMMENT, p, data, encoding); - return nullptr; - } - p += mir_strlen(startTag); - p = ReadText(p, &value, false, endTag, false, encoding); - return p; -} - - -const char* TiXmlAttribute::Parse(const char* p, TiXmlParsingData* data, TiXmlEncoding encoding) -{ - p = SkipWhiteSpace(p, encoding); - if (!p || !*p) return nullptr; - - // int tabsize = 4; - // if (document) - // tabsize = document->TabSize(); - - if (data) { - data->Stamp(p, encoding); - location = data->Cursor(); - } - // Read the name, the '=' and the value. - const char* pErr = p; - p = ReadName(p, &name, encoding); - if (!p || !*p) { - if (document) document->SetError(TIXML_ERROR_READING_ATTRIBUTES, pErr, data, encoding); - return nullptr; - } - p = SkipWhiteSpace(p, encoding); - if (!p || !*p || *p != '=') { - if (document) document->SetError(TIXML_ERROR_READING_ATTRIBUTES, p, data, encoding); - return nullptr; - } - - ++p; // skip '=' - p = SkipWhiteSpace(p, encoding); - if (!p || !*p) { - if (document) document->SetError(TIXML_ERROR_READING_ATTRIBUTES, p, data, encoding); - return nullptr; - } - - const char* end; - const char SINGLE_QUOTE = '\''; - const char DOUBLE_QUOTE = '\"'; - - if (*p == SINGLE_QUOTE) { - ++p; - end = "\'"; // single quote in string - p = ReadText(p, &value, false, end, false, encoding); - } - else if (*p == DOUBLE_QUOTE) { - ++p; - end = "\""; // double quote in string - p = ReadText(p, &value, false, end, false, encoding); - } - else { - // All attribute values should be in single or double quotes. - // But this is such a common error that the parser will try - // its best, even without them. - value = ""; - while (p && *p // existence - && !IsWhiteSpace(*p) && *p != '\n' && *p != '\r' // whitespace - && *p != '/' && *p != '>') // tag end - { - if (*p == SINGLE_QUOTE || *p == DOUBLE_QUOTE) { - // [ 1451649 ] Attribute values with trailing quotes not handled correctly - // We did not have an opening quote but seem to have a - // closing one. Give up and throw an error. - if (document) document->SetError(TIXML_ERROR_READING_ATTRIBUTES, p, data, encoding); - return nullptr; - } - value += *p; - ++p; - } - } - return p; -} - -#ifdef TIXML_USE_STL -void TiXmlText::StreamIn(TIXML_ISTREAM * in, TIXML_STRING * tag) -{ - if (cdata) { - int c = in->get(); - if (c <= 0) { - TiXmlDocument* document = GetDocument(); - if (document) - document->SetError(TIXML_ERROR_EMBEDDED_NULL, 0, 0, TIXML_ENCODING_UNKNOWN); - return; - } - - (*tag) += (char)c; - - if (c == '>' - && tag->at(tag->length() - 2) == ']' - && tag->at(tag->length() - 3) == ']') { - // All is well. - return; - } - } - else { - while (in->good()) { - int c = in->peek(); - if (c == '<') - return; - if (c <= 0) { - TiXmlDocument* document = GetDocument(); - if (document) - document->SetError(TIXML_ERROR_EMBEDDED_NULL, 0, 0, TIXML_ENCODING_UNKNOWN); - return; - } - - (*tag) += (char)c; - in->get(); - } - } -} -#endif - -const char* TiXmlText::Parse(const char* p, TiXmlParsingData* data, TiXmlEncoding encoding) -{ - value = ""; - TiXmlDocument* document = GetDocument(); - - if (data) { - data->Stamp(p, encoding); - location = data->Cursor(); - } - - const char* const startTag = ""; - - if (cdata || StringEqual(p, startTag, false, encoding)) { - cdata = true; - - if (!StringEqual(p, startTag, false, encoding)) { - document->SetError(TIXML_ERROR_PARSING_CDATA, p, data, encoding); - return nullptr; - } - p += mir_strlen(startTag); - - // Keep all the white space, ignore the encoding, etc. - while (p && *p - && !StringEqual(p, endTag, false, encoding) - ) { - value += *p; - ++p; - } - - TIXML_STRING dummy; - p = ReadText(p, &dummy, false, endTag, false, encoding); - return p; - } - else { - bool ignoreWhite = true; - - const char* end = "<"; - p = ReadText(p, &value, ignoreWhite, end, false, encoding); - if (p) - return p - 1; // don't truncate the '<' - return nullptr; - } -} - -#ifdef TIXML_USE_STL -void TiXmlDeclaration::StreamIn(TIXML_ISTREAM * in, TIXML_STRING * tag) -{ - while (in->good()) { - int c = in->get(); - if (c <= 0) { - TiXmlDocument* document = GetDocument(); - if (document) - document->SetError(TIXML_ERROR_EMBEDDED_NULL, 0, 0, TIXML_ENCODING_UNKNOWN); - return; - } - (*tag) += (char)c; - - if (c == '>') { - // All is well. - return; - } - } -} -#endif - -const char* TiXmlDeclaration::Parse(const char* p, TiXmlParsingData* data, TiXmlEncoding _encoding) -{ - p = SkipWhiteSpace(p, _encoding); - // Find the beginning, find the end, and look for - // the stuff in-between. - TiXmlDocument* document = GetDocument(); - if (!p || !*p || !StringEqual(p, "SetError(TIXML_ERROR_PARSING_DECLARATION, nullptr, nullptr, _encoding); - return nullptr; - } - if (data) { - data->Stamp(p, _encoding); - location = data->Cursor(); - } - p += 5; - - version = ""; - encoding = ""; - standalone = ""; - - while (p && *p) { - if (*p == '>') { - ++p; - return p; - } - - p = SkipWhiteSpace(p, _encoding); - if (StringEqual(p, "version", true, _encoding)) { - TiXmlAttribute attrib; - p = attrib.Parse(p, data, _encoding); - version = attrib.Value(); - } - else if (StringEqual(p, "encoding", true, _encoding)) { - TiXmlAttribute attrib; - p = attrib.Parse(p, data, _encoding); - encoding = attrib.Value(); - } - else if (StringEqual(p, "standalone", true, _encoding)) { - TiXmlAttribute attrib; - p = attrib.Parse(p, data, _encoding); - standalone = attrib.Value(); - } - else { - // Read over whatever it is. - while (p && *p && *p != '>' && !IsWhiteSpace(*p)) - ++p; - } - } - return nullptr; -} - -bool TiXmlText::Blank() const -{ - for (unsigned i = 0; i < value.length(); i++) - if (!IsWhiteSpace(value[i])) - return false; - return true; -} diff --git a/plugins/UserInfoEx/src/stdafx.h b/plugins/UserInfoEx/src/stdafx.h index 7812332a92..095017dd57 100644 --- a/plugins/UserInfoEx/src/stdafx.h +++ b/plugins/UserInfoEx/src/stdafx.h @@ -141,8 +141,6 @@ unsigned int hashSettingW_M2(const char * key); //new Murma2 hash #include "psp_base.h" #include "psp_options.h" #include "ex_import/svc_ExImport.h" -#include "ex_import/tinystr.h" -#include "ex_import/tinyxml.h" #include "ex_import/mir_rfcCodecs.h" #include "ex_import/classExImContactBase.h" #include "ex_import/dlg_ExImProgress.h" diff --git a/plugins/UserInfoEx/src/version.h b/plugins/UserInfoEx/src/version.h index d8383d418e..6df9e5274a 100644 --- a/plugins/UserInfoEx/src/version.h +++ b/plugins/UserInfoEx/src/version.h @@ -1,7 +1,7 @@ #define __MAJOR_VERSION 0 #define __MINOR_VERSION 8 #define __RELEASE_NUM 5 -#define __BUILD_NUM 1 +#define __BUILD_NUM 2 #include -- cgit v1.2.3