[xiph-commits] r16638 - in trunk/oggdsf/src/lib/helper: . common pugixml
cristianadam at svn.xiph.org
cristianadam at svn.xiph.org
Mon Oct 12 14:33:00 PDT 2009
Author: cristianadam
Date: 2009-10-12 14:33:00 -0700 (Mon, 12 Oct 2009)
New Revision: 16638
Added:
trunk/oggdsf/src/lib/helper/common/
trunk/oggdsf/src/lib/helper/common/Log.h
trunk/oggdsf/src/lib/helper/common/util.h
trunk/oggdsf/src/lib/helper/pugixml/
trunk/oggdsf/src/lib/helper/pugixml/LICENSE
trunk/oggdsf/src/lib/helper/pugixml/pugiconfig.hpp
trunk/oggdsf/src/lib/helper/pugixml/pugixml-2005.vcproj
trunk/oggdsf/src/lib/helper/pugixml/pugixml.cpp
trunk/oggdsf/src/lib/helper/pugixml/pugixml.hpp
trunk/oggdsf/src/lib/helper/pugixml/pugixml.vcproj
trunk/oggdsf/src/lib/helper/pugixml/pugixpath.cpp
Log:
Added lightweight xml parsing, logging libraries.
Added: trunk/oggdsf/src/lib/helper/common/Log.h
===================================================================
--- trunk/oggdsf/src/lib/helper/common/Log.h (rev 0)
+++ trunk/oggdsf/src/lib/helper/common/Log.h 2009-10-12 21:33:00 UTC (rev 16638)
@@ -0,0 +1,486 @@
+//===========================================================================
+// Copyright (C) 2009 Cristian Adam
+//
+// Based upon Dr. Dobb's "Logging In C++" (September 05, 2007) article
+// by Petru Marginean
+//
+//Redistribution and use in source and binary forms, with or without
+//modification, are permitted provided that the following conditions
+//are met:
+//
+//- Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//
+//- Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+//
+//- Neither the name of Cristian Adam nor the names of contributors
+// may be used to endorse or promote products derived from this software
+// without specific prior written permission.
+//
+//THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+//``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+//LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+//PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE ORGANISATION OR
+//CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+//EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+//PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+//PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+//LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+//NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+//SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//===========================================================================
+
+#ifndef __LOG_H__
+#define __LOG_H__
+
+#include <sstream>
+#include <iomanip>
+#include <string>
+#include <vector>
+#include <map>
+#include <cstdio>
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#include <MMSystem.h>
+
+#ifndef WINCE
+#pragma message("Automatically linking to winmm.lib")
+#pragma comment (lib, "winmm")
+#else
+#pragma message("Automatically linking to mmtimer.lib")
+#pragma comment (lib, "mmtimer")
+#endif
+
+inline std::wstring NowTime();
+
+enum LogLevel
+{
+ logNONE, // Used with ReportingLevel to suppress all logging at runtime.
+ logERROR,
+ logWARNING,
+ logINFO,
+ logDEBUG,
+ logDEBUG1,
+ logDEBUG2,
+ logDEBUG3,
+ logDEBUG4
+};
+
+template <typename T>
+class LogT : public T
+{
+public:
+ LogT();
+ virtual ~LogT();
+
+ std::wostringstream& Get(LogLevel level = logINFO);
+
+public:
+ static LogLevel& ReportingLevel();
+ static std::wstring ToString(LogLevel level);
+ static LogLevel FromString(const std::wstring& level);
+
+protected:
+ std::wostringstream os;
+
+private:
+ LogT(const LogT&);
+ LogT& operator =(const LogT&);
+};
+
+template <typename T>
+LogT<T>::LogT()
+{
+}
+
+template <typename T>
+std::wostringstream& LogT<T>::Get(LogLevel level)
+{
+ os << L"- " << NowTime();
+ os << L" " << ToString(level) << L": ";
+ os << std::wstring(level > logDEBUG ? level - logDEBUG : 0, L'\t');
+
+ return os;
+}
+
+template <typename T>
+LogT<T>::~LogT()
+{
+ os << L"\r\n";
+ T::Output(os.str());
+}
+
+template <typename T>
+LogLevel& LogT<T>::ReportingLevel()
+{
+ static LogLevel reportingLevel = logDEBUG4;
+ return reportingLevel;
+}
+
+template <typename T>
+std::wstring LogT<T>::ToString(LogLevel level)
+{
+ static const wchar_t* const buffer[] =
+ {
+ L"ERROR", L"WARNING", L"INFO", L"DEBUG",
+ L"DEBUG1", L"DEBUG2", L"DEBUG3", L"DEBUG4"
+ };
+ return buffer[level - 1];
+}
+
+template <typename T>
+LogLevel LogT<T>::FromString(const std::wstring& level)
+{
+ typedef std::map<std::wstring, LogLevel> LogLevelNamesMap;
+ static LogLevelNamesMap logLevels;
+
+ if (logLevels.empty())
+ {
+ logLevels[L"ERROR"] = logERROR;
+ logLevels[L"WARNING"] = logWARNING;
+ logLevels[L"INFO"] = logINFO;
+ logLevels[L"DEBUG"] = logDEBUG;
+ logLevels[L"DEBUG1"] = logDEBUG1;
+ logLevels[L"DEBUG2"] = logDEBUG2;
+ logLevels[L"DEBUG3"] = logDEBUG3;
+ logLevels[L"DEBUG4"] = logDEBUG4;
+ }
+
+ LogLevelNamesMap::iterator it = logLevels.find(level);
+ if (it == logLevels.end())
+ {
+ Log<T>().Get(logWARNING) << L"Unknown logging level '" << level
+ << L"'. Using INFO level as default.";
+
+ return logINFO;
+ }
+
+ return it->second;
+}
+
+//===========================================================================
+
+#ifdef __ATLSTR_H__
+inline std::wostream& operator << (std::wostream& wos, const CString& str)
+{
+ wos << static_cast<const wchar_t*>(str);
+ return wos;
+}
+#endif
+
+#ifdef __ATLCOMCLI_H__
+inline std::wostream& operator << (std::wostream& wos, const CComBSTR& str)
+{
+ wos << static_cast<const wchar_t*>(str);
+ return wos;
+}
+
+inline std::wostream& operator << (std::wostream& wos, const CComVariant& var)
+{
+ switch (var.vt)
+ {
+ case VT_I1:
+ wos << var.cVal;
+ break;
+ case VT_UI1:
+ wos << var.bVal;
+ break;
+ case VT_I2:
+ wos << var.iVal;
+ break;
+ case VT_UI2:
+ wos << var.uiVal;
+ break;
+ case VT_I4:
+ wos << var.lVal;
+ break;
+ case VT_UI4:
+ wos << var.ulVal;
+ break;
+ case VT_INT:
+ wos << var.intVal;
+ break;
+ case VT_UINT:
+ wos << var.uintVal;
+ break;
+ case VT_ERROR:
+ wos << var.lVal;
+ break;
+ case VT_I8:
+ wos << var.llVal;
+ break;
+ case VT_UI8:
+ wos << var.ullVal;
+ break;
+ case VT_R4:
+ wos << var.fltVal;
+ break;
+ case VT_R8:
+ case VT_CY:
+ case VT_DATE:
+ wos << var.dblVal;
+ case VT_BOOL:
+ wos << std::boolalpha << (var.iVal == VARIANT_TRUE);
+ break;
+ case VT_BSTR:
+ wos << var.bstrVal;
+ break;
+ }
+ return wos;
+}
+
+#endif
+
+typedef __int64 REFERENCE_TIME;
+
+class ReferenceTime
+{
+ static const REFERENCE_TIME UNITS = 10000;
+
+ REFERENCE_TIME m_time;
+
+public:
+ ReferenceTime() : m_time(0)
+ {
+ }
+
+ ReferenceTime(REFERENCE_TIME time) : m_time(time)
+ {
+ }
+
+ ReferenceTime(long milliseconds)
+ {
+ m_time = milliseconds * UNITS;
+ }
+
+ REFERENCE_TIME GetUnits() const
+ {
+ return m_time;
+ }
+
+ long Millisecs() const
+ {
+ return static_cast<long>(m_time / UNITS);
+ }
+
+ operator REFERENCE_TIME() const
+ {
+ return m_time;
+ }
+
+ ReferenceTime& operator = (const ReferenceTime& other)
+ {
+ m_time = other.m_time;
+ return *this;
+ }
+
+ ReferenceTime& operator += (const ReferenceTime& other)
+ {
+ m_time += other.m_time;
+ return *this;
+ }
+
+ ReferenceTime& operator -= (const ReferenceTime& other)
+ {
+ m_time -= other.m_time;
+ return *this;
+ }
+};
+
+inline std::wostream& operator << (std::wostream& wos, const ReferenceTime& time)
+{
+ long milliseconds = time.Millisecs();
+
+ wos << std::setfill(L'0')
+ << std::setw(2)
+ << milliseconds / 1000 / 3600 << L":"
+ << std::setw(2)
+ << milliseconds / 1000 % 3600 / 60 << L":"
+ << std::setw(2)
+ << milliseconds / 1000 % 60 << L"."
+ << std::setw(3)
+ << milliseconds % 1000;
+
+ return wos;
+}
+
+#ifdef __REFTIME__
+inline std::wostream& operator << (std::wostream& wos, const CRefTime& time)
+{
+ wos << ReferenceTime(time);
+ return wos;
+}
+#endif
+
+
+inline std::wostream& operator << (std::wostream& wos, const IID& guid)
+{
+ wos << std::setfill(L'0') << L"{"
+ << std::setw(8) << std::hex
+ << guid.Data1 << L"-"
+ << std::setw(4) << std::hex
+ << guid.Data2 << L"-"
+ << std::setw(4) << std::hex
+ << guid.Data3 << L"-"
+ << std::setw(2) << std::hex
+ << guid.Data4[0]
+ << std::setw(2) << std::hex
+ << guid.Data4[1] << L"-"
+ << std::setw(2) << std::hex
+ << guid.Data4[2]
+ << std::setw(2) << std::hex
+ << guid.Data4[3]
+ << std::setw(2) << std::hex
+ << guid.Data4[4]
+ << std::setw(2) << std::hex
+ << guid.Data4[5]
+ << std::setw(2) << std::hex
+ << guid.Data4[6]
+ << std::setw(2) << std::hex
+ << guid.Data4[7] << L"}";
+
+ return wos;
+}
+
+template<typename T>
+struct ToStringImpl
+{
+ static std::wstring ToString(T t)
+ {
+ std::wostringstream wos;
+ wos << t;
+ return wos.str();
+ }
+};
+
+template<typename T>
+struct ToStringImpl<T*>
+{
+ static std::wstring ToString(T* p)
+ {
+ std::wostringstream wos;
+ if (p)
+ {
+ wos << *p;
+ return wos.str();
+ }
+
+ wos << "(null)";
+ return wos.str();
+ }
+};
+
+template<typename T>
+inline std::wstring ToString(T t)
+{
+ return ToStringImpl<T>::ToString(t);
+}
+
+//===========================================================================
+
+class Output2FILE
+{
+public:
+ static HANDLE& Stream(const std::wstring& logFile = L"");
+ static void Output(const std::wstring& msg);
+};
+
+inline HANDLE& Output2FILE::Stream(const std::wstring& logFile /*= L""*/)
+{
+#ifndef WINCE
+ static HANDLE streamHandle = ::GetStdHandle(STD_OUTPUT_HANDLE);
+#else
+ static HANDLE streamHandle = INVALID_HANDLE_VALUE;
+#endif
+
+ if (!logFile.empty())
+ {
+ if (streamHandle != INVALID_HANDLE_VALUE
+#ifndef WINCE
+ && streamHandle != ::GetStdHandle(STD_OUTPUT_HANDLE)
+#endif
+ )
+ {
+ ::CloseHandle(streamHandle);
+ }
+
+ streamHandle = ::CreateFile(logFile.c_str(),
+ GENERIC_WRITE, FILE_SHARE_READ, 0, OPEN_ALWAYS,
+ FILE_ATTRIBUTE_NORMAL, 0);
+
+ // Append to the existing file or set the UTF-8 BOM to a newly created file
+ if (::GetLastError() == ERROR_ALREADY_EXISTS)
+ {
+ ::SetFilePointer(streamHandle, 0, 0, FILE_END);
+ }
+ else
+ {
+ std::vector<unsigned char> bom;
+ bom.push_back(0xef);
+ bom.push_back(0xbb);
+ bom.push_back(0xbf);
+
+ DWORD bytesWritten = 0;
+ ::WriteFile(streamHandle, &*bom.begin(), bom.size(), &bytesWritten, 0);
+ }
+ }
+
+ return streamHandle;
+}
+
+inline void Output2FILE::Output(const std::wstring& msg)
+{
+ HANDLE streamHandle = Stream();
+
+ if (streamHandle == INVALID_HANDLE_VALUE)
+ {
+ return;
+ }
+
+ std::string utf8msg;
+
+ // Transform wide chars to UTF-8
+ int chars = ::WideCharToMultiByte(CP_UTF8, 0, &*msg.begin(), msg.size(), 0, 0, 0, 0);
+ utf8msg.resize(chars);
+
+ ::WideCharToMultiByte(CP_UTF8, 0, &*msg.begin(), msg.size(), &*utf8msg.begin(), chars, 0, 0);
+
+ DWORD bytesWritten;
+ ::WriteFile(streamHandle, utf8msg.c_str(), utf8msg.size(), &bytesWritten, 0);
+}
+
+typedef LogT<Output2FILE> Log;
+
+#ifndef LOG_MAX_LEVEL
+#define LOG_MAX_LEVEL logDEBUG4
+#endif
+
+#define LOG(level) \
+ if (level > LOG_MAX_LEVEL) ; \
+ else if (level > Log::ReportingLevel() || !Output2FILE::Stream()) ; \
+ else Log().Get(level)
+
+inline std::wstring NowTime()
+{
+ std::wstring time(9, L'0');
+
+ if (::GetTimeFormat(LOCALE_USER_DEFAULT, 0, 0, L"HH':'mm':'ss",
+ &*time.begin(), time.size()) == 0)
+ {
+ return L"Error in NowTime()";
+ }
+
+ std::wostringstream os;
+ static DWORD first = ::timeGetTime();
+
+ os << time.c_str() << L"."
+ << std::setfill(L'0') << std::setw(3)
+ << (long)(::timeGetTime() - first) % 1000;
+
+ return os.str();
+}
+
+
+#endif //__LOG_H__
Added: trunk/oggdsf/src/lib/helper/common/util.h
===================================================================
--- trunk/oggdsf/src/lib/helper/common/util.h (rev 0)
+++ trunk/oggdsf/src/lib/helper/common/util.h 2009-10-12 21:33:00 UTC (rev 16638)
@@ -0,0 +1,74 @@
+#ifndef UTIL_H
+#define UTIL_H
+
+#include <shlobj.h>
+#include <fstream>
+#include "pugixml/pugixml.hpp"
+
+namespace util
+{
+ inline void ConfigureLog(HANDLE hModule)
+ {
+ using namespace std;
+ using namespace pugi;
+
+ // Obtain the module name
+ wstring moduleFileName;
+ moduleFileName.resize(MAX_PATH);
+
+ int chars = ::GetModuleFileName(static_cast<HMODULE>(hModule), &*moduleFileName.begin(), moduleFileName.size());
+ moduleFileName.resize(chars);
+
+ size_t lastBackslash = moduleFileName.rfind(L'\\') + 1;
+ size_t lastDot = moduleFileName.rfind(L'.');
+
+ wstring moduleName = moduleFileName.substr(lastBackslash, lastDot - lastBackslash);
+
+ // Obtain the user data configuration directory
+ wstring configLocation;
+ configLocation.resize(MAX_PATH);
+ ::SHGetSpecialFolderPath(0, &*configLocation.begin(), CSIDL_APPDATA, false);
+ configLocation.resize(wcslen(configLocation.c_str()));
+
+ configLocation += L"\\Xiph.org\\oggcodecs";
+
+ // Open the settings xml and read the log configuration
+ wstring xmlFileName = configLocation;
+ xmlFileName += L"\\settings.xml";
+
+ ifstream xmlConfigStream;
+ xmlConfigStream.open(xmlFileName.c_str());
+
+ xml_document doc;
+ doc.load(xmlConfigStream);
+
+ stringstream queryString;
+ queryString << "/Configuration/Module[@Name=\"" << CW2A(moduleName.c_str()) << "\"]/Log";
+
+ xpath_query query(queryString.str().c_str());
+
+ string levelString = doc.select_single_node(query).node().attribute("Level").value();
+
+ unsigned short level = logNONE;
+ if (!levelString.empty())
+ {
+ istringstream is;
+ is.str(levelString);
+
+ is >> level;
+ }
+
+ Log::ReportingLevel() = static_cast<LogLevel>(level);
+
+ if (level != logNONE)
+ {
+ wstring logFileName = configLocation;
+ logFileName += L"\\";
+ logFileName += moduleName + L".log";
+
+ Log::Stream(logFileName);
+ }
+ }
+}
+
+#endif // UTIL_H
\ No newline at end of file
Added: trunk/oggdsf/src/lib/helper/pugixml/LICENSE
===================================================================
--- trunk/oggdsf/src/lib/helper/pugixml/LICENSE (rev 0)
+++ trunk/oggdsf/src/lib/helper/pugixml/LICENSE 2009-10-12 21:33:00 UTC (rev 16638)
@@ -0,0 +1,22 @@
+Copyright (c) 2006-2009 Arseny Kapoulkine
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
Added: trunk/oggdsf/src/lib/helper/pugixml/pugiconfig.hpp
===================================================================
--- trunk/oggdsf/src/lib/helper/pugixml/pugiconfig.hpp (rev 0)
+++ trunk/oggdsf/src/lib/helper/pugixml/pugiconfig.hpp 2009-10-12 21:33:00 UTC (rev 16638)
@@ -0,0 +1,35 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// Pug Improved XML Parser - Version 0.42
+// --------------------------------------------------------
+// Copyright (C) 2006-2009, by Arseny Kapoulkine (arseny.kapoulkine at gmail.com)
+// Report bugs and download new versions at http://code.google.com/p/pugixml/
+//
+// This work is based on the pugxml parser, which is:
+// Copyright (C) 2003, by Kristen Wegner (kristen at tima.net)
+// Released into the Public Domain. Use at your own risk.
+// See pugxml.xml for further information, history, etc.
+// Contributions by Neville Franks (readonly at getsoft.com).
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef HEADER_PUGICONFIG_HPP
+#define HEADER_PUGICONFIG_HPP
+
+// Uncomment this to disable STL
+// #define PUGIXML_NO_STL
+
+// Uncomment this to disable XPath
+// #define PUGIXML_NO_XPATH
+
+// Uncomment this to disable exceptions
+// Note: you can't use XPath with PUGIXML_NO_EXCEPTIONS
+// #define PUGIXML_NO_EXCEPTIONS
+
+// Set this to control attributes for public classes/functions, i.e.:
+// #define PUGIXML_API __declspec(dllexport) // to export all public symbols from DLL
+// #define PUGIXML_CLASS __declspec(dllimport) // to import all classes from DLL
+// #define PUGIXML_FUNCTION __fastcall // to set calling conventions to all public functions to fastcall
+// In absence of PUGIXML_CLASS/PUGIXML_FUNCTION definitions PUGIXML_API is used instead
+
+#endif
Added: trunk/oggdsf/src/lib/helper/pugixml/pugixml-2005.vcproj
===================================================================
--- trunk/oggdsf/src/lib/helper/pugixml/pugixml-2005.vcproj (rev 0)
+++ trunk/oggdsf/src/lib/helper/pugixml/pugixml-2005.vcproj 2009-10-12 21:33:00 UTC (rev 16638)
@@ -0,0 +1,731 @@
+<?xml version="1.0" encoding="windows-1250"?>
+<VisualStudioProject
+ ProjectType="Visual C++"
+ Version="8.00"
+ Name="pugixml"
+ ProjectGUID="{87F50139-2ED9-4174-AC3A-58AD515DAB8C}"
+ RootNamespace="pugixml"
+ Keyword="Win32Proj"
+ >
+ <Platforms>
+ <Platform
+ Name="Win32"
+ />
+ <Platform
+ Name="x64"
+ />
+ <Platform
+ Name="Windows Mobile 5.0 Pocket PC SDK 2 (ARMV4I)"
+ />
+ <Platform
+ Name="Windows Mobile 5.0 Smartphone SDK 2 (ARMV4I)"
+ />
+ <Platform
+ Name="Windows Mobile 6 Professional SDK (ARMV4I)"
+ />
+ </Platforms>
+ <ToolFiles>
+ </ToolFiles>
+ <Configurations>
+ <Configuration
+ Name="Debug|Win32"
+ OutputDirectory="$(SolutionDir)$(PlatformName)\$(ConfigurationName)"
+ IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"
+ ConfigurationType="4"
+ CharacterSet="1"
+ >
+ <Tool
+ Name="VCPreBuildEventTool"
+ />
+ <Tool
+ Name="VCCustomBuildTool"
+ />
+ <Tool
+ Name="VCXMLDataGeneratorTool"
+ />
+ <Tool
+ Name="VCWebServiceProxyGeneratorTool"
+ />
+ <Tool
+ Name="VCMIDLTool"
+ />
+ <Tool
+ Name="VCCLCompilerTool"
+ Optimization="0"
+ PreprocessorDefinitions="WIN32;_DEBUG;_LIB"
+ MinimalRebuild="true"
+ BasicRuntimeChecks="3"
+ RuntimeLibrary="3"
+ UsePrecompiledHeader="0"
+ WarningLevel="3"
+ Detect64BitPortabilityProblems="true"
+ DebugInformationFormat="4"
+ />
+ <Tool
+ Name="VCManagedResourceCompilerTool"
+ />
+ <Tool
+ Name="VCResourceCompilerTool"
+ />
+ <Tool
+ Name="VCPreLinkEventTool"
+ />
+ <Tool
+ Name="VCLibrarianTool"
+ />
+ <Tool
+ Name="VCALinkTool"
+ />
+ <Tool
+ Name="VCXDCMakeTool"
+ />
+ <Tool
+ Name="VCBscMakeTool"
+ />
+ <Tool
+ Name="VCFxCopTool"
+ />
+ <Tool
+ Name="VCPostBuildEventTool"
+ />
+ </Configuration>
+ <Configuration
+ Name="Debug|x64"
+ OutputDirectory="$(SolutionDir)$(PlatformName)\$(ConfigurationName)"
+ IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"
+ ConfigurationType="4"
+ CharacterSet="1"
+ >
+ <Tool
+ Name="VCPreBuildEventTool"
+ />
+ <Tool
+ Name="VCCustomBuildTool"
+ />
+ <Tool
+ Name="VCXMLDataGeneratorTool"
+ />
+ <Tool
+ Name="VCWebServiceProxyGeneratorTool"
+ />
+ <Tool
+ Name="VCMIDLTool"
+ TargetEnvironment="3"
+ />
+ <Tool
+ Name="VCCLCompilerTool"
+ Optimization="0"
+ PreprocessorDefinitions="WIN32;_DEBUG;_LIB"
+ MinimalRebuild="true"
+ BasicRuntimeChecks="3"
+ RuntimeLibrary="3"
+ UsePrecompiledHeader="0"
+ WarningLevel="3"
+ Detect64BitPortabilityProblems="true"
+ DebugInformationFormat="3"
+ />
+ <Tool
+ Name="VCManagedResourceCompilerTool"
+ />
+ <Tool
+ Name="VCResourceCompilerTool"
+ />
+ <Tool
+ Name="VCPreLinkEventTool"
+ />
+ <Tool
+ Name="VCLibrarianTool"
+ />
+ <Tool
+ Name="VCALinkTool"
+ />
+ <Tool
+ Name="VCXDCMakeTool"
+ />
+ <Tool
+ Name="VCBscMakeTool"
+ />
+ <Tool
+ Name="VCFxCopTool"
+ />
+ <Tool
+ Name="VCPostBuildEventTool"
+ />
+ </Configuration>
+ <Configuration
+ Name="Debug|Windows Mobile 5.0 Pocket PC SDK 2 (ARMV4I)"
+ OutputDirectory="$(SolutionDir)$(PlatformName)\$(ConfigurationName)"
+ IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"
+ ConfigurationType="4"
+ CharacterSet="1"
+ >
+ <Tool
+ Name="VCPreBuildEventTool"
+ />
+ <Tool
+ Name="VCCustomBuildTool"
+ />
+ <Tool
+ Name="VCXMLDataGeneratorTool"
+ />
+ <Tool
+ Name="VCWebServiceProxyGeneratorTool"
+ />
+ <Tool
+ Name="VCMIDLTool"
+ TargetEnvironment="1"
+ />
+ <Tool
+ Name="VCCLCompilerTool"
+ ExecutionBucket="7"
+ Optimization="0"
+ PreprocessorDefinitions="WIN32;_DEBUG;_LIB;_WIN32_WCE=$(CEVER);UNDER_CE;WINCE;$(ARCHFAM);$(_ARCHFAM_);$(PLATFORMDEFINES)"
+ MinimalRebuild="true"
+ RuntimeLibrary="3"
+ UsePrecompiledHeader="0"
+ WarningLevel="3"
+ />
+ <Tool
+ Name="VCManagedResourceCompilerTool"
+ />
+ <Tool
+ Name="VCResourceCompilerTool"
+ />
+ <Tool
+ Name="VCPreLinkEventTool"
+ />
+ <Tool
+ Name="VCLibrarianTool"
+ />
+ <Tool
+ Name="VCALinkTool"
+ />
+ <Tool
+ Name="VCXDCMakeTool"
+ />
+ <Tool
+ Name="VCBscMakeTool"
+ />
+ <Tool
+ Name="VCCodeSignTool"
+ />
+ <Tool
+ Name="VCPostBuildEventTool"
+ />
+ <DeploymentTool
+ ForceDirty="-1"
+ RemoteDirectory=""
+ RegisterOutput="0"
+ AdditionalFiles=""
+ />
+ <DebuggerTool
+ />
+ </Configuration>
+ <Configuration
+ Name="Debug|Windows Mobile 5.0 Smartphone SDK 2 (ARMV4I)"
+ OutputDirectory="$(SolutionDir)$(PlatformName)\$(ConfigurationName)"
+ IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"
+ ConfigurationType="4"
+ CharacterSet="1"
+ >
+ <Tool
+ Name="VCPreBuildEventTool"
+ />
+ <Tool
+ Name="VCCustomBuildTool"
+ />
+ <Tool
+ Name="VCXMLDataGeneratorTool"
+ />
+ <Tool
+ Name="VCWebServiceProxyGeneratorTool"
+ />
+ <Tool
+ Name="VCMIDLTool"
+ TargetEnvironment="1"
+ />
+ <Tool
+ Name="VCCLCompilerTool"
+ ExecutionBucket="7"
+ Optimization="0"
+ PreprocessorDefinitions="WIN32;_DEBUG;_LIB;_WIN32_WCE=$(CEVER);UNDER_CE;WINCE;$(ARCHFAM);$(_ARCHFAM_);$(PLATFORMDEFINES)"
+ MinimalRebuild="false"
+ RuntimeLibrary="3"
+ UsePrecompiledHeader="0"
+ WarningLevel="3"
+ />
+ <Tool
+ Name="VCManagedResourceCompilerTool"
+ />
+ <Tool
+ Name="VCResourceCompilerTool"
+ />
+ <Tool
+ Name="VCPreLinkEventTool"
+ />
+ <Tool
+ Name="VCLibrarianTool"
+ />
+ <Tool
+ Name="VCALinkTool"
+ />
+ <Tool
+ Name="VCXDCMakeTool"
+ />
+ <Tool
+ Name="VCBscMakeTool"
+ />
+ <Tool
+ Name="VCCodeSignTool"
+ />
+ <Tool
+ Name="VCPostBuildEventTool"
+ />
+ <DeploymentTool
+ ForceDirty="-1"
+ RemoteDirectory=""
+ RegisterOutput="0"
+ AdditionalFiles=""
+ />
+ <DebuggerTool
+ />
+ </Configuration>
+ <Configuration
+ Name="Debug|Windows Mobile 6 Professional SDK (ARMV4I)"
+ OutputDirectory="$(SolutionDir)$(PlatformName)\$(ConfigurationName)"
+ IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"
+ ConfigurationType="4"
+ CharacterSet="1"
+ >
+ <Tool
+ Name="VCPreBuildEventTool"
+ />
+ <Tool
+ Name="VCCustomBuildTool"
+ />
+ <Tool
+ Name="VCXMLDataGeneratorTool"
+ />
+ <Tool
+ Name="VCWebServiceProxyGeneratorTool"
+ />
+ <Tool
+ Name="VCMIDLTool"
+ TargetEnvironment="1"
+ />
+ <Tool
+ Name="VCCLCompilerTool"
+ ExecutionBucket="7"
+ Optimization="0"
+ PreprocessorDefinitions="WIN32;_DEBUG;_LIB;_WIN32_WCE=$(CEVER);UNDER_CE;WINCE;$(ARCHFAM);$(_ARCHFAM_);$(PLATFORMDEFINES)"
+ MinimalRebuild="true"
+ RuntimeLibrary="3"
+ UsePrecompiledHeader="0"
+ WarningLevel="3"
+ />
+ <Tool
+ Name="VCManagedResourceCompilerTool"
+ />
+ <Tool
+ Name="VCResourceCompilerTool"
+ />
+ <Tool
+ Name="VCPreLinkEventTool"
+ />
+ <Tool
+ Name="VCLibrarianTool"
+ />
+ <Tool
+ Name="VCALinkTool"
+ />
+ <Tool
+ Name="VCXDCMakeTool"
+ />
+ <Tool
+ Name="VCBscMakeTool"
+ />
+ <Tool
+ Name="VCCodeSignTool"
+ />
+ <Tool
+ Name="VCPostBuildEventTool"
+ />
+ <DeploymentTool
+ ForceDirty="-1"
+ RemoteDirectory=""
+ RegisterOutput="0"
+ AdditionalFiles=""
+ />
+ <DebuggerTool
+ />
+ </Configuration>
+ <Configuration
+ Name="Release|Win32"
+ OutputDirectory="$(SolutionDir)$(PlatformName)\$(ConfigurationName)"
+ IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"
+ ConfigurationType="4"
+ CharacterSet="1"
+ WholeProgramOptimization="1"
+ >
+ <Tool
+ Name="VCPreBuildEventTool"
+ />
+ <Tool
+ Name="VCCustomBuildTool"
+ />
+ <Tool
+ Name="VCXMLDataGeneratorTool"
+ />
+ <Tool
+ Name="VCWebServiceProxyGeneratorTool"
+ />
+ <Tool
+ Name="VCMIDLTool"
+ />
+ <Tool
+ Name="VCCLCompilerTool"
+ PreprocessorDefinitions="WIN32;NDEBUG;_LIB"
+ RuntimeLibrary="2"
+ UsePrecompiledHeader="0"
+ WarningLevel="3"
+ Detect64BitPortabilityProblems="true"
+ DebugInformationFormat="3"
+ />
+ <Tool
+ Name="VCManagedResourceCompilerTool"
+ />
+ <Tool
+ Name="VCResourceCompilerTool"
+ />
+ <Tool
+ Name="VCPreLinkEventTool"
+ />
+ <Tool
+ Name="VCLibrarianTool"
+ />
+ <Tool
+ Name="VCALinkTool"
+ />
+ <Tool
+ Name="VCXDCMakeTool"
+ />
+ <Tool
+ Name="VCBscMakeTool"
+ />
+ <Tool
+ Name="VCFxCopTool"
+ />
+ <Tool
+ Name="VCPostBuildEventTool"
+ />
+ </Configuration>
+ <Configuration
+ Name="Release|x64"
+ OutputDirectory="$(SolutionDir)$(PlatformName)\$(ConfigurationName)"
+ IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"
+ ConfigurationType="4"
+ CharacterSet="1"
+ WholeProgramOptimization="1"
+ >
+ <Tool
+ Name="VCPreBuildEventTool"
+ />
+ <Tool
+ Name="VCCustomBuildTool"
+ />
+ <Tool
+ Name="VCXMLDataGeneratorTool"
+ />
+ <Tool
+ Name="VCWebServiceProxyGeneratorTool"
+ />
+ <Tool
+ Name="VCMIDLTool"
+ TargetEnvironment="3"
+ />
+ <Tool
+ Name="VCCLCompilerTool"
+ PreprocessorDefinitions="WIN32;NDEBUG;_LIB"
+ RuntimeLibrary="2"
+ UsePrecompiledHeader="0"
+ WarningLevel="3"
+ Detect64BitPortabilityProblems="true"
+ DebugInformationFormat="3"
+ />
+ <Tool
+ Name="VCManagedResourceCompilerTool"
+ />
+ <Tool
+ Name="VCResourceCompilerTool"
+ />
+ <Tool
+ Name="VCPreLinkEventTool"
+ />
+ <Tool
+ Name="VCLibrarianTool"
+ />
+ <Tool
+ Name="VCALinkTool"
+ />
+ <Tool
+ Name="VCXDCMakeTool"
+ />
+ <Tool
+ Name="VCBscMakeTool"
+ />
+ <Tool
+ Name="VCFxCopTool"
+ />
+ <Tool
+ Name="VCPostBuildEventTool"
+ />
+ </Configuration>
+ <Configuration
+ Name="Release|Windows Mobile 5.0 Pocket PC SDK 2 (ARMV4I)"
+ OutputDirectory="$(SolutionDir)$(PlatformName)\$(ConfigurationName)"
+ IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"
+ ConfigurationType="4"
+ CharacterSet="1"
+ WholeProgramOptimization="1"
+ >
+ <Tool
+ Name="VCPreBuildEventTool"
+ />
+ <Tool
+ Name="VCCustomBuildTool"
+ />
+ <Tool
+ Name="VCXMLDataGeneratorTool"
+ />
+ <Tool
+ Name="VCWebServiceProxyGeneratorTool"
+ />
+ <Tool
+ Name="VCMIDLTool"
+ TargetEnvironment="1"
+ />
+ <Tool
+ Name="VCCLCompilerTool"
+ ExecutionBucket="7"
+ PreprocessorDefinitions="WIN32;NDEBUG;_LIB;_WIN32_WCE=$(CEVER);UNDER_CE;WINCE;$(ARCHFAM);$(_ARCHFAM_);$(PLATFORMDEFINES)"
+ RuntimeLibrary="2"
+ UsePrecompiledHeader="0"
+ WarningLevel="3"
+ DebugInformationFormat="3"
+ />
+ <Tool
+ Name="VCManagedResourceCompilerTool"
+ />
+ <Tool
+ Name="VCResourceCompilerTool"
+ />
+ <Tool
+ Name="VCPreLinkEventTool"
+ />
+ <Tool
+ Name="VCLibrarianTool"
+ />
+ <Tool
+ Name="VCALinkTool"
+ />
+ <Tool
+ Name="VCXDCMakeTool"
+ />
+ <Tool
+ Name="VCBscMakeTool"
+ />
+ <Tool
+ Name="VCCodeSignTool"
+ />
+ <Tool
+ Name="VCPostBuildEventTool"
+ />
+ <DeploymentTool
+ ForceDirty="-1"
+ RemoteDirectory=""
+ RegisterOutput="0"
+ AdditionalFiles=""
+ />
+ <DebuggerTool
+ />
+ </Configuration>
+ <Configuration
+ Name="Release|Windows Mobile 5.0 Smartphone SDK 2 (ARMV4I)"
+ OutputDirectory="$(SolutionDir)$(PlatformName)\$(ConfigurationName)"
+ IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"
+ ConfigurationType="4"
+ CharacterSet="1"
+ WholeProgramOptimization="1"
+ >
+ <Tool
+ Name="VCPreBuildEventTool"
+ />
+ <Tool
+ Name="VCCustomBuildTool"
+ />
+ <Tool
+ Name="VCXMLDataGeneratorTool"
+ />
+ <Tool
+ Name="VCWebServiceProxyGeneratorTool"
+ />
+ <Tool
+ Name="VCMIDLTool"
+ TargetEnvironment="1"
+ />
+ <Tool
+ Name="VCCLCompilerTool"
+ ExecutionBucket="7"
+ PreprocessorDefinitions="WIN32;NDEBUG;_LIB;_WIN32_WCE=$(CEVER);UNDER_CE;WINCE;$(ARCHFAM);$(_ARCHFAM_);$(PLATFORMDEFINES)"
+ RuntimeLibrary="2"
+ UsePrecompiledHeader="0"
+ WarningLevel="3"
+ DebugInformationFormat="3"
+ />
+ <Tool
+ Name="VCManagedResourceCompilerTool"
+ />
+ <Tool
+ Name="VCResourceCompilerTool"
+ />
+ <Tool
+ Name="VCPreLinkEventTool"
+ />
+ <Tool
+ Name="VCLibrarianTool"
+ />
+ <Tool
+ Name="VCALinkTool"
+ />
+ <Tool
+ Name="VCXDCMakeTool"
+ />
+ <Tool
+ Name="VCBscMakeTool"
+ />
+ <Tool
+ Name="VCCodeSignTool"
+ />
+ <Tool
+ Name="VCPostBuildEventTool"
+ />
+ <DeploymentTool
+ ForceDirty="-1"
+ RemoteDirectory=""
+ RegisterOutput="0"
+ AdditionalFiles=""
+ />
+ <DebuggerTool
+ />
+ </Configuration>
+ <Configuration
+ Name="Release|Windows Mobile 6 Professional SDK (ARMV4I)"
+ OutputDirectory="$(SolutionDir)$(PlatformName)\$(ConfigurationName)"
+ IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"
+ ConfigurationType="4"
+ CharacterSet="1"
+ WholeProgramOptimization="1"
+ >
+ <Tool
+ Name="VCPreBuildEventTool"
+ />
+ <Tool
+ Name="VCCustomBuildTool"
+ />
+ <Tool
+ Name="VCXMLDataGeneratorTool"
+ />
+ <Tool
+ Name="VCWebServiceProxyGeneratorTool"
+ />
+ <Tool
+ Name="VCMIDLTool"
+ TargetEnvironment="1"
+ />
+ <Tool
+ Name="VCCLCompilerTool"
+ ExecutionBucket="7"
+ PreprocessorDefinitions="WIN32;NDEBUG;_LIB;_WIN32_WCE=$(CEVER);UNDER_CE;WINCE;$(ARCHFAM);$(_ARCHFAM_);$(PLATFORMDEFINES)"
+ RuntimeLibrary="2"
+ UsePrecompiledHeader="0"
+ WarningLevel="3"
+ DebugInformationFormat="3"
+ />
+ <Tool
+ Name="VCManagedResourceCompilerTool"
+ />
+ <Tool
+ Name="VCResourceCompilerTool"
+ />
+ <Tool
+ Name="VCPreLinkEventTool"
+ />
+ <Tool
+ Name="VCLibrarianTool"
+ />
+ <Tool
+ Name="VCALinkTool"
+ />
+ <Tool
+ Name="VCXDCMakeTool"
+ />
+ <Tool
+ Name="VCBscMakeTool"
+ />
+ <Tool
+ Name="VCCodeSignTool"
+ />
+ <Tool
+ Name="VCPostBuildEventTool"
+ />
+ <DeploymentTool
+ ForceDirty="-1"
+ RemoteDirectory=""
+ RegisterOutput="0"
+ AdditionalFiles=""
+ />
+ <DebuggerTool
+ />
+ </Configuration>
+ </Configurations>
+ <References>
+ </References>
+ <Files>
+ <Filter
+ Name="Source Files"
+ Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
+ UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
+ >
+ <File
+ RelativePath=".\pugixml.cpp"
+ >
+ </File>
+ <File
+ RelativePath=".\pugixpath.cpp"
+ >
+ </File>
+ </Filter>
+ <Filter
+ Name="Header Files"
+ Filter="h;hpp;hxx;hm;inl;inc;xsd"
+ UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
+ >
+ <File
+ RelativePath=".\pugiconfig.hpp"
+ >
+ </File>
+ <File
+ RelativePath=".\pugixml.hpp"
+ >
+ </File>
+ </Filter>
+ <Filter
+ Name="Resource Files"
+ Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav"
+ UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
+ >
+ </Filter>
+ </Files>
+ <Globals>
+ </Globals>
+</VisualStudioProject>
Added: trunk/oggdsf/src/lib/helper/pugixml/pugixml.cpp
===================================================================
--- trunk/oggdsf/src/lib/helper/pugixml/pugixml.cpp (rev 0)
+++ trunk/oggdsf/src/lib/helper/pugixml/pugixml.cpp 2009-10-12 21:33:00 UTC (rev 16638)
@@ -0,0 +1,3110 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// Pug Improved XML Parser - Version 0.42
+// --------------------------------------------------------
+// Copyright (C) 2006-2009, by Arseny Kapoulkine (arseny.kapoulkine at gmail.com)
+// Report bugs and download new versions at http://code.google.com/p/pugixml/
+//
+// This work is based on the pugxml parser, which is:
+// Copyright (C) 2003, by Kristen Wegner (kristen at tima.net)
+// Released into the Public Domain. Use at your own risk.
+// See pugxml.xml for further information, history, etc.
+// Contributions by Neville Franks (readonly at getsoft.com).
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "pugixml.hpp"
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <assert.h>
+
+// For placement new
+#include <new>
+
+#if !defined(PUGIXML_NO_XPATH) && defined(PUGIXML_NO_EXCEPTIONS)
+#error No exception mode can not be used with XPath support
+#endif
+
+#ifndef PUGIXML_NO_STL
+# include <istream>
+# include <ostream>
+#endif
+
+#ifdef _MSC_VER
+# pragma warning(disable: 4127) // conditional expression is constant
+# pragma warning(disable: 4996) // this function or variable may be unsafe
+#endif
+
+#ifdef __BORLANDC__
+# pragma warn -8008 // condition is always false
+# pragma warn -8066 // unreachable code
+#endif
+
+#ifdef __BORLANDC__
+// BC workaround
+using std::memmove;
+using std::memcpy;
+#endif
+
+#define STATIC_ASSERT(cond) { static const char condition_failed[(cond) ? 1 : -1] = {0}; (void)condition_failed[0]; }
+
+namespace
+{
+ void* default_allocate(size_t size)
+ {
+ return malloc(size);
+ }
+
+ void default_deallocate(void* ptr)
+ {
+ free(ptr);
+ }
+
+ pugi::allocation_function global_allocate = default_allocate;
+ pugi::deallocation_function global_deallocate = default_deallocate;
+}
+
+namespace pugi
+{
+ struct xml_document_struct;
+
+ class xml_allocator
+ {
+ public:
+ xml_allocator(xml_memory_block* root): _root(root)
+ {
+ }
+
+ xml_document_struct* allocate_document();
+ xml_node_struct* allocate_node(xml_node_type type);
+ xml_attribute_struct* allocate_attribute();
+
+ private:
+ xml_memory_block* _root;
+
+ void* memalloc(size_t size)
+ {
+ if (_root->size + size <= memory_block_size)
+ {
+ void* buf = _root->data + _root->size;
+ _root->size += size;
+ return buf;
+ }
+ else
+ {
+ void* new_block = global_allocate(sizeof(xml_memory_block));
+
+ _root->next = new (new_block) xml_memory_block();
+ _root = _root->next;
+
+ _root->size = size;
+
+ return _root->data;
+ }
+ }
+ };
+
+ /// A 'name=value' XML attribute structure.
+ struct xml_attribute_struct
+ {
+ /// Default ctor
+ xml_attribute_struct(): name_insitu(true), value_insitu(true), document_order(0), name(0), value(0), prev_attribute(0), next_attribute(0)
+ {
+ }
+
+ void destroy()
+ {
+ if (!name_insitu)
+ {
+ global_deallocate(name);
+ name = 0;
+ }
+
+ if (!value_insitu)
+ {
+ global_deallocate(value);
+ value = 0;
+ }
+ }
+
+ bool name_insitu : 1;
+ bool value_insitu : 1;
+ unsigned int document_order : 30; ///< Document order value
+
+ char* name; ///< Pointer to attribute name.
+ char* value; ///< Pointer to attribute value.
+
+ xml_attribute_struct* prev_attribute; ///< Previous attribute
+ xml_attribute_struct* next_attribute; ///< Next attribute
+ };
+
+ /// An XML document tree node.
+ struct xml_node_struct
+ {
+ /// Default ctor
+ /// \param type - node type
+ xml_node_struct(xml_node_type type = node_element): type(type), name_insitu(true), value_insitu(true), document_order(0), parent(0), name(0), value(0), first_child(0), last_child(0), prev_sibling(0), next_sibling(0), first_attribute(0), last_attribute(0)
+ {
+ }
+
+ void destroy()
+ {
+ parent = 0;
+
+ if (!name_insitu)
+ {
+ global_deallocate(name);
+ name = 0;
+ }
+
+ if (!value_insitu)
+ {
+ global_deallocate(value);
+ value = 0;
+ }
+
+ for (xml_attribute_struct* attr = first_attribute; attr; attr = attr->next_attribute)
+ attr->destroy();
+
+ for (xml_node_struct* node = first_child; node; node = node->next_sibling)
+ node->destroy();
+ }
+
+ xml_node_struct* append_node(xml_allocator& alloc, xml_node_type type = node_element)
+ {
+ xml_node_struct* child = alloc.allocate_node(type);
+ child->parent = this;
+
+ if (last_child)
+ {
+ last_child->next_sibling = child;
+ child->prev_sibling = last_child;
+ last_child = child;
+ }
+ else first_child = last_child = child;
+
+ return child;
+ }
+
+ xml_attribute_struct* append_attribute(xml_allocator& alloc)
+ {
+ xml_attribute_struct* a = alloc.allocate_attribute();
+
+ if (last_attribute)
+ {
+ last_attribute->next_attribute = a;
+ a->prev_attribute = last_attribute;
+ last_attribute = a;
+ }
+ else first_attribute = last_attribute = a;
+
+ return a;
+ }
+
+ unsigned int type : 3; ///< Node type; see xml_node_type.
+ bool name_insitu : 1;
+ bool value_insitu : 1;
+ unsigned int document_order : 27; ///< Document order value
+
+ xml_node_struct* parent; ///< Pointer to parent
+
+ char* name; ///< Pointer to element name.
+ char* value; ///< Pointer to any associated string data.
+
+ xml_node_struct* first_child; ///< First child
+ xml_node_struct* last_child; ///< Last child
+
+ xml_node_struct* prev_sibling; ///< Left brother
+ xml_node_struct* next_sibling; ///< Right brother
+
+ xml_attribute_struct* first_attribute; ///< First attribute
+ xml_attribute_struct* last_attribute; ///< Last attribute
+ };
+
+ struct xml_document_struct: public xml_node_struct
+ {
+ xml_document_struct(): xml_node_struct(node_document), allocator(0), buffer(0)
+ {
+ }
+
+ xml_allocator allocator;
+ const char* buffer;
+ };
+
+ xml_document_struct* xml_allocator::allocate_document()
+ {
+ return new (memalloc(sizeof(xml_document_struct))) xml_document_struct;
+ }
+
+ xml_node_struct* xml_allocator::allocate_node(xml_node_type type)
+ {
+ return new (memalloc(sizeof(xml_node_struct))) xml_node_struct(type);
+ }
+
+ xml_attribute_struct* xml_allocator::allocate_attribute()
+ {
+ return new (memalloc(sizeof(xml_attribute_struct))) xml_attribute_struct;
+ }
+}
+
+namespace
+{
+ using namespace pugi;
+
+ const unsigned char UTF8_BYTE_MASK = 0xBF;
+ const unsigned char UTF8_BYTE_MARK = 0x80;
+ const unsigned char UTF8_BYTE_MASK_READ = 0x3F;
+ const unsigned char UTF8_FIRST_BYTE_MARK[7] = { 0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC };
+
+ enum chartype
+ {
+ ct_parse_pcdata = 1, // \0, &, \r, <
+ ct_parse_attr = 2, // \0, &, \r, ', "
+ ct_parse_attr_ws = 4, // \0, &, \r, ', ", \n, space, tab
+ ct_space = 8, // \r, \n, space, tab
+ ct_parse_cdata = 16, // \0, ], >, \r
+ ct_parse_comment = 32, // \0, -, >, \r
+ ct_symbol = 64, // Any symbol > 127, a-z, A-Z, 0-9, _, :, -, .
+ ct_start_symbol = 128 // Any symbol > 127, a-z, A-Z, _, :
+ };
+
+ const unsigned char chartype_table[256] =
+ {
+ 55, 0, 0, 0, 0, 0, 0, 0, 0, 12, 12, 0, 0, 63, 0, 0, // 0-15
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 16-31
+ 12, 0, 6, 0, 0, 0, 7, 6, 0, 0, 0, 0, 0, 96, 64, 0, // 32-47
+ 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 192, 0, 1, 0, 48, 0, // 48-63
+ 0, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, // 64-79
+ 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 0, 0, 16, 0, 192, // 80-95
+ 0, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, // 96-111
+ 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 0, 0, 0, 0, 0, // 112-127
+
+ 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, // 128+
+ 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192,
+ 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192,
+ 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192,
+ 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192,
+ 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192,
+ 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192,
+ 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192
+ };
+
+ bool is_chartype(char c, chartype ct)
+ {
+ return !!(chartype_table[static_cast<unsigned char>(c)] & ct);
+ }
+
+ bool strcpy_insitu(char*& dest, bool& insitu, const char* source)
+ {
+ size_t source_size = strlen(source);
+
+ if (dest && strlen(dest) >= source_size)
+ {
+ strcpy(dest, source);
+
+ return true;
+ }
+ else
+ {
+ char* buf = static_cast<char*>(global_allocate(source_size + 1));
+ if (!buf) return false;
+
+ strcpy(buf, source);
+
+ if (!insitu) global_deallocate(dest);
+
+ dest = buf;
+ insitu = false;
+
+ return true;
+ }
+ }
+
+ // Get the size that is needed for strutf16_utf8 applied to all s characters
+ size_t strutf16_utf8_size(const wchar_t* s)
+ {
+ size_t length = 0;
+
+ for (; *s; ++s)
+ {
+ unsigned int ch = *s;
+
+ if (ch < 0x80) length += 1;
+ else if (ch < 0x800) length += 2;
+ else if (ch < 0x10000) length += 3;
+ else if (ch < 0x200000) length += 4;
+ }
+
+ return length;
+ }
+
+ // Write utf16 char to stream, return position after the last written char
+ // \return position after last char
+ char* strutf16_utf8(char* s, unsigned int ch)
+ {
+ unsigned int length;
+
+ if (ch < 0x80) length = 1;
+ else if (ch < 0x800) length = 2;
+ else if (ch < 0x10000) length = 3;
+ else if (ch < 0x200000) length = 4;
+ else return s;
+
+ s += length;
+
+ // Scary scary fall throughs.
+ switch (length)
+ {
+ case 4:
+ *--s = (char)((ch | UTF8_BYTE_MARK) & UTF8_BYTE_MASK);
+ ch >>= 6;
+ case 3:
+ *--s = (char)((ch | UTF8_BYTE_MARK) & UTF8_BYTE_MASK);
+ ch >>= 6;
+ case 2:
+ *--s = (char)((ch | UTF8_BYTE_MARK) & UTF8_BYTE_MASK);
+ ch >>= 6;
+ case 1:
+ *--s = (char)(ch | UTF8_FIRST_BYTE_MARK[length]);
+ }
+
+ return s + length;
+ }
+
+ // Get the size that is needed for strutf8_utf16 applied to all s characters
+ size_t strutf8_utf16_size(const char* s)
+ {
+ size_t length = 0;
+
+ for (; *s; ++s)
+ {
+ unsigned char ch = static_cast<unsigned char>(*s);
+
+ if (ch < 0x80 || (ch >= 0xC0 && ch < 0xFC)) ++length;
+ }
+
+ return length;
+ }
+
+ // Read utf16 char from utf8 stream, return position after the last read char
+ // \return position after the last char
+ const char* strutf8_utf16(const char* s, unsigned int& ch)
+ {
+ unsigned int length;
+
+ const unsigned char* str = reinterpret_cast<const unsigned char*>(s);
+
+ if (*str < UTF8_BYTE_MARK)
+ {
+ ch = *str;
+ return s + 1;
+ }
+ else if (*str < 0xC0)
+ {
+ ch = ' ';
+ return s + 1;
+ }
+ else if (*str < 0xE0) length = 2;
+ else if (*str < 0xF0) length = 3;
+ else if (*str < 0xF8) length = 4;
+ else if (*str < 0xFC) length = 5;
+ else
+ {
+ ch = ' ';
+ return s + 1;
+ }
+
+ ch = (*str++ & ~UTF8_FIRST_BYTE_MARK[length]);
+
+ // Scary scary fall throughs.
+ switch (length)
+ {
+ case 5:
+ ch <<= 6;
+ ch += (*str++ & UTF8_BYTE_MASK_READ);
+ case 4:
+ ch <<= 6;
+ ch += (*str++ & UTF8_BYTE_MASK_READ);
+ case 3:
+ ch <<= 6;
+ ch += (*str++ & UTF8_BYTE_MASK_READ);
+ case 2:
+ ch <<= 6;
+ ch += (*str++ & UTF8_BYTE_MASK_READ);
+ }
+
+ return reinterpret_cast<const char*>(str);
+ }
+
+ template <bool _1> struct opt1_to_type
+ {
+ static const bool o1;
+ };
+
+ template <bool _1> const bool opt1_to_type<_1>::o1 = _1;
+
+ template <bool _1, bool _2> struct opt2_to_type
+ {
+ static const bool o1;
+ static const bool o2;
+ };
+
+ template <bool _1, bool _2> const bool opt2_to_type<_1, _2>::o1 = _1;
+ template <bool _1, bool _2> const bool opt2_to_type<_1, _2>::o2 = _2;
+
+ template <bool _1, bool _2, bool _3, bool _4> struct opt4_to_type
+ {
+ static const bool o1;
+ static const bool o2;
+ static const bool o3;
+ static const bool o4;
+ };
+
+ template <bool _1, bool _2, bool _3, bool _4> const bool opt4_to_type<_1, _2, _3, _4>::o1 = _1;
+ template <bool _1, bool _2, bool _3, bool _4> const bool opt4_to_type<_1, _2, _3, _4>::o2 = _2;
+ template <bool _1, bool _2, bool _3, bool _4> const bool opt4_to_type<_1, _2, _3, _4>::o3 = _3;
+ template <bool _1, bool _2, bool _3, bool _4> const bool opt4_to_type<_1, _2, _3, _4>::o4 = _4;
+
+ struct gap
+ {
+ char* end;
+ size_t size;
+
+ gap(): end(0), size(0)
+ {
+ }
+
+ // Push new gap, move s count bytes further (skipping the gap).
+ // Collapse previous gap.
+ void push(char*& s, size_t count)
+ {
+ if (end) // there was a gap already; collapse it
+ {
+ // Move [old_gap_end, new_gap_start) to [old_gap_start, ...)
+ memmove(end - size, end, s - end);
+ }
+
+ s += count; // end of current gap
+
+ // "merge" two gaps
+ end = s;
+ size += count;
+ }
+
+ // Collapse all gaps, return past-the-end pointer
+ char* flush(char* s)
+ {
+ if (end)
+ {
+ // Move [old_gap_end, current_pos) to [old_gap_start, ...)
+ memmove(end - size, end, s - end);
+
+ return s - size;
+ }
+ else return s;
+ }
+ };
+
+ char* strconv_escape(char* s, gap& g)
+ {
+ char* stre = s + 1;
+
+ switch (*stre)
+ {
+ case '#': // &#...
+ {
+ unsigned int ucsc = 0;
+
+ ++stre;
+
+ if (*stre == 'x') // &#x... (hex code)
+ {
+ ++stre;
+
+ while (*stre)
+ {
+ if (*stre >= '0' && *stre <= '9')
+ ucsc = 16 * ucsc + (*stre++ - '0');
+ else if (*stre >= 'A' && *stre <= 'F')
+ ucsc = 16 * ucsc + (*stre++ - 'A' + 10);
+ else if (*stre >= 'a' && *stre <= 'f')
+ ucsc = 16 * ucsc + (*stre++ - 'a' + 10);
+ else if (*stre == ';')
+ break;
+ else // cancel
+ return stre;
+ }
+
+ if (*stre != ';') return stre;
+
+ ++stre;
+ }
+ else // &#... (dec code)
+ {
+ while (*stre >= '0' && *stre <= '9')
+ ucsc = 10 * ucsc + (*stre++ - '0');
+
+ if (*stre != ';') return stre;
+
+ ++stre;
+ }
+
+ s = strutf16_utf8(s, ucsc);
+
+ g.push(s, stre - s);
+ return stre;
+ }
+ case 'a': // &a
+ {
+ ++stre;
+
+ if (*stre == 'm') // &am
+ {
+ if (*++stre == 'p' && *++stre == ';') // &
+ {
+ *s++ = '&';
+ ++stre;
+
+ g.push(s, stre - s);
+ return stre;
+ }
+ }
+ else if (*stre == 'p') // &ap
+ {
+ if (*++stre == 'o' && *++stre == 's' && *++stre == ';') // '
+ {
+ *s++ = '\'';
+ ++stre;
+
+ g.push(s, stre - s);
+ return stre;
+ }
+ }
+ break;
+ }
+ case 'g': // &g
+ {
+ if (*++stre == 't' && *++stre == ';') // >
+ {
+ *s++ = '>';
+ ++stre;
+
+ g.push(s, stre - s);
+ return stre;
+ }
+ break;
+ }
+ case 'l': // &l
+ {
+ if (*++stre == 't' && *++stre == ';') // <
+ {
+ *s++ = '<';
+ ++stre;
+
+ g.push(s, stre - s);
+ return stre;
+ }
+ break;
+ }
+ case 'q': // &q
+ {
+ if (*++stre == 'u' && *++stre == 'o' && *++stre == 't' && *++stre == ';') // "
+ {
+ *s++ = '"';
+ ++stre;
+
+ g.push(s, stre - s);
+ return stre;
+ }
+ break;
+ }
+ }
+
+ return stre;
+ }
+
+ char* strconv_comment(char* s)
+ {
+ if (!*s) return 0;
+
+ gap g;
+
+ while (true)
+ {
+ while (!is_chartype(*s, ct_parse_comment)) ++s;
+
+ if (*s == '\r') // Either a single 0x0d or 0x0d 0x0a pair
+ {
+ *s++ = '\n'; // replace first one with 0x0a
+
+ if (*s == '\n') g.push(s, 1);
+ }
+ else if (*s == '-' && *(s+1) == '-' && *(s+2) == '>') // comment ends here
+ {
+ *g.flush(s) = 0;
+
+ return s + 3;
+ }
+ else if (*s == 0)
+ {
+ return 0;
+ }
+ else ++s;
+ }
+ }
+
+ char* strconv_cdata(char* s)
+ {
+ if (!*s) return 0;
+
+ gap g;
+
+ while (true)
+ {
+ while (!is_chartype(*s, ct_parse_cdata)) ++s;
+
+ if (*s == '\r') // Either a single 0x0d or 0x0d 0x0a pair
+ {
+ *s++ = '\n'; // replace first one with 0x0a
+
+ if (*s == '\n') g.push(s, 1);
+ }
+ else if (*s == ']' && *(s+1) == ']' && *(s+2) == '>') // CDATA ends here
+ {
+ *g.flush(s) = 0;
+
+ return s + 1;
+ }
+ else if (*s == 0)
+ {
+ return 0;
+ }
+ else ++s;
+ }
+ }
+
+ template <typename opt2> char* strconv_pcdata_t(char* s, opt2)
+ {
+ const bool opt_eol = opt2::o1;
+ const bool opt_escape = opt2::o2;
+
+ if (!*s) return 0;
+
+ gap g;
+
+ while (true)
+ {
+ while (!is_chartype(*s, ct_parse_pcdata)) ++s;
+
+ if (opt_eol && *s == '\r') // Either a single 0x0d or 0x0d 0x0a pair
+ {
+ *s++ = '\n'; // replace first one with 0x0a
+
+ if (*s == '\n') g.push(s, 1);
+ }
+ else if (opt_escape && *s == '&')
+ {
+ s = strconv_escape(s, g);
+ }
+ else if (*s == '<') // PCDATA ends here
+ {
+ *g.flush(s) = 0;
+
+ return s + 1;
+ }
+ else if (*s == 0)
+ {
+ return s;
+ }
+ else ++s;
+ }
+ }
+
+ char* strconv_pcdata(char* s, unsigned int optmask)
+ {
+ STATIC_ASSERT(parse_escapes == 0x10 && parse_eol == 0x20);
+
+ switch ((optmask >> 4) & 3) // get bitmask for flags (eol escapes)
+ {
+ case 0: return strconv_pcdata_t(s, opt2_to_type<0, 0>());
+ case 1: return strconv_pcdata_t(s, opt2_to_type<0, 1>());
+ case 2: return strconv_pcdata_t(s, opt2_to_type<1, 0>());
+ case 3: return strconv_pcdata_t(s, opt2_to_type<1, 1>());
+ default: return 0; // should not get here
+ }
+ }
+
+ template <typename opt4> char* strconv_attribute_t(char* s, char end_quote, opt4)
+ {
+ const bool opt_wconv = opt4::o1;
+ const bool opt_wnorm = opt4::o2;
+ const bool opt_eol = opt4::o3;
+ const bool opt_escape = opt4::o4;
+
+ if (!*s) return 0;
+
+ gap g;
+
+ // Trim whitespaces
+ if (opt_wnorm)
+ {
+ char* str = s;
+
+ while (is_chartype(*str, ct_space)) ++str;
+
+ if (str != s)
+ g.push(s, str - s);
+ }
+
+ while (true)
+ {
+ while (!is_chartype(*s, (opt_wnorm || opt_wconv) ? ct_parse_attr_ws : ct_parse_attr)) ++s;
+
+ if (opt_wnorm && is_chartype(*s, ct_space))
+ {
+ *s++ = ' ';
+
+ if (is_chartype(*s, ct_space))
+ {
+ char* str = s + 1;
+ while (is_chartype(*str, ct_space)) ++str;
+
+ g.push(s, str - s);
+ }
+ }
+ else if (opt_wconv && is_chartype(*s, ct_space))
+ {
+ if (opt_eol)
+ {
+ if (*s == '\r')
+ {
+ *s++ = ' ';
+
+ if (*s == '\n') g.push(s, 1);
+ }
+ else *s++ = ' ';
+ }
+ else *s++ = ' ';
+ }
+ else if (opt_eol && *s == '\r')
+ {
+ *s++ = '\n';
+
+ if (*s == '\n') g.push(s, 1);
+ }
+ else if (*s == end_quote)
+ {
+ char* str = g.flush(s);
+
+ if (opt_wnorm)
+ {
+ do *str-- = 0;
+ while (is_chartype(*str, ct_space));
+ }
+ else *str = 0;
+
+ return s + 1;
+ }
+ else if (opt_escape && *s == '&')
+ {
+ s = strconv_escape(s, g);
+ }
+ else if (!*s)
+ {
+ return 0;
+ }
+ else ++s;
+ }
+ }
+
+ char* strconv_attribute(char* s, char end_quote, unsigned int optmask)
+ {
+ STATIC_ASSERT(parse_escapes == 0x10 && parse_eol == 0x20 && parse_wnorm_attribute == 0x40 && parse_wconv_attribute == 0x80);
+
+ switch ((optmask >> 4) & 15) // get bitmask for flags (wconv wnorm eol escapes)
+ {
+ case 0: return strconv_attribute_t(s, end_quote, opt4_to_type<0, 0, 0, 0>());
+ case 1: return strconv_attribute_t(s, end_quote, opt4_to_type<0, 0, 0, 1>());
+ case 2: return strconv_attribute_t(s, end_quote, opt4_to_type<0, 0, 1, 0>());
+ case 3: return strconv_attribute_t(s, end_quote, opt4_to_type<0, 0, 1, 1>());
+ case 4: return strconv_attribute_t(s, end_quote, opt4_to_type<0, 1, 0, 0>());
+ case 5: return strconv_attribute_t(s, end_quote, opt4_to_type<0, 1, 0, 1>());
+ case 6: return strconv_attribute_t(s, end_quote, opt4_to_type<0, 1, 1, 0>());
+ case 7: return strconv_attribute_t(s, end_quote, opt4_to_type<0, 1, 1, 1>());
+ case 8: return strconv_attribute_t(s, end_quote, opt4_to_type<1, 0, 0, 0>());
+ case 9: return strconv_attribute_t(s, end_quote, opt4_to_type<1, 0, 0, 1>());
+ case 10: return strconv_attribute_t(s, end_quote, opt4_to_type<1, 0, 1, 0>());
+ case 11: return strconv_attribute_t(s, end_quote, opt4_to_type<1, 0, 1, 1>());
+ case 12: return strconv_attribute_t(s, end_quote, opt4_to_type<1, 1, 0, 0>());
+ case 13: return strconv_attribute_t(s, end_quote, opt4_to_type<1, 1, 0, 1>());
+ case 14: return strconv_attribute_t(s, end_quote, opt4_to_type<1, 1, 1, 0>());
+ case 15: return strconv_attribute_t(s, end_quote, opt4_to_type<1, 1, 1, 1>());
+ default: return 0; // should not get here
+ }
+ }
+
+ inline xml_parse_result make_parse_result(xml_parse_status status, unsigned int offset, unsigned int line)
+ {
+ xml_parse_result result = {status, offset, line};
+ return result;
+ }
+
+ #define MAKE_PARSE_RESULT(status) make_parse_result(status, 0, __LINE__)
+
+ struct xml_parser
+ {
+ xml_allocator& alloc;
+
+ // Parser utilities.
+ #define SKIPWS() { while (is_chartype(*s, ct_space)) ++s; }
+ #define OPTSET(OPT) ( optmsk & OPT )
+ #define PUSHNODE(TYPE) { cursor = cursor->append_node(alloc,TYPE); }
+ #define POPNODE() { cursor = cursor->parent; }
+ #define SCANFOR(X) { while (*s != 0 && !(X)) ++s; }
+ #define SCANWHILE(X) { while ((X)) ++s; }
+ #define ENDSEG() { ch = *s; *s = 0; ++s; }
+ #define ERROR(err, m) make_parse_result(err, static_cast<unsigned int>(m - buffer_start), __LINE__)
+ #define CHECK_ERROR(err, m) { if (*s == 0) return ERROR(err, m); }
+
+ xml_parser(xml_allocator& alloc): alloc(alloc)
+ {
+ }
+
+ xml_parse_result parse(char* s, xml_node_struct* xmldoc, unsigned int optmsk = parse_default)
+ {
+ if (!s || !xmldoc) return MAKE_PARSE_RESULT(status_internal_error);
+
+ char* buffer_start = s;
+
+ // UTF-8 BOM
+ if ((unsigned char)*s == 0xEF && (unsigned char)*(s+1) == 0xBB && (unsigned char)*(s+2) == 0xBF)
+ s += 3;
+
+ char ch = 0;
+ xml_node_struct* cursor = xmldoc;
+ char* mark = s;
+
+ while (*s != 0)
+ {
+ if (*s == '<')
+ {
+ ++s;
+
+ LOC_TAG:
+ if (*s == '?') // '<?...'
+ {
+ ++s;
+
+ if (!is_chartype(*s, ct_start_symbol)) // bad PI
+ return ERROR(status_bad_pi, s);
+ else if (OPTSET(parse_pi) || OPTSET(parse_declaration))
+ {
+ mark = s;
+ SCANWHILE(is_chartype(*s, ct_symbol)); // Read PI target
+ CHECK_ERROR(status_bad_pi, s);
+
+ if (!is_chartype(*s, ct_space) && *s != '?') // Target has to end with space or ?
+ return ERROR(status_bad_pi, s);
+
+ ENDSEG();
+ CHECK_ERROR(status_bad_pi, s);
+
+ if (ch == '?') // nothing except target present
+ {
+ if (*s != '>') return ERROR(status_bad_pi, s);
+ ++s;
+
+ // stricmp / strcasecmp is not portable
+ if ((mark[0] == 'x' || mark[0] == 'X') && (mark[1] == 'm' || mark[1] == 'M')
+ && (mark[2] == 'l' || mark[2] == 'L') && mark[3] == 0)
+ {
+ if (OPTSET(parse_declaration))
+ {
+ PUSHNODE(node_declaration);
+
+ cursor->name = mark;
+
+ POPNODE();
+ }
+ }
+ else if (OPTSET(parse_pi))
+ {
+ PUSHNODE(node_pi); // Append a new node on the tree.
+
+ cursor->name = mark;
+
+ POPNODE();
+ }
+ }
+ // stricmp / strcasecmp is not portable
+ else if ((mark[0] == 'x' || mark[0] == 'X') && (mark[1] == 'm' || mark[1] == 'M')
+ && (mark[2] == 'l' || mark[2] == 'L') && mark[3] == 0)
+ {
+ if (OPTSET(parse_declaration))
+ {
+ PUSHNODE(node_declaration);
+
+ cursor->name = mark;
+
+ // scan for tag end
+ mark = s;
+
+ SCANFOR(*s == '?' && *(s+1) == '>'); // Look for '?>'.
+ CHECK_ERROR(status_bad_pi, s);
+
+ // replace ending ? with / to terminate properly
+ *s = '/';
+
+ // parse attributes
+ s = mark;
+
+ goto LOC_ATTRIBUTES;
+ }
+ }
+ else
+ {
+ if (OPTSET(parse_pi))
+ {
+ PUSHNODE(node_pi); // Append a new node on the tree.
+
+ cursor->name = mark;
+ }
+
+ if (is_chartype(ch, ct_space))
+ {
+ SKIPWS();
+ CHECK_ERROR(status_bad_pi, s);
+
+ mark = s;
+ }
+ else mark = 0;
+
+ SCANFOR(*s == '?' && *(s+1) == '>'); // Look for '?>'.
+ CHECK_ERROR(status_bad_pi, s);
+
+ ENDSEG();
+ CHECK_ERROR(status_bad_pi, s);
+
+ ++s; // Step over >
+
+ if (OPTSET(parse_pi))
+ {
+ cursor->value = mark;
+
+ POPNODE();
+ }
+ }
+ }
+ else // not parsing PI
+ {
+ SCANFOR(*s == '?' && *(s+1) == '>'); // Look for '?>'.
+ CHECK_ERROR(status_bad_pi, s);
+
+ s += 2;
+ }
+ }
+ else if (*s == '!') // '<!...'
+ {
+ ++s;
+
+ if (*s == '-') // '<!-...'
+ {
+ ++s;
+
+ if (*s == '-') // '<!--...'
+ {
+ ++s;
+
+ if (OPTSET(parse_comments))
+ {
+ PUSHNODE(node_comment); // Append a new node on the tree.
+ cursor->value = s; // Save the offset.
+ }
+
+ if (OPTSET(parse_eol) && OPTSET(parse_comments))
+ {
+ s = strconv_comment(s);
+
+ if (!s) return ERROR(status_bad_comment, cursor->value);
+ }
+ else
+ {
+ // Scan for terminating '-->'.
+ SCANFOR(*s == '-' && *(s+1) == '-' && *(s+2) == '>');
+ CHECK_ERROR(status_bad_comment, s);
+
+ if (OPTSET(parse_comments))
+ *s = 0; // Zero-terminate this segment at the first terminating '-'.
+
+ s += 3; // Step over the '\0->'.
+ }
+
+ if (OPTSET(parse_comments))
+ {
+ POPNODE(); // Pop since this is a standalone.
+ }
+ }
+ else return ERROR(status_bad_comment, s);
+ }
+ else if (*s == '[')
+ {
+ // '<![CDATA[...'
+ if (*++s=='C' && *++s=='D' && *++s=='A' && *++s=='T' && *++s=='A' && *++s == '[')
+ {
+ ++s;
+
+ if (OPTSET(parse_cdata))
+ {
+ PUSHNODE(node_cdata); // Append a new node on the tree.
+ cursor->value = s; // Save the offset.
+
+ if (OPTSET(parse_eol))
+ {
+ s = strconv_cdata(s);
+
+ if (!s) return ERROR(status_bad_cdata, cursor->value);
+ }
+ else
+ {
+ // Scan for terminating ']]>'.
+ SCANFOR(*s == ']' && *(s+1) == ']' && *(s+2) == '>');
+ CHECK_ERROR(status_bad_cdata, s);
+
+ ENDSEG(); // Zero-terminate this segment.
+ CHECK_ERROR(status_bad_cdata, s);
+ }
+
+ POPNODE(); // Pop since this is a standalone.
+ }
+ else // Flagged for discard, but we still have to scan for the terminator.
+ {
+ // Scan for terminating ']]>'.
+ SCANFOR(*s == ']' && *(s+1) == ']' && *(s+2) == '>');
+ CHECK_ERROR(status_bad_cdata, s);
+
+ ++s;
+ }
+
+ s += 2; // Step over the last ']>'.
+ }
+ else return ERROR(status_bad_cdata, s);
+ }
+ else if (*s=='D' && *++s=='O' && *++s=='C' && *++s=='T' && *++s=='Y' && *++s=='P' && *++s=='E')
+ {
+ ++s;
+
+ SKIPWS(); // Eat any whitespace.
+ CHECK_ERROR(status_bad_doctype, s);
+
+ LOC_DOCTYPE:
+ SCANFOR(*s == '\'' || *s == '"' || *s == '[' || *s == '>');
+ CHECK_ERROR(status_bad_doctype, s);
+
+ if (*s == '\'' || *s == '"') // '...SYSTEM "..."
+ {
+ ch = *s++;
+ SCANFOR(*s == ch);
+ CHECK_ERROR(status_bad_doctype, s);
+
+ ++s;
+ goto LOC_DOCTYPE;
+ }
+
+ if(*s == '[') // '...[...'
+ {
+ ++s;
+ unsigned int bd = 1; // Bracket depth counter.
+ while (*s!=0) // Loop till we're out of all brackets.
+ {
+ if (*s == ']') --bd;
+ else if (*s == '[') ++bd;
+ if (bd == 0) break;
+ ++s;
+ }
+ }
+
+ SCANFOR(*s == '>');
+ CHECK_ERROR(status_bad_doctype, s);
+
+ ++s;
+ }
+ else return ERROR(status_unrecognized_tag, s);
+ }
+ else if (is_chartype(*s, ct_start_symbol)) // '<#...'
+ {
+ PUSHNODE(node_element); // Append a new node to the tree.
+
+ cursor->name = s;
+
+ SCANWHILE(is_chartype(*s, ct_symbol)); // Scan for a terminator.
+ CHECK_ERROR(status_bad_start_element, s);
+
+ ENDSEG(); // Save char in 'ch', terminate & step over.
+ CHECK_ERROR(status_bad_start_element, s);
+
+ if (ch == '/') // '<#.../'
+ {
+ if (*s != '>') return ERROR(status_bad_start_element, s);
+
+ POPNODE(); // Pop.
+
+ ++s;
+ }
+ else if (ch == '>')
+ {
+ // end of tag
+ }
+ else if (is_chartype(ch, ct_space))
+ {
+ LOC_ATTRIBUTES:
+ while (true)
+ {
+ SKIPWS(); // Eat any whitespace.
+ CHECK_ERROR(status_bad_start_element, s);
+
+ if (is_chartype(*s, ct_start_symbol)) // <... #...
+ {
+ xml_attribute_struct* a = cursor->append_attribute(alloc); // Make space for this attribute.
+ a->name = s; // Save the offset.
+
+ SCANWHILE(is_chartype(*s, ct_symbol)); // Scan for a terminator.
+ CHECK_ERROR(status_bad_attribute, s);
+
+ ENDSEG(); // Save char in 'ch', terminate & step over.
+ CHECK_ERROR(status_bad_attribute, s);
+
+ if (is_chartype(ch, ct_space))
+ {
+ SKIPWS(); // Eat any whitespace.
+ CHECK_ERROR(status_bad_attribute, s);
+
+ ch = *s;
+ ++s;
+ }
+
+ if (ch == '=') // '<... #=...'
+ {
+ SKIPWS(); // Eat any whitespace.
+ CHECK_ERROR(status_bad_attribute, s);
+
+ if (*s == '\'' || *s == '"') // '<... #="...'
+ {
+ ch = *s; // Save quote char to avoid breaking on "''" -or- '""'.
+ ++s; // Step over the quote.
+ a->value = s; // Save the offset.
+
+ s = strconv_attribute(s, ch, optmsk);
+
+ if (!s) return ERROR(status_bad_attribute, a->value);
+
+ // After this line the loop continues from the start;
+ // Whitespaces, / and > are ok, symbols and EOF are wrong,
+ // everything else will be detected
+ if (is_chartype(*s, ct_start_symbol)) return ERROR(status_bad_attribute, s);
+
+ CHECK_ERROR(status_bad_start_element, s);
+ }
+ else return ERROR(status_bad_attribute, s);
+ }
+ else return ERROR(status_bad_attribute, s);
+ }
+ else if (*s == '/')
+ {
+ ++s;
+
+ if (*s != '>') return ERROR(status_bad_start_element, s);
+
+ POPNODE(); // Pop.
+
+ ++s;
+
+ break;
+ }
+ else if (*s == '>')
+ {
+ ++s;
+
+ break;
+ }
+ else return ERROR(status_bad_start_element, s);
+ }
+
+ // !!!
+ }
+ else return ERROR(status_bad_start_element, s);
+ }
+ else if (*s == '/')
+ {
+ ++s;
+
+ if (!cursor) return ERROR(status_bad_end_element, s);
+
+ char* name = cursor->name;
+ if (!name) return ERROR(status_end_element_mismatch, s);
+
+ while (*s && is_chartype(*s, ct_symbol))
+ {
+ if (*s++ != *name++) return ERROR(status_end_element_mismatch, s);
+ }
+
+ if (*name) return ERROR(status_end_element_mismatch, s);
+
+ POPNODE(); // Pop.
+
+ SKIPWS();
+ CHECK_ERROR(status_bad_end_element, s);
+
+ if (*s != '>') return ERROR(status_bad_end_element, s);
+ ++s;
+ }
+ else return ERROR(status_unrecognized_tag, s);
+ }
+ else
+ {
+ mark = s; // Save this offset while searching for a terminator.
+
+ SKIPWS(); // Eat whitespace if no genuine PCDATA here.
+
+ if ((mark == s || !OPTSET(parse_ws_pcdata)) && (!*s || *s == '<'))
+ {
+ continue;
+ }
+
+ s = mark;
+
+ if (static_cast<xml_node_type>(cursor->type) != node_document)
+ {
+ PUSHNODE(node_pcdata); // Append a new node on the tree.
+ cursor->value = s; // Save the offset.
+
+ s = strconv_pcdata(s, optmsk);
+
+ if (!s) return ERROR(status_bad_pcdata, cursor->value);
+
+ POPNODE(); // Pop since this is a standalone.
+
+ if (!*s) break;
+ }
+ else
+ {
+ SCANFOR(*s == '<'); // '...<'
+ if (!*s) break;
+
+ ++s;
+ }
+
+ // We're after '<'
+ goto LOC_TAG;
+ }
+ }
+
+ if (cursor != xmldoc) return ERROR(status_end_element_mismatch, s);
+
+ return ERROR(status_ok, s);
+ }
+
+ private:
+ xml_parser(const xml_parser&);
+ const xml_parser& operator=(const xml_parser&);
+ };
+
+ // Compare lhs with [rhs_begin, rhs_end)
+ int strcmprange(const char* lhs, const char* rhs_begin, const char* rhs_end)
+ {
+ while (*lhs && rhs_begin != rhs_end && *lhs == *rhs_begin)
+ {
+ ++lhs;
+ ++rhs_begin;
+ }
+
+ if (rhs_begin == rhs_end && *lhs == 0) return 0;
+ else return 1;
+ }
+
+ // Character set pattern match.
+ int strcmpwild_cset(const char** src, const char** dst)
+ {
+ int find = 0, excl = 0, star = 0;
+
+ if (**src == '!')
+ {
+ excl = 1;
+ ++(*src);
+ }
+
+ while (**src != ']' || star == 1)
+ {
+ if (find == 0)
+ {
+ if (**src == '-' && *(*src-1) < *(*src+1) && *(*src+1) != ']' && star == 0)
+ {
+ if (**dst >= *(*src-1) && **dst <= *(*src+1))
+ {
+ find = 1;
+ ++(*src);
+ }
+ }
+ else if (**src == **dst) find = 1;
+ }
+ ++(*src);
+ star = 0;
+ }
+
+ if (excl == 1) find = (1 - find);
+ if (find == 1) ++(*dst);
+
+ return find;
+ }
+
+ // Wildcard pattern match.
+ int strcmpwild_astr(const char** src, const char** dst)
+ {
+ int find = 1;
+ ++(*src);
+ while ((**dst != 0 && **src == '?') || **src == '*')
+ {
+ if(**src == '?') ++(*dst);
+ ++(*src);
+ }
+ while (**src == '*') ++(*src);
+ if (**dst == 0 && **src != 0) return 0;
+ if (**dst == 0 && **src == 0) return 1;
+ else
+ {
+ if (impl::strcmpwild(*src,*dst))
+ {
+ do
+ {
+ ++(*dst);
+ while(**src != **dst && **src != '[' && **dst != 0)
+ ++(*dst);
+ }
+ while ((**dst != 0) ? impl::strcmpwild(*src,*dst) : 0 != (find=0));
+ }
+ if (**dst == 0 && **src == 0) find = 1;
+ return find;
+ }
+ }
+
+ // Output facilities
+ struct xml_buffered_writer
+ {
+ xml_buffered_writer(const xml_buffered_writer&);
+ xml_buffered_writer& operator=(const xml_buffered_writer&);
+
+ xml_buffered_writer(xml_writer& writer): writer(writer), bufsize(0)
+ {
+ }
+
+ ~xml_buffered_writer()
+ {
+ flush();
+ }
+
+ void flush()
+ {
+ if (bufsize > 0) writer.write(buffer, bufsize);
+ bufsize = 0;
+ }
+
+ void write(const void* data, size_t size)
+ {
+ if (bufsize + size > sizeof(buffer))
+ {
+ flush();
+
+ if (size > sizeof(buffer))
+ {
+ writer.write(data, size);
+ return;
+ }
+ }
+
+ memcpy(buffer + bufsize, data, size);
+ bufsize += size;
+ }
+
+ void write(const char* data)
+ {
+ write(data, strlen(data));
+ }
+
+ void write(char data)
+ {
+ if (bufsize + 1 > sizeof(buffer)) flush();
+
+ buffer[bufsize++] = data;
+ }
+
+ xml_writer& writer;
+ char buffer[8192];
+ size_t bufsize;
+ };
+
+ template <typename opt1> void text_output_escaped(xml_buffered_writer& writer, const char* s, opt1)
+ {
+ const bool attribute = opt1::o1;
+
+ while (*s)
+ {
+ const char* prev = s;
+
+ // While *s is a usual symbol
+ while (*s && *s != '&' && *s != '<' && *s != '>' && (*s != '"' || !attribute)
+ && ((unsigned char)*s >= 32 || (*s == '\r' && !attribute) || (*s == '\n' && !attribute) || *s == '\t'))
+ ++s;
+
+ writer.write(prev, static_cast<size_t>(s - prev));
+
+ switch (*s)
+ {
+ case 0: break;
+ case '&':
+ writer.write("&");
+ ++s;
+ break;
+ case '<':
+ writer.write("<");
+ ++s;
+ break;
+ case '>':
+ writer.write(">");
+ ++s;
+ break;
+ case '"':
+ writer.write(""");
+ ++s;
+ break;
+ case '\r':
+ writer.write(" ");
+ ++s;
+ break;
+ case '\n':
+ writer.write(" ");
+ ++s;
+ break;
+ default: // s is not a usual symbol
+ {
+ unsigned int ch = (unsigned char)*s++;
+
+ char buf[8];
+ sprintf(buf, "&#%u;", ch);
+
+ writer.write(buf);
+ }
+ }
+ }
+ }
+
+ void node_output(xml_buffered_writer& writer, const xml_node& node, const char* indent, unsigned int flags, unsigned int depth)
+ {
+ if ((flags & format_indent) != 0 && (flags & format_raw) == 0)
+ for (unsigned int i = 0; i < depth; ++i) writer.write(indent);
+
+ switch (node.type())
+ {
+ case node_document:
+ {
+ for (xml_node n = node.first_child(); n; n = n.next_sibling())
+ node_output(writer, n, indent, flags, depth);
+ break;
+ }
+
+ case node_element:
+ {
+ writer.write('<');
+ writer.write(node.name());
+
+ for (xml_attribute a = node.first_attribute(); a; a = a.next_attribute())
+ {
+ writer.write(' ');
+ writer.write(a.name());
+ writer.write('=');
+ writer.write('"');
+
+ text_output_escaped(writer, a.value(), opt1_to_type<1>());
+
+ writer.write('"');
+ }
+
+ if (flags & format_raw)
+ {
+ if (!node.first_child())
+ writer.write(" />");
+ else
+ {
+ writer.write('>');
+
+ for (xml_node n = node.first_child(); n; n = n.next_sibling())
+ node_output(writer, n, indent, flags, depth + 1);
+
+ writer.write('<');
+ writer.write('/');
+ writer.write(node.name());
+ writer.write('>');
+ }
+ }
+ else if (!node.first_child())
+ writer.write(" />\n");
+ else if (node.first_child() == node.last_child() && node.first_child().type() == node_pcdata)
+ {
+ writer.write('>');
+
+ text_output_escaped(writer, node.first_child().value(), opt1_to_type<0>());
+
+ writer.write('<');
+ writer.write('/');
+ writer.write(node.name());
+ writer.write('>');
+ writer.write('\n');
+ }
+ else
+ {
+ writer.write('>');
+ writer.write('\n');
+
+ for (xml_node n = node.first_child(); n; n = n.next_sibling())
+ node_output(writer, n, indent, flags, depth + 1);
+
+ if ((flags & format_indent) != 0 && (flags & format_raw) == 0)
+ for (unsigned int i = 0; i < depth; ++i) writer.write(indent);
+
+ writer.write('<');
+ writer.write('/');
+ writer.write(node.name());
+ writer.write('>');
+ writer.write('\n');
+ }
+
+ break;
+ }
+
+ case node_pcdata:
+ text_output_escaped(writer, node.value(), opt1_to_type<0>());
+ break;
+
+ case node_cdata:
+ writer.write("<![CDATA[");
+ writer.write(node.value());
+ writer.write("]]>");
+ if ((flags & format_raw) == 0) writer.write('\n');
+ break;
+
+ case node_comment:
+ writer.write("<!--");
+ writer.write(node.value());
+ writer.write("-->");
+ if ((flags & format_raw) == 0) writer.write('\n');
+ break;
+
+ case node_pi:
+ writer.write("<?");
+ writer.write(node.name());
+ if (node.value()[0])
+ {
+ writer.write(' ');
+ writer.write(node.value());
+ }
+ writer.write("?>");
+ if ((flags & format_raw) == 0) writer.write('\n');
+ break;
+
+ case node_declaration:
+ {
+ writer.write("<?");
+ writer.write(node.name());
+
+ for (xml_attribute a = node.first_attribute(); a; a = a.next_attribute())
+ {
+ writer.write(' ');
+ writer.write(a.name());
+ writer.write('=');
+ writer.write('"');
+
+ text_output_escaped(writer, a.value(), opt1_to_type<1>());
+
+ writer.write('"');
+ }
+
+ writer.write("?>");
+ if ((flags & format_raw) == 0) writer.write('\n');
+ break;
+ }
+
+ default:
+ assert(false);
+ }
+ }
+
+ void recursive_copy_skip(xml_node& dest, const xml_node& source, const xml_node& skip)
+ {
+ assert(dest.type() == source.type());
+
+ switch (source.type())
+ {
+ case node_element:
+ {
+ dest.set_name(source.name());
+
+ for (xml_attribute a = source.first_attribute(); a; a = a.next_attribute())
+ dest.append_attribute(a.name()).set_value(a.value());
+
+ for (xml_node c = source.first_child(); c; c = c.next_sibling())
+ {
+ if (c == skip) continue;
+
+ xml_node cc = dest.append_child(c.type());
+ assert(cc);
+
+ recursive_copy_skip(cc, c, skip);
+ }
+
+ break;
+ }
+
+ case node_pcdata:
+ case node_cdata:
+ case node_comment:
+ case node_pi:
+ dest.set_value(source.value());
+ break;
+
+ case node_declaration:
+ dest.set_name(source.name());
+ dest.set_value(source.value());
+ break;
+
+ default:
+ assert(false);
+ }
+ }
+}
+
+namespace pugi
+{
+ namespace impl
+ {
+ // Compare two strings
+ int PUGIXML_FUNCTION strcmp(const char* src, const char* dst)
+ {
+ return ::strcmp(src, dst);
+ }
+
+ // Compare two strings, with globbing, and character sets.
+ int PUGIXML_FUNCTION strcmpwild(const char* src, const char* dst)
+ {
+ int find = 1;
+ for(; *src != 0 && find == 1 && *dst != 0; ++src)
+ {
+ switch (*src)
+ {
+ case '?': ++dst; break;
+ case '[': ++src; find = strcmpwild_cset(&src,&dst); break;
+ case '*': find = strcmpwild_astr(&src,&dst); --src; break;
+ default : find = (int) (*src == *dst); ++dst;
+ }
+ }
+ while (*src == '*' && find == 1) ++src;
+ return (find == 1 && *dst == 0 && *src == 0) ? 0 : 1;
+ }
+ }
+
+ xml_writer_file::xml_writer_file(void* file): file(file)
+ {
+ }
+
+ void xml_writer_file::write(const void* data, size_t size)
+ {
+ fwrite(data, size, 1, static_cast<FILE*>(file));
+ }
+
+#ifndef PUGIXML_NO_STL
+ xml_writer_stream::xml_writer_stream(std::ostream& stream): stream(&stream)
+ {
+ }
+
+ void xml_writer_stream::write(const void* data, size_t size)
+ {
+ stream->write(reinterpret_cast<const char*>(data), static_cast<std::streamsize>(size));
+ }
+#endif
+
+ xml_tree_walker::xml_tree_walker(): _depth(0)
+ {
+ }
+
+ xml_tree_walker::~xml_tree_walker()
+ {
+ }
+
+ int xml_tree_walker::depth() const
+ {
+ return _depth;
+ }
+
+ bool xml_tree_walker::begin(xml_node&)
+ {
+ return true;
+ }
+
+ bool xml_tree_walker::end(xml_node&)
+ {
+ return true;
+ }
+
+ xml_attribute::xml_attribute(): _attr(0)
+ {
+ }
+
+ xml_attribute::xml_attribute(xml_attribute_struct* attr): _attr(attr)
+ {
+ }
+
+#ifdef __MWERKS__
+ xml_attribute::operator xml_attribute::unspecified_bool_type() const
+ {
+ return _attr ? &xml_attribute::empty : 0;
+ }
+#else
+ xml_attribute::operator xml_attribute::unspecified_bool_type() const
+ {
+ return _attr ? &xml_attribute::_attr : 0;
+ }
+#endif
+
+ bool xml_attribute::operator!() const
+ {
+ return !_attr;
+ }
+
+ bool xml_attribute::operator==(const xml_attribute& r) const
+ {
+ return (_attr == r._attr);
+ }
+
+ bool xml_attribute::operator!=(const xml_attribute& r) const
+ {
+ return (_attr != r._attr);
+ }
+
+ bool xml_attribute::operator<(const xml_attribute& r) const
+ {
+ return (_attr < r._attr);
+ }
+
+ bool xml_attribute::operator>(const xml_attribute& r) const
+ {
+ return (_attr > r._attr);
+ }
+
+ bool xml_attribute::operator<=(const xml_attribute& r) const
+ {
+ return (_attr <= r._attr);
+ }
+
+ bool xml_attribute::operator>=(const xml_attribute& r) const
+ {
+ return (_attr >= r._attr);
+ }
+
+ xml_attribute xml_attribute::next_attribute() const
+ {
+ return _attr ? xml_attribute(_attr->next_attribute) : xml_attribute();
+ }
+
+ xml_attribute xml_attribute::previous_attribute() const
+ {
+ return _attr ? xml_attribute(_attr->prev_attribute) : xml_attribute();
+ }
+
+ int xml_attribute::as_int() const
+ {
+ return (_attr && _attr->value) ? atoi(_attr->value) : 0;
+ }
+
+ unsigned int xml_attribute::as_uint() const
+ {
+ int result = (_attr && _attr->value) ? atoi(_attr->value) : 0;
+ return result < 0 ? 0 : static_cast<unsigned int>(result);
+ }
+
+ double xml_attribute::as_double() const
+ {
+ return (_attr && _attr->value) ? atof(_attr->value) : 0;
+ }
+
+ float xml_attribute::as_float() const
+ {
+ return (_attr && _attr->value) ? (float)atof(_attr->value) : 0;
+ }
+
+ bool xml_attribute::as_bool() const
+ {
+ // only look at first char
+ char first = (_attr && _attr->value) ? *_attr->value : '\0';
+
+ // 1*, t* (true), T* (True), y* (yes), Y* (YES)
+ return (first == '1' || first == 't' || first == 'T' || first == 'y' || first == 'Y');
+ }
+
+ bool xml_attribute::empty() const
+ {
+ return !_attr;
+ }
+
+ const char* xml_attribute::name() const
+ {
+ return (_attr && _attr->name) ? _attr->name : "";
+ }
+
+ const char* xml_attribute::value() const
+ {
+ return (_attr && _attr->value) ? _attr->value : "";
+ }
+
+ unsigned int xml_attribute::document_order() const
+ {
+ return _attr ? _attr->document_order : 0;
+ }
+
+ xml_attribute& xml_attribute::operator=(const char* rhs)
+ {
+ set_value(rhs);
+ return *this;
+ }
+
+ xml_attribute& xml_attribute::operator=(int rhs)
+ {
+ set_value(rhs);
+ return *this;
+ }
+
+ xml_attribute& xml_attribute::operator=(unsigned int rhs)
+ {
+ set_value(rhs);
+ return *this;
+ }
+
+ xml_attribute& xml_attribute::operator=(double rhs)
+ {
+ set_value(rhs);
+ return *this;
+ }
+
+ xml_attribute& xml_attribute::operator=(bool rhs)
+ {
+ set_value(rhs);
+ return *this;
+ }
+
+ bool xml_attribute::set_name(const char* rhs)
+ {
+ if (!_attr) return false;
+
+ bool insitu = _attr->name_insitu;
+ bool res = strcpy_insitu(_attr->name, insitu, rhs);
+ _attr->name_insitu = insitu;
+
+ return res;
+ }
+
+ bool xml_attribute::set_value(const char* rhs)
+ {
+ if (!_attr) return false;
+
+ bool insitu = _attr->value_insitu;
+ bool res = strcpy_insitu(_attr->value, insitu, rhs);
+ _attr->value_insitu = insitu;
+
+ return res;
+ }
+
+ bool xml_attribute::set_value(int rhs)
+ {
+ char buf[128];
+ sprintf(buf, "%d", rhs);
+ return set_value(buf);
+ }
+
+ bool xml_attribute::set_value(unsigned int rhs)
+ {
+ char buf[128];
+ sprintf(buf, "%u", rhs);
+ return set_value(buf);
+ }
+
+ bool xml_attribute::set_value(double rhs)
+ {
+ char buf[128];
+ sprintf(buf, "%g", rhs);
+ return set_value(buf);
+ }
+
+ bool xml_attribute::set_value(bool rhs)
+ {
+ return set_value(rhs ? "true" : "false");
+ }
+
+#ifdef __BORLANDC__
+ bool operator&&(const xml_attribute& lhs, bool rhs)
+ {
+ return lhs ? rhs : false;
+ }
+
+ bool operator||(const xml_attribute& lhs, bool rhs)
+ {
+ return lhs ? true : rhs;
+ }
+#endif
+
+ xml_node::xml_node(): _root(0)
+ {
+ }
+
+ xml_node::xml_node(xml_node_struct* p): _root(p)
+ {
+ }
+
+#ifdef __MWERKS__
+ xml_node::operator xml_node::unspecified_bool_type() const
+ {
+ return _root ? &xml_node::empty : 0;
+ }
+#else
+ xml_node::operator xml_node::unspecified_bool_type() const
+ {
+ return _root ? &xml_node::_root : 0;
+ }
+#endif
+
+ bool xml_node::operator!() const
+ {
+ return !_root;
+ }
+
+ xml_node::iterator xml_node::begin() const
+ {
+ return _root ? iterator(_root->first_child) : iterator();
+ }
+
+ xml_node::iterator xml_node::end() const
+ {
+ return _root ? iterator(0, _root->last_child) : iterator();
+ }
+
+ xml_node::attribute_iterator xml_node::attributes_begin() const
+ {
+ return _root ? attribute_iterator(_root->first_attribute) : attribute_iterator();
+ }
+
+ xml_node::attribute_iterator xml_node::attributes_end() const
+ {
+ return _root ? attribute_iterator(0, _root->last_attribute) : attribute_iterator();
+ }
+
+ bool xml_node::operator==(const xml_node& r) const
+ {
+ return (_root == r._root);
+ }
+
+ bool xml_node::operator!=(const xml_node& r) const
+ {
+ return (_root != r._root);
+ }
+
+ bool xml_node::operator<(const xml_node& r) const
+ {
+ return (_root < r._root);
+ }
+
+ bool xml_node::operator>(const xml_node& r) const
+ {
+ return (_root > r._root);
+ }
+
+ bool xml_node::operator<=(const xml_node& r) const
+ {
+ return (_root <= r._root);
+ }
+
+ bool xml_node::operator>=(const xml_node& r) const
+ {
+ return (_root >= r._root);
+ }
+
+ bool xml_node::empty() const
+ {
+ return !_root;
+ }
+
+ xml_allocator& xml_node::get_allocator() const
+ {
+ xml_node_struct* r = root()._root;
+
+ return static_cast<xml_document_struct*>(r)->allocator;
+ }
+
+ const char* xml_node::name() const
+ {
+ return (_root && _root->name) ? _root->name : "";
+ }
+
+ xml_node_type xml_node::type() const
+ {
+ return _root ? static_cast<xml_node_type>(_root->type) : node_null;
+ }
+
+ const char* xml_node::value() const
+ {
+ return (_root && _root->value) ? _root->value : "";
+ }
+
+ xml_node xml_node::child(const char* name) const
+ {
+ if (!_root) return xml_node();
+
+ for (xml_node_struct* i = _root->first_child; i; i = i->next_sibling)
+ if (i->name && !strcmp(name, i->name)) return xml_node(i);
+
+ return xml_node();
+ }
+
+ xml_node xml_node::child_w(const char* name) const
+ {
+ if (!_root) return xml_node();
+
+ for (xml_node_struct* i = _root->first_child; i; i = i->next_sibling)
+ if (i->name && !impl::strcmpwild(name, i->name)) return xml_node(i);
+
+ return xml_node();
+ }
+
+ xml_attribute xml_node::attribute(const char* name) const
+ {
+ if (!_root) return xml_attribute();
+
+ for (xml_attribute_struct* i = _root->first_attribute; i; i = i->next_attribute)
+ if (i->name && !strcmp(name, i->name))
+ return xml_attribute(i);
+
+ return xml_attribute();
+ }
+
+ xml_attribute xml_node::attribute_w(const char* name) const
+ {
+ if (!_root) return xml_attribute();
+
+ for (xml_attribute_struct* i = _root->first_attribute; i; i = i->next_attribute)
+ if (i->name && !impl::strcmpwild(name, i->name))
+ return xml_attribute(i);
+
+ return xml_attribute();
+ }
+
+ xml_node xml_node::next_sibling(const char* name) const
+ {
+ if (!_root) return xml_node();
+
+ for (xml_node_struct* i = _root->next_sibling; i; i = i->next_sibling)
+ if (i->name && !strcmp(name, i->name)) return xml_node(i);
+
+ return xml_node();
+ }
+
+ xml_node xml_node::next_sibling_w(const char* name) const
+ {
+ if (!_root) return xml_node();
+
+ for (xml_node_struct* i = _root->next_sibling; i; i = i->next_sibling)
+ if (i->name && !impl::strcmpwild(name, i->name)) return xml_node(i);
+
+ return xml_node();
+ }
+
+ xml_node xml_node::next_sibling() const
+ {
+ if (!_root) return xml_node();
+
+ if (_root->next_sibling) return xml_node(_root->next_sibling);
+ else return xml_node();
+ }
+
+ xml_node xml_node::previous_sibling(const char* name) const
+ {
+ if (!_root) return xml_node();
+
+ for (xml_node_struct* i = _root->prev_sibling; i; i = i->prev_sibling)
+ if (i->name && !strcmp(name, i->name)) return xml_node(i);
+
+ return xml_node();
+ }
+
+ xml_node xml_node::previous_sibling_w(const char* name) const
+ {
+ if (!_root) return xml_node();
+
+ for (xml_node_struct* i = _root->prev_sibling; i; i = i->prev_sibling)
+ if (i->name && !impl::strcmpwild(name, i->name)) return xml_node(i);
+
+ return xml_node();
+ }
+
+ xml_node xml_node::previous_sibling() const
+ {
+ if (!_root) return xml_node();
+
+ if (_root->prev_sibling) return xml_node(_root->prev_sibling);
+ else return xml_node();
+ }
+
+ xml_node xml_node::parent() const
+ {
+ return _root ? xml_node(_root->parent) : xml_node();
+ }
+
+ xml_node xml_node::root() const
+ {
+ xml_node r = *this;
+ while (r && r.parent()) r = r.parent();
+ return r;
+ }
+
+ const char* xml_node::child_value() const
+ {
+ if (!_root) return "";
+
+ for (xml_node_struct* i = _root->first_child; i; i = i->next_sibling)
+ if ((static_cast<xml_node_type>(i->type) == node_pcdata || static_cast<xml_node_type>(i->type) == node_cdata) && i->value)
+ return i->value;
+
+ return "";
+ }
+
+ const char* xml_node::child_value(const char* name) const
+ {
+ return child(name).child_value();
+ }
+
+ const char* xml_node::child_value_w(const char* name) const
+ {
+ return child_w(name).child_value();
+ }
+
+ xml_attribute xml_node::first_attribute() const
+ {
+ return _root ? xml_attribute(_root->first_attribute) : xml_attribute();
+ }
+
+ xml_attribute xml_node::last_attribute() const
+ {
+ return _root ? xml_attribute(_root->last_attribute) : xml_attribute();
+ }
+
+ xml_node xml_node::first_child() const
+ {
+ return _root ? xml_node(_root->first_child) : xml_node();
+ }
+
+ xml_node xml_node::last_child() const
+ {
+ return _root ? xml_node(_root->last_child) : xml_node();
+ }
+
+ bool xml_node::set_name(const char* rhs)
+ {
+ switch (type())
+ {
+ case node_pi:
+ case node_declaration:
+ case node_element:
+ {
+ bool insitu = _root->name_insitu;
+ bool res = strcpy_insitu(_root->name, insitu, rhs);
+ _root->name_insitu = insitu;
+
+ return res;
+ }
+
+ default:
+ return false;
+ }
+ }
+
+ bool xml_node::set_value(const char* rhs)
+ {
+ switch (type())
+ {
+ case node_pi:
+ case node_cdata:
+ case node_pcdata:
+ case node_comment:
+ {
+ bool insitu = _root->value_insitu;
+ bool res = strcpy_insitu(_root->value, insitu, rhs);
+ _root->value_insitu = insitu;
+
+ return res;
+ }
+
+ default:
+ return false;
+ }
+ }
+
+ xml_attribute xml_node::append_attribute(const char* name)
+ {
+ if (type() != node_element && type() != node_declaration) return xml_attribute();
+
+ xml_attribute a(_root->append_attribute(get_allocator()));
+ a.set_name(name);
+
+ return a;
+ }
+
+ xml_attribute xml_node::insert_attribute_before(const char* name, const xml_attribute& attr)
+ {
+ if ((type() != node_element && type() != node_declaration) || attr.empty()) return xml_attribute();
+
+ // check that attribute belongs to *this
+ xml_attribute_struct* cur = attr._attr;
+
+ while (cur->prev_attribute) cur = cur->prev_attribute;
+
+ if (cur != _root->first_attribute) return xml_attribute();
+
+ xml_attribute a(get_allocator().allocate_attribute());
+ a.set_name(name);
+
+ if (attr._attr->prev_attribute)
+ attr._attr->prev_attribute->next_attribute = a._attr;
+ else
+ _root->first_attribute = a._attr;
+
+ a._attr->prev_attribute = attr._attr->prev_attribute;
+ a._attr->next_attribute = attr._attr;
+ attr._attr->prev_attribute = a._attr;
+
+ return a;
+ }
+
+ xml_attribute xml_node::insert_attribute_after(const char* name, const xml_attribute& attr)
+ {
+ if ((type() != node_element && type() != node_declaration) || attr.empty()) return xml_attribute();
+
+ // check that attribute belongs to *this
+ xml_attribute_struct* cur = attr._attr;
+
+ while (cur->prev_attribute) cur = cur->prev_attribute;
+
+ if (cur != _root->first_attribute) return xml_attribute();
+
+ xml_attribute a(get_allocator().allocate_attribute());
+ a.set_name(name);
+
+ if (attr._attr->next_attribute)
+ attr._attr->next_attribute->prev_attribute = a._attr;
+ else
+ _root->last_attribute = a._attr;
+
+ a._attr->next_attribute = attr._attr->next_attribute;
+ a._attr->prev_attribute = attr._attr;
+ attr._attr->next_attribute = a._attr;
+
+ return a;
+ }
+
+ xml_attribute xml_node::append_copy(const xml_attribute& proto)
+ {
+ if (!proto) return xml_attribute();
+
+ xml_attribute result = append_attribute(proto.name());
+ result.set_value(proto.value());
+
+ return result;
+ }
+
+ xml_attribute xml_node::insert_copy_after(const xml_attribute& proto, const xml_attribute& attr)
+ {
+ if (!proto) return xml_attribute();
+
+ xml_attribute result = insert_attribute_after(proto.name(), attr);
+ result.set_value(proto.value());
+
+ return result;
+ }
+
+ xml_attribute xml_node::insert_copy_before(const xml_attribute& proto, const xml_attribute& attr)
+ {
+ if (!proto) return xml_attribute();
+
+ xml_attribute result = insert_attribute_before(proto.name(), attr);
+ result.set_value(proto.value());
+
+ return result;
+ }
+
+ xml_node xml_node::append_child(xml_node_type type)
+ {
+ if ((this->type() != node_element && this->type() != node_document) || type == node_document || type == node_null) return xml_node();
+
+ return xml_node(_root->append_node(get_allocator(), type));
+ }
+
+ xml_node xml_node::insert_child_before(xml_node_type type, const xml_node& node)
+ {
+ if ((this->type() != node_element && this->type() != node_document) || type == node_document || type == node_null) return xml_node();
+ if (node.parent() != *this) return xml_node();
+
+ xml_node n(get_allocator().allocate_node(type));
+ n._root->parent = _root;
+
+ if (node._root->prev_sibling)
+ node._root->prev_sibling->next_sibling = n._root;
+ else
+ _root->first_child = n._root;
+
+ n._root->prev_sibling = node._root->prev_sibling;
+ n._root->next_sibling = node._root;
+ node._root->prev_sibling = n._root;
+
+ return n;
+ }
+
+ xml_node xml_node::insert_child_after(xml_node_type type, const xml_node& node)
+ {
+ if ((this->type() != node_element && this->type() != node_document) || type == node_document || type == node_null) return xml_node();
+ if (node.parent() != *this) return xml_node();
+
+ xml_node n(get_allocator().allocate_node(type));
+ n._root->parent = _root;
+
+ if (node._root->next_sibling)
+ node._root->next_sibling->prev_sibling = n._root;
+ else
+ _root->last_child = n._root;
+
+ n._root->next_sibling = node._root->next_sibling;
+ n._root->prev_sibling = node._root;
+ node._root->next_sibling = n._root;
+
+ return n;
+ }
+
+ xml_node xml_node::append_copy(const xml_node& proto)
+ {
+ xml_node result = append_child(proto.type());
+
+ if (result) recursive_copy_skip(result, proto, result);
+
+ return result;
+ }
+
+ xml_node xml_node::insert_copy_after(const xml_node& proto, const xml_node& node)
+ {
+ xml_node result = insert_child_after(proto.type(), node);
+
+ if (result) recursive_copy_skip(result, proto, result);
+
+ return result;
+ }
+
+ xml_node xml_node::insert_copy_before(const xml_node& proto, const xml_node& node)
+ {
+ xml_node result = insert_child_before(proto.type(), node);
+
+ if (result) recursive_copy_skip(result, proto, result);
+
+ return result;
+ }
+
+ void xml_node::remove_attribute(const char* name)
+ {
+ remove_attribute(attribute(name));
+ }
+
+ void xml_node::remove_attribute(const xml_attribute& a)
+ {
+ if (!_root) return;
+
+ // check that attribute belongs to *this
+ xml_attribute_struct* attr = a._attr;
+
+ while (attr->prev_attribute) attr = attr->prev_attribute;
+
+ if (attr != _root->first_attribute) return;
+
+ if (a._attr->next_attribute) a._attr->next_attribute->prev_attribute = a._attr->prev_attribute;
+ else _root->last_attribute = a._attr->prev_attribute;
+
+ if (a._attr->prev_attribute) a._attr->prev_attribute->next_attribute = a._attr->next_attribute;
+ else _root->first_attribute = a._attr->next_attribute;
+
+ a._attr->destroy();
+ }
+
+ void xml_node::remove_child(const char* name)
+ {
+ remove_child(child(name));
+ }
+
+ void xml_node::remove_child(const xml_node& n)
+ {
+ if (!_root || n.parent() != *this) return;
+
+ if (n._root->next_sibling) n._root->next_sibling->prev_sibling = n._root->prev_sibling;
+ else _root->last_child = n._root->prev_sibling;
+
+ if (n._root->prev_sibling) n._root->prev_sibling->next_sibling = n._root->next_sibling;
+ else _root->first_child = n._root->next_sibling;
+
+ n._root->destroy();
+ }
+
+ xml_node xml_node::find_child_by_attribute(const char* name, const char* attr_name, const char* attr_value) const
+ {
+ if (!_root) return xml_node();
+
+ for (xml_node_struct* i = _root->first_child; i; i = i->next_sibling)
+ if (i->name && !strcmp(name, i->name))
+ {
+ for (xml_attribute_struct* a = i->first_attribute; a; a = a->next_attribute)
+ if (!strcmp(attr_name, a->name) && !strcmp(attr_value, a->value))
+ return xml_node(i);
+ }
+
+ return xml_node();
+ }
+
+ xml_node xml_node::find_child_by_attribute_w(const char* name, const char* attr_name, const char* attr_value) const
+ {
+ if (!_root) return xml_node();
+
+ for (xml_node_struct* i = _root->first_child; i; i = i->next_sibling)
+ if (i->name && !impl::strcmpwild(name, i->name))
+ {
+ for (xml_attribute_struct* a = i->first_attribute; a; a = a->next_attribute)
+ if (!impl::strcmpwild(attr_name, a->name) && !impl::strcmpwild(attr_value, a->value))
+ return xml_node(i);
+ }
+
+ return xml_node();
+ }
+
+ xml_node xml_node::find_child_by_attribute(const char* attr_name, const char* attr_value) const
+ {
+ if (!_root) return xml_node();
+
+ for (xml_node_struct* i = _root->first_child; i; i = i->next_sibling)
+ for (xml_attribute_struct* a = i->first_attribute; a; a = a->next_attribute)
+ if (!strcmp(attr_name, a->name) && !strcmp(attr_value, a->value))
+ return xml_node(i);
+
+ return xml_node();
+ }
+
+ xml_node xml_node::find_child_by_attribute_w(const char* attr_name, const char* attr_value) const
+ {
+ if (!_root) return xml_node();
+
+ for (xml_node_struct* i = _root->first_child; i; i = i->next_sibling)
+ for (xml_attribute_struct* a = i->first_attribute; a; a = a->next_attribute)
+ if (!impl::strcmpwild(attr_name, a->name) && !impl::strcmpwild(attr_value, a->value))
+ return xml_node(i);
+
+ return xml_node();
+ }
+
+#ifndef PUGIXML_NO_STL
+ std::string xml_node::path(char delimiter) const
+ {
+ std::string path;
+
+ xml_node cursor = *this; // Make a copy.
+
+ path = cursor.name();
+
+ while (cursor.parent())
+ {
+ cursor = cursor.parent();
+
+ std::string temp = cursor.name();
+ temp += delimiter;
+ temp += path;
+ path.swap(temp);
+ }
+
+ return path;
+ }
+#endif
+
+ xml_node xml_node::first_element_by_path(const char* path, char delimiter) const
+ {
+ xml_node found = *this; // Current search context.
+
+ if (!_root || !path || !path[0]) return found;
+
+ if (path[0] == delimiter)
+ {
+ // Absolute path; e.g. '/foo/bar'
+ while (found.parent()) found = found.parent();
+ ++path;
+ }
+
+ const char* path_segment = path;
+
+ while (*path_segment == delimiter) ++path_segment;
+
+ const char* path_segment_end = path_segment;
+
+ while (*path_segment_end && *path_segment_end != delimiter) ++path_segment_end;
+
+ if (path_segment == path_segment_end) return found;
+
+ const char* next_segment = path_segment_end;
+
+ while (*next_segment == delimiter) ++next_segment;
+
+ if (*path_segment == '.' && path_segment + 1 == path_segment_end)
+ return found.first_element_by_path(next_segment, delimiter);
+ else if (*path_segment == '.' && *(path_segment+1) == '.' && path_segment + 2 == path_segment_end)
+ return found.parent().first_element_by_path(next_segment, delimiter);
+ else
+ {
+ for (xml_node_struct* j = found._root->first_child; j; j = j->next_sibling)
+ {
+ if (j->name && !strcmprange(j->name, path_segment, path_segment_end))
+ {
+ xml_node subsearch = xml_node(j).first_element_by_path(next_segment, delimiter);
+
+ if (subsearch) return subsearch;
+ }
+ }
+
+ return xml_node();
+ }
+ }
+
+ bool xml_node::traverse(xml_tree_walker& walker)
+ {
+ walker._depth = 0;
+
+ if (!walker.begin(*this)) return false;
+
+ xml_node cur = first_child();
+
+ if (cur)
+ {
+ do
+ {
+ if (!walker.for_each(cur))
+ return false;
+
+ if (cur.first_child())
+ {
+ ++walker._depth;
+ cur = cur.first_child();
+ }
+ else if (cur.next_sibling())
+ cur = cur.next_sibling();
+ else
+ {
+ // Borland C++ workaround
+ while (!cur.next_sibling() && cur != *this && (bool)cur.parent())
+ {
+ --walker._depth;
+ cur = cur.parent();
+ }
+
+ if (cur != *this)
+ cur = cur.next_sibling();
+ }
+ }
+ while (cur && cur != *this);
+ }
+
+ if (!walker.end(*this)) return false;
+
+ return true;
+ }
+
+ unsigned int xml_node::document_order() const
+ {
+ return _root ? _root->document_order : 0;
+ }
+
+ void xml_node::precompute_document_order_impl()
+ {
+ if (type() != node_document) return;
+
+ unsigned int current = 1;
+ xml_node cur = *this;
+
+ for (;;)
+ {
+ cur._root->document_order = current++;
+
+ for (xml_attribute a = cur.first_attribute(); a; a = a.next_attribute())
+ a._attr->document_order = current++;
+
+ if (cur.first_child())
+ cur = cur.first_child();
+ else if (cur.next_sibling())
+ cur = cur.next_sibling();
+ else
+ {
+ while (cur && !cur.next_sibling()) cur = cur.parent();
+ cur = cur.next_sibling();
+
+ if (!cur) break;
+ }
+ }
+ }
+
+ void xml_node::print(xml_writer& writer, const char* indent, unsigned int flags, unsigned int depth)
+ {
+ if (!_root) return;
+
+ xml_buffered_writer buffered_writer(writer);
+
+ node_output(buffered_writer, *this, indent, flags, depth);
+ }
+
+#ifndef PUGIXML_NO_STL
+ void xml_node::print(std::ostream& stream, const char* indent, unsigned int flags, unsigned int depth)
+ {
+ if (!_root) return;
+
+ xml_writer_stream writer(stream);
+
+ print(writer, indent, flags, depth);
+ }
+#endif
+
+ int xml_node::offset_debug() const
+ {
+ xml_node_struct* r = root()._root;
+
+ if (!r) return -1;
+
+ const char* buffer = static_cast<xml_document_struct*>(r)->buffer;
+
+ if (!buffer) return -1;
+
+ switch (type())
+ {
+ case node_document:
+ return 0;
+
+ case node_element:
+ case node_declaration:
+ return _root->name_insitu ? static_cast<int>(_root->name - buffer) : -1;
+
+ case node_pcdata:
+ case node_cdata:
+ case node_comment:
+ case node_pi:
+ return _root->value_insitu ? static_cast<int>(_root->value - buffer) : -1;
+
+ default:
+ return -1;
+ }
+ }
+
+#ifdef __BORLANDC__
+ bool operator&&(const xml_node& lhs, bool rhs)
+ {
+ return lhs ? rhs : false;
+ }
+
+ bool operator||(const xml_node& lhs, bool rhs)
+ {
+ return lhs ? true : rhs;
+ }
+#endif
+
+ xml_node_iterator::xml_node_iterator()
+ {
+ }
+
+ xml_node_iterator::xml_node_iterator(const xml_node& node): _wrap(node)
+ {
+ }
+
+ xml_node_iterator::xml_node_iterator(xml_node_struct* ref): _wrap(ref)
+ {
+ }
+
+ xml_node_iterator::xml_node_iterator(xml_node_struct* ref, xml_node_struct* prev): _prev(prev), _wrap(ref)
+ {
+ }
+
+ bool xml_node_iterator::operator==(const xml_node_iterator& rhs) const
+ {
+ return (_wrap == rhs._wrap);
+ }
+
+ bool xml_node_iterator::operator!=(const xml_node_iterator& rhs) const
+ {
+ return (_wrap != rhs._wrap);
+ }
+
+ xml_node& xml_node_iterator::operator*()
+ {
+ return _wrap;
+ }
+
+ xml_node* xml_node_iterator::operator->()
+ {
+ return &_wrap;
+ }
+
+ const xml_node_iterator& xml_node_iterator::operator++()
+ {
+ _prev = _wrap;
+ _wrap = xml_node(_wrap._root->next_sibling);
+ return *this;
+ }
+
+ xml_node_iterator xml_node_iterator::operator++(int)
+ {
+ xml_node_iterator temp = *this;
+ ++*this;
+ return temp;
+ }
+
+ const xml_node_iterator& xml_node_iterator::operator--()
+ {
+ if (_wrap._root) _wrap = xml_node(_wrap._root->prev_sibling);
+ else _wrap = _prev;
+ return *this;
+ }
+
+ xml_node_iterator xml_node_iterator::operator--(int)
+ {
+ xml_node_iterator temp = *this;
+ --*this;
+ return temp;
+ }
+
+ xml_attribute_iterator::xml_attribute_iterator()
+ {
+ }
+
+ xml_attribute_iterator::xml_attribute_iterator(const xml_attribute& attr): _wrap(attr)
+ {
+ }
+
+ xml_attribute_iterator::xml_attribute_iterator(xml_attribute_struct* ref): _wrap(ref)
+ {
+ }
+
+ xml_attribute_iterator::xml_attribute_iterator(xml_attribute_struct* ref, xml_attribute_struct* prev): _prev(prev), _wrap(ref)
+ {
+ }
+
+ bool xml_attribute_iterator::operator==(const xml_attribute_iterator& rhs) const
+ {
+ return (_wrap == rhs._wrap);
+ }
+
+ bool xml_attribute_iterator::operator!=(const xml_attribute_iterator& rhs) const
+ {
+ return (_wrap != rhs._wrap);
+ }
+
+ xml_attribute& xml_attribute_iterator::operator*()
+ {
+ return _wrap;
+ }
+
+ xml_attribute* xml_attribute_iterator::operator->()
+ {
+ return &_wrap;
+ }
+
+ const xml_attribute_iterator& xml_attribute_iterator::operator++()
+ {
+ _prev = _wrap;
+ _wrap = xml_attribute(_wrap._attr->next_attribute);
+ return *this;
+ }
+
+ xml_attribute_iterator xml_attribute_iterator::operator++(int)
+ {
+ xml_attribute_iterator temp = *this;
+ ++*this;
+ return temp;
+ }
+
+ const xml_attribute_iterator& xml_attribute_iterator::operator--()
+ {
+ if (_wrap._attr) _wrap = xml_attribute(_wrap._attr->prev_attribute);
+ else _wrap = _prev;
+ return *this;
+ }
+
+ xml_attribute_iterator xml_attribute_iterator::operator--(int)
+ {
+ xml_attribute_iterator temp = *this;
+ --*this;
+ return temp;
+ }
+
+ xml_memory_block::xml_memory_block(): next(0), size(0)
+ {
+ }
+
+ const char* xml_parse_result::description() const
+ {
+ switch (status)
+ {
+ case status_ok: return "No error";
+
+ case status_file_not_found: return "File was not found";
+ case status_io_error: return "Error reading from file/stream";
+ case status_out_of_memory: return "Could not allocate memory";
+ case status_internal_error: return "Internal error occured";
+
+ case status_unrecognized_tag: return "Could not determine tag type";
+
+ case status_bad_pi: return "Error parsing document declaration/processing instruction";
+ case status_bad_comment: return "Error parsing comment";
+ case status_bad_cdata: return "Error parsing CDATA section";
+ case status_bad_doctype: return "Error parsing document type declaration";
+ case status_bad_pcdata: return "Error parsing PCDATA section";
+ case status_bad_start_element: return "Error parsing start element tag";
+ case status_bad_attribute: return "Error parsing element attribute";
+ case status_bad_end_element: return "Error parsing end element tag";
+ case status_end_element_mismatch: return "Start-end tags mismatch";
+
+ default: return "Unknown error";
+ }
+ }
+
+ xml_document::xml_document(): _buffer(0)
+ {
+ create();
+ }
+
+ xml_document::~xml_document()
+ {
+ destroy();
+ }
+
+ void xml_document::create()
+ {
+ xml_allocator alloc(&_memory);
+
+ _root = alloc.allocate_document(); // Allocate a new root.
+ xml_allocator& a = static_cast<xml_document_struct*>(_root)->allocator;
+ a = alloc;
+ }
+
+ void xml_document::destroy()
+ {
+ if (_buffer)
+ {
+ global_deallocate(_buffer);
+ _buffer = 0;
+ }
+
+ if (_root) _root->destroy();
+
+ xml_memory_block* current = _memory.next;
+
+ while (current)
+ {
+ xml_memory_block* next = current->next;
+ global_deallocate(current);
+ current = next;
+ }
+
+ _memory.next = 0;
+ _memory.size = 0;
+
+ create();
+ }
+
+#ifndef PUGIXML_NO_STL
+ xml_parse_result xml_document::load(std::istream& stream, unsigned int options)
+ {
+ destroy();
+
+ if (!stream.good()) return MAKE_PARSE_RESULT(status_io_error);
+
+ std::streamoff length, pos = stream.tellg();
+ stream.seekg(0, std::ios::end);
+ length = stream.tellg();
+ stream.seekg(pos, std::ios::beg);
+
+ if (!stream.good()) return MAKE_PARSE_RESULT(status_io_error);
+
+ char* s = static_cast<char*>(global_allocate(length + 1));
+ if (!s) return MAKE_PARSE_RESULT(status_out_of_memory);
+
+ stream.read(s, length);
+
+ if (stream.gcount() > length || stream.gcount() == 0)
+ {
+ global_deallocate(s);
+ return MAKE_PARSE_RESULT(status_io_error);
+ }
+
+ s[stream.gcount()] = 0;
+
+ return parse(transfer_ownership_tag(), s, options); // Parse the input string.
+ }
+#endif
+
+ xml_parse_result xml_document::load(const char* contents, unsigned int options)
+ {
+ destroy();
+
+ char* s = static_cast<char*>(global_allocate(strlen(contents) + 1));
+ if (!s) return MAKE_PARSE_RESULT(status_out_of_memory);
+
+ strcpy(s, contents);
+
+ return parse(transfer_ownership_tag(), s, options); // Parse the input string.
+ }
+
+ xml_parse_result xml_document::load_file(const char* name, unsigned int options)
+ {
+ destroy();
+
+ FILE* file = fopen(name, "rb");
+ if (!file) return MAKE_PARSE_RESULT(status_file_not_found);
+
+ fseek(file, 0, SEEK_END);
+ long length = ftell(file);
+ fseek(file, 0, SEEK_SET);
+
+ if (length < 0)
+ {
+ fclose(file);
+ return MAKE_PARSE_RESULT(status_io_error);
+ }
+
+ char* s = static_cast<char*>(global_allocate(length + 1));
+
+ if (!s)
+ {
+ fclose(file);
+ return MAKE_PARSE_RESULT(status_out_of_memory);
+ }
+
+ size_t read = fread(s, (size_t)length, 1, file);
+ fclose(file);
+
+ if (read != 1)
+ {
+ global_deallocate(s);
+ return MAKE_PARSE_RESULT(status_io_error);
+ }
+
+ s[length] = 0;
+
+ return parse(transfer_ownership_tag(), s, options); // Parse the input string.
+ }
+
+ xml_parse_result xml_document::parse(char* xmlstr, unsigned int options)
+ {
+ destroy();
+
+ // for offset_debug
+ static_cast<xml_document_struct*>(_root)->buffer = xmlstr;
+
+ xml_allocator& alloc = static_cast<xml_document_struct*>(_root)->allocator;
+
+ xml_parser parser(alloc);
+
+ return parser.parse(xmlstr, _root, options); // Parse the input string.
+ }
+
+ xml_parse_result xml_document::parse(const transfer_ownership_tag&, char* xmlstr, unsigned int options)
+ {
+ xml_parse_result res = parse(xmlstr, options);
+
+ if (res) _buffer = xmlstr;
+ else global_deallocate(xmlstr);
+
+ return res;
+ }
+
+ void xml_document::save(xml_writer& writer, const char* indent, unsigned int flags)
+ {
+ xml_buffered_writer buffered_writer(writer);
+
+ if (flags & format_write_bom_utf8)
+ {
+ static const unsigned char utf8_bom[] = {0xEF, 0xBB, 0xBF};
+ buffered_writer.write(utf8_bom, 3);
+ }
+
+ if (!(flags & format_no_declaration))
+ {
+ buffered_writer.write("<?xml version=\"1.0\"?>");
+ if (!(flags & format_raw)) buffered_writer.write("\n");
+ }
+
+ node_output(buffered_writer, *this, indent, flags, 0);
+ }
+
+ bool xml_document::save_file(const char* name, const char* indent, unsigned int flags)
+ {
+ FILE* file = fopen(name, "wb");
+ if (!file) return false;
+
+ xml_writer_file writer(file);
+ save(writer, indent, flags);
+
+ fclose(file);
+
+ return true;
+ }
+
+ void xml_document::precompute_document_order()
+ {
+ precompute_document_order_impl();
+ }
+
+#ifndef PUGIXML_NO_STL
+ std::string PUGIXML_FUNCTION as_utf8(const wchar_t* str)
+ {
+ std::string result;
+ result.reserve(strutf16_utf8_size(str));
+
+ for (; *str; ++str)
+ {
+ char buffer[6];
+
+ result.append(buffer, strutf16_utf8(buffer, *str));
+ }
+
+ return result;
+ }
+
+ std::wstring PUGIXML_FUNCTION as_utf16(const char* str)
+ {
+ std::wstring result;
+ result.reserve(strutf8_utf16_size(str));
+
+ for (; *str;)
+ {
+ unsigned int ch;
+ str = strutf8_utf16(str, ch);
+ result += (wchar_t)ch;
+ }
+
+ return result;
+ }
+#endif
+
+ void PUGIXML_FUNCTION set_memory_management_functions(allocation_function allocate, deallocation_function deallocate)
+ {
+ global_allocate = allocate;
+ global_deallocate = deallocate;
+ }
+}
Added: trunk/oggdsf/src/lib/helper/pugixml/pugixml.hpp
===================================================================
--- trunk/oggdsf/src/lib/helper/pugixml/pugixml.hpp (rev 0)
+++ trunk/oggdsf/src/lib/helper/pugixml/pugixml.hpp 2009-10-12 21:33:00 UTC (rev 16638)
@@ -0,0 +1,2097 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// Pug Improved XML Parser - Version 0.42
+// --------------------------------------------------------
+// Copyright (C) 2006-2009, by Arseny Kapoulkine (arseny.kapoulkine at gmail.com)
+// Report bugs and download new versions at http://code.google.com/p/pugixml/
+//
+// This work is based on the pugxml parser, which is:
+// Copyright (C) 2003, by Kristen Wegner (kristen at tima.net)
+// Released into the Public Domain. Use at your own risk.
+// See pugxml.xml for further information, history, etc.
+// Contributions by Neville Franks (readonly at getsoft.com).
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef HEADER_PUGIXML_HPP
+#define HEADER_PUGIXML_HPP
+
+#include "pugiconfig.hpp"
+
+#ifndef PUGIXML_NO_STL
+# include <string>
+# include <iosfwd>
+#endif
+
+// No XPath without STL
+#ifdef PUGIXML_NO_STL
+# ifndef PUGIXML_NO_XPATH
+# define PUGIXML_NO_XPATH
+# endif
+#endif
+
+// If no API is defined, assume default
+#ifndef PUGIXML_API
+# define PUGIXML_API
+#endif
+
+// If no API for classes is defined, assume default
+#ifndef PUGIXML_CLASS
+# define PUGIXML_CLASS PUGIXML_API
+#endif
+
+// If no API for functions is defined, assume default
+#ifndef PUGIXML_FUNCTION
+# define PUGIXML_FUNCTION PUGIXML_API
+#endif
+
+#include <stddef.h>
+
+/// The PugiXML Parser namespace.
+namespace pugi
+{
+ /// Tree node classification.
+ enum xml_node_type
+ {
+ node_null, ///< Undifferentiated entity
+ node_document, ///< A document tree's absolute root.
+ node_element, ///< E.g. '<...>'
+ node_pcdata, ///< E.g. '>...<'
+ node_cdata, ///< E.g. '<![CDATA[...]]>'
+ node_comment, ///< E.g. '<!--...-->'
+ node_pi, ///< E.g. '<?...?>'
+ node_declaration ///< E.g. '<?xml ...?>'
+ };
+
+ // Parsing options
+
+ /**
+ * Memory block size, used for fast allocator. Memory for DOM tree is allocated in blocks of
+ * memory_block_size + 4.
+ * This value affects size of xml_memory class.
+ */
+ const size_t memory_block_size = 32768;
+
+ /**
+ * Minimal parsing mode. Equivalent to turning all other flags off. This set of flags means
+ * that pugixml does not add pi/cdata sections or comments to DOM tree and does not perform
+ * any conversions for input data, meaning fastest parsing.
+ */
+ const unsigned int parse_minimal = 0x0000;
+
+ /**
+ * This flag determines if processing instructions (nodes with type node_pi; such nodes have the
+ * form of <? target content ?> or <? target ?> in XML) are to be put in DOM tree. If this flag is off,
+ * they are not put in the tree, but are still parsed and checked for correctness.
+ *
+ * The corresponding node in DOM tree will have type node_pi, name "target" and value "content",
+ * if any.
+ *
+ * Note that <?xml ...?> (document declaration) is not considered to be a PI.
+ *
+ * This flag is off by default.
+ */
+ const unsigned int parse_pi = 0x0001;
+
+ /**
+ * This flag determines if comments (nodes with type node_comment; such nodes have the form of
+ * <!-- content --> in XML) are to be put in DOM tree. If this flag is off, they are not put in
+ * the tree, but are still parsed and checked for correctness.
+ *
+ * The corresponding node in DOM tree will have type node_comment, empty name and value "content".
+ *
+ * This flag is off by default.
+ */
+ const unsigned int parse_comments = 0x0002;
+
+ /**
+ * This flag determines if CDATA sections (nodes with type node_cdata; such nodes have the form
+ * of <![CDATA[[content]]> in XML) are to be put in DOM tree. If this flag is off, they are not
+ * put in the tree, but are still parsed and checked for correctness.
+ *
+ * The corresponding node in DOM tree will have type node_cdata, empty name and value "content".
+ *
+ * This flag is on by default.
+ */
+ const unsigned int parse_cdata = 0x0004;
+
+ /**
+ * This flag determines if nodes with PCDATA (regular text) that consist only of whitespace
+ * characters are to be put in DOM tree. Often whitespace-only data is not significant for the
+ * application, and the cost of allocating and storing such nodes (both memory and speed-wise)
+ * can be significant. For example, after parsing XML string "<node> <a/> </node>", <node> element
+ * will have 3 children when parse_ws_pcdata is set (child with type node_pcdata and value=" ",
+ * child with type node_element and name "a", and another child with type node_pcdata and
+ * value=" "), and only 1 child when parse_ws_pcdata is not set.
+ *
+ * This flag is off by default.
+ */
+ const unsigned int parse_ws_pcdata = 0x0008;
+
+ /**
+ * This flag determines if character and entity references are to be expanded during the parsing
+ * process. Character references are &#...; or &#x...; (... is Unicode numeric representation of
+ * character in either decimal (&#...;) or hexadecimal (&#x...;) form), entity references are &...;
+ * Note that as pugixml does not handle DTD, the only allowed entities are predefined ones -
+ * &lt;, &gt;, &amp;, &apos; and &quot;. If character/entity reference can not be expanded, it is
+ * leaved as is, so you can do additional processing later.
+ * Reference expansion is performed in attribute values and PCDATA content.
+ *
+ * This flag is on by default.
+ */
+ const unsigned int parse_escapes = 0x0010;
+
+ /**
+ * This flag determines if EOL handling (that is, replacing sequences 0x0d 0x0a by a single 0x0a
+ * character, and replacing all standalone 0x0d characters by 0x0a) is to be performed on input
+ * data (that is, comments contents, PCDATA/CDATA contents and attribute values).
+ *
+ * This flag is on by default.
+ */
+ const unsigned int parse_eol = 0x0020;
+
+ /**
+ * This flag determines if attribute value normalization should be performed for all attributes,
+ * assuming that their type is not CDATA. This means, that:
+ * 1. Whitespace characters (new line, tab and space) are replaced with space (' ')
+ * 2. Afterwards sequences of spaces are replaced with a single space
+ * 3. Leading/trailing whitespace characters are trimmed
+ *
+ * This flag is off by default.
+ */
+ const unsigned int parse_wnorm_attribute = 0x0040;
+
+ /**
+ * This flag determines if attribute value normalization should be performed for all attributes,
+ * assuming that their type is CDATA. This means, that whitespace characters (new line, tab and
+ * space) are replaced with space (' '). Note, that the actions performed while this flag is on
+ * are also performed if parse_wnorm_attribute is on, so this flag has no effect if
+ * parse_wnorm_attribute flag is set.
+ *
+ * This flag is on by default.
+ */
+ const unsigned int parse_wconv_attribute = 0x0080;
+
+ /**
+ * This flag determines if XML document declaration (this node has the form of <?xml ... ?> in XML)
+ * are to be put in DOM tree. If this flag is off, it is not put in the tree, but is still parsed
+ * and checked for correctness.
+ *
+ * The corresponding node in DOM tree will have type node_declaration, name "xml" and attributes,
+ * if any.
+ *
+ * This flag is off by default.
+ */
+ const unsigned int parse_declaration = 0x0100;
+
+ /**
+ * This is the default set of flags. It includes parsing CDATA sections (comments/PIs are not
+ * parsed), performing character and entity reference expansion, replacing whitespace characters
+ * with spaces in attribute values and performing EOL handling. Note, that PCDATA sections
+ * consisting only of whitespace characters are not parsed (by default) for performance reasons.
+ */
+ const unsigned int parse_default = parse_cdata | parse_escapes | parse_wconv_attribute | parse_eol;
+
+ // Formatting flags
+
+ /**
+ * Indent the nodes that are written to output stream with as many indentation strings as deep
+ * the node is in DOM tree.
+ *
+ * This flag is on by default.
+ */
+ const unsigned int format_indent = 0x01;
+
+ /**
+ * This flag determines if UTF-8 BOM is to be written to output stream.
+ *
+ * This flag is off by default.
+ */
+ const unsigned int format_write_bom_utf8 = 0x02;
+
+ /**
+ * If this flag is on, no indentation is performed and no line breaks are written to output file.
+ * This means that the data is written to output stream as is.
+ *
+ * This flag is off by default.
+ */
+ const unsigned int format_raw = 0x04;
+
+ /**
+ * If this flag is on, no default XML declaration is written to output file.
+ * This means that there will be no XML declaration in output stream unless there was one in XML document
+ * (i.e. if it was parsed with parse_declaration flag).
+ *
+ * This flag is off by default.
+ */
+ const unsigned int format_no_declaration = 0x08;
+
+ /**
+ * This is the default set of formatting flags. It includes indenting nodes depending on their
+ * depth in DOM tree.
+ */
+ const unsigned int format_default = format_indent;
+
+ // Forward declarations
+ struct xml_attribute_struct;
+ struct xml_node_struct;
+
+ class xml_allocator;
+
+ class xml_node_iterator;
+ class xml_attribute_iterator;
+
+ class xml_tree_walker;
+
+ class xml_node;
+
+ #ifndef PUGIXML_NO_XPATH
+ class xpath_node;
+ class xpath_node_set;
+ class xpath_ast_node;
+ class xpath_allocator;
+
+ /**
+ * A class that holds compiled XPath query and allows to evaluate query result
+ */
+ class PUGIXML_CLASS xpath_query
+ {
+ private:
+ // Noncopyable semantics
+ xpath_query(const xpath_query&);
+ xpath_query& operator=(const xpath_query&);
+
+ xpath_allocator* m_alloc;
+ xpath_ast_node* m_root;
+
+ void compile(const char* query);
+
+ public:
+ /**
+ * Ctor from string with XPath expression.
+ * Throws xpath_exception on compilation error, std::bad_alloc on out of memory error.
+ *
+ * \param query - string with XPath expression
+ */
+ explicit xpath_query(const char* query);
+
+ /**
+ * Dtor
+ */
+ ~xpath_query();
+
+ /**
+ * Evaluate expression as boolean value for the context node \a n.
+ * If expression does not directly evaluate to boolean, the expression result is converted
+ * as through boolean() XPath function call.
+ * Throws std::bad_alloc on out of memory error.
+ *
+ * \param n - context node
+ * \return evaluation result
+ */
+ bool evaluate_boolean(const xml_node& n);
+
+ /**
+ * Evaluate expression as double value for the context node \a n.
+ * If expression does not directly evaluate to double, the expression result is converted
+ * as through number() XPath function call.
+ * Throws std::bad_alloc on out of memory error.
+ *
+ * \param n - context node
+ * \return evaluation result
+ */
+ double evaluate_number(const xml_node& n);
+
+ /**
+ * Evaluate expression as string value for the context node \a n.
+ * If expression does not directly evaluate to string, the expression result is converted
+ * as through string() XPath function call.
+ * Throws std::bad_alloc on out of memory error.
+ *
+ * \param n - context node
+ * \return evaluation result
+ */
+ std::string evaluate_string(const xml_node& n);
+
+ /**
+ * Evaluate expression as node set for the context node \a n.
+ * If expression does not directly evaluate to node set, function returns empty node set.
+ * Throws std::bad_alloc on out of memory error.
+ *
+ * \param n - context node
+ * \return evaluation result
+ */
+ xpath_node_set evaluate_node_set(const xml_node& n);
+ };
+ #endif
+
+ /**
+ * Abstract writer class
+ * \see xml_node::print
+ */
+ class PUGIXML_CLASS xml_writer
+ {
+ public:
+ /**
+ * Virtual dtor
+ */
+ virtual ~xml_writer() {}
+
+ /**
+ * Write memory chunk into stream/file/whatever
+ *
+ * \param data - data pointer
+ * \param size - data size
+ */
+ virtual void write(const void* data, size_t size) = 0;
+ };
+
+ /** xml_writer implementation for FILE*
+ * \see xml_writer
+ */
+ class PUGIXML_CLASS xml_writer_file: public xml_writer
+ {
+ public:
+ /**
+ * Construct writer instance
+ *
+ * \param file - this is FILE* object, void* is used to avoid header dependencies on stdio
+ */
+ xml_writer_file(void* file);
+
+ virtual void write(const void* data, size_t size);
+
+ private:
+ void* file;
+ };
+
+ #ifndef PUGIXML_NO_STL
+ /** xml_writer implementation for streams
+ * \see xml_writer
+ */
+ class PUGIXML_CLASS xml_writer_stream: public xml_writer
+ {
+ public:
+ /**
+ * Construct writer instance
+ *
+ * \param stream - output stream object
+ */
+ xml_writer_stream(std::ostream& stream);
+
+ virtual void write(const void* data, size_t size);
+
+ private:
+ std::ostream* stream;
+ };
+ #endif
+
+ /**
+ * A light-weight wrapper for manipulating attributes in DOM tree.
+ * Note: xml_attribute does not allocate any memory for the attribute it wraps; it only wraps a
+ * pointer to existing attribute.
+ */
+ class PUGIXML_CLASS xml_attribute
+ {
+ friend class xml_attribute_iterator;
+ friend class xml_node;
+
+ private:
+ xml_attribute_struct* _attr;
+
+ /// \internal Safe bool type
+#ifdef __MWERKS__
+ typedef bool (xml_attribute::*unspecified_bool_type)() const;
+#else
+ typedef xml_attribute_struct* xml_attribute::*unspecified_bool_type;
+#endif
+
+ /// \internal Initializing ctor
+ explicit xml_attribute(xml_attribute_struct* attr);
+
+ public:
+ /**
+ * Default ctor. Constructs an empty attribute.
+ */
+ xml_attribute();
+
+ public:
+ /**
+ * Safe bool conversion.
+ * Allows xml_node to be used in a context where boolean variable is expected, such as 'if (node)'.
+ */
+ operator unspecified_bool_type() const;
+
+ // Borland C++ workaround
+ bool operator!() const;
+
+ /**
+ * Compare wrapped pointer to the attribute to the pointer that is wrapped by \a r.
+ *
+ * \param r - value to compare to
+ * \return comparison result
+ */
+ bool operator==(const xml_attribute& r) const;
+
+ /**
+ * Compare wrapped pointer to the attribute to the pointer that is wrapped by \a r.
+ *
+ * \param r - value to compare to
+ * \return comparison result
+ */
+ bool operator!=(const xml_attribute& r) const;
+
+ /**
+ * Compare wrapped pointer to the attribute to the pointer that is wrapped by \a r.
+ *
+ * \param r - value to compare to
+ * \return comparison result
+ */
+ bool operator<(const xml_attribute& r) const;
+
+ /**
+ * Compare wrapped pointer to the attribute to the pointer that is wrapped by \a r.
+ *
+ * \param r - value to compare to
+ * \return comparison result
+ */
+ bool operator>(const xml_attribute& r) const;
+
+ /**
+ * Compare wrapped pointer to the attribute to the pointer that is wrapped by \a r.
+ *
+ * \param r - value to compare to
+ * \return comparison result
+ */
+ bool operator<=(const xml_attribute& r) const;
+
+ /**
+ * Compare wrapped pointer to the attribute to the pointer that is wrapped by \a r.
+ *
+ * \param r - value to compare to
+ * \return comparison result
+ */
+ bool operator>=(const xml_attribute& r) const;
+
+ public:
+ /**
+ * Get next attribute in attribute list of node that contains the attribute.
+ *
+ * \return next attribute, if any; empty attribute otherwise
+ */
+ xml_attribute next_attribute() const;
+
+ /**
+ * Get previous attribute in attribute list of node that contains the attribute.
+ *
+ * \return previous attribute, if any; empty attribute otherwise
+ */
+ xml_attribute previous_attribute() const;
+
+ /**
+ * Cast attribute value as int.
+ *
+ * \return attribute value as int, or 0 if conversion did not succeed or attribute is empty
+ */
+ int as_int() const;
+
+ /**
+ * Cast attribute value as unsigned int.
+ *
+ * \return attribute value as unsigned int, or 0 if conversion did not succeed or attribute is empty
+ * \note values out of non-negative int range (usually [0, 2^31-1]) get clamped to range boundaries
+ */
+ unsigned int as_uint() const;
+
+ /**
+ * Cast attribute value as double.
+ *
+ * \return attribute value as double, or 0.0 if conversion did not succeed or attribute is empty
+ */
+ double as_double() const;
+
+ /**
+ * Cast attribute value as float.
+ *
+ * \return attribute value as float, or 0.0f if conversion did not succeed or attribute is empty
+ */
+ float as_float() const;
+
+ /**
+ * Cast attribute value as bool. Returns true for attributes with values that start with '1',
+ * 't', 'T', 'y', 'Y', returns false for other attributes.
+ *
+ * \return attribute value as bool, or false if conversion did not succeed or attribute is empty
+ */
+ bool as_bool() const;
+
+ /// \internal Document order or 0 if not set
+ unsigned int document_order() const;
+
+ public:
+ /**
+ * Set attribute value to \a rhs.
+ *
+ * \param rhs - new attribute value
+ * \return self
+ */
+ xml_attribute& operator=(const char* rhs);
+
+ /**
+ * Set attribute value to \a rhs.
+ *
+ * \param rhs - new attribute value
+ * \return self
+ */
+ xml_attribute& operator=(int rhs);
+
+ /**
+ * Set attribute value to \a rhs.
+ *
+ * \param rhs - new attribute value
+ * \return self
+ */
+ xml_attribute& operator=(unsigned int rhs);
+
+ /**
+ * Set attribute value to \a rhs.
+ *
+ * \param rhs - new attribute value
+ * \return self
+ */
+ xml_attribute& operator=(double rhs);
+
+ /**
+ * Set attribute value to either 'true' or 'false' (depends on whether \a rhs is true or false).
+ *
+ * \param rhs - new attribute value
+ * \return self
+ */
+ xml_attribute& operator=(bool rhs);
+
+ /**
+ * Set attribute name to \a rhs.
+ *
+ * \param rhs - new attribute name
+ * \return success flag (call fails if attribute is empty or there is not enough memory)
+ */
+ bool set_name(const char* rhs);
+
+ /**
+ * Set attribute value to \a rhs.
+ *
+ * \param rhs - new attribute value
+ * \return success flag (call fails if attribute is empty or there is not enough memory)
+ */
+ bool set_value(const char* rhs);
+
+ /**
+ * Set attribute value to \a rhs.
+ *
+ * \param rhs - new attribute value
+ * \return success flag (call fails if attribute is empty or there is not enough memory)
+ */
+ bool set_value(int rhs);
+
+ /**
+ * Set attribute value to \a rhs.
+ *
+ * \param rhs - new attribute value
+ * \return success flag (call fails if attribute is empty or there is not enough memory)
+ */
+ bool set_value(unsigned int rhs);
+
+ /**
+ * Set attribute value to \a rhs.
+ *
+ * \param rhs - new attribute value
+ * \return success flag (call fails if attribute is empty or there is not enough memory)
+ */
+ bool set_value(double rhs);
+
+ /**
+ * Set attribute value to either 'true' or 'false' (depends on whether \a rhs is true or false).
+ *
+ * \param rhs - new attribute value
+ * \return success flag (call fails if attribute is empty or there is not enough memory)
+ */
+ bool set_value(bool rhs);
+
+ public:
+ /**
+ * Check if attribute is empty.
+ *
+ * \return true if attribute is empty, false otherwise
+ */
+ bool empty() const;
+
+ public:
+ /**
+ * Get attribute name.
+ *
+ * \return attribute name, or "" if attribute is empty
+ */
+ const char* name() const;
+
+ /**
+ * Get attribute value.
+ *
+ * \return attribute value, or "" if attribute is empty
+ */
+ const char* value() const;
+ };
+
+#ifdef __BORLANDC__
+ // Borland C++ workaround
+ bool PUGIXML_FUNCTION operator&&(const xml_attribute& lhs, bool rhs);
+ bool PUGIXML_FUNCTION operator||(const xml_attribute& lhs, bool rhs);
+#endif
+
+ /**
+ * A light-weight wrapper for manipulating nodes in DOM tree.
+ * Note: xml_node does not allocate any memory for the node it wraps; it only wraps a pointer to
+ * existing node.
+ */
+ class PUGIXML_CLASS xml_node
+ {
+ friend class xml_node_iterator;
+
+ protected:
+ xml_node_struct* _root;
+
+ /// \internal Safe bool type
+#ifdef __MWERKS__
+ typedef bool (xml_node::*unspecified_bool_type)() const;
+#else
+ typedef xml_node_struct* xml_node::*unspecified_bool_type;
+#endif
+
+ /// \internal Initializing ctor
+ explicit xml_node(xml_node_struct* p);
+
+ /// \internal Precompute document order (valid only for document node)
+ void precompute_document_order_impl();
+
+ /// \internal Get allocator
+ xml_allocator& get_allocator() const;
+
+ public:
+ /**
+ * Default ctor. Constructs an empty node.
+ */
+ xml_node();
+
+ public:
+ /**
+ * Safe bool conversion.
+ * Allows xml_node to be used in a context where boolean variable is expected, such as 'if (node)'.
+ */
+ operator unspecified_bool_type() const;
+
+ // Borland C++ workaround
+ bool operator!() const;
+
+ /**
+ * Compare wrapped pointer to the attribute to the pointer that is wrapped by \a r.
+ *
+ * \param r - value to compare to
+ * \return comparison result
+ */
+ bool operator==(const xml_node& r) const;
+
+ /**
+ * Compare wrapped pointer to the attribute to the pointer that is wrapped by \a r.
+ *
+ * \param r - value to compare to
+ * \return comparison result
+ */
+ bool operator!=(const xml_node& r) const;
+
+ /**
+ * Compare wrapped pointer to the attribute to the pointer that is wrapped by \a r.
+ *
+ * \param r - value to compare to
+ * \return comparison result
+ */
+ bool operator<(const xml_node& r) const;
+
+ /**
+ * Compare wrapped pointer to the attribute to the pointer that is wrapped by \a r.
+ *
+ * \param r - value to compare to
+ * \return comparison result
+ */
+ bool operator>(const xml_node& r) const;
+
+ /**
+ * Compare wrapped pointer to the attribute to the pointer that is wrapped by \a r.
+ *
+ * \param r - value to compare to
+ * \return comparison result
+ */
+ bool operator<=(const xml_node& r) const;
+
+ /**
+ * Compare wrapped pointer to the attribute to the pointer that is wrapped by \a r.
+ *
+ * \param r - value to compare to
+ * \return comparison result
+ */
+ bool operator>=(const xml_node& r) const;
+
+ public:
+ /**
+ * Node iterator type (for child nodes).
+ * \see xml_node_iterator
+ */
+ typedef xml_node_iterator iterator;
+
+ /**
+ * Node iterator type (for child nodes).
+ * \see xml_attribute_iterator
+ */
+ typedef xml_attribute_iterator attribute_iterator;
+
+ /**
+ * Access the begin iterator for this node's collection of child nodes.
+ *
+ * \return iterator that points to the first child node, or past-the-end iterator if node is empty or has no children
+ */
+ iterator begin() const;
+
+ /**
+ * Access the end iterator for this node's collection of child nodes.
+ *
+ * \return past-the-end iterator for child list
+ */
+ iterator end() const;
+
+ /**
+ * Access the begin iterator for this node's collection of attributes.
+ *
+ * \return iterator that points to the first attribute, or past-the-end iterator if node is empty or has no attributes
+ */
+ attribute_iterator attributes_begin() const;
+
+ /**
+ * Access the end iterator for this node's collection of attributes.
+ *
+ * \return past-the-end iterator for attribute list
+ */
+ attribute_iterator attributes_end() const;
+
+ public:
+ /**
+ * Check if node is empty.
+ *
+ * \return true if node is empty, false otherwise
+ */
+ bool empty() const;
+
+ public:
+ /**
+ * Get node type
+ *
+ * \return node type; node_null for empty nodes
+ */
+ xml_node_type type() const;
+
+ /**
+ * Get node name (element name for element nodes, PI target for PI)
+ *
+ * \return node name, if any; "" otherwise
+ */
+ const char* name() const;
+
+ /**
+ * Get node value (comment/PI/PCDATA/CDATA contents, depending on node type)
+ *
+ * \return node value, if any; "" otherwise
+ */
+ const char* value() const;
+
+ /**
+ * Get child with the specified name
+ *
+ * \param name - child name
+ * \return child with the specified name, if any; empty node otherwise
+ */
+ xml_node child(const char* name) const;
+
+ /**
+ * Get child with the name that matches specified pattern
+ *
+ * \param name - child name pattern
+ * \return child with the name that matches pattern, if any; empty node otherwise
+ */
+ xml_node child_w(const char* name) const;
+
+ /**
+ * Get attribute with the specified name
+ *
+ * \param name - attribute name
+ * \return attribute with the specified name, if any; empty attribute otherwise
+ */
+ xml_attribute attribute(const char* name) const;
+
+ /**
+ * Get attribute with the name that matches specified pattern
+ *
+ * \param name - attribute name pattern
+ * \return attribute with the name that matches pattern, if any; empty attribute otherwise
+ */
+ xml_attribute attribute_w(const char* name) const;
+
+ /**
+ * Get first of following sibling nodes with the specified name
+ *
+ * \param name - sibling name
+ * \return node with the specified name, if any; empty node otherwise
+ */
+ xml_node next_sibling(const char* name) const;
+
+ /**
+ * Get first of the following sibling nodes with the name that matches specified pattern
+ *
+ * \param name - sibling name pattern
+ * \return node with the name that matches pattern, if any; empty node otherwise
+ */
+ xml_node next_sibling_w(const char* name) const;
+
+ /**
+ * Get following sibling
+ *
+ * \return following sibling node, if any; empty node otherwise
+ */
+ xml_node next_sibling() const;
+
+ /**
+ * Get first of preceding sibling nodes with the specified name
+ *
+ * \param name - sibling name
+ * \return node with the specified name, if any; empty node otherwise
+ */
+ xml_node previous_sibling(const char* name) const;
+
+ /**
+ * Get first of the preceding sibling nodes with the name that matches specified pattern
+ *
+ * \param name - sibling name pattern
+ * \return node with the name that matches pattern, if any; empty node otherwise
+ */
+ xml_node previous_sibling_w(const char* name) const;
+
+ /**
+ * Get preceding sibling
+ *
+ * \return preceding sibling node, if any; empty node otherwise
+ */
+ xml_node previous_sibling() const;
+
+ /**
+ * Get parent node
+ *
+ * \return parent node if any; empty node otherwise
+ */
+ xml_node parent() const;
+
+ /**
+ * Get root of DOM tree this node belongs to.
+ *
+ * \return tree root
+ */
+ xml_node root() const;
+
+ /**
+ * Get child value of current node; that is, value of the first child node of type PCDATA/CDATA
+ *
+ * \return child value of current node, if any; "" otherwise
+ */
+ const char* child_value() const;
+
+ /**
+ * Get child value of child with specified name. \see child_value
+ * node.child_value(name) is equivalent to node.child(name).child_value()
+ *
+ * \param name - child name
+ * \return child value of specified child node, if any; "" otherwise
+ */
+ const char* child_value(const char* name) const;
+
+ /**
+ * Get child value of child with name that matches the specified pattern. \see child_value
+ * node.child_value_w(name) is equivalent to node.child_w(name).child_value()
+ *
+ * \param name - child name pattern
+ * \return child value of specified child node, if any; "" otherwise
+ */
+ const char* child_value_w(const char* name) const;
+
+ public:
+ /**
+ * Set node name to \a rhs (for PI/element nodes). \see name
+ *
+ * \param rhs - new node name
+ * \return success flag (call fails if node is of the wrong type or there is not enough memory)
+ */
+ bool set_name(const char* rhs);
+
+ /**
+ * Set node value to \a rhs (for PI/PCDATA/CDATA/comment nodes). \see value
+ *
+ * \param rhs - new node value
+ * \return success flag (call fails if node is of the wrong type or there is not enough memory)
+ */
+ bool set_value(const char* rhs);
+
+ /**
+ * Add attribute with specified name (for element nodes)
+ *
+ * \param name - attribute name
+ * \return added attribute, or empty attribute if there was an error (wrong node type)
+ */
+ xml_attribute append_attribute(const char* name);
+
+ /**
+ * Insert attribute with specified name after \a attr (for element nodes)
+ *
+ * \param name - attribute name
+ * \param attr - attribute to insert a new one after
+ * \return inserted attribute, or empty attribute if there was an error (wrong node type, or attr does not belong to node)
+ */
+ xml_attribute insert_attribute_after(const char* name, const xml_attribute& attr);
+
+ /**
+ * Insert attribute with specified name before \a attr (for element nodes)
+ *
+ * \param name - attribute name
+ * \param attr - attribute to insert a new one before
+ * \return inserted attribute, or empty attribute if there was an error (wrong node type, or attr does not belong to node)
+ */
+ xml_attribute insert_attribute_before(const char* name, const xml_attribute& attr);
+
+ /**
+ * Add a copy of the specified attribute (for element nodes)
+ *
+ * \param proto - attribute prototype which is to be copied
+ * \return inserted attribute, or empty attribute if there was an error (wrong node type)
+ */
+ xml_attribute append_copy(const xml_attribute& proto);
+
+ /**
+ * Insert a copy of the specified attribute after \a attr (for element nodes)
+ *
+ * \param proto - attribute prototype which is to be copied
+ * \param attr - attribute to insert a new one after
+ * \return inserted attribute, or empty attribute if there was an error (wrong node type, or attr does not belong to node)
+ */
+ xml_attribute insert_copy_after(const xml_attribute& proto, const xml_attribute& attr);
+
+ /**
+ * Insert a copy of the specified attribute before \a attr (for element nodes)
+ *
+ * \param proto - attribute prototype which is to be copied
+ * \param attr - attribute to insert a new one before
+ * \return inserted attribute, or empty attribute if there was an error (wrong node type, or attr does not belong to node)
+ */
+ xml_attribute insert_copy_before(const xml_attribute& proto, const xml_attribute& attr);
+
+ /**
+ * Add child node with specified type (for element nodes)
+ *
+ * \param type - node type
+ * \return added node, or empty node if there was an error (wrong node type)
+ */
+ xml_node append_child(xml_node_type type = node_element);
+
+ /**
+ * Insert child node with specified type after \a node (for element nodes)
+ *
+ * \param type - node type
+ * \param node - node to insert a new one after
+ * \return inserted node, or empty node if there was an error (wrong node type, or \a node is not a child of this node)
+ */
+ xml_node insert_child_after(xml_node_type type, const xml_node& node);
+
+ /**
+ * Insert child node with specified type before \a node (for element nodes)
+ *
+ * \param type - node type
+ * \param node - node to insert a new one before
+ * \return inserted node, or empty node if there was an error (wrong node type, or \a node is not a child of this node)
+ */
+ xml_node insert_child_before(xml_node_type type, const xml_node& node);
+
+ /**
+ * Add a copy of the specified node as a child (for element nodes)
+ *
+ * \param proto - node prototype which is to be copied
+ * \return inserted node, or empty node if there was an error (wrong node type)
+ */
+ xml_node append_copy(const xml_node& proto);
+
+ /**
+ * Insert a copy of the specified node after \a node (for element nodes)
+ *
+ * \param proto - node prototype which is to be copied
+ * \param node - node to insert a new one after
+ * \return inserted node, or empty node if there was an error (wrong node type, or \a node is not a child of this node)
+ */
+ xml_node insert_copy_after(const xml_node& proto, const xml_node& node);
+
+ /**
+ * Insert a copy of the specified node before \a node (for element nodes)
+ *
+ * \param proto - node prototype which is to be copied
+ * \param node - node to insert a new one before
+ * \return inserted node, or empty node if there was an error (wrong node type, or \a node is not a child of this node)
+ */
+ xml_node insert_copy_before(const xml_node& proto, const xml_node& node);
+
+ /**
+ * Remove specified attribute
+ *
+ * \param a - attribute to be removed
+ */
+ void remove_attribute(const xml_attribute& a);
+
+ /**
+ * Remove attribute with the specified name, if any
+ *
+ * \param name - attribute name
+ */
+ void remove_attribute(const char* name);
+
+ /**
+ * Remove specified child
+ *
+ * \param n - child node to be removed
+ */
+ void remove_child(const xml_node& n);
+
+ /**
+ * Remove child with the specified name, if any
+ *
+ * \param name - child name
+ */
+ void remove_child(const char* name);
+
+ public:
+ /**
+ * Get first attribute
+ *
+ * \return first attribute, if any; empty attribute otherwise
+ */
+ xml_attribute first_attribute() const;
+
+ /**
+ * Get last attribute
+ *
+ * \return last attribute, if any; empty attribute otherwise
+ */
+ xml_attribute last_attribute() const;
+
+ /**
+ * Get all elements from subtree with given name
+ *
+ * \param name - node name
+ * \param it - output iterator (for example, std::back_insert_iterator (result of std::back_inserter))
+ */
+ template <typename OutputIterator> void all_elements_by_name(const char* name, OutputIterator it) const;
+
+ /**
+ * Get all elements from subtree with name that matches given pattern
+ *
+ * \param name - node name pattern
+ * \param it - output iterator (for example, std::back_insert_iterator (result of std::back_inserter))
+ */
+ template <typename OutputIterator> void all_elements_by_name_w(const char* name, OutputIterator it) const;
+
+ /**
+ * Get first child
+ *
+ * \return first child, if any; empty node otherwise
+ */
+ xml_node first_child() const;
+
+ /**
+ * Get last child
+ *
+ * \return last child, if any; empty node otherwise
+ */
+ xml_node last_child() const;
+
+ /**
+ * Find attribute using predicate
+ *
+ * \param pred - predicate, that takes xml_attribute and returns bool
+ * \return first attribute for which predicate returned true, or empty attribute
+ */
+ template <typename Predicate> xml_attribute find_attribute(Predicate pred) const;
+
+ /**
+ * Find child node using predicate
+ *
+ * \param pred - predicate, that takes xml_node and returns bool
+ * \return first child node for which predicate returned true, or empty node
+ */
+ template <typename Predicate> xml_node find_child(Predicate pred) const;
+
+ /**
+ * Find node from subtree using predicate
+ *
+ * \param pred - predicate, that takes xml_node and returns bool
+ * \return first node from subtree for which predicate returned true, or empty node
+ */
+ template <typename Predicate> xml_node find_node(Predicate pred) const;
+
+ /**
+ * Find child node with the specified name that has specified attribute
+ *
+ * \param name - child node name
+ * \param attr_name - attribute name of child node
+ * \param attr_value - attribute value of child node
+ * \return first matching child node, or empty node
+ */
+ xml_node find_child_by_attribute(const char* name, const char* attr_name, const char* attr_value) const;
+
+ /**
+ * Find child node with the specified name that has specified attribute (use pattern matching for node name and attribute name/value)
+ *
+ * \param name - pattern for child node name
+ * \param attr_name - pattern for attribute name of child node
+ * \param attr_value - pattern for attribute value of child node
+ * \return first matching child node, or empty node
+ */
+ xml_node find_child_by_attribute_w(const char* name, const char* attr_name, const char* attr_value) const;
+
+ /**
+ * Find child node that has specified attribute
+ *
+ * \param attr_name - attribute name of child node
+ * \param attr_value - attribute value of child node
+ * \return first matching child node, or empty node
+ */
+ xml_node find_child_by_attribute(const char* attr_name, const char* attr_value) const;
+
+ /**
+ * Find child node that has specified attribute (use pattern matching for attribute name/value)
+ *
+ * \param attr_name - pattern for attribute name of child node
+ * \param attr_value - pattern for attribute value of child node
+ * \return first matching child node, or empty node
+ */
+ xml_node find_child_by_attribute_w(const char* attr_name, const char* attr_value) const;
+
+ #ifndef PUGIXML_NO_STL
+ /**
+ * Get the absolute node path from root as a text string.
+ *
+ * \param delimiter - delimiter character to insert between element names
+ * \return path string (e.g. '/bookstore/book/author').
+ */
+ std::string path(char delimiter = '/') const;
+ #endif
+
+ /**
+ * Search for a node by path.
+ * \param path - path string; e.g. './foo/bar' (relative to node), '/foo/bar' (relative
+ * to root), '../foo/bar'.
+ * \param delimiter - delimiter character to use while tokenizing path
+ * \return matching node, if any; empty node otherwise
+ */
+ xml_node first_element_by_path(const char* path, char delimiter = '/') const;
+
+ /**
+ * Recursively traverse subtree with xml_tree_walker
+ * \see xml_tree_walker::begin
+ * \see xml_tree_walker::for_each
+ * \see xml_tree_walker::end
+ *
+ * \param walker - tree walker to traverse subtree with
+ * \return traversal result
+ */
+ bool traverse(xml_tree_walker& walker);
+
+ #ifndef PUGIXML_NO_XPATH
+ /**
+ * Select single node by evaluating XPath query
+ *
+ * \param query - query string
+ * \return first node from the resulting node set by document order, or empty node if none found
+ */
+ xpath_node select_single_node(const char* query) const;
+
+ /**
+ * Select single node by evaluating XPath query
+ *
+ * \param query - compiled query
+ * \return first node from the resulting node set by document order, or empty node if none found
+ */
+ xpath_node select_single_node(xpath_query& query) const;
+
+ /**
+ * Select node set by evaluating XPath query
+ *
+ * \param query - query string
+ * \return resulting node set
+ */
+ xpath_node_set select_nodes(const char* query) const;
+
+ /**
+ * Select node set by evaluating XPath query
+ *
+ * \param query - compiled query
+ * \return resulting node set
+ */
+ xpath_node_set select_nodes(xpath_query& query) const;
+ #endif
+
+ /// \internal Document order or 0 if not set
+ unsigned int document_order() const;
+
+ /**
+ * Print subtree to writer
+ *
+ * \param writer - writer object
+ * \param indent - indentation string
+ * \param flags - formatting flags
+ * \param depth - starting depth (used for indentation)
+ */
+ void print(xml_writer& writer, const char* indent = "\t", unsigned int flags = format_default, unsigned int depth = 0);
+
+ #ifndef PUGIXML_NO_STL
+ /**
+ * Print subtree to stream
+ *
+ * \param os - output stream
+ * \param indent - indentation string
+ * \param flags - formatting flags
+ * \param depth - starting depth (used for indentation)
+ * \deprecated Use print() with xml_writer_stream instead
+ */
+ void print(std::ostream& os, const char* indent = "\t", unsigned int flags = format_default, unsigned int depth = 0);
+ #endif
+
+ /**
+ * Get node offset in parsed file/string (in bytes) for debugging purposes
+ *
+ * \return offset in bytes to start of node data, or -1 in case of error
+ * \note This will return -1 if node information changed to the extent that it's no longer possible to calculate offset, for example
+ * if element node name has significantly changed; this is guaranteed to return correct offset only for nodes that have not changed
+ * since parsing.
+ */
+ int offset_debug() const;
+ };
+
+#ifdef __BORLANDC__
+ // Borland C++ workaround
+ bool PUGIXML_FUNCTION operator&&(const xml_node& lhs, bool rhs);
+ bool PUGIXML_FUNCTION operator||(const xml_node& lhs, bool rhs);
+#endif
+
+ /**
+ * Child node iterator.
+ * It's a bidirectional iterator with value type 'xml_node'.
+ */
+ class PUGIXML_CLASS xml_node_iterator
+#ifndef PUGIXML_NO_STL
+ : public std::iterator<std::bidirectional_iterator_tag, xml_node>
+#endif
+#ifdef _MSC_VER
+# pragma warning(push)
+# pragma warning(disable: 4251 4275) // C4251 and C4275 can be ignored for _Container_base, as per MSDN
+#endif
+ {
+#ifdef _MSC_VER
+# pragma warning(pop)
+#endif
+ friend class xml_node;
+
+ private:
+ xml_node _prev;
+ xml_node _wrap;
+
+ /// \internal Initializing ctor
+ explicit xml_node_iterator(xml_node_struct* ref);
+
+ public:
+ /**
+ * Default ctor
+ */
+ xml_node_iterator();
+
+ /**
+ * Initializing ctor
+ *
+ * \param node - node that iterator will point at
+ */
+ xml_node_iterator(const xml_node& node);
+
+ /**
+ * Initializing ctor (for past-the-end)
+ *
+ * \param ref - should be 0
+ * \param prev - previous node
+ */
+ xml_node_iterator(xml_node_struct* ref, xml_node_struct* prev);
+
+ /**
+ * Check if this iterator is equal to \a rhs
+ *
+ * \param rhs - other iterator
+ * \return comparison result
+ */
+ bool operator==(const xml_node_iterator& rhs) const;
+
+ /**
+ * Check if this iterator is not equal to \a rhs
+ *
+ * \param rhs - other iterator
+ * \return comparison result
+ */
+ bool operator!=(const xml_node_iterator& rhs) const;
+
+ /**
+ * Dereferencing operator
+ *
+ * \return reference to the node iterator points at
+ */
+ xml_node& operator*();
+
+ /**
+ * Member access operator
+ *
+ * \return poitner to the node iterator points at
+ */
+ xml_node* operator->();
+
+ /**
+ * Pre-increment operator
+ *
+ * \return self
+ */
+ const xml_node_iterator& operator++();
+
+ /**
+ * Post-increment operator
+ *
+ * \return old value
+ */
+ xml_node_iterator operator++(int);
+
+ /**
+ * Pre-decrement operator
+ *
+ * \return self
+ */
+ const xml_node_iterator& operator--();
+
+ /**
+ * Post-decrement operator
+ *
+ * \return old value
+ */
+ xml_node_iterator operator--(int);
+ };
+
+ /**
+ * Attribute iterator.
+ * It's a bidirectional iterator with value type 'xml_attribute'.
+ */
+ class PUGIXML_CLASS xml_attribute_iterator
+#ifndef PUGIXML_NO_STL
+ : public std::iterator<std::bidirectional_iterator_tag, xml_attribute>
+#endif
+#ifdef _MSC_VER
+# pragma warning(push)
+# pragma warning(disable: 4251 4275) // C4251 and C4275 can be ignored for _Container_base, as per MSDN
+#endif
+ {
+#ifdef _MSC_VER
+# pragma warning(pop)
+#endif
+ friend class xml_node;
+
+ private:
+ xml_attribute _prev;
+ xml_attribute _wrap;
+
+ /// \internal Initializing ctor
+ explicit xml_attribute_iterator(xml_attribute_struct* ref);
+
+ public:
+ /**
+ * Default ctor
+ */
+ xml_attribute_iterator();
+
+ /**
+ * Initializing ctor
+ *
+ * \param node - node that iterator will point at
+ */
+ xml_attribute_iterator(const xml_attribute& node);
+
+ /**
+ * Initializing ctor (for past-the-end)
+ *
+ * \param ref - should be 0
+ * \param prev - previous node
+ */
+ xml_attribute_iterator(xml_attribute_struct* ref, xml_attribute_struct* prev);
+
+ /**
+ * Check if this iterator is equal to \a rhs
+ *
+ * \param rhs - other iterator
+ * \return comparison result
+ */
+ bool operator==(const xml_attribute_iterator& rhs) const;
+
+ /**
+ * Check if this iterator is not equal to \a rhs
+ *
+ * \param rhs - other iterator
+ * \return comparison result
+ */
+ bool operator!=(const xml_attribute_iterator& rhs) const;
+
+ /**
+ * Dereferencing operator
+ *
+ * \return reference to the node iterator points at
+ */
+ xml_attribute& operator*();
+
+ /**
+ * Member access operator
+ *
+ * \return poitner to the node iterator points at
+ */
+ xml_attribute* operator->();
+
+ /**
+ * Pre-increment operator
+ *
+ * \return self
+ */
+ const xml_attribute_iterator& operator++();
+
+ /**
+ * Post-increment operator
+ *
+ * \return old value
+ */
+ xml_attribute_iterator operator++(int);
+
+ /**
+ * Pre-decrement operator
+ *
+ * \return self
+ */
+ const xml_attribute_iterator& operator--();
+
+ /**
+ * Post-decrement operator
+ *
+ * \return old value
+ */
+ xml_attribute_iterator operator--(int);
+ };
+
+ /**
+ * Abstract tree walker class
+ * \see xml_node::traverse
+ */
+ class PUGIXML_CLASS xml_tree_walker
+ {
+ friend class xml_node;
+
+ private:
+ int _depth;
+
+ protected:
+ /**
+ * Get node depth
+ *
+ * \return node depth
+ */
+ int depth() const;
+
+ public:
+ /**
+ * Default ctor
+ */
+ xml_tree_walker();
+
+ /**
+ * Virtual dtor
+ */
+ virtual ~xml_tree_walker();
+
+ public:
+ /**
+ * Callback that is called when traversal of node begins.
+ *
+ * \return returning false will abort the traversal
+ */
+ virtual bool begin(xml_node&);
+
+ /**
+ * Callback that is called for each node traversed
+ *
+ * \return returning false will abort the traversal
+ */
+ virtual bool for_each(xml_node&) = 0;
+
+ /**
+ * Callback that is called when traversal of node ends.
+ *
+ * \return returning false will abort the traversal
+ */
+ virtual bool end(xml_node&);
+ };
+
+ /// \internal Memory block
+ struct PUGIXML_CLASS xml_memory_block
+ {
+ xml_memory_block();
+
+ xml_memory_block* next;
+ size_t size;
+
+ char data[memory_block_size];
+ };
+
+ /**
+ * Struct used to distinguish parsing with ownership transfer from parsing without it.
+ * \see xml_document::parse
+ */
+ struct transfer_ownership_tag {};
+
+ /**
+ * Parsing status enumeration, returned as part of xml_parse_result struct
+ */
+ enum xml_parse_status
+ {
+ status_ok = 0, ///< No error
+
+ status_file_not_found, ///< File was not found during load_file()
+ status_io_error, ///< Error reading from file/stream
+ status_out_of_memory, ///< Could not allocate memory
+ status_internal_error, ///< Internal error occured
+
+ status_unrecognized_tag, ///< Parser could not determine tag type
+
+ status_bad_pi, ///< Parsing error occured while parsing document declaration/processing instruction (<?...?>)
+ status_bad_comment, ///< Parsing error occured while parsing comment (<!--...-->)
+ status_bad_cdata, ///< Parsing error occured while parsing CDATA section (<![CDATA[...]]>)
+ status_bad_doctype, ///< Parsing error occured while parsing document type declaration
+ status_bad_pcdata, ///< Parsing error occured while parsing PCDATA section (>...<)
+ status_bad_start_element, ///< Parsing error occured while parsing start element tag (<name ...>)
+ status_bad_attribute, ///< Parsing error occured while parsing element attribute
+ status_bad_end_element, ///< Parsing error occured while parsing end element tag (</name>)
+ status_end_element_mismatch ///< There was a mismatch of start-end tags (closing tag had incorrect name, some tag was not closed or there was an excessive closing tag)
+ };
+
+ /**
+ * Parser result
+ */
+ struct PUGIXML_CLASS xml_parse_result
+ {
+ /// Parsing status (\see xml_parse_status)
+ xml_parse_status status;
+
+ /// Last parsed offset (in bytes from file/string start)
+ unsigned int offset;
+
+ /// Line in parser source which reported this
+ unsigned int line;
+
+ /// Cast to bool operator
+ operator bool() const
+ {
+ return status == status_ok;
+ }
+
+ /// Get error description
+ const char* description() const;
+ };
+
+ /**
+ * Document class (DOM tree root).
+ * This class has noncopyable semantics (private copy ctor/assignment operator).
+ */
+ class PUGIXML_CLASS xml_document: public xml_node
+ {
+ private:
+ char* _buffer;
+
+ xml_memory_block _memory;
+
+ xml_document(const xml_document&);
+ const xml_document& operator=(const xml_document&);
+
+ void create();
+ void destroy();
+
+ public:
+ /**
+ * Default ctor, makes empty document
+ */
+ xml_document();
+
+ /**
+ * Dtor
+ */
+ ~xml_document();
+
+ public:
+#ifndef PUGIXML_NO_STL
+ /**
+ * Load document from stream.
+ *
+ * \param stream - stream with xml data
+ * \param options - parsing options
+ * \return parsing result
+ */
+ xml_parse_result load(std::istream& stream, unsigned int options = parse_default);
+#endif
+
+ /**
+ * Load document from string.
+ *
+ * \param contents - input string
+ * \param options - parsing options
+ * \return parsing result
+ */
+ xml_parse_result load(const char* contents, unsigned int options = parse_default);
+
+ /**
+ * Load document from file
+ *
+ * \param name - file name
+ * \param options - parsing options
+ * \return parsing result
+ */
+ xml_parse_result load_file(const char* name, unsigned int options = parse_default);
+
+ /**
+ * Parse the given XML string in-situ.
+ * The string is modified; you should ensure that string data will persist throughout the
+ * document's lifetime. Although, document does not gain ownership over the string, so you
+ * should free the memory occupied by it manually.
+ *
+ * \param xmlstr - readwrite string with xml data
+ * \param options - parsing options
+ * \return parsing result
+ */
+ xml_parse_result parse(char* xmlstr, unsigned int options = parse_default);
+
+ /**
+ * Parse the given XML string in-situ (gains ownership).
+ * The string is modified; document gains ownership over the string, so you don't have to worry
+ * about it's lifetime.
+ * Call example: doc.parse(transfer_ownership_tag(), string, options);
+ *
+ * \param xmlstr - readwrite string with xml data
+ * \param options - parsing options
+ * \return parsing result
+ */
+ xml_parse_result parse(const transfer_ownership_tag&, char* xmlstr, unsigned int options = parse_default);
+
+ /**
+ * Save XML to writer
+ *
+ * \param writer - writer object
+ * \param indent - indentation string
+ * \param flags - formatting flags
+ */
+ void save(xml_writer& writer, const char* indent = "\t", unsigned int flags = format_default);
+
+ /**
+ * Save XML to file
+ *
+ * \param name - file name
+ * \param indent - indentation string
+ * \param flags - formatting flags
+ * \return success flag
+ */
+ bool save_file(const char* name, const char* indent = "\t", unsigned int flags = format_default);
+
+ /**
+ * Compute document order for the whole tree
+ * Sometimes this makes evaluation of XPath queries faster.
+ */
+ void precompute_document_order();
+ };
+
+#ifndef PUGIXML_NO_XPATH
+ /**
+ * XPath exception class.
+ */
+ class PUGIXML_CLASS xpath_exception: public std::exception
+ {
+ private:
+ const char* m_message;
+
+ public:
+ /**
+ * Construct exception from static error string
+ *
+ * \param message - error string
+ */
+ explicit xpath_exception(const char* message);
+
+ /**
+ * Return error message
+ *
+ * \return error message
+ */
+ virtual const char* what() const throw();
+ };
+
+ /**
+ * XPath node class.
+ *
+ * XPath defines node to be either xml_node or xml_attribute in pugixml terminology, so xpath_node
+ * is either xml_node or xml_attribute.
+ */
+ class PUGIXML_CLASS xpath_node
+ {
+ private:
+ xml_node m_node;
+ xml_attribute m_attribute;
+
+ /// \internal Safe bool type
+ typedef xml_node xpath_node::*unspecified_bool_type;
+
+ public:
+ /**
+ * Construct empty XPath node
+ */
+ xpath_node();
+
+ /**
+ * Construct XPath node from XML node
+ *
+ * \param node - XML node
+ */
+ xpath_node(const xml_node& node);
+
+ /**
+ * Construct XPath node from XML attribute
+ *
+ * \param attribute - XML attribute
+ * \param parent - attribute's parent node
+ */
+ xpath_node(const xml_attribute& attribute, const xml_node& parent);
+
+ /**
+ * Get XML node, if any
+ *
+ * \return contained XML node, empty node otherwise
+ */
+ xml_node node() const;
+
+ /**
+ * Get XML attribute, if any
+ *
+ * \return contained XML attribute, if any, empty attribute otherwise
+ */
+ xml_attribute attribute() const;
+
+ /**
+ * Get parent of contained XML attribute, if any
+ *
+ * \return parent of contained XML attribute, if any, empty node otherwise
+ */
+ xml_node parent() const;
+
+ /**
+ * Safe bool conversion.
+ * Allows xpath_node to be used in a context where boolean variable is expected, such as 'if (node)'.
+ */
+ operator unspecified_bool_type() const;
+
+ /**
+ * Compares two XPath nodes
+ *
+ * \param n - XPath node to compare to
+ * \return comparison result
+ */
+ bool operator==(const xpath_node& n) const;
+
+ /**
+ * Compares two XPath nodes
+ *
+ * \param n - XPath node to compare to
+ * \return comparison result
+ */
+ bool operator!=(const xpath_node& n) const;
+ };
+
+ /**
+ * Not necessarily ordered constant collection of XPath nodes
+ */
+ class PUGIXML_CLASS xpath_node_set
+ {
+ friend class xpath_ast_node;
+
+ public:
+ /// Collection type
+ enum type_t
+ {
+ type_unsorted, ///< Not ordered
+ type_sorted, ///< Sorted by document order (ascending)
+ type_sorted_reverse ///< Sorted by document order (descending)
+ };
+
+ /// Constant iterator type
+ typedef const xpath_node* const_iterator;
+
+ private:
+ type_t m_type;
+
+ xpath_node m_storage;
+
+ xpath_node* m_begin;
+ xpath_node* m_end;
+ xpath_node* m_eos;
+
+ bool m_using_storage;
+
+ typedef xpath_node* iterator;
+
+ iterator mut_begin();
+ iterator mut_end();
+
+ void push_back(const xpath_node& n);
+
+ template <typename Iterator> void append(Iterator begin, Iterator end);
+
+ void truncate(iterator it);
+
+ void remove_duplicates();
+
+ public:
+ /**
+ * Default ctor
+ * Constructs empty set
+ */
+ xpath_node_set();
+
+ /**
+ * Dtor
+ */
+ ~xpath_node_set();
+
+ /**
+ * Copy ctor
+ *
+ * \param ns - set to copy
+ */
+ xpath_node_set(const xpath_node_set& ns);
+
+ /**
+ * Assignment operator
+ *
+ * \param ns - set to assign
+ * \return self
+ */
+ xpath_node_set& operator=(const xpath_node_set& ns);
+
+ /**
+ * Get collection type
+ *
+ * \return collection type
+ */
+ type_t type() const;
+
+ /**
+ * Get collection size
+ *
+ * \return collection size
+ */
+ size_t size() const;
+
+ /**
+ * Get begin constant iterator for collection
+ *
+ * \return begin constant iterator
+ */
+ const_iterator begin() const;
+
+ /**
+ * Get end iterator for collection
+ *
+ * \return end iterator
+ */
+ const_iterator end() const;
+
+ /**
+ * Sort the collection in ascending/descending order by document order
+ *
+ * \param reverse - whether to sort in ascending (false) or descending (true) order
+ */
+ void sort(bool reverse = false);
+
+ /**
+ * Get first node in the collection by document order
+ *
+ * \return first node by document order
+ */
+ xpath_node first() const;
+
+ /**
+ * Return true if collection is empty
+ *
+ * \return true if collection is empty, false otherwise
+ */
+ bool empty() const;
+ };
+#endif
+
+#ifndef PUGIXML_NO_STL
+ /**
+ * Convert utf16 to utf8
+ *
+ * \param str - input UTF16 string
+ * \return output UTF8 string
+ */
+ std::string PUGIXML_FUNCTION as_utf8(const wchar_t* str);
+
+ /**
+ * Convert utf8 to utf16
+ *
+ * \param str - input UTF8 string
+ * \return output UTF16 string
+ */
+ std::wstring PUGIXML_FUNCTION as_utf16(const char* str);
+#endif
+
+ /**
+ * Memory allocation function
+ *
+ * \param size - allocation size
+ * \return pointer to allocated memory on success, NULL on failure
+ */
+ typedef void* (*allocation_function)(size_t size);
+
+ /**
+ * Memory deallocation function
+ *
+ * \param ptr - pointer to memory previously allocated by allocation function
+ */
+ typedef void (*deallocation_function)(void* ptr);
+
+ /**
+ * Override default memory management functions
+ *
+ * All subsequent allocations/deallocations will be performed via supplied functions. Take care not to
+ * change memory management functions if any xml_document instances are still alive - this is considered
+ * undefined behaviour (expect crashes/memory damages/etc.).
+ *
+ * \param allocate - allocation function
+ * \param deallocate - deallocation function
+ *
+ * \note XPath-related allocations, as well as allocations in functions that return std::string (xml_node::path, as_utf8, as_utf16)
+ * are not performed via these functions.
+ * \note If you're using parse() with ownership transfer, you have to allocate the buffer you pass to parse() with allocation
+ * function you set via this function.
+ */
+ void PUGIXML_FUNCTION set_memory_management_functions(allocation_function allocate, deallocation_function deallocate);
+}
+
+// Inline implementation
+
+namespace pugi
+{
+ namespace impl
+ {
+ int PUGIXML_FUNCTION strcmp(const char*, const char*);
+ int PUGIXML_FUNCTION strcmpwild(const char*, const char*);
+ }
+
+ template <typename OutputIterator> void xml_node::all_elements_by_name(const char* name, OutputIterator it) const
+ {
+ if (!_root) return;
+
+ for (xml_node node = first_child(); node; node = node.next_sibling())
+ {
+ if (node.type() == node_element)
+ {
+ if (!impl::strcmp(name, node.name()))
+ {
+ *it = node;
+ ++it;
+ }
+
+ if (node.first_child()) node.all_elements_by_name(name, it);
+ }
+ }
+ }
+
+ template <typename OutputIterator> void xml_node::all_elements_by_name_w(const char* name, OutputIterator it) const
+ {
+ if (!_root) return;
+
+ for (xml_node node = first_child(); node; node = node.next_sibling())
+ {
+ if (node.type() == node_element)
+ {
+ if (!impl::strcmpwild(name, node.name()))
+ {
+ *it = node;
+ ++it;
+ }
+
+ if (node.first_child()) node.all_elements_by_name_w(name, it);
+ }
+ }
+ }
+
+ template <typename Predicate> inline xml_attribute xml_node::find_attribute(Predicate pred) const
+ {
+ if (!_root) return xml_attribute();
+
+ for (xml_attribute attrib = first_attribute(); attrib; attrib = attrib.next_attribute())
+ if (pred(attrib))
+ return attrib;
+
+ return xml_attribute();
+ }
+
+ template <typename Predicate> inline xml_node xml_node::find_child(Predicate pred) const
+ {
+ if (!_root) return xml_node();
+
+ for (xml_node node = first_child(); node; node = node.next_sibling())
+ if (pred(node))
+ return node;
+
+ return xml_node();
+ }
+
+ template <typename Predicate> inline xml_node xml_node::find_node(Predicate pred) const
+ {
+ if (!_root) return xml_node();
+
+ for (xml_node node = first_child(); node; node = node.next_sibling())
+ {
+ if (pred(node))
+ return node;
+
+ if (node.first_child())
+ {
+ xml_node found = node.find_node(pred);
+ if (found) return found;
+ }
+ }
+
+ return xml_node();
+ }
+}
+
+#endif
Added: trunk/oggdsf/src/lib/helper/pugixml/pugixml.vcproj
===================================================================
--- trunk/oggdsf/src/lib/helper/pugixml/pugixml.vcproj (rev 0)
+++ trunk/oggdsf/src/lib/helper/pugixml/pugixml.vcproj 2009-10-12 21:33:00 UTC (rev 16638)
@@ -0,0 +1,731 @@
+<?xml version="1.0" encoding="windows-1250"?>
+<VisualStudioProject
+ ProjectType="Visual C++"
+ Version="9.00"
+ Name="pugixml"
+ ProjectGUID="{87F50139-2ED9-4174-AC3A-58AD515DAB8C}"
+ RootNamespace="pugixml"
+ Keyword="Win32Proj"
+ >
+ <Platforms>
+ <Platform
+ Name="Win32"
+ />
+ <Platform
+ Name="x64"
+ />
+ <Platform
+ Name="Windows Mobile 5.0 Pocket PC SDK 2 (ARMV4I)"
+ />
+ <Platform
+ Name="Windows Mobile 5.0 Smartphone SDK 2 (ARMV4I)"
+ />
+ <Platform
+ Name="Windows Mobile 6 Professional SDK (ARMV4I)"
+ />
+ </Platforms>
+ <ToolFiles>
+ </ToolFiles>
+ <Configurations>
+ <Configuration
+ Name="Debug|Win32"
+ OutputDirectory="$(SolutionDir)$(PlatformName)\$(ConfigurationName)"
+ IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"
+ ConfigurationType="4"
+ CharacterSet="1"
+ >
+ <Tool
+ Name="VCPreBuildEventTool"
+ />
+ <Tool
+ Name="VCCustomBuildTool"
+ />
+ <Tool
+ Name="VCXMLDataGeneratorTool"
+ />
+ <Tool
+ Name="VCWebServiceProxyGeneratorTool"
+ />
+ <Tool
+ Name="VCMIDLTool"
+ />
+ <Tool
+ Name="VCCLCompilerTool"
+ Optimization="0"
+ PreprocessorDefinitions="WIN32;_DEBUG;_LIB"
+ MinimalRebuild="true"
+ BasicRuntimeChecks="3"
+ RuntimeLibrary="3"
+ UsePrecompiledHeader="0"
+ WarningLevel="3"
+ Detect64BitPortabilityProblems="true"
+ DebugInformationFormat="4"
+ />
+ <Tool
+ Name="VCManagedResourceCompilerTool"
+ />
+ <Tool
+ Name="VCResourceCompilerTool"
+ />
+ <Tool
+ Name="VCPreLinkEventTool"
+ />
+ <Tool
+ Name="VCLibrarianTool"
+ />
+ <Tool
+ Name="VCALinkTool"
+ />
+ <Tool
+ Name="VCXDCMakeTool"
+ />
+ <Tool
+ Name="VCBscMakeTool"
+ />
+ <Tool
+ Name="VCFxCopTool"
+ />
+ <Tool
+ Name="VCPostBuildEventTool"
+ />
+ </Configuration>
+ <Configuration
+ Name="Debug|x64"
+ OutputDirectory="$(SolutionDir)$(PlatformName)\$(ConfigurationName)"
+ IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"
+ ConfigurationType="4"
+ CharacterSet="1"
+ >
+ <Tool
+ Name="VCPreBuildEventTool"
+ />
+ <Tool
+ Name="VCCustomBuildTool"
+ />
+ <Tool
+ Name="VCXMLDataGeneratorTool"
+ />
+ <Tool
+ Name="VCWebServiceProxyGeneratorTool"
+ />
+ <Tool
+ Name="VCMIDLTool"
+ TargetEnvironment="3"
+ />
+ <Tool
+ Name="VCCLCompilerTool"
+ Optimization="0"
+ PreprocessorDefinitions="WIN32;_DEBUG;_LIB"
+ MinimalRebuild="true"
+ BasicRuntimeChecks="3"
+ RuntimeLibrary="3"
+ UsePrecompiledHeader="0"
+ WarningLevel="3"
+ Detect64BitPortabilityProblems="true"
+ DebugInformationFormat="3"
+ />
+ <Tool
+ Name="VCManagedResourceCompilerTool"
+ />
+ <Tool
+ Name="VCResourceCompilerTool"
+ />
+ <Tool
+ Name="VCPreLinkEventTool"
+ />
+ <Tool
+ Name="VCLibrarianTool"
+ />
+ <Tool
+ Name="VCALinkTool"
+ />
+ <Tool
+ Name="VCXDCMakeTool"
+ />
+ <Tool
+ Name="VCBscMakeTool"
+ />
+ <Tool
+ Name="VCFxCopTool"
+ />
+ <Tool
+ Name="VCPostBuildEventTool"
+ />
+ </Configuration>
+ <Configuration
+ Name="Debug|Windows Mobile 5.0 Pocket PC SDK 2 (ARMV4I)"
+ OutputDirectory="$(SolutionDir)$(PlatformName)\$(ConfigurationName)"
+ IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"
+ ConfigurationType="4"
+ CharacterSet="1"
+ >
+ <Tool
+ Name="VCPreBuildEventTool"
+ />
+ <Tool
+ Name="VCCustomBuildTool"
+ />
+ <Tool
+ Name="VCXMLDataGeneratorTool"
+ />
+ <Tool
+ Name="VCWebServiceProxyGeneratorTool"
+ />
+ <Tool
+ Name="VCMIDLTool"
+ TargetEnvironment="1"
+ />
+ <Tool
+ Name="VCCLCompilerTool"
+ ExecutionBucket="7"
+ Optimization="0"
+ PreprocessorDefinitions="WIN32;_DEBUG;_LIB;_WIN32_WCE=$(CEVER);UNDER_CE;WINCE;$(ARCHFAM);$(_ARCHFAM_);$(PLATFORMDEFINES)"
+ MinimalRebuild="true"
+ RuntimeLibrary="3"
+ UsePrecompiledHeader="0"
+ WarningLevel="3"
+ />
+ <Tool
+ Name="VCManagedResourceCompilerTool"
+ />
+ <Tool
+ Name="VCResourceCompilerTool"
+ />
+ <Tool
+ Name="VCPreLinkEventTool"
+ />
+ <Tool
+ Name="VCLibrarianTool"
+ />
+ <Tool
+ Name="VCALinkTool"
+ />
+ <Tool
+ Name="VCXDCMakeTool"
+ />
+ <Tool
+ Name="VCBscMakeTool"
+ />
+ <Tool
+ Name="VCCodeSignTool"
+ />
+ <Tool
+ Name="VCPostBuildEventTool"
+ />
+ <DeploymentTool
+ ForceDirty="-1"
+ RemoteDirectory=""
+ RegisterOutput="0"
+ AdditionalFiles=""
+ />
+ <DebuggerTool
+ />
+ </Configuration>
+ <Configuration
+ Name="Debug|Windows Mobile 5.0 Smartphone SDK 2 (ARMV4I)"
+ OutputDirectory="$(SolutionDir)$(PlatformName)\$(ConfigurationName)"
+ IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"
+ ConfigurationType="4"
+ CharacterSet="1"
+ >
+ <Tool
+ Name="VCPreBuildEventTool"
+ />
+ <Tool
+ Name="VCCustomBuildTool"
+ />
+ <Tool
+ Name="VCXMLDataGeneratorTool"
+ />
+ <Tool
+ Name="VCWebServiceProxyGeneratorTool"
+ />
+ <Tool
+ Name="VCMIDLTool"
+ TargetEnvironment="1"
+ />
+ <Tool
+ Name="VCCLCompilerTool"
+ ExecutionBucket="7"
+ Optimization="0"
+ PreprocessorDefinitions="WIN32;_DEBUG;_LIB;_WIN32_WCE=$(CEVER);UNDER_CE;WINCE;$(ARCHFAM);$(_ARCHFAM_);$(PLATFORMDEFINES)"
+ MinimalRebuild="false"
+ RuntimeLibrary="3"
+ UsePrecompiledHeader="0"
+ WarningLevel="3"
+ />
+ <Tool
+ Name="VCManagedResourceCompilerTool"
+ />
+ <Tool
+ Name="VCResourceCompilerTool"
+ />
+ <Tool
+ Name="VCPreLinkEventTool"
+ />
+ <Tool
+ Name="VCLibrarianTool"
+ />
+ <Tool
+ Name="VCALinkTool"
+ />
+ <Tool
+ Name="VCXDCMakeTool"
+ />
+ <Tool
+ Name="VCBscMakeTool"
+ />
+ <Tool
+ Name="VCCodeSignTool"
+ />
+ <Tool
+ Name="VCPostBuildEventTool"
+ />
+ <DeploymentTool
+ ForceDirty="-1"
+ RemoteDirectory=""
+ RegisterOutput="0"
+ AdditionalFiles=""
+ />
+ <DebuggerTool
+ />
+ </Configuration>
+ <Configuration
+ Name="Debug|Windows Mobile 6 Professional SDK (ARMV4I)"
+ OutputDirectory="$(SolutionDir)$(PlatformName)\$(ConfigurationName)"
+ IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"
+ ConfigurationType="4"
+ CharacterSet="1"
+ >
+ <Tool
+ Name="VCPreBuildEventTool"
+ />
+ <Tool
+ Name="VCCustomBuildTool"
+ />
+ <Tool
+ Name="VCXMLDataGeneratorTool"
+ />
+ <Tool
+ Name="VCWebServiceProxyGeneratorTool"
+ />
+ <Tool
+ Name="VCMIDLTool"
+ TargetEnvironment="1"
+ />
+ <Tool
+ Name="VCCLCompilerTool"
+ ExecutionBucket="7"
+ Optimization="0"
+ PreprocessorDefinitions="WIN32;_DEBUG;_LIB;_WIN32_WCE=$(CEVER);UNDER_CE;WINCE;$(ARCHFAM);$(_ARCHFAM_);$(PLATFORMDEFINES)"
+ MinimalRebuild="true"
+ RuntimeLibrary="3"
+ UsePrecompiledHeader="0"
+ WarningLevel="3"
+ />
+ <Tool
+ Name="VCManagedResourceCompilerTool"
+ />
+ <Tool
+ Name="VCResourceCompilerTool"
+ />
+ <Tool
+ Name="VCPreLinkEventTool"
+ />
+ <Tool
+ Name="VCLibrarianTool"
+ />
+ <Tool
+ Name="VCALinkTool"
+ />
+ <Tool
+ Name="VCXDCMakeTool"
+ />
+ <Tool
+ Name="VCBscMakeTool"
+ />
+ <Tool
+ Name="VCCodeSignTool"
+ />
+ <Tool
+ Name="VCPostBuildEventTool"
+ />
+ <DeploymentTool
+ ForceDirty="-1"
+ RemoteDirectory=""
+ RegisterOutput="0"
+ AdditionalFiles=""
+ />
+ <DebuggerTool
+ />
+ </Configuration>
+ <Configuration
+ Name="Release|Win32"
+ OutputDirectory="$(SolutionDir)$(PlatformName)\$(ConfigurationName)"
+ IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"
+ ConfigurationType="4"
+ CharacterSet="1"
+ WholeProgramOptimization="1"
+ >
+ <Tool
+ Name="VCPreBuildEventTool"
+ />
+ <Tool
+ Name="VCCustomBuildTool"
+ />
+ <Tool
+ Name="VCXMLDataGeneratorTool"
+ />
+ <Tool
+ Name="VCWebServiceProxyGeneratorTool"
+ />
+ <Tool
+ Name="VCMIDLTool"
+ />
+ <Tool
+ Name="VCCLCompilerTool"
+ PreprocessorDefinitions="WIN32;NDEBUG;_LIB"
+ RuntimeLibrary="2"
+ UsePrecompiledHeader="0"
+ WarningLevel="3"
+ Detect64BitPortabilityProblems="true"
+ DebugInformationFormat="3"
+ />
+ <Tool
+ Name="VCManagedResourceCompilerTool"
+ />
+ <Tool
+ Name="VCResourceCompilerTool"
+ />
+ <Tool
+ Name="VCPreLinkEventTool"
+ />
+ <Tool
+ Name="VCLibrarianTool"
+ />
+ <Tool
+ Name="VCALinkTool"
+ />
+ <Tool
+ Name="VCXDCMakeTool"
+ />
+ <Tool
+ Name="VCBscMakeTool"
+ />
+ <Tool
+ Name="VCFxCopTool"
+ />
+ <Tool
+ Name="VCPostBuildEventTool"
+ />
+ </Configuration>
+ <Configuration
+ Name="Release|x64"
+ OutputDirectory="$(SolutionDir)$(PlatformName)\$(ConfigurationName)"
+ IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"
+ ConfigurationType="4"
+ CharacterSet="1"
+ WholeProgramOptimization="1"
+ >
+ <Tool
+ Name="VCPreBuildEventTool"
+ />
+ <Tool
+ Name="VCCustomBuildTool"
+ />
+ <Tool
+ Name="VCXMLDataGeneratorTool"
+ />
+ <Tool
+ Name="VCWebServiceProxyGeneratorTool"
+ />
+ <Tool
+ Name="VCMIDLTool"
+ TargetEnvironment="3"
+ />
+ <Tool
+ Name="VCCLCompilerTool"
+ PreprocessorDefinitions="WIN32;NDEBUG;_LIB"
+ RuntimeLibrary="2"
+ UsePrecompiledHeader="0"
+ WarningLevel="3"
+ Detect64BitPortabilityProblems="true"
+ DebugInformationFormat="3"
+ />
+ <Tool
+ Name="VCManagedResourceCompilerTool"
+ />
+ <Tool
+ Name="VCResourceCompilerTool"
+ />
+ <Tool
+ Name="VCPreLinkEventTool"
+ />
+ <Tool
+ Name="VCLibrarianTool"
+ />
+ <Tool
+ Name="VCALinkTool"
+ />
+ <Tool
+ Name="VCXDCMakeTool"
+ />
+ <Tool
+ Name="VCBscMakeTool"
+ />
+ <Tool
+ Name="VCFxCopTool"
+ />
+ <Tool
+ Name="VCPostBuildEventTool"
+ />
+ </Configuration>
+ <Configuration
+ Name="Release|Windows Mobile 5.0 Pocket PC SDK 2 (ARMV4I)"
+ OutputDirectory="$(SolutionDir)$(PlatformName)\$(ConfigurationName)"
+ IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"
+ ConfigurationType="4"
+ CharacterSet="1"
+ WholeProgramOptimization="1"
+ >
+ <Tool
+ Name="VCPreBuildEventTool"
+ />
+ <Tool
+ Name="VCCustomBuildTool"
+ />
+ <Tool
+ Name="VCXMLDataGeneratorTool"
+ />
+ <Tool
+ Name="VCWebServiceProxyGeneratorTool"
+ />
+ <Tool
+ Name="VCMIDLTool"
+ TargetEnvironment="1"
+ />
+ <Tool
+ Name="VCCLCompilerTool"
+ ExecutionBucket="7"
+ PreprocessorDefinitions="WIN32;NDEBUG;_LIB;_WIN32_WCE=$(CEVER);UNDER_CE;WINCE;$(ARCHFAM);$(_ARCHFAM_);$(PLATFORMDEFINES)"
+ RuntimeLibrary="2"
+ UsePrecompiledHeader="0"
+ WarningLevel="3"
+ DebugInformationFormat="3"
+ />
+ <Tool
+ Name="VCManagedResourceCompilerTool"
+ />
+ <Tool
+ Name="VCResourceCompilerTool"
+ />
+ <Tool
+ Name="VCPreLinkEventTool"
+ />
+ <Tool
+ Name="VCLibrarianTool"
+ />
+ <Tool
+ Name="VCALinkTool"
+ />
+ <Tool
+ Name="VCXDCMakeTool"
+ />
+ <Tool
+ Name="VCBscMakeTool"
+ />
+ <Tool
+ Name="VCCodeSignTool"
+ />
+ <Tool
+ Name="VCPostBuildEventTool"
+ />
+ <DeploymentTool
+ ForceDirty="-1"
+ RemoteDirectory=""
+ RegisterOutput="0"
+ AdditionalFiles=""
+ />
+ <DebuggerTool
+ />
+ </Configuration>
+ <Configuration
+ Name="Release|Windows Mobile 5.0 Smartphone SDK 2 (ARMV4I)"
+ OutputDirectory="$(SolutionDir)$(PlatformName)\$(ConfigurationName)"
+ IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"
+ ConfigurationType="4"
+ CharacterSet="1"
+ WholeProgramOptimization="1"
+ >
+ <Tool
+ Name="VCPreBuildEventTool"
+ />
+ <Tool
+ Name="VCCustomBuildTool"
+ />
+ <Tool
+ Name="VCXMLDataGeneratorTool"
+ />
+ <Tool
+ Name="VCWebServiceProxyGeneratorTool"
+ />
+ <Tool
+ Name="VCMIDLTool"
+ TargetEnvironment="1"
+ />
+ <Tool
+ Name="VCCLCompilerTool"
+ ExecutionBucket="7"
+ PreprocessorDefinitions="WIN32;NDEBUG;_LIB;_WIN32_WCE=$(CEVER);UNDER_CE;WINCE;$(ARCHFAM);$(_ARCHFAM_);$(PLATFORMDEFINES)"
+ RuntimeLibrary="2"
+ UsePrecompiledHeader="0"
+ WarningLevel="3"
+ DebugInformationFormat="3"
+ />
+ <Tool
+ Name="VCManagedResourceCompilerTool"
+ />
+ <Tool
+ Name="VCResourceCompilerTool"
+ />
+ <Tool
+ Name="VCPreLinkEventTool"
+ />
+ <Tool
+ Name="VCLibrarianTool"
+ />
+ <Tool
+ Name="VCALinkTool"
+ />
+ <Tool
+ Name="VCXDCMakeTool"
+ />
+ <Tool
+ Name="VCBscMakeTool"
+ />
+ <Tool
+ Name="VCCodeSignTool"
+ />
+ <Tool
+ Name="VCPostBuildEventTool"
+ />
+ <DeploymentTool
+ ForceDirty="-1"
+ RemoteDirectory=""
+ RegisterOutput="0"
+ AdditionalFiles=""
+ />
+ <DebuggerTool
+ />
+ </Configuration>
+ <Configuration
+ Name="Release|Windows Mobile 6 Professional SDK (ARMV4I)"
+ OutputDirectory="$(SolutionDir)$(PlatformName)\$(ConfigurationName)"
+ IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"
+ ConfigurationType="4"
+ CharacterSet="1"
+ WholeProgramOptimization="1"
+ >
+ <Tool
+ Name="VCPreBuildEventTool"
+ />
+ <Tool
+ Name="VCCustomBuildTool"
+ />
+ <Tool
+ Name="VCXMLDataGeneratorTool"
+ />
+ <Tool
+ Name="VCWebServiceProxyGeneratorTool"
+ />
+ <Tool
+ Name="VCMIDLTool"
+ TargetEnvironment="1"
+ />
+ <Tool
+ Name="VCCLCompilerTool"
+ ExecutionBucket="7"
+ PreprocessorDefinitions="WIN32;NDEBUG;_LIB;_WIN32_WCE=$(CEVER);UNDER_CE;WINCE;$(ARCHFAM);$(_ARCHFAM_);$(PLATFORMDEFINES)"
+ RuntimeLibrary="2"
+ UsePrecompiledHeader="0"
+ WarningLevel="3"
+ DebugInformationFormat="3"
+ />
+ <Tool
+ Name="VCManagedResourceCompilerTool"
+ />
+ <Tool
+ Name="VCResourceCompilerTool"
+ />
+ <Tool
+ Name="VCPreLinkEventTool"
+ />
+ <Tool
+ Name="VCLibrarianTool"
+ />
+ <Tool
+ Name="VCALinkTool"
+ />
+ <Tool
+ Name="VCXDCMakeTool"
+ />
+ <Tool
+ Name="VCBscMakeTool"
+ />
+ <Tool
+ Name="VCCodeSignTool"
+ />
+ <Tool
+ Name="VCPostBuildEventTool"
+ />
+ <DeploymentTool
+ ForceDirty="-1"
+ RemoteDirectory=""
+ RegisterOutput="0"
+ AdditionalFiles=""
+ />
+ <DebuggerTool
+ />
+ </Configuration>
+ </Configurations>
+ <References>
+ </References>
+ <Files>
+ <Filter
+ Name="Source Files"
+ Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
+ UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
+ >
+ <File
+ RelativePath=".\pugixml.cpp"
+ >
+ </File>
+ <File
+ RelativePath=".\pugixpath.cpp"
+ >
+ </File>
+ </Filter>
+ <Filter
+ Name="Header Files"
+ Filter="h;hpp;hxx;hm;inl;inc;xsd"
+ UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
+ >
+ <File
+ RelativePath=".\pugiconfig.hpp"
+ >
+ </File>
+ <File
+ RelativePath=".\pugixml.hpp"
+ >
+ </File>
+ </Filter>
+ <Filter
+ Name="Resource Files"
+ Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav"
+ UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
+ >
+ </Filter>
+ </Files>
+ <Globals>
+ </Globals>
+</VisualStudioProject>
Added: trunk/oggdsf/src/lib/helper/pugixml/pugixpath.cpp
===================================================================
--- trunk/oggdsf/src/lib/helper/pugixml/pugixpath.cpp (rev 0)
+++ trunk/oggdsf/src/lib/helper/pugixml/pugixpath.cpp 2009-10-12 21:33:00 UTC (rev 16638)
@@ -0,0 +1,3618 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// Pug Improved XML Parser - Version 0.42
+// --------------------------------------------------------
+// Copyright (C) 2006-2009, by Arseny Kapoulkine (arseny.kapoulkine at gmail.com)
+// Report bugs and download new versions at http://code.google.com/p/pugixml/
+//
+// This work is based on the pugxml parser, which is:
+// Copyright (C) 2003, by Kristen Wegner (kristen at tima.net)
+// Released into the Public Domain. Use at your own risk.
+// See pugxml.xml for further information, history, etc.
+// Contributions by Neville Franks (readonly at getsoft.com).
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "pugixml.hpp"
+
+#ifndef PUGIXML_NO_XPATH
+
+#include <algorithm>
+
+#include <assert.h>
+
+#include <stdio.h>
+#include <math.h>
+#include <float.h>
+#include <ctype.h>
+#include <string.h>
+
+#if defined(_MSC_VER)
+# pragma warning(disable: 4127) // conditional expression is constant
+# pragma warning(disable: 4702) // unreachable code
+# pragma warning(disable: 4996) // this function or variable may be unsafe
+#endif
+
+namespace
+{
+ using namespace pugi;
+
+ enum chartype
+ {
+ ct_space = 1, // \r, \n, space, tab
+ ct_start_symbol = 2, // Any symbol > 127, a-z, A-Z, _, :
+ ct_digit = 4, // 0-9
+ ct_symbol = 8 // Any symbol > 127, a-z, A-Z, 0-9, _, :, -, .
+ };
+
+ const unsigned char chartype_table[256] =
+ {
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, // 0-15
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 16-31
+ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 8, 0, // 32-47
+ 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 10, 0, 0, 0, 0, 0, // 48-63
+ 0, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, // 64-79
+ 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 0, 0, 0, 0, 10, // 80-95
+ 0, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, // 96-111
+ 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 0, 0, 0, 0, 0, // 112-127
+
+ 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, // 128+
+ 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
+ 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
+ 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
+ 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
+ 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
+ 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
+ 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10
+ };
+
+ bool is_chartype(char c, chartype ct)
+ {
+ return !!(chartype_table[static_cast<unsigned char>(c)] & ct);
+ }
+
+ bool starts_with(const std::string& s, const char* pattern)
+ {
+ return s.compare(0, strlen(pattern), pattern) == 0;
+ }
+
+ std::string string_value(const xpath_node& na)
+ {
+ if (na.attribute())
+ return na.attribute().value();
+ else
+ {
+ const xml_node& n = na.node();
+
+ switch (n.type())
+ {
+ case node_pcdata:
+ case node_cdata:
+ case node_comment:
+ case node_pi:
+ return n.value();
+
+ case node_document:
+ case node_element:
+ {
+ std::string result;
+
+ xml_node c = n.first_child();
+
+ while (c)
+ {
+ if (c.type() == node_pcdata || c.type() == node_cdata)
+ result += c.value();
+
+ if (c.first_child())
+ c = c.first_child();
+ else if (c.next_sibling())
+ c = c.next_sibling();
+ else
+ {
+ while (c && c != n) c = c.parent();
+
+ if (c == n) break;
+
+ c = c.next_sibling();
+ }
+ }
+
+ return result;
+ }
+
+ default:
+ return "";
+ }
+ }
+ }
+
+ unsigned int node_height(xml_node n)
+ {
+ unsigned int result = 0;
+
+ while (n)
+ {
+ ++result;
+ n = n.parent();
+ }
+
+ return result;
+ }
+
+ // precondition: node_height of ln is <= node_height of rn, ln != rn
+ bool node_is_before(xml_node ln, unsigned int lh, xml_node rn, unsigned int rh)
+ {
+ assert(lh <= rh);
+
+ while (lh < rh)
+ {
+ --rh;
+ rn = rn.parent();
+ }
+
+ if (ln == rn) return true;
+
+ while (ln.parent() != rn.parent())
+ {
+ ln = ln.parent();
+ rn = rn.parent();
+ }
+
+ for (; ln; ln = ln.next_sibling())
+ if (ln == rn)
+ return true;
+
+ return false;
+ }
+
+ struct document_order_comparator
+ {
+ bool operator()(const xpath_node& lhs, const xpath_node& rhs) const
+ {
+ unsigned int lo = lhs.attribute() ? lhs.attribute().document_order() : lhs.node().document_order();
+ unsigned int ro = rhs.attribute() ? rhs.attribute().document_order() : rhs.node().document_order();
+
+ if (lo != 0 && ro != 0)
+ return lo < ro;
+
+ xml_node ln = lhs.node(), rn = rhs.node();
+
+ if (lhs.attribute() && rhs.attribute())
+ {
+ if (lhs.parent() == rhs.parent())
+ {
+ for (xml_attribute a = lhs.attribute(); a; a = a.next_attribute())
+ if (a == rhs.attribute())
+ return true;
+
+ return false;
+ }
+
+ ln = lhs.parent();
+ rn = rhs.parent();
+ }
+ else if (lhs.attribute())
+ {
+ if (lhs.parent() == rhs.node()) return false;
+
+ ln = lhs.parent();
+ }
+ else if (rhs.attribute())
+ {
+ if (rhs.parent() == lhs.node()) return true;
+
+ rn = rhs.parent();
+ }
+
+ if (ln == rn) return false;
+
+ unsigned int lh = node_height(ln);
+ unsigned int rh = node_height(rn);
+
+ return (lh <= rh) ? node_is_before(ln, lh, rn, rh) : !node_is_before(rn, rh, ln, lh);
+ }
+ };
+
+ struct duplicate_comparator
+ {
+ bool operator()(const xpath_node& lhs, const xpath_node& rhs) const
+ {
+ if (lhs.attribute()) return rhs.attribute() ? lhs.attribute() < rhs.attribute() : true;
+ else return rhs.attribute() ? false : lhs.node() < rhs.node();
+ }
+ };
+
+ /* From trio
+ *
+ * Endian-agnostic indexing macro.
+ *
+ * The value of internalEndianMagic, when converted into a 64-bit
+ * integer, becomes 0x0706050403020100 (we could have used a 64-bit
+ * integer value instead of a double, but not all platforms supports
+ * that type). The value is automatically encoded with the correct
+ * endianess by the compiler, which means that we can support any
+ * kind of endianess. The individual bytes are then used as an index
+ * for the IEEE 754 bit-patterns and masks.
+ */
+ #define DOUBLE_INDEX(x) (((unsigned char *)&internal_endian_magic)[7-(x)])
+
+ static const double internal_endian_magic = 7.949928895127363e-275;
+
+ static const unsigned char ieee_754_exponent_mask[] = { 0x7F, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
+
+ static const unsigned char ieee_754_mantissa_mask[] = { 0x00, 0x0F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
+
+ static const unsigned char ieee_754_qnan_array[] = { 0x7F, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
+
+ bool is_special(double value, bool& has_mantissa)
+ {
+ bool is_special_quantity = true;
+
+ has_mantissa = false;
+
+ for (unsigned int i = 0; i < sizeof(double); ++i)
+ {
+ unsigned char current = ((unsigned char *)&value)[DOUBLE_INDEX(i)];
+
+ is_special_quantity = is_special_quantity && (current & ieee_754_exponent_mask[i]) == ieee_754_exponent_mask[i];
+ has_mantissa = has_mantissa || (current & ieee_754_mantissa_mask[i]) != 0;
+ }
+
+ return is_special_quantity;
+ }
+
+ double gen_nan()
+ {
+#if FLT_RADIX == 2 && DBL_MAX_EXP == 1024 && DBL_MANT_DIG == 53
+ // IEEE 754
+
+ double result = 0;
+
+ for (unsigned int i = 0; i < sizeof(double); ++i)
+ {
+ ((unsigned char *)&result)[DOUBLE_INDEX(i)] = ieee_754_qnan_array[i];
+ }
+
+ return result;
+#else
+ const volatile double zero = 0.0;
+ return zero / zero;
+#endif
+ }
+
+ bool is_nan(double value)
+ {
+#if defined(__USE_ISOC99)
+ return isnan(value);
+#elif (defined(_MSC_VER) || defined(__BORLANDC__)) && !defined(__COMO__)
+ return !!_isnan(value);
+#elif FLT_RADIX == 2 && DBL_MAX_EXP == 1024 && DBL_MANT_DIG == 53
+ // IEEE 754
+
+ bool has_mantissa;
+
+ bool is_special_quantity = is_special(value, has_mantissa);
+
+ return (is_special_quantity && has_mantissa);
+#else
+ return value != value;
+#endif
+ }
+
+ bool is_inf(double value)
+ {
+#if defined(__USE_ISOC99)
+ return !isfinite(value);
+#elif (defined(_MSC_VER) || defined(__BORLANDC__)) && !defined(__COMO__)
+ return !_finite(value);
+#elif FLT_RADIX == 2 && DBL_MAX_EXP == 1024 && DBL_MANT_DIG == 53
+ // IEEE 754
+
+ bool has_mantissa;
+
+ bool is_special_quantity = is_special(value, has_mantissa);
+
+ return (is_special_quantity && !has_mantissa);
+#else
+ return value + 1 == value && value - 1 == value;
+#endif
+ }
+
+ bool convert_number_to_boolean(double value)
+ {
+ return (value != 0 && !is_nan(value));
+ }
+
+ std::string convert_number_to_string(double value)
+ {
+ if (is_nan(value)) return "NaN";
+ else if (is_inf(value)) return value < 0 ? "-Infinity" : "Infinity";
+
+ char buf[100];
+
+ if (value == (int)value) sprintf(buf, "%d", (int)value);
+ else
+ {
+ sprintf(buf, "%f", value);
+
+ // trim trailing zeros after decimal point
+ if (strchr(buf, '.'))
+ {
+ char* ptr = buf + strlen(buf) - 1;
+ for (; *ptr == '0'; --ptr) ;
+ *(ptr+1) = 0;
+ }
+ }
+
+ return std::string(buf);
+ }
+
+ double convert_string_to_number(const char* string)
+ {
+ while (is_chartype(*string, ct_space)) ++string;
+
+ double sign = 1;
+
+ if (*string == '-')
+ {
+ sign = -1;
+ ++string;
+ }
+
+ double r = 0;
+
+ if (!*string) return gen_nan();
+
+ while (is_chartype(*string, ct_digit))
+ {
+ r = r * 10 + (*string - '0');
+ ++string;
+ }
+
+ if (*string)
+ {
+ if (is_chartype(*string, ct_space))
+ {
+ while (is_chartype(*string, ct_space)) ++string;
+ if (*string) return gen_nan();
+ }
+
+ if (*string != '.') return gen_nan();
+
+ ++string;
+
+ double power = 0.1;
+
+ while (is_chartype(*string, ct_digit))
+ {
+ r += power * (*string - '0');
+ power /= 10;
+ ++string;
+ }
+
+ while (is_chartype(*string, ct_space)) ++string;
+ if (*string) return gen_nan();
+ }
+
+ return r * sign;
+ }
+
+ double ieee754_round(double value)
+ {
+ return is_nan(value) ? value : floor(value + 0.5);
+ }
+
+ const char* local_name(const char* name)
+ {
+ const char* p = strchr(name, ':');
+
+ return p ? p + 1 : name;
+ }
+
+ const char* namespace_uri(const xml_node& node)
+ {
+ const char* pos = strchr(node.name(), ':');
+
+ std::string ns = "xmlns";
+
+ if (pos)
+ {
+ ns += ':';
+ ns.append(node.name(), pos);
+ }
+
+ xml_node p = node.parent();
+
+ while (p)
+ {
+ xml_attribute a = p.attribute(ns.c_str());
+
+ if (a) return a.value();
+
+ p = p.parent();
+ }
+
+ return "";
+ }
+
+ const char* namespace_uri(const xml_attribute& attr, const xml_node& parent)
+ {
+ const char* pos = strchr(attr.name(), ':');
+
+ // Default namespace does not apply to attributes
+ if (!pos) return "";
+
+ std::string ns = "xmlns:";
+ ns.append(attr.name(), pos);
+
+ xml_node p = parent;
+
+ while (p)
+ {
+ xml_attribute a = p.attribute(ns.c_str());
+
+ if (a) return a.value();
+
+ p = p.parent();
+ }
+
+ return "";
+ }
+
+ template <class T> struct equal_to
+ {
+ bool operator()(const T& lhs, const T& rhs) const
+ {
+ return lhs == rhs;
+ }
+ };
+
+ template <class T> struct not_equal_to
+ {
+ bool operator()(const T& lhs, const T& rhs) const
+ {
+ return lhs != rhs;
+ }
+ };
+
+ template <class T> struct greater
+ {
+ bool operator()(const T& lhs, const T& rhs) const
+ {
+ return lhs > rhs;
+ }
+ };
+
+ template <class T> struct less
+ {
+ bool operator()(const T& lhs, const T& rhs) const
+ {
+ return lhs < rhs;
+ }
+ };
+
+ template <class T> struct greater_equal
+ {
+ bool operator()(const T& lhs, const T& rhs) const
+ {
+ return lhs >= rhs;
+ }
+ };
+
+ template <class T> struct less_equal
+ {
+ bool operator()(const T& lhs, const T& rhs) const
+ {
+ return lhs <= rhs;
+ }
+ };
+}
+
+namespace pugi
+{
+ xpath_exception::xpath_exception(const char* message): m_message(message)
+ {
+ }
+
+ const char* xpath_exception::what() const throw()
+ {
+ return m_message;
+ }
+
+ const size_t xpath_memory_block_size = 4096; ///< Memory block size, 4 kb
+
+ class xpath_allocator
+ {
+ struct memory_block
+ {
+ memory_block(): next(0), size(0)
+ {
+ }
+
+ memory_block* next;
+ size_t size;
+
+ char data[xpath_memory_block_size];
+ };
+
+ memory_block* m_root;
+
+ public:
+ xpath_allocator(): m_root(0)
+ {
+ m_root = new memory_block;
+ }
+
+ ~xpath_allocator()
+ {
+ while (m_root)
+ {
+ memory_block* cur = m_root->next;
+ delete m_root;
+ m_root = cur;
+ }
+ }
+
+ void* alloc(size_t size)
+ {
+ if (m_root->size + size <= xpath_memory_block_size)
+ {
+ void* buf = m_root->data + m_root->size;
+ m_root->size += size;
+ return buf;
+ }
+ else
+ {
+ memory_block* block;
+
+ if (size > xpath_memory_block_size)
+ block = static_cast<memory_block*>(operator new(size + sizeof(memory_block) - xpath_memory_block_size));
+ else
+ block = new memory_block;
+
+ block->next = m_root;
+ block->size = size;
+
+ m_root = block;
+
+ return block->data;
+ }
+ }
+
+ void* node();
+ };
+
+ xpath_node::xpath_node()
+ {
+ }
+
+ xpath_node::xpath_node(const xml_node& node): m_node(node)
+ {
+ }
+
+ xpath_node::xpath_node(const xml_attribute& attribute, const xml_node& parent): m_node(parent), m_attribute(attribute)
+ {
+ }
+
+ xml_node xpath_node::node() const
+ {
+ return m_attribute ? xml_node() : m_node;
+ }
+
+ xml_attribute xpath_node::attribute() const
+ {
+ return m_attribute;
+ }
+
+ xml_node xpath_node::parent() const
+ {
+ return m_attribute ? m_node : m_node.parent();
+ }
+
+ xpath_node::operator xpath_node::unspecified_bool_type() const
+ {
+ return (m_node || m_attribute) ? &xpath_node::m_node : 0;
+ }
+
+ bool xpath_node::operator==(const xpath_node& n) const
+ {
+ return m_node == n.m_node && m_attribute == n.m_attribute;
+ }
+
+ bool xpath_node::operator!=(const xpath_node& n) const
+ {
+ return m_node != n.m_node || m_attribute != n.m_attribute;
+ }
+
+ xpath_node_set::xpath_node_set(): m_type(type_unsorted), m_begin(&m_storage), m_end(&m_storage), m_eos(&m_storage + 1), m_using_storage(true)
+ {
+ }
+
+ xpath_node_set::~xpath_node_set()
+ {
+ if (!m_using_storage) delete[] m_begin;
+ }
+
+ xpath_node_set::xpath_node_set(const xpath_node_set& ns): m_type(type_unsorted), m_begin(&m_storage), m_end(&m_storage), m_eos(&m_storage + 1), m_using_storage(true)
+ {
+ *this = ns;
+ }
+
+ xpath_node_set& xpath_node_set::operator=(const xpath_node_set& ns)
+ {
+ if (!m_using_storage) delete[] m_begin;
+
+ m_begin = m_end = m_eos = 0;
+
+ if (ns.size() == 1)
+ {
+ m_storage = *ns.m_begin;
+ m_begin = &m_storage;
+ m_end = m_eos = &m_storage + 1;
+ m_using_storage = true;
+ }
+ else
+ {
+ m_using_storage = false;
+ append(ns.begin(), ns.end());
+ }
+
+ return *this;
+ }
+
+ xpath_node_set::type_t xpath_node_set::type() const
+ {
+ return m_type;
+ }
+
+ size_t xpath_node_set::size() const
+ {
+ return m_end - m_begin;
+ }
+
+ bool xpath_node_set::empty() const
+ {
+ return size() == 0;
+ }
+
+ xpath_node_set::iterator xpath_node_set::mut_begin()
+ {
+ return m_begin;
+ }
+
+ xpath_node_set::const_iterator xpath_node_set::begin() const
+ {
+ return m_begin;
+ }
+
+ xpath_node_set::iterator xpath_node_set::mut_end()
+ {
+ return m_end;
+ }
+
+ xpath_node_set::const_iterator xpath_node_set::end() const
+ {
+ return m_end;
+ }
+
+ void xpath_node_set::sort(bool reverse)
+ {
+ std::sort(m_begin, m_end, document_order_comparator());
+
+ if (reverse)
+ std::reverse(m_begin, m_end);
+
+ m_type = reverse ? type_sorted_reverse : type_sorted;
+ }
+
+ void xpath_node_set::push_back(const xpath_node& n)
+ {
+ if (m_end == m_eos)
+ append(&n, &n + 1);
+ else
+ {
+ *m_end = n;
+ ++m_end;
+ }
+ }
+
+ template <typename Iterator> void xpath_node_set::append(Iterator begin, Iterator end)
+ {
+ size_t count = std::distance(begin, end);
+ size_t size = m_end - m_begin;
+ size_t capacity = m_eos - m_begin;
+
+ if (capacity < size + count)
+ {
+ if (capacity < 2) capacity = 2;
+
+ while (capacity < size + count) capacity += capacity / 2;
+
+ xpath_node* storage = new xpath_node[capacity];
+ std::copy(m_begin, m_end, storage);
+
+ if (!m_using_storage) delete[] m_begin;
+
+ m_using_storage = false;
+
+ m_begin = storage;
+ m_end = storage + size;
+ m_eos = storage + capacity;
+ }
+
+ std::copy(begin, end, m_end);
+ m_end += count;
+ }
+
+ void xpath_node_set::truncate(iterator it)
+ {
+ m_end = it;
+ }
+
+ xpath_node xpath_node_set::first() const
+ {
+ switch (m_type)
+ {
+ case type_sorted: return *m_begin;
+ case type_sorted_reverse: return *(m_end - 1);
+ case type_unsorted: return *std::min_element(begin(), end(), document_order_comparator());
+ default: return xpath_node();
+ }
+ }
+
+ void xpath_node_set::remove_duplicates()
+ {
+ if (m_type == type_unsorted)
+ {
+ std::sort(m_begin, m_end, duplicate_comparator());
+ }
+
+ truncate(std::unique(m_begin, m_end));
+ }
+
+ struct xpath_context
+ {
+ xml_node root;
+ xpath_node n;
+ size_t position, size;
+ };
+
+ enum lexeme_t
+ {
+ lex_none = 0,
+ lex_equal,
+ lex_not_equal,
+ lex_less,
+ lex_greater,
+ lex_less_or_equal,
+ lex_greater_or_equal,
+ lex_plus,
+ lex_minus,
+ lex_multiply,
+ lex_union,
+ lex_var_ref,
+ lex_open_brace,
+ lex_close_brace,
+ lex_quoted_string,
+ lex_number,
+ lex_slash,
+ lex_double_slash,
+ lex_open_square_brace,
+ lex_close_square_brace,
+ lex_string,
+ lex_comma,
+ lex_axis_attribute,
+ lex_dot,
+ lex_double_dot
+ };
+
+ class xpath_lexer
+ {
+ private:
+ const char* m_cur;
+
+ char* m_cur_lexeme_contents;
+ size_t m_clc_size;
+ size_t m_clc_capacity;
+
+ lexeme_t m_cur_lexeme;
+
+ void contents_clear()
+ {
+ m_clc_size = 0;
+ }
+
+ void contents_push(char c)
+ {
+ if (m_clc_size == m_clc_capacity)
+ {
+ if (!m_clc_capacity) m_clc_capacity = 16;
+ else m_clc_capacity *= 2;
+
+ char* s = new char[m_clc_capacity + 1];
+ if (m_cur_lexeme_contents) strcpy(s, m_cur_lexeme_contents);
+
+ delete[] m_cur_lexeme_contents;
+ m_cur_lexeme_contents = s;
+ }
+
+ m_cur_lexeme_contents[m_clc_size++] = c;
+ m_cur_lexeme_contents[m_clc_size] = 0;
+ }
+
+ public:
+ explicit xpath_lexer(const char* query): m_cur(query)
+ {
+ m_clc_capacity = m_clc_size = 0;
+ m_cur_lexeme_contents = 0;
+
+ next();
+ }
+
+ ~xpath_lexer()
+ {
+ delete[] m_cur_lexeme_contents;
+ }
+
+ const char* state() const
+ {
+ return m_cur;
+ }
+
+ void reset(const char* state)
+ {
+ m_cur = state;
+ next();
+ }
+
+ void next()
+ {
+ contents_clear();
+
+ while (is_chartype(*m_cur, ct_space)) ++m_cur;
+
+ switch (*m_cur)
+ {
+ case 0:
+ m_cur_lexeme = lex_none;
+ break;
+
+ case '>':
+ if (*(m_cur+1) == '=')
+ {
+ m_cur += 2;
+ m_cur_lexeme = lex_greater_or_equal;
+ }
+ else
+ {
+ m_cur += 1;
+ m_cur_lexeme = lex_greater;
+ }
+ break;
+
+ case '<':
+ if (*(m_cur+1) == '=')
+ {
+ m_cur += 2;
+ m_cur_lexeme = lex_less_or_equal;
+ }
+ else
+ {
+ m_cur += 1;
+ m_cur_lexeme = lex_less;
+ }
+ break;
+
+ case '!':
+ if (*(m_cur+1) == '=')
+ {
+ m_cur += 2;
+ m_cur_lexeme = lex_not_equal;
+ }
+ else
+ {
+ m_cur_lexeme = lex_none;
+ }
+ break;
+
+ case '=':
+ m_cur += 1;
+ m_cur_lexeme = lex_equal;
+
+ break;
+
+ case '+':
+ m_cur += 1;
+ m_cur_lexeme = lex_plus;
+
+ break;
+
+ case '-':
+ m_cur += 1;
+ m_cur_lexeme = lex_minus;
+
+ break;
+
+ case '*':
+ m_cur += 1;
+ m_cur_lexeme = lex_multiply;
+
+ break;
+
+ case '|':
+ m_cur += 1;
+ m_cur_lexeme = lex_union;
+
+ break;
+
+ case '$':
+ m_cur += 1;
+ m_cur_lexeme = lex_var_ref;
+
+ break;
+
+ case '(':
+ m_cur += 1;
+ m_cur_lexeme = lex_open_brace;
+
+ break;
+
+ case ')':
+ m_cur += 1;
+ m_cur_lexeme = lex_close_brace;
+
+ break;
+
+ case '[':
+ m_cur += 1;
+ m_cur_lexeme = lex_open_square_brace;
+
+ break;
+
+ case ']':
+ m_cur += 1;
+ m_cur_lexeme = lex_close_square_brace;
+
+ break;
+
+ case ',':
+ m_cur += 1;
+ m_cur_lexeme = lex_comma;
+
+ break;
+
+ case '/':
+ if (*(m_cur+1) == '/')
+ {
+ m_cur += 2;
+ m_cur_lexeme = lex_double_slash;
+ }
+ else
+ {
+ m_cur += 1;
+ m_cur_lexeme = lex_slash;
+ }
+ break;
+
+ case '.':
+ if (*(m_cur+1) == '.')
+ {
+ m_cur += 2;
+ m_cur_lexeme = lex_double_dot;
+ }
+ else if (is_chartype(*(m_cur+1), ct_digit))
+ {
+ contents_push('0');
+ contents_push('.');
+
+ ++m_cur;
+
+ while (is_chartype(*m_cur, ct_digit))
+ contents_push(*m_cur++);
+
+ m_cur_lexeme = lex_number;
+ }
+ else
+ {
+ m_cur += 1;
+ m_cur_lexeme = lex_dot;
+ }
+ break;
+
+ case '@':
+ m_cur += 1;
+ m_cur_lexeme = lex_axis_attribute;
+
+ break;
+
+ case '"':
+ case '\'':
+ {
+ char terminator = *m_cur;
+
+ ++m_cur;
+
+ while (*m_cur && *m_cur != terminator)
+ contents_push(*m_cur++);
+
+ if (!*m_cur)
+ m_cur_lexeme = lex_none;
+ else
+ {
+ m_cur += 1;
+ m_cur_lexeme = lex_quoted_string;
+ }
+
+ break;
+ }
+
+ default:
+ if (is_chartype(*m_cur, ct_digit))
+ {
+ while (is_chartype(*m_cur, ct_digit))
+ contents_push(*m_cur++);
+
+ if (*m_cur == '.' && is_chartype(*(m_cur+1), ct_digit))
+ {
+ contents_push(*m_cur++);
+
+ while (is_chartype(*m_cur, ct_digit))
+ contents_push(*m_cur++);
+ }
+
+ m_cur_lexeme = lex_number;
+ }
+ else if (is_chartype(*m_cur, ct_start_symbol))
+ {
+ while (is_chartype(*m_cur, ct_symbol))
+ contents_push(*m_cur++);
+
+ while (is_chartype(*m_cur, ct_space)) ++m_cur;
+
+ m_cur_lexeme = lex_string;
+ }
+ else
+ {
+ throw xpath_exception("Unrecognized token");
+ }
+ }
+ }
+
+ lexeme_t current() const
+ {
+ return m_cur_lexeme;
+ }
+
+ const char* contents() const
+ {
+ return m_cur_lexeme_contents;
+ }
+ };
+
+ enum ast_type_t
+ {
+ ast_none,
+ ast_op_or, // left or right
+ ast_op_and, // left and right
+ ast_op_equal, // left = right
+ ast_op_not_equal, // left != right
+ ast_op_less, // left < right
+ ast_op_greater, // left > right
+ ast_op_less_or_equal, // left <= right
+ ast_op_greater_or_equal, // left >= right
+ ast_op_add, // left + right
+ ast_op_subtract, // left - right
+ ast_op_multiply, // left * right
+ ast_op_divide, // left / right
+ ast_op_mod, // left % right
+ ast_op_negate, // left - right
+ ast_op_union, // left | right
+ ast_predicate, // apply predicate to set; next points to next predicate
+ ast_filter, // select * from left where right
+ ast_filter_posinv, // select * from left where right; proximity position invariant
+ ast_variable, // variable value
+ ast_string_constant, // string constant
+ ast_number_constant, // number constant
+ ast_func_last, // last()
+ ast_func_position, // position()
+ ast_func_count, // count(left)
+ ast_func_id, // id(left)
+ ast_func_local_name_0, // local-name()
+ ast_func_local_name_1, // local-name(left)
+ ast_func_namespace_uri_0, // namespace-uri()
+ ast_func_namespace_uri_1, // namespace-uri(left)
+ ast_func_name_0, // name()
+ ast_func_name_1, // name(left)
+ ast_func_string_0, // string()
+ ast_func_string_1, // string(left)
+ ast_func_concat, // concat(left, right, siblings)
+ ast_func_starts_with, // starts_with(left, right)
+ ast_func_contains, // contains(left, right)
+ ast_func_substring_before, // substring-before(left, right)
+ ast_func_substring_after, // substring-after(left, right)
+ ast_func_substring_2, // substring(left, right)
+ ast_func_substring_3, // substring(left, right, third)
+ ast_func_string_length_0, // string-length()
+ ast_func_string_length_1, // string-length(left)
+ ast_func_normalize_space_0, // normalize-space()
+ ast_func_normalize_space_1, // normalize-space(left)
+ ast_func_translate, // translate(left, right, third)
+ ast_func_boolean, // boolean(left)
+ ast_func_not, // not(left)
+ ast_func_true, // true()
+ ast_func_false, // false()
+ ast_func_lang, // lang(left)
+ ast_func_number_0, // number()
+ ast_func_number_1, // number(left)
+ ast_func_sum, // sum(left)
+ ast_func_floor, // floor(left)
+ ast_func_ceiling, // ceiling(left)
+ ast_func_round, // round(left)
+ ast_step, // process set left with step
+ ast_step_root // select root node
+ };
+
+ enum ast_rettype_t
+ {
+ ast_type_none,
+ ast_type_node_set,
+ ast_type_number,
+ ast_type_string,
+ ast_type_boolean
+ };
+
+ enum axis_t
+ {
+ axis_ancestor,
+ axis_ancestor_or_self,
+ axis_attribute,
+ axis_child,
+ axis_descendant,
+ axis_descendant_or_self,
+ axis_following,
+ axis_following_sibling,
+ axis_namespace,
+ axis_parent,
+ axis_preceding,
+ axis_preceding_sibling,
+ axis_self
+ };
+
+ enum nodetest_t
+ {
+ nodetest_name,
+ nodetest_type_node,
+ nodetest_type_comment,
+ nodetest_type_pi,
+ nodetest_type_text,
+ nodetest_pi,
+ nodetest_all,
+ nodetest_all_in_namespace
+ };
+
+ template <axis_t N> struct axis_to_type
+ {
+ static const axis_t axis;
+ };
+
+ template <axis_t N> const axis_t axis_to_type<N>::axis = N;
+
+ class xpath_ast_node
+ {
+ private:
+ ast_type_t m_type;
+
+ ast_rettype_t m_rettype;
+
+ // tree node structure
+ xpath_ast_node* m_left;
+ xpath_ast_node* m_right;
+ xpath_ast_node* m_third;
+ xpath_ast_node* m_next;
+
+ // variable name for ast_variable
+ // string value for ast_constant
+ // node test for ast_step (node name/namespace/node type/pi target)
+ const char* m_contents;
+
+ // for t_step / t_predicate
+ axis_t m_axis;
+ nodetest_t m_test;
+
+ xpath_ast_node(const xpath_ast_node&);
+ xpath_ast_node& operator=(const xpath_ast_node&);
+
+ template <class Cbool, class Cdouble, class Cstring> struct compare_eq
+ {
+ static bool run(xpath_ast_node* lhs, xpath_ast_node* rhs, xpath_context& c)
+ {
+ if (lhs->rettype() != ast_type_node_set && rhs->rettype() != ast_type_node_set)
+ {
+ if (lhs->rettype() == ast_type_boolean || rhs->rettype() == ast_type_boolean)
+ return Cbool()(lhs->eval_boolean(c), rhs->eval_boolean(c));
+ else if (lhs->rettype() == ast_type_number || rhs->rettype() == ast_type_number)
+ return Cdouble()(lhs->eval_number(c), rhs->eval_number(c));
+ else if (lhs->rettype() == ast_type_string || rhs->rettype() == ast_type_string)
+ return Cstring()(lhs->eval_string(c), rhs->eval_string(c));
+ else
+ {
+ assert(!"Wrong types");
+ return false;
+ }
+ }
+ else if (lhs->rettype() == ast_type_node_set && rhs->rettype() == ast_type_node_set)
+ {
+ xpath_node_set ls = lhs->eval_node_set(c);
+ xpath_node_set rs = rhs->eval_node_set(c);
+
+ for (xpath_node_set::const_iterator li = ls.begin(); li != ls.end(); ++li)
+ for (xpath_node_set::const_iterator ri = rs.begin(); ri != rs.end(); ++ri)
+ {
+ if (Cstring()(string_value(*li), string_value(*ri)))
+ return true;
+ }
+
+ return false;
+ }
+ else if (lhs->rettype() != ast_type_node_set && rhs->rettype() == ast_type_node_set)
+ {
+ if (lhs->rettype() == ast_type_boolean)
+ return Cbool()(lhs->eval_boolean(c), rhs->eval_boolean(c));
+ else if (lhs->rettype() == ast_type_number)
+ {
+ double l = lhs->eval_number(c);
+ xpath_node_set rs = rhs->eval_node_set(c);
+
+ for (xpath_node_set::const_iterator ri = rs.begin(); ri != rs.end(); ++ri)
+ {
+ if (Cdouble()(l, convert_string_to_number(string_value(*ri).c_str())) == true)
+ return true;
+ }
+
+ return false;
+ }
+ else if (lhs->rettype() == ast_type_string)
+ {
+ std::string l = lhs->eval_string(c);
+ xpath_node_set rs = rhs->eval_node_set(c);
+
+ for (xpath_node_set::const_iterator ri = rs.begin(); ri != rs.end(); ++ri)
+ {
+ if (Cstring()(l, string_value(*ri)) == true)
+ return true;
+ }
+
+ return false;
+ }
+ else
+ {
+ assert(!"Wrong types");
+ return false;
+ }
+ }
+ else if (lhs->rettype() == ast_type_node_set && rhs->rettype() != ast_type_node_set)
+ {
+ if (rhs->rettype() == ast_type_boolean)
+ return Cbool()(lhs->eval_boolean(c), rhs->eval_boolean(c));
+ else if (rhs->rettype() == ast_type_number)
+ {
+ xpath_node_set ls = lhs->eval_node_set(c);
+ double r = rhs->eval_number(c);
+
+ for (xpath_node_set::const_iterator li = ls.begin(); li != ls.end(); ++li)
+ {
+ if (Cdouble()(convert_string_to_number(string_value(*li).c_str()), r) == true)
+ return true;
+ }
+
+ return false;
+ }
+ else if (rhs->rettype() == ast_type_string)
+ {
+ xpath_node_set ls = lhs->eval_node_set(c);
+ std::string r = rhs->eval_string(c);
+
+ for (xpath_node_set::const_iterator li = ls.begin(); li != ls.end(); ++li)
+ {
+ if (Cstring()(string_value(*li), r) == true)
+ return true;
+ }
+
+ return false;
+ }
+ else
+ {
+ assert(!"Wrong types");
+ return false;
+ }
+ }
+ else
+ {
+ assert(!"Wrong types");
+ return false;
+ }
+ }
+ };
+
+ template <class Cdouble> struct compare_rel
+ {
+ static bool run(xpath_ast_node* lhs, xpath_ast_node* rhs, xpath_context& c)
+ {
+ if (lhs->rettype() != ast_type_node_set && rhs->rettype() != ast_type_node_set)
+ return Cdouble()(lhs->eval_number(c), rhs->eval_number(c));
+ else if (lhs->rettype() == ast_type_node_set && rhs->rettype() == ast_type_node_set)
+ {
+ xpath_node_set ls = lhs->eval_node_set(c);
+ xpath_node_set rs = rhs->eval_node_set(c);
+
+ for (xpath_node_set::const_iterator li = ls.begin(); li != ls.end(); ++li)
+ {
+ double l = convert_string_to_number(string_value(*li).c_str());
+
+ for (xpath_node_set::const_iterator ri = rs.begin(); ri != rs.end(); ++ri)
+ {
+ if (Cdouble()(l, convert_string_to_number(string_value(*ri).c_str())) == true)
+ return true;
+ }
+ }
+
+ return false;
+ }
+ else if (lhs->rettype() != ast_type_node_set && rhs->rettype() == ast_type_node_set)
+ {
+ double l = lhs->eval_number(c);
+ xpath_node_set rs = rhs->eval_node_set(c);
+
+ for (xpath_node_set::const_iterator ri = rs.begin(); ri != rs.end(); ++ri)
+ {
+ if (Cdouble()(l, convert_string_to_number(string_value(*ri).c_str())) == true)
+ return true;
+ }
+
+ return false;
+ }
+ else if (lhs->rettype() == ast_type_node_set && rhs->rettype() != ast_type_node_set)
+ {
+ xpath_node_set ls = lhs->eval_node_set(c);
+ double r = rhs->eval_number(c);
+
+ for (xpath_node_set::const_iterator li = ls.begin(); li != ls.end(); ++li)
+ {
+ if (Cdouble()(convert_string_to_number(string_value(*li).c_str()), r) == true)
+ return true;
+ }
+
+ return false;
+ }
+ else
+ {
+ assert(!"Wrong types");
+ return false;
+ }
+ }
+ };
+
+ void apply_predicate(xpath_node_set& ns, size_t first, xpath_ast_node* expr, const xpath_context& context)
+ {
+ xpath_context c;
+ c.root = context.root;
+
+ size_t i = 0;
+ size_t size = ns.size() - first;
+
+ xpath_node_set::iterator last = ns.mut_begin() + first;
+
+ // remove_if... or well, sort of
+ for (xpath_node_set::iterator it = last; it != ns.end(); ++it, ++i)
+ {
+ c.n = *it;
+ c.position = i + 1;
+ c.size = size;
+
+ if (expr->rettype() == ast_type_number)
+ {
+ if (expr->eval_number(c) == i + 1)
+ *last++ = *it;
+ }
+ else if (expr->eval_boolean(c))
+ *last++ = *it;
+ }
+
+ ns.truncate(last);
+ }
+
+ void apply_predicates(xpath_node_set& ns, size_t first, const xpath_context& context)
+ {
+ if (ns.size() <= first) return;
+
+ for (xpath_ast_node* pred = m_right; pred; pred = pred->m_next)
+ {
+ apply_predicate(ns, first, pred->m_left, context);
+ }
+ }
+
+ void step_push(xpath_node_set& ns, const xml_attribute& a, const xml_node& parent)
+ {
+ // There are no attribute nodes corresponding to attributes that declare namespaces
+ // That is, "xmlns:..." or "xmlns"
+ if (!strncmp(a.name(), "xmlns", 5) && (a.name()[5] == 0 || a.name()[5] == ':')) return;
+
+ switch (m_test)
+ {
+ case nodetest_name:
+ if (!strcmp(a.name(), m_contents)) ns.push_back(xpath_node(a, parent));
+ break;
+
+ case nodetest_type_node:
+ case nodetest_all:
+ ns.push_back(xpath_node(a, parent));
+ break;
+
+ case nodetest_all_in_namespace:
+ if (!strncmp(a.name(), m_contents, strlen(m_contents)) && a.name()[strlen(m_contents)] == ':')
+ ns.push_back(xpath_node(a, parent));
+ break;
+
+ default:
+ ;
+ }
+ }
+
+ void step_push(xpath_node_set& ns, const xml_node& n)
+ {
+ switch (m_test)
+ {
+ case nodetest_name:
+ if (n.type() == node_element && !strcmp(n.name(), m_contents)) ns.push_back(n);
+ break;
+
+ case nodetest_type_node:
+ ns.push_back(n);
+ break;
+
+ case nodetest_type_comment:
+ if (n.type() == node_comment)
+ ns.push_back(n);
+ break;
+
+ case nodetest_type_text:
+ if (n.type() == node_pcdata || n.type() == node_cdata)
+ ns.push_back(n);
+ break;
+
+ case nodetest_type_pi:
+ if (n.type() == node_pi)
+ ns.push_back(n);
+ break;
+
+ case nodetest_pi:
+ if (n.type() == node_pi && !strcmp(n.name(), m_contents))
+ ns.push_back(n);
+ break;
+
+ case nodetest_all:
+ if (n.type() == node_element)
+ ns.push_back(n);
+ break;
+
+ case nodetest_all_in_namespace:
+ if (n.type() == node_element && !strncmp(n.name(), m_contents, strlen(m_contents)) &&
+ n.name()[strlen(m_contents)] == ':')
+ ns.push_back(n);
+ break;
+ }
+ }
+
+ template <class T> void step_fill(xpath_node_set& ns, const xml_node& n, T)
+ {
+ const axis_t axis = T::axis;
+
+ switch (axis)
+ {
+ case axis_attribute:
+ {
+ ns.m_type = ns.empty() ? xpath_node_set::type_sorted : xpath_node_set::type_unsorted;
+
+ for (xml_attribute a = n.first_attribute(); a; a = a.next_attribute())
+ step_push(ns, a, n);
+
+ break;
+ }
+
+ case axis_child:
+ {
+ ns.m_type = ns.empty() ? xpath_node_set::type_sorted : xpath_node_set::type_unsorted;
+
+ for (xml_node c = n.first_child(); c; c = c.next_sibling())
+ step_push(ns, c);
+
+ break;
+ }
+
+ case axis_descendant:
+ case axis_descendant_or_self:
+ {
+ ns.m_type = ns.empty() ? xpath_node_set::type_sorted : xpath_node_set::type_unsorted;
+
+ if (axis == axis_descendant_or_self)
+ step_push(ns, n);
+
+ xml_node cur = n.first_child();
+
+ if (cur)
+ {
+ do
+ {
+ step_push(ns, cur);
+
+ if (cur.first_child())
+ cur = cur.first_child();
+ else if (cur.next_sibling())
+ cur = cur.next_sibling();
+ else
+ {
+ // Borland C++ workaround
+ while (!cur.next_sibling() && cur != n && (bool)cur.parent())
+ cur = cur.parent();
+
+ if (cur != n)
+ cur = cur.next_sibling();
+ }
+ }
+ while (cur && cur != n);
+ }
+
+ break;
+ }
+
+ case axis_following_sibling:
+ {
+ ns.m_type = ns.empty() ? xpath_node_set::type_sorted : xpath_node_set::type_unsorted;
+
+ for (xml_node c = n.next_sibling(); c; c = c.next_sibling())
+ step_push(ns, c);
+
+ break;
+ }
+
+ case axis_preceding_sibling:
+ {
+ ns.m_type = ns.empty() ? xpath_node_set::type_sorted_reverse : xpath_node_set::type_unsorted;
+
+ for (xml_node c = n.previous_sibling(); c; c = c.previous_sibling())
+ step_push(ns, c);
+
+ break;
+ }
+
+ case axis_following:
+ {
+ ns.m_type = ns.empty() ? xpath_node_set::type_sorted : xpath_node_set::type_unsorted;
+
+ xml_node cur = n;
+
+ for (;;)
+ {
+ if (cur.first_child())
+ cur = cur.first_child();
+ else if (cur.next_sibling())
+ cur = cur.next_sibling();
+ else
+ {
+ while (cur && !cur.next_sibling()) cur = cur.parent();
+ cur = cur.next_sibling();
+
+ if (!cur) break;
+ }
+
+ step_push(ns, cur);
+ }
+
+ break;
+ }
+
+ case axis_preceding:
+ {
+ ns.m_type = ns.empty() ? xpath_node_set::type_sorted_reverse : xpath_node_set::type_unsorted;
+
+ xml_node cur = n;
+
+ while (cur && !cur.previous_sibling()) cur = cur.parent();
+ cur = cur.previous_sibling();
+
+ if (cur)
+ {
+ for (;;)
+ {
+ if (cur.last_child())
+ cur = cur.last_child();
+ else
+ {
+ // leaf node
+ step_push(ns, cur);
+
+ if (cur.previous_sibling())
+ cur = cur.previous_sibling();
+ else
+ {
+ do
+ {
+ cur = cur.parent();
+ if (!cur) break;
+
+ step_push(ns, cur);
+ }
+ while (!cur.previous_sibling());
+
+ cur = cur.previous_sibling();
+
+ if (!cur) break;
+ }
+ }
+ }
+ }
+
+ break;
+ }
+
+ case axis_ancestor:
+ case axis_ancestor_or_self:
+ {
+ ns.m_type = ns.empty() ? xpath_node_set::type_sorted_reverse : xpath_node_set::type_unsorted;
+
+ if (axis == axis_ancestor_or_self)
+ step_push(ns, n);
+
+ xml_node cur = n.parent();
+
+ while (cur)
+ {
+ step_push(ns, cur);
+
+ cur = cur.parent();
+ }
+
+ break;
+ }
+
+ default:
+ assert(!"Unimplemented axis");
+ }
+ }
+
+ template <class T> void step_fill(xpath_node_set& ns, const xml_attribute& a, const xml_node& p, T)
+ {
+ const axis_t axis = T::axis;
+
+ switch (axis)
+ {
+ case axis_ancestor:
+ case axis_ancestor_or_self:
+ {
+ ns.m_type = ns.empty() ? xpath_node_set::type_sorted_reverse : xpath_node_set::type_unsorted;
+
+ if (axis == axis_ancestor_or_self)
+ step_push(ns, a, p);
+
+ xml_node cur = p;
+
+ while (cur)
+ {
+ step_push(ns, cur);
+
+ cur = cur.parent();
+ }
+
+ break;
+ }
+
+ default:
+ assert(!"Unimplemented axis");
+ }
+ }
+
+ template <class T> void step_do(xpath_node_set& ns, xpath_context& c, T v)
+ {
+ const axis_t axis = T::axis;
+
+ switch (axis)
+ {
+ case axis_parent:
+ if (m_left)
+ {
+ xpath_node_set s = m_left->eval_node_set(c);
+
+ for (xpath_node_set::const_iterator it = s.begin(); it != s.end(); ++it)
+ {
+ xml_node p = it->parent();
+ if (p)
+ {
+ size_t s = ns.size();
+
+ step_push(ns, p);
+
+ apply_predicates(ns, s, c);
+ }
+ }
+ }
+ else
+ {
+ xml_node p = c.n.parent();
+ if (p)
+ {
+ step_push(ns, p);
+
+ apply_predicates(ns, 0, c);
+ }
+ }
+
+ break;
+
+ case axis_self:
+ if (m_left)
+ {
+ xpath_node_set s = m_left->eval_node_set(c);
+
+ for (xpath_node_set::const_iterator it = s.begin(); it != s.end(); ++it)
+ {
+ size_t s = ns.size();
+
+ if (it->attribute()) step_push(ns, it->attribute(), it->parent());
+ else step_push(ns, it->node());
+
+ apply_predicates(ns, s, c);
+ }
+ }
+ else
+ {
+ if (c.n.node()) step_push(ns, c.n.node());
+ else step_push(ns, c.n.attribute(), c.n.parent());
+
+ apply_predicates(ns, 0, c);
+ }
+
+ break;
+
+ case axis_namespace:
+ break;
+
+ case axis_ancestor:
+ case axis_ancestor_or_self:
+ if (m_left)
+ {
+ xpath_node_set s = m_left->eval_node_set(c);
+
+ for (xpath_node_set::const_iterator it = s.begin(); it != s.end(); ++it)
+ {
+ size_t s = ns.size();
+
+ if (it->node())
+ step_fill(ns, it->node(), v);
+ else
+ step_fill(ns, it->attribute(), it->parent(), v);
+
+ apply_predicates(ns, s, c);
+ }
+ }
+ else
+ {
+ if (c.n.node()) step_fill(ns, c.n.node(), v);
+ else step_fill(ns, c.n.attribute(), c.n.parent(), v);
+
+ apply_predicates(ns, 0, c);
+ }
+
+ break;
+
+ case axis_following:
+ case axis_following_sibling:
+ case axis_preceding:
+ case axis_preceding_sibling:
+ case axis_attribute:
+ case axis_child:
+ case axis_descendant:
+ case axis_descendant_or_self:
+ if (m_left)
+ {
+ xpath_node_set s = m_left->eval_node_set(c);
+
+ for (xpath_node_set::const_iterator it = s.begin(); it != s.end(); ++it)
+ {
+ size_t s = ns.size();
+
+ if (it->node())
+ step_fill(ns, it->node(), v);
+
+ apply_predicates(ns, s, c);
+ }
+ }
+ else if (c.n.node())
+ {
+ step_fill(ns, c.n.node(), v);
+
+ apply_predicates(ns, 0, c);
+ }
+
+ break;
+
+ default:
+ assert(!"Unimplemented axis");
+ }
+ }
+
+ void set_contents(const char* value, xpath_allocator& a)
+ {
+ if (value)
+ {
+ char* c = static_cast<char*>(a.alloc(strlen(value) + 1));
+ strcpy(c, value);
+ m_contents = c;
+ }
+ else m_contents = 0;
+ }
+ public:
+ xpath_ast_node(ast_type_t type, const char* contents, xpath_allocator& a): m_type(type), m_rettype(ast_type_none), m_contents(0)
+ {
+ set_contents(contents, a);
+ }
+
+ xpath_ast_node(ast_type_t type, xpath_ast_node* left, xpath_ast_node* right, axis_t axis): m_type(type),
+ m_rettype(ast_type_none), m_left(left), m_right(right), m_third(0), m_next(0), m_contents(0),
+ m_axis(axis)
+ {
+ }
+
+ xpath_ast_node(ast_type_t type, xpath_ast_node* left = 0, xpath_ast_node* right = 0, xpath_ast_node* third = 0): m_type(type),
+ m_rettype(ast_type_none), m_left(left), m_right(right), m_third(third), m_next(0), m_contents(0)
+ {
+ }
+
+ xpath_ast_node(ast_type_t type, xpath_ast_node* left, axis_t axis, nodetest_t test, const char* contents, xpath_allocator& a):
+ m_type(type), m_rettype(ast_type_none), m_left(left), m_right(0), m_third(0), m_next(0),
+ m_contents(0), m_axis(axis), m_test(test)
+ {
+ set_contents(contents, a);
+ }
+
+ void set_next(xpath_ast_node* value)
+ {
+ m_next = value;
+ }
+
+ void set_right(xpath_ast_node* value)
+ {
+ m_right = value;
+ }
+
+ bool eval_boolean(xpath_context& c)
+ {
+ switch (m_type)
+ {
+ case ast_op_or:
+ if (m_left->eval_boolean(c)) return true;
+ else return m_right->eval_boolean(c);
+
+ case ast_op_and:
+ if (!m_left->eval_boolean(c)) return false;
+ else return m_right->eval_boolean(c);
+
+ case ast_op_equal:
+ return compare_eq<equal_to<bool>, equal_to<double>, equal_to<std::string> >::run(m_left, m_right, c);
+
+ case ast_op_not_equal:
+ return compare_eq<not_equal_to<bool>, not_equal_to<double>, not_equal_to<std::string> >::run(m_left, m_right, c);
+
+ case ast_op_less:
+ return compare_rel<less<double> >::run(m_left, m_right, c);
+
+ case ast_op_greater:
+ return compare_rel<greater<double> >::run(m_left, m_right, c);
+
+ case ast_op_less_or_equal:
+ return compare_rel<less_equal<double> >::run(m_left, m_right, c);
+
+ case ast_op_greater_or_equal:
+ return compare_rel<greater_equal<double> >::run(m_left, m_right, c);
+
+ case ast_func_starts_with:
+ return starts_with(m_left->eval_string(c), m_right->eval_string(c).c_str());
+
+ case ast_func_contains:
+ return m_left->eval_string(c).find(m_right->eval_string(c)) != std::string::npos;
+
+ case ast_func_boolean:
+ return m_left->eval_boolean(c);
+
+ case ast_func_not:
+ return !m_left->eval_boolean(c);
+
+ case ast_func_true:
+ return true;
+
+ case ast_func_false:
+ return false;
+
+ case ast_func_lang:
+ {
+ if (c.n.attribute()) return false;
+
+ std::string lang = m_left->eval_string(c);
+
+ xml_node n = c.n.node();
+
+ while (n.type() != node_document)
+ {
+ xml_attribute a = n.attribute("xml:lang");
+
+ if (a)
+ {
+ const char* value = a.value();
+
+ // strnicmp / strncasecmp is not portable
+ for (std::string::iterator it = lang.begin(); it != lang.end(); ++it)
+ {
+ if (tolower(*it) != tolower(*value)) return false;
+ ++value;
+ }
+
+ return *value == 0 || *value == '-';
+ }
+ }
+
+ return false;
+ }
+
+ default:
+ {
+ switch (m_rettype)
+ {
+ case ast_type_number:
+ return convert_number_to_boolean(eval_number(c));
+
+ case ast_type_string:
+ return !eval_string(c).empty();
+
+ case ast_type_node_set:
+ return !eval_node_set(c).empty();
+
+ default:
+ assert(!"Wrong expression for ret type boolean");
+ return false;
+ }
+ }
+ }
+ }
+
+ double eval_number(xpath_context& c)
+ {
+ switch (m_type)
+ {
+ case ast_op_add:
+ return m_left->eval_number(c) + m_right->eval_number(c);
+
+ case ast_op_subtract:
+ return m_left->eval_number(c) - m_right->eval_number(c);
+
+ case ast_op_multiply:
+ return m_left->eval_number(c) * m_right->eval_number(c);
+
+ case ast_op_divide:
+ return m_left->eval_number(c) / m_right->eval_number(c);
+
+ case ast_op_mod:
+ return fmod(m_left->eval_number(c), m_right->eval_number(c));
+
+ case ast_op_negate:
+ return -m_left->eval_number(c);
+
+ case ast_number_constant:
+ return convert_string_to_number(m_contents);
+
+ case ast_func_last:
+ return (double)c.size;
+
+ case ast_func_position:
+ return (double)c.position;
+
+ case ast_func_count:
+ return (double)m_left->eval_node_set(c).size();
+
+ case ast_func_string_length_0:
+ return (double)string_value(c.n).size();
+
+ case ast_func_string_length_1:
+ return (double)m_left->eval_string(c).size();
+
+ case ast_func_number_0:
+ return convert_string_to_number(string_value(c.n).c_str());
+
+ case ast_func_number_1:
+ return m_left->eval_number(c);
+
+ case ast_func_sum:
+ {
+ double r = 0;
+
+ xpath_node_set ns = m_left->eval_node_set(c);
+
+ for (xpath_node_set::const_iterator it = ns.begin(); it != ns.end(); ++it)
+ r += convert_string_to_number(string_value(*it).c_str());
+
+ return r;
+ }
+
+ case ast_func_floor:
+ {
+ double r = m_left->eval_number(c);
+
+ return r == r ? floor(r) : r;
+ }
+
+ case ast_func_ceiling:
+ {
+ double r = m_left->eval_number(c);
+
+ return r == r ? ceil(r) : r;
+ }
+
+ case ast_func_round:
+ // correct except for negative zero (it returns positive zero instead of negative)
+ return ieee754_round(m_left->eval_number(c));
+
+ default:
+ {
+ switch (m_rettype)
+ {
+ case ast_type_boolean:
+ return eval_boolean(c) ? 1 : 0;
+
+ case ast_type_string:
+ return convert_string_to_number(eval_string(c).c_str());
+
+ case ast_type_node_set:
+ return convert_string_to_number(eval_string(c).c_str());
+
+ default:
+ assert(!"Wrong expression for ret type number");
+ return 0;
+ }
+
+ }
+ }
+ }
+
+ std::string eval_string(xpath_context& c)
+ {
+ switch (m_type)
+ {
+ case ast_string_constant:
+ return m_contents;
+
+ case ast_func_local_name_0:
+ {
+ xpath_node na = c.n;
+
+ if (na.attribute()) return local_name(na.attribute().name());
+ else return local_name(na.node().name());
+ }
+
+ case ast_func_local_name_1:
+ {
+ xpath_node_set ns = m_left->eval_node_set(c);
+ if (ns.empty()) return "";
+
+ xpath_node na = ns.first();
+
+ if (na.attribute()) return local_name(na.attribute().name());
+ else return local_name(na.node().name());
+ }
+
+ case ast_func_name_0:
+ {
+ xpath_node na = c.n;
+
+ if (na.attribute()) return na.attribute().name();
+ else return na.node().name();
+ }
+
+ case ast_func_name_1:
+ {
+ xpath_node_set ns = m_left->eval_node_set(c);
+ if (ns.empty()) return "";
+
+ xpath_node na = ns.first();
+
+ if (na.attribute()) return na.attribute().name();
+ else return na.node().name();
+ }
+
+ case ast_func_namespace_uri_0:
+ {
+ xpath_node na = c.n;
+
+ if (na.attribute()) return namespace_uri(na.attribute(), na.parent());
+ else return namespace_uri(na.node());
+ }
+
+ case ast_func_namespace_uri_1:
+ {
+ xpath_node_set ns = m_left->eval_node_set(c);
+ if (ns.empty()) return "";
+
+ xpath_node na = ns.first();
+
+ if (na.attribute()) return namespace_uri(na.attribute(), na.parent());
+ else return namespace_uri(na.node());
+ }
+
+ case ast_func_string_0:
+ return string_value(c.n);
+
+ case ast_func_string_1:
+ return m_left->eval_string(c);
+
+ case ast_func_concat:
+ {
+ std::string r = m_left->eval_string(c);
+
+ for (xpath_ast_node* n = m_right; n; n = n->m_next)
+ r += n->eval_string(c);
+
+ return r;
+ }
+
+ case ast_func_substring_before:
+ {
+ std::string s = m_left->eval_string(c);
+ std::string::size_type pos = s.find(m_right->eval_string(c));
+
+ if (pos == std::string::npos) return "";
+ else return std::string(s.begin(), s.begin() + pos);
+ }
+
+ case ast_func_substring_after:
+ {
+ std::string s = m_left->eval_string(c);
+ std::string p = m_right->eval_string(c);
+
+ std::string::size_type pos = s.find(p);
+
+ if (pos == std::string::npos) return "";
+ else return std::string(s.begin() + pos + p.length(), s.end());
+ }
+
+ case ast_func_substring_2:
+ {
+ std::string s = m_left->eval_string(c);
+ double first = ieee754_round(m_right->eval_number(c));
+
+ if (is_nan(first)) return ""; // NaN
+ else if (first >= s.length() + 1) return "";
+
+ size_t pos = first < 1 ? 1 : (size_t)first;
+
+ return s.substr(pos - 1);
+ }
+
+ case ast_func_substring_3:
+ {
+ std::string s = m_left->eval_string(c);
+ double first = ieee754_round(m_right->eval_number(c));
+ double last = first + ieee754_round(m_third->eval_number(c));
+
+ if (is_nan(first) || is_nan(last)) return "";
+ else if (first >= s.length() + 1) return "";
+ else if (first >= last) return "";
+
+ size_t pos = first < 1 ? 1 : (size_t)first;
+ size_t end = last >= s.length() + 1 ? s.length() + 1 : (size_t)last;
+
+ size_t size_requested = end - pos;
+ size_t size_to_end = s.length() - pos + 1;
+
+ return s.substr(pos - 1, size_requested < size_to_end ? size_requested : size_to_end);
+ }
+
+ case ast_func_normalize_space_0:
+ case ast_func_normalize_space_1:
+ {
+ std::string s = m_type == ast_func_normalize_space_0 ? string_value(c.n) : m_left->eval_string(c);
+
+ std::string r;
+ r.reserve(s.size());
+
+ for (std::string::const_iterator it = s.begin(); it != s.end(); ++it)
+ {
+ if (is_chartype(*it, ct_space))
+ {
+ if (!r.empty() && r[r.size() - 1] != ' ')
+ r += ' ';
+ }
+ else r += *it;
+ }
+
+ std::string::size_type pos = r.find_last_not_of(' ');
+ if (pos == std::string::npos) r = "";
+ else r.erase(r.begin() + pos + 1, r.end());
+
+ return r;
+ }
+
+ case ast_func_translate:
+ {
+ std::string s = m_left->eval_string(c);
+ std::string from = m_right->eval_string(c);
+ std::string to = m_third->eval_string(c);
+
+ for (std::string::iterator it = s.begin(); it != s.end(); )
+ {
+ std::string::size_type pos = from.find(*it);
+
+ if (pos != std::string::npos && pos >= to.length())
+ it = s.erase(it);
+ else if (pos != std::string::npos)
+ *it = to[pos];
+ }
+
+ return s;
+ }
+
+ default:
+ {
+ switch (m_rettype)
+ {
+ case ast_type_boolean:
+ return eval_boolean(c) ? "true" : "false";
+
+ case ast_type_number:
+ return convert_number_to_string(eval_number(c));
+
+ case ast_type_node_set:
+ {
+ xpath_node_set ns = eval_node_set(c);
+ return ns.empty() ? std::string("") : string_value(ns.first());
+ }
+
+ default:
+ assert(!"Wrong expression for ret type string");
+ return "";
+ }
+ }
+ }
+ }
+
+ xpath_node_set eval_node_set(xpath_context& c)
+ {
+ switch (m_type)
+ {
+ case ast_op_union:
+ {
+ xpath_node_set ls = m_left->eval_node_set(c);
+ xpath_node_set rs = m_right->eval_node_set(c);
+
+ ls.append(rs.begin(), rs.end());
+
+ ls.remove_duplicates();
+
+ return ls;
+ }
+
+ case ast_filter:
+ {
+ xpath_node_set set = m_left->eval_node_set(c);
+ set.sort();
+
+ xpath_context oc = c;
+
+ size_t i = 0;
+
+ xpath_node_set::iterator last = set.mut_begin();
+
+ // remove_if... or well, sort of
+ for (xpath_node_set::const_iterator it = set.begin(); it != set.end(); ++it, ++i)
+ {
+ c.n = *it;
+ c.position = i + 1;
+ c.size = set.size();
+
+ if (m_right->rettype() == ast_type_number)
+ {
+ if (m_right->eval_number(c) == i + 1)
+ *last++ = *it;
+ }
+ else if (m_right->eval_boolean(c))
+ *last++ = *it;
+ }
+
+ c = oc;
+
+ set.truncate(last);
+
+ return set;
+ }
+
+ case ast_filter_posinv:
+ {
+ xpath_node_set set = m_left->eval_node_set(c);
+
+ xpath_context oc = c;
+
+ size_t i = 0;
+
+ xpath_node_set::iterator last = set.mut_begin();
+
+ // remove_if... or well, sort of
+ for (xpath_node_set::const_iterator it = set.begin(); it != set.end(); ++it, ++i)
+ {
+ c.n = *it;
+ c.position = i + 1;
+ c.size = set.size();
+
+ if (m_right->eval_boolean(c))
+ *last++ = *it;
+ }
+
+ c = oc;
+
+ set.truncate(last);
+
+ return set;
+ }
+
+ case ast_func_id:
+ return xpath_node_set();
+
+ case ast_step:
+ {
+ xpath_node_set ns;
+
+ switch (m_axis)
+ {
+ case axis_ancestor:
+ step_do(ns, c, axis_to_type<axis_ancestor>());
+ break;
+
+ case axis_ancestor_or_self:
+ step_do(ns, c, axis_to_type<axis_ancestor_or_self>());
+ break;
+
+ case axis_attribute:
+ step_do(ns, c, axis_to_type<axis_attribute>());
+ break;
+
+ case axis_child:
+ step_do(ns, c, axis_to_type<axis_child>());
+ break;
+
+ case axis_descendant:
+ step_do(ns, c, axis_to_type<axis_descendant>());
+ break;
+
+ case axis_descendant_or_self:
+ step_do(ns, c, axis_to_type<axis_descendant_or_self>());
+ break;
+
+ case axis_following:
+ step_do(ns, c, axis_to_type<axis_following>());
+ break;
+
+ case axis_following_sibling:
+ step_do(ns, c, axis_to_type<axis_following_sibling>());
+ break;
+
+ case axis_namespace:
+ step_do(ns, c, axis_to_type<axis_namespace>());
+ break;
+
+ case axis_parent:
+ step_do(ns, c, axis_to_type<axis_parent>());
+ break;
+
+ case axis_preceding:
+ step_do(ns, c, axis_to_type<axis_preceding>());
+ break;
+
+ case axis_preceding_sibling:
+ step_do(ns, c, axis_to_type<axis_preceding_sibling>());
+ break;
+
+ case axis_self:
+ step_do(ns, c, axis_to_type<axis_self>());
+ break;
+
+ default:
+ assert(!"Axis not implemented");
+ return xpath_node_set();
+ }
+
+ ns.remove_duplicates();
+
+ return ns;
+ }
+
+ case ast_step_root:
+ {
+ xpath_node_set ns;
+
+ ns.push_back(c.root);
+
+ apply_predicates(ns, 0, c);
+
+ return ns;
+ }
+
+ default:
+ assert(!"Wrong expression for ret type node set");
+ return xpath_node_set();
+ }
+ }
+
+ bool contains(ast_type_t type)
+ {
+ if (m_type == type) return true;
+
+ switch (m_type)
+ {
+ case ast_op_or:
+ case ast_op_and:
+ case ast_op_equal:
+ case ast_op_not_equal:
+ case ast_op_less:
+ case ast_op_greater:
+ case ast_op_less_or_equal:
+ case ast_op_greater_or_equal:
+ case ast_op_add:
+ case ast_op_subtract:
+ case ast_op_multiply:
+ case ast_op_divide:
+ case ast_op_mod:
+ case ast_op_negate:
+ return m_left->contains(type) || m_right->contains(type);
+
+ case ast_op_union:
+ case ast_predicate:
+ case ast_filter:
+ case ast_filter_posinv:
+ return false;
+
+ case ast_variable:
+ throw xpath_exception("Semantics error: variables are not supported");
+
+ case ast_string_constant:
+ case ast_number_constant:
+ case ast_func_last:
+ case ast_func_position:
+ return false;
+
+ case ast_func_count:
+ case ast_func_id:
+ case ast_func_local_name_0:
+ case ast_func_local_name_1:
+ case ast_func_namespace_uri_0:
+ case ast_func_namespace_uri_1:
+ case ast_func_name_0:
+ case ast_func_name_1:
+ case ast_func_string_0:
+ case ast_func_string_1:
+ if (m_left) return m_left->contains(type);
+ return false;
+
+ case ast_func_concat:
+ {
+ if (m_left->contains(type)) return true;
+
+ for (xpath_ast_node* n = m_right; n; n = n->m_next)
+ if (n->contains(type)) return true;
+
+ return false;
+ }
+
+ case ast_func_starts_with:
+ case ast_func_contains:
+ case ast_func_substring_before:
+ case ast_func_substring_after:
+ case ast_func_substring_2:
+ case ast_func_substring_3:
+ case ast_func_string_length_0:
+ case ast_func_string_length_1:
+ case ast_func_normalize_space_0:
+ case ast_func_normalize_space_1:
+ case ast_func_translate:
+ case ast_func_boolean:
+ case ast_func_not:
+ case ast_func_true:
+ case ast_func_false:
+ case ast_func_lang:
+ case ast_func_number_0:
+ case ast_func_number_1:
+ case ast_func_sum:
+ case ast_func_floor:
+ case ast_func_ceiling:
+ case ast_func_round:
+ if (m_left && m_left->contains(type)) return true;
+ if (m_right && m_right->contains(type)) return true;
+ if (m_third && m_third->contains(type)) return true;
+
+ return false;
+
+ case ast_step:
+ case ast_step_root:
+ return false;
+
+ default:
+ throw xpath_exception("Unknown semantics error");
+#ifdef __DMC__
+ return false; // Digital Mars C++
+#endif
+ }
+ }
+
+ void check_semantics()
+ {
+ switch (m_type)
+ {
+ case ast_op_or:
+ case ast_op_and:
+ case ast_op_equal:
+ case ast_op_not_equal:
+ case ast_op_less:
+ case ast_op_greater:
+ case ast_op_less_or_equal:
+ case ast_op_greater_or_equal:
+ m_left->check_semantics();
+ m_right->check_semantics();
+ m_rettype = ast_type_boolean;
+ break;
+
+ case ast_op_add:
+ case ast_op_subtract:
+ case ast_op_multiply:
+ case ast_op_divide:
+ case ast_op_mod:
+ m_left->check_semantics();
+ m_right->check_semantics();
+ m_rettype = ast_type_number;
+ break;
+
+ case ast_op_negate:
+ m_left->check_semantics();
+ m_rettype = ast_type_number;
+ break;
+
+ case ast_op_union:
+ m_left->check_semantics();
+ m_right->check_semantics();
+ if (m_left->rettype() != ast_type_node_set || m_right->rettype() != ast_type_node_set)
+ throw xpath_exception("Semantics error: union operator has to be applied to node sets");
+ m_rettype = ast_type_node_set;
+ break;
+
+ case ast_filter:
+ case ast_filter_posinv:
+ m_left->check_semantics();
+ m_right->check_semantics();
+ if (m_left->rettype() != ast_type_node_set)
+ throw xpath_exception("Semantics error: predicate has to be applied to node set");
+ m_rettype = ast_type_node_set;
+
+ if (!m_right->contains(ast_func_position) && m_right->rettype() != ast_type_number)
+ m_type = ast_filter_posinv;
+ break;
+
+ case ast_predicate:
+ m_left->check_semantics();
+ m_rettype = ast_type_node_set;
+ break;
+
+ case ast_variable:
+ throw xpath_exception("Semantics error: variable are not supported");
+
+ case ast_string_constant:
+ m_rettype = ast_type_string;
+ break;
+
+ case ast_number_constant:
+ m_rettype = ast_type_number;
+ break;
+
+ case ast_func_last:
+ case ast_func_position:
+ m_rettype = ast_type_number;
+ break;
+
+ case ast_func_count:
+ m_left->check_semantics();
+ if (m_left->rettype() != ast_type_node_set)
+ throw xpath_exception("Semantics error: count() has to be applied to node set");
+ m_rettype = ast_type_number;
+ break;
+
+ case ast_func_id:
+ m_left->check_semantics();
+ m_rettype = ast_type_node_set;
+ break;
+
+ case ast_func_local_name_0:
+ case ast_func_local_name_1:
+ case ast_func_namespace_uri_0:
+ case ast_func_namespace_uri_1:
+ case ast_func_name_0:
+ case ast_func_name_1:
+ if (m_left)
+ {
+ m_left->check_semantics();
+ if (m_left->rettype() != ast_type_node_set)
+ throw xpath_exception("Semantics error: function has to be applied to node set");
+ }
+ m_rettype = ast_type_string;
+ break;
+
+ case ast_func_string_0:
+ case ast_func_string_1:
+ if (m_left) m_left->check_semantics();
+ m_rettype = ast_type_string;
+ break;
+
+ case ast_func_concat:
+ {
+ m_left->check_semantics();
+
+ for (xpath_ast_node* n = m_right; n; n = n->m_next)
+ n->check_semantics();
+
+ m_rettype = ast_type_string;
+ break;
+ }
+
+ case ast_func_starts_with:
+ case ast_func_contains:
+ m_left->check_semantics();
+ m_right->check_semantics();
+ m_rettype = ast_type_boolean;
+ break;
+
+ case ast_func_substring_before:
+ case ast_func_substring_after:
+ case ast_func_substring_2:
+ case ast_func_substring_3:
+ m_left->check_semantics();
+ m_right->check_semantics();
+ if (m_third) m_third->check_semantics();
+ m_rettype = ast_type_string;
+ break;
+
+ case ast_func_string_length_0:
+ case ast_func_string_length_1:
+ if (m_left) m_left->check_semantics();
+ m_rettype = ast_type_number;
+ break;
+
+ case ast_func_normalize_space_0:
+ case ast_func_normalize_space_1:
+ case ast_func_translate:
+ if (m_left) m_left->check_semantics();
+ if (m_right) m_right->check_semantics();
+ if (m_third) m_third->check_semantics();
+ m_rettype = ast_type_string;
+ break;
+
+ case ast_func_boolean:
+ case ast_func_not:
+ case ast_func_true:
+ case ast_func_false:
+ case ast_func_lang:
+ if (m_left) m_left->check_semantics();
+ m_rettype = ast_type_boolean;
+ break;
+
+ case ast_func_number_0:
+ case ast_func_number_1:
+ if (m_left) m_left->check_semantics();
+ m_rettype = ast_type_number;
+ break;
+
+ case ast_func_sum:
+ m_left->check_semantics();
+ if (m_left->rettype() != ast_type_node_set)
+ throw xpath_exception("Semantics error: sum() has to be applied to node set");
+ m_rettype = ast_type_number;
+ break;
+
+ case ast_func_floor:
+ case ast_func_ceiling:
+ case ast_func_round:
+ if (m_left) m_left->check_semantics();
+ m_rettype = ast_type_number;
+ break;
+
+ case ast_step:
+ {
+ if (m_left)
+ {
+ m_left->check_semantics();
+ if (m_left->rettype() != ast_type_node_set)
+ throw xpath_exception("Semantics error: step has to be applied to node set");
+ }
+
+ for (xpath_ast_node* n = m_right; n; n = n->m_next)
+ n->check_semantics();
+
+ m_rettype = ast_type_node_set;
+ break;
+ }
+
+ case ast_step_root:
+ m_rettype = ast_type_node_set;
+ break;
+
+ default:
+ throw xpath_exception("Unknown semantics error");
+ }
+ }
+
+ ast_rettype_t rettype() const
+ {
+ return m_rettype;
+ }
+ };
+
+ void* xpath_allocator::node()
+ {
+ return alloc(sizeof(xpath_ast_node));
+ }
+
+ class xpath_parser
+ {
+ private:
+ xpath_allocator& m_alloc;
+ xpath_lexer m_lexer;
+
+ xpath_parser(const xpath_parser&);
+ xpath_parser& operator=(const xpath_parser&);
+
+ // PrimaryExpr ::= VariableReference | '(' Expr ')' | Literal | Number | FunctionCall
+ xpath_ast_node* parse_primary_expression()
+ {
+ switch (m_lexer.current())
+ {
+ case lex_var_ref:
+ {
+ m_lexer.next();
+
+ if (m_lexer.current() != lex_string)
+ throw xpath_exception("incorrect variable reference");
+
+ xpath_ast_node* n = new (m_alloc.node()) xpath_ast_node(ast_variable, m_lexer.contents(), m_alloc);
+ m_lexer.next();
+
+ return n;
+ }
+
+ case lex_open_brace:
+ {
+ m_lexer.next();
+
+ xpath_ast_node* n = parse_expression();
+
+ if (m_lexer.current() != lex_close_brace)
+ throw xpath_exception("unmatched braces");
+
+ m_lexer.next();
+
+ return n;
+ }
+
+ case lex_quoted_string:
+ {
+ xpath_ast_node* n = new (m_alloc.node()) xpath_ast_node(ast_string_constant, m_lexer.contents(), m_alloc);
+ m_lexer.next();
+
+ return n;
+ }
+
+ case lex_number:
+ {
+ xpath_ast_node* n = new (m_alloc.node()) xpath_ast_node(ast_number_constant, m_lexer.contents(), m_alloc);
+ m_lexer.next();
+
+ return n;
+ }
+
+ case lex_string:
+ {
+ xpath_ast_node* args[4];
+ size_t argc = 0;
+
+ std::string function = m_lexer.contents();
+ m_lexer.next();
+
+ bool func_concat = (function == "concat");
+ xpath_ast_node* last_concat = 0;
+
+ if (m_lexer.current() != lex_open_brace)
+ throw xpath_exception("Unrecognized function call");
+ m_lexer.next();
+
+ if (m_lexer.current() != lex_close_brace)
+ args[argc++] = parse_expression();
+
+ while (m_lexer.current() != lex_close_brace)
+ {
+ if (m_lexer.current() != lex_comma)
+ throw xpath_exception("no comma between function arguments");
+ m_lexer.next();
+
+ xpath_ast_node* n = parse_expression();
+
+ if (func_concat)
+ {
+ if (argc < 2) args[argc++] = last_concat = n;
+ else
+ {
+ last_concat->set_next(n);
+ last_concat = n;
+ }
+ }
+ else if (argc >= 4)
+ throw xpath_exception("Too many function arguments");
+ else
+ args[argc++] = n;
+ }
+
+ m_lexer.next();
+
+ ast_type_t type = ast_none;
+
+ switch (function[0])
+ {
+ case 'b':
+ {
+ if (function == "boolean" && argc == 1)
+ type = ast_func_boolean;
+
+ break;
+ }
+
+ case 'c':
+ {
+ if (function == "count" && argc == 1)
+ type = ast_func_count;
+ else if (function == "contains" && argc == 2)
+ type = ast_func_contains;
+ else if (function == "concat" && argc == 2)
+ {
+ // set_next was done earlier
+ return new (m_alloc.node()) xpath_ast_node(ast_func_concat, args[0], args[1]);
+ }
+ else if (function == "ceiling" && argc == 1)
+ type = ast_func_ceiling;
+
+ break;
+ }
+
+ case 'f':
+ {
+ if (function == "false" && argc == 0)
+ type = ast_func_false;
+ else if (function == "floor" && argc == 1)
+ type = ast_func_floor;
+
+ break;
+ }
+
+ case 'i':
+ {
+ if (function == "id" && argc == 1)
+ type = ast_func_id;
+
+ break;
+ }
+
+ case 'l':
+ {
+ if (function == "last" && argc == 0)
+ type = ast_func_last;
+ else if (function == "lang" && argc == 1)
+ type = ast_func_lang;
+ else if (function == "local-name" && argc <= 1)
+ type = argc == 0 ? ast_func_local_name_0 : ast_func_local_name_1;
+
+ break;
+ }
+
+ case 'n':
+ {
+ if (function == "name" && argc <= 1)
+ type = argc == 0 ? ast_func_name_0 : ast_func_name_1;
+ else if (function == "namespace-uri" && argc <= 1)
+ type = argc == 0 ? ast_func_namespace_uri_0 : ast_func_namespace_uri_1;
+ else if (function == "normalize-space" && argc <= 1)
+ type = argc == 0 ? ast_func_normalize_space_0 : ast_func_normalize_space_1;
+ else if (function == "not" && argc == 1)
+ type = ast_func_not;
+ else if (function == "number" && argc <= 1)
+ type = argc == 0 ? ast_func_number_0 : ast_func_number_1;
+
+ break;
+ }
+
+ case 'p':
+ {
+ if (function == "position" && argc == 0)
+ type = ast_func_position;
+
+ break;
+ }
+
+ case 'r':
+ {
+ if (function == "round" && argc == 1)
+ type = ast_func_round;
+
+ break;
+ }
+
+ case 's':
+ {
+ if (function == "string" && argc <= 1)
+ type = argc == 0 ? ast_func_string_0 : ast_func_string_1;
+ else if (function == "string-length" && argc <= 1)
+ type = argc == 0 ? ast_func_string_length_0 : ast_func_string_length_1;
+ else if (function == "starts-with" && argc == 2)
+ type = ast_func_starts_with;
+ else if (function == "substring-before" && argc == 2)
+ type = ast_func_substring_before;
+ else if (function == "substring-after" && argc == 2)
+ type = ast_func_substring_after;
+ else if (function == "substring" && (argc == 2 || argc == 3))
+ type = argc == 2 ? ast_func_substring_2 : ast_func_substring_3;
+ else if (function == "sum" && argc == 1)
+ type = ast_func_sum;
+
+ break;
+ }
+
+ case 't':
+ {
+ if (function == "translate" && argc == 3)
+ type = ast_func_translate;
+ else if (function == "true" && argc == 0)
+ type = ast_func_true;
+
+ break;
+ }
+
+ }
+
+ if (type != ast_none)
+ {
+ switch (argc)
+ {
+ case 0: return new (m_alloc.node()) xpath_ast_node(type);
+ case 1: return new (m_alloc.node()) xpath_ast_node(type, args[0]);
+ case 2: return new (m_alloc.node()) xpath_ast_node(type, args[0], args[1]);
+ case 3: return new (m_alloc.node()) xpath_ast_node(type, args[0], args[1], args[2]);
+ }
+ }
+
+ throw xpath_exception("Unrecognized function or wrong parameter count");
+ }
+
+ default:
+ throw xpath_exception("unrecognizable primary expression");
+#ifdef __DMC__
+ return 0; // Digital Mars C++
+#endif
+ }
+ }
+
+ // FilterExpr ::= PrimaryExpr | FilterExpr Predicate
+ // Predicate ::= '[' PredicateExpr ']'
+ // PredicateExpr ::= Expr
+ xpath_ast_node* parse_filter_expression()
+ {
+ xpath_ast_node* n = parse_primary_expression();
+
+ while (m_lexer.current() == lex_open_square_brace)
+ {
+ m_lexer.next();
+
+ n = new (m_alloc.node()) xpath_ast_node(ast_filter, n, parse_expression(), axis_child);
+
+ if (m_lexer.current() != lex_close_square_brace)
+ throw xpath_exception("Unmatched square brace");
+
+ m_lexer.next();
+ }
+
+ return n;
+ }
+
+ // Step ::= AxisSpecifier NodeTest Predicate* | AbbreviatedStep
+ // AxisSpecifier ::= AxisName '::' | '@'?
+ // NodeTest ::= NameTest | NodeType '(' ')' | 'processing-instruction' '(' Literal ')'
+ // NameTest ::= '*' | NCName ':' '*' | QName
+ // AbbreviatedStep ::= '.' | '..'
+ xpath_ast_node* parse_step(xpath_ast_node* set)
+ {
+ axis_t axis;
+
+ if (m_lexer.current() == lex_axis_attribute)
+ {
+ axis = axis_attribute;
+
+ m_lexer.next();
+ }
+ else if (m_lexer.current() == lex_dot)
+ {
+ m_lexer.next();
+
+ return new (m_alloc.node()) xpath_ast_node(ast_step, set, axis_self, nodetest_type_node, 0, m_alloc);
+ }
+ else if (m_lexer.current() == lex_double_dot)
+ {
+ m_lexer.next();
+
+ return new (m_alloc.node()) xpath_ast_node(ast_step, set, axis_parent, nodetest_type_node, 0, m_alloc);
+ }
+ else // implied child axis
+ axis = axis_child;
+
+ nodetest_t nt_type;
+ std::string nt_name;
+
+ if (m_lexer.current() == lex_string)
+ {
+ // node name test
+ nt_name = m_lexer.contents();
+ m_lexer.next();
+
+ // possible axis name here - check.
+ if (nt_name.find("::") == std::string::npos && m_lexer.current() == lex_string && m_lexer.contents()[0] == ':' && m_lexer.contents()[1] == ':')
+ {
+ nt_name += m_lexer.contents();
+ m_lexer.next();
+ }
+
+ // possible namespace test
+ if (m_lexer.current() == lex_string && m_lexer.contents()[0] == ':')
+ {
+ std::string::size_type colon_pos = nt_name.find(':');
+
+ // either there is no : in current string or there is, but it's :: and there's nothing more
+ if (colon_pos == std::string::npos ||
+ (colon_pos + 1 < nt_name.size() && nt_name[colon_pos + 1] == ':' &&
+ nt_name.find(':', colon_pos + 2) == std::string::npos))
+ {
+ nt_name += m_lexer.contents();
+ m_lexer.next();
+ }
+ }
+
+ bool axis_specified = true;
+
+ switch (nt_name[0])
+ {
+ case 'a':
+ if (starts_with(nt_name, "ancestor::")) axis = axis_ancestor;
+ else if (starts_with(nt_name, "ancestor-or-self::")) axis = axis_ancestor_or_self;
+ else if (starts_with(nt_name, "attribute::")) axis = axis_attribute;
+ else axis_specified = false;
+
+ break;
+
+ case 'c':
+ if (starts_with(nt_name, "child::")) axis = axis_child;
+ else axis_specified = false;
+
+ break;
+
+ case 'd':
+ if (starts_with(nt_name, "descendant::")) axis = axis_descendant;
+ else if (starts_with(nt_name, "descendant-or-self::")) axis = axis_descendant_or_self;
+ else axis_specified = false;
+
+ break;
+
+ case 'f':
+ if (starts_with(nt_name, "following::")) axis = axis_following;
+ else if (starts_with(nt_name, "following-sibling::")) axis = axis_following_sibling;
+ else axis_specified = false;
+
+ break;
+
+ case 'n':
+ if (starts_with(nt_name, "namespace::")) axis = axis_namespace;
+ else axis_specified = false;
+
+ break;
+
+ case 'p':
+ if (starts_with(nt_name, "parent::")) axis = axis_parent;
+ else if (starts_with(nt_name, "preceding::")) axis = axis_preceding;
+ else if (starts_with(nt_name, "preceding-sibling::")) axis = axis_preceding_sibling;
+ else axis_specified = false;
+
+ break;
+
+ case 's':
+ if (starts_with(nt_name, "self::")) axis = axis_ancestor_or_self;
+ else axis_specified = false;
+
+ break;
+
+ default:
+ axis_specified = false;
+ }
+
+ if (axis_specified)
+ {
+ nt_name.erase(0, nt_name.find("::") + 2);
+ }
+
+ if (nt_name.empty() && m_lexer.current() == lex_string)
+ {
+ nt_name += m_lexer.contents();
+ m_lexer.next();
+ }
+
+ // node type test or processing-instruction
+ if (m_lexer.current() == lex_open_brace)
+ {
+ m_lexer.next();
+
+ if (m_lexer.current() == lex_close_brace)
+ {
+ m_lexer.next();
+
+ if (nt_name == "node")
+ nt_type = nodetest_type_node;
+ else if (nt_name == "text")
+ nt_type = nodetest_type_text;
+ else if (nt_name == "comment")
+ nt_type = nodetest_type_comment;
+ else if (nt_name == "processing-instruction")
+ nt_type = nodetest_type_pi;
+ else
+ throw xpath_exception("Unrecognized node type");
+
+ nt_name.erase(nt_name.begin(), nt_name.end());
+ }
+ else if (nt_name == "processing-instruction")
+ {
+ if (m_lexer.current() != lex_quoted_string)
+ throw xpath_exception("Only literals are allowed as arguments to processing-instruction()");
+
+ nt_type = nodetest_pi;
+ nt_name = m_lexer.contents();
+ m_lexer.next();
+
+ if (m_lexer.current() != lex_close_brace)
+ throw xpath_exception("Unmatched brace near processing-instruction()");
+ m_lexer.next();
+ }
+ else
+ throw xpath_exception("Unmatched brace near node type test");
+
+ }
+ // namespace *
+ else if (m_lexer.current() == lex_multiply)
+ {
+ // Only strings of form 'namespace:*' are permitted
+ if (nt_name.empty())
+ nt_type = nodetest_all;
+ else
+ {
+ if (nt_name.find(':') != nt_name.size() - 1)
+ throw xpath_exception("Wrong namespace-like node test");
+
+ nt_name.erase(nt_name.size() - 1);
+
+ nt_type = nodetest_all_in_namespace;
+ }
+
+ m_lexer.next();
+ }
+ else nt_type = nodetest_name;
+ }
+ else if (m_lexer.current() == lex_multiply)
+ {
+ nt_type = nodetest_all;
+ m_lexer.next();
+ }
+ else throw xpath_exception("Unrecognized node test");
+
+ xpath_ast_node* n = new (m_alloc.node()) xpath_ast_node(ast_step, set, axis, nt_type, nt_name.c_str(), m_alloc);
+
+ xpath_ast_node* last = 0;
+
+ while (m_lexer.current() == lex_open_square_brace)
+ {
+ m_lexer.next();
+
+ xpath_ast_node* pred = new (m_alloc.node()) xpath_ast_node(ast_predicate, parse_expression(), 0, axis);
+
+ if (m_lexer.current() != lex_close_square_brace)
+ throw xpath_exception("unmatched square brace");
+ m_lexer.next();
+
+ if (last) last->set_next(pred);
+ else n->set_right(pred);
+
+ last = pred;
+ }
+
+ return n;
+ }
+
+ // RelativeLocationPath ::= Step | RelativeLocationPath '/' Step | RelativeLocationPath '//' Step
+ xpath_ast_node* parse_relative_location_path(xpath_ast_node* set)
+ {
+ xpath_ast_node* n = parse_step(set);
+
+ while (m_lexer.current() == lex_slash || m_lexer.current() == lex_double_slash)
+ {
+ lexeme_t l = m_lexer.current();
+ m_lexer.next();
+
+ if (l == lex_double_slash)
+ n = new (m_alloc.node()) xpath_ast_node(ast_step, n, axis_descendant_or_self, nodetest_type_node, 0, m_alloc);
+
+ n = parse_step(n);
+ }
+
+ return n;
+ }
+
+ // LocationPath ::= RelativeLocationPath | AbsoluteLocationPath
+ // AbsoluteLocationPath ::= '/' RelativeLocationPath? | '//' RelativeLocationPath
+ xpath_ast_node* parse_location_path()
+ {
+ if (m_lexer.current() == lex_slash)
+ {
+ // Save state for next lexeme - that is, whatever follows '/'
+ const char* state = m_lexer.state();
+
+ m_lexer.next();
+
+ xpath_ast_node* n = new (m_alloc.node()) xpath_ast_node(ast_step_root);
+
+ try
+ {
+ n = parse_relative_location_path(n);
+ }
+ catch (const xpath_exception&)
+ {
+ m_lexer.reset(state);
+ }
+
+ return n;
+ }
+ else if (m_lexer.current() == lex_double_slash)
+ {
+ m_lexer.next();
+
+ xpath_ast_node* n = new (m_alloc.node()) xpath_ast_node(ast_step_root);
+ n = new (m_alloc.node()) xpath_ast_node(ast_step, n, axis_descendant_or_self, nodetest_type_node, 0, m_alloc);
+
+ return parse_relative_location_path(n);
+ }
+ else
+ {
+ return parse_relative_location_path(0);
+ }
+ }
+
+ // PathExpr ::= LocationPath
+ // | FilterExpr
+ // | FilterExpr '/' RelativeLocationPath
+ // | FilterExpr '//' RelativeLocationPath
+ xpath_ast_node* parse_path_expression()
+ {
+ // Clarification.
+ // PathExpr begins with either LocationPath or FilterExpr.
+ // FilterExpr begins with PrimaryExpr
+ // PrimaryExpr begins with '$' in case of it being a variable reference,
+ // '(' in case of it being an expression, string literal, number constant or
+ // function call.
+
+ if (m_lexer.current() == lex_var_ref || m_lexer.current() == lex_open_brace ||
+ m_lexer.current() == lex_quoted_string || m_lexer.current() == lex_number ||
+ m_lexer.current() == lex_string)
+ {
+ if (m_lexer.current() == lex_string)
+ {
+ // This is either a function call, or not - if not, we shall proceed with location path
+ const char* state = m_lexer.state();
+
+ while (*state && *state <= 32) ++state;
+
+ if (*state != '(') return parse_location_path();
+ }
+
+ xpath_ast_node* n = parse_filter_expression();
+
+ if (m_lexer.current() == lex_slash || m_lexer.current() == lex_double_slash)
+ {
+ lexeme_t l = m_lexer.current();
+ m_lexer.next();
+
+ if (l == lex_double_slash)
+ n = new (m_alloc.node()) xpath_ast_node(ast_step, n, axis_descendant_or_self, nodetest_type_node, 0, m_alloc);
+
+ // select from location path
+ return parse_relative_location_path(n);
+ }
+
+ return n;
+ }
+ else return parse_location_path();
+ }
+
+ // UnionExpr ::= PathExpr | UnionExpr '|' PathExpr
+ xpath_ast_node* parse_union_expression()
+ {
+ xpath_ast_node* n = parse_path_expression();
+
+ while (m_lexer.current() == lex_union)
+ {
+ m_lexer.next();
+
+ n = new (m_alloc.node()) xpath_ast_node(ast_op_union, n, parse_union_expression());
+ }
+
+ return n;
+ }
+
+ // UnaryExpr ::= UnionExpr | '-' UnaryExpr
+ xpath_ast_node* parse_unary_expression()
+ {
+ if (m_lexer.current() == lex_minus)
+ {
+ m_lexer.next();
+
+ return new (m_alloc.node()) xpath_ast_node(ast_op_negate, parse_unary_expression());
+ }
+ else return parse_union_expression();
+ }
+
+ // MultiplicativeExpr ::= UnaryExpr
+ // | MultiplicativeExpr '*' UnaryExpr
+ // | MultiplicativeExpr 'div' UnaryExpr
+ // | MultiplicativeExpr 'mod' UnaryExpr
+ xpath_ast_node* parse_multiplicative_expression()
+ {
+ xpath_ast_node* n = parse_unary_expression();
+
+ while (m_lexer.current() == lex_multiply || (m_lexer.current() == lex_string &&
+ (!strcmp(m_lexer.contents(), "mod") || !strcmp(m_lexer.contents(), "div"))))
+ {
+ ast_type_t op = m_lexer.current() == lex_multiply ? ast_op_multiply :
+ !strcmp(m_lexer.contents(), "div") ? ast_op_divide : ast_op_mod;
+ m_lexer.next();
+
+ n = new (m_alloc.node()) xpath_ast_node(op, n, parse_unary_expression());
+ }
+
+ return n;
+ }
+
+ // AdditiveExpr ::= MultiplicativeExpr
+ // | AdditiveExpr '+' MultiplicativeExpr
+ // | AdditiveExpr '-' MultiplicativeExpr
+ xpath_ast_node* parse_additive_expression()
+ {
+ xpath_ast_node* n = parse_multiplicative_expression();
+
+ while (m_lexer.current() == lex_plus || m_lexer.current() == lex_minus)
+ {
+ lexeme_t l = m_lexer.current();
+
+ m_lexer.next();
+
+ n = new (m_alloc.node()) xpath_ast_node(l == lex_plus ? ast_op_add : ast_op_subtract, n, parse_multiplicative_expression());
+ }
+
+ return n;
+ }
+
+ // RelationalExpr ::= AdditiveExpr
+ // | RelationalExpr '<' AdditiveExpr
+ // | RelationalExpr '>' AdditiveExpr
+ // | RelationalExpr '<=' AdditiveExpr
+ // | RelationalExpr '>=' AdditiveExpr
+ xpath_ast_node* parse_relational_expression()
+ {
+ xpath_ast_node* n = parse_additive_expression();
+
+ while (m_lexer.current() == lex_less || m_lexer.current() == lex_less_or_equal ||
+ m_lexer.current() == lex_greater || m_lexer.current() == lex_greater_or_equal)
+ {
+ lexeme_t l = m_lexer.current();
+ m_lexer.next();
+
+ n = new (m_alloc.node()) xpath_ast_node(l == lex_less ? ast_op_less : l == lex_greater ? ast_op_greater :
+ l == lex_less_or_equal ? ast_op_less_or_equal : ast_op_greater_or_equal,
+ n, parse_additive_expression());
+ }
+
+ return n;
+ }
+
+ // EqualityExpr ::= RelationalExpr
+ // | EqualityExpr '=' RelationalExpr
+ // | EqualityExpr '!=' RelationalExpr
+ xpath_ast_node* parse_equality_expression()
+ {
+ xpath_ast_node* n = parse_relational_expression();
+
+ while (m_lexer.current() == lex_equal || m_lexer.current() == lex_not_equal)
+ {
+ lexeme_t l = m_lexer.current();
+
+ m_lexer.next();
+
+ n = new (m_alloc.node()) xpath_ast_node(l == lex_equal ? ast_op_equal : ast_op_not_equal, n, parse_relational_expression());
+ }
+
+ return n;
+ }
+
+ // AndExpr ::= EqualityExpr | AndExpr 'and' EqualityExpr
+ xpath_ast_node* parse_and_expression()
+ {
+ xpath_ast_node* n = parse_equality_expression();
+
+ while (m_lexer.current() == lex_string && !strcmp(m_lexer.contents(), "and"))
+ {
+ m_lexer.next();
+
+ n = new (m_alloc.node()) xpath_ast_node(ast_op_and, n, parse_equality_expression());
+ }
+
+ return n;
+ }
+
+ // OrExpr ::= AndExpr | OrExpr 'or' AndExpr
+ xpath_ast_node* parse_or_expression()
+ {
+ xpath_ast_node* n = parse_and_expression();
+
+ while (m_lexer.current() == lex_string && !strcmp(m_lexer.contents(), "or"))
+ {
+ m_lexer.next();
+
+ n = new (m_alloc.node()) xpath_ast_node(ast_op_or, n, parse_and_expression());
+ }
+
+ return n;
+ }
+
+ // Expr ::= OrExpr
+ xpath_ast_node* parse_expression()
+ {
+ return parse_or_expression();
+ }
+
+ public:
+ explicit xpath_parser(const char* query, xpath_allocator& alloc): m_alloc(alloc), m_lexer(query)
+ {
+ }
+
+ xpath_ast_node* parse()
+ {
+ xpath_ast_node* result = parse_expression();
+
+ if (m_lexer.current() != lex_none)
+ {
+ // there are still unparsed tokens left, error
+ throw xpath_exception("Incorrect query");
+ }
+
+ return result;
+ }
+ };
+
+ xpath_query::xpath_query(const char* query): m_alloc(0), m_root(0)
+ {
+ compile(query);
+ }
+
+ xpath_query::~xpath_query()
+ {
+ delete m_alloc;
+ }
+
+ void xpath_query::compile(const char* query)
+ {
+ delete m_alloc;
+ m_alloc = new xpath_allocator;
+
+ xpath_parser p(query, *m_alloc);
+
+ m_root = p.parse();
+ m_root->check_semantics();
+ }
+
+ bool xpath_query::evaluate_boolean(const xml_node& n)
+ {
+ if (!m_root) return false;
+
+ xpath_context c;
+
+ c.root = n.root();
+ c.n = n;
+ c.position = 1;
+ c.size = 1;
+
+ return m_root->eval_boolean(c);
+ }
+
+ double xpath_query::evaluate_number(const xml_node& n)
+ {
+ if (!m_root) return gen_nan();
+
+ xpath_context c;
+
+ c.root = n.root();
+ c.n = n;
+ c.position = 1;
+ c.size = 1;
+
+ return m_root->eval_number(c);
+ }
+
+ std::string xpath_query::evaluate_string(const xml_node& n)
+ {
+ if (!m_root) return std::string();
+
+ xpath_context c;
+
+ c.root = n.root();
+ c.n = n;
+ c.position = 1;
+ c.size = 1;
+
+ return m_root->eval_string(c);
+ }
+
+ xpath_node_set xpath_query::evaluate_node_set(const xml_node& n)
+ {
+ if (!m_root) return xpath_node_set();
+
+ xpath_context c;
+
+ c.root = n.root();
+ c.n = n;
+ c.position = 1;
+ c.size = 1;
+
+ return m_root->eval_node_set(c);
+ }
+
+ xpath_node xml_node::select_single_node(const char* query) const
+ {
+ xpath_query q(query);
+ return select_single_node(q);
+ }
+
+ xpath_node xml_node::select_single_node(xpath_query& query) const
+ {
+ xpath_node_set s = query.evaluate_node_set(*this);
+ return s.empty() ? xpath_node() : s.first();
+ }
+
+ xpath_node_set xml_node::select_nodes(const char* query) const
+ {
+ xpath_query q(query);
+ return select_nodes(q);
+ }
+
+ xpath_node_set xml_node::select_nodes(xpath_query& query) const
+ {
+ return query.evaluate_node_set(*this);
+ }
+}
+
+#endif
More information about the commits
mailing list