TinyXML is a simple, small, C++ XML parser that can be easily integrated into other programs.
-In brief, TinyXML parses an XML document, and builds from that a Document Object Model (DOM) that can be read, modified, and saved.
-XML stands for "eXtensible Markup Language." It allows you to create your own document markups. Where HTML does a very good job of marking documents for browsers, XML allows you to define any kind of document markup, for example a document that describes a "to do" list for an organizer application. XML is a very structured and convenient format. All those random file formats created to store application data can all be replaced with XML. One parser for everything.
-There are different ways to access and interact with XML data. TinyXML uses a Document Object Model (DOM), meaning the XML data is parsed into a C++ objects that can be browsed and manipulated, and then written to disk or another output stream. You can also construct an XML document from scratch with C++ objects and write this to disk or another output stream.
-TinyXML is designed to be easy and fast to learn. It is two headers and four cpp files. Simply add these to your project and off you go. There is an example file - xmltest.cpp - to get you started.
-TinyXML is released under the ZLib license, so you can use it in open source or commercial code. The details of the license are at the top of every source file.
-TinyXML attempts to be a flexible parser, but with truly correct and compliant XML output. TinyXML should compile on any reasonably C++ compliant system. It does not rely on exceptions or RTTI. It can be compiled with or without STL support. TinyXML fully supports the UTF-8 encoding, and the first 64k character entities.
In brief, TinyXML parses an XML document, and builds from that a Document Object Model (DOM) that can be read, modified, and saved.
XML stands for "eXtensible Markup Language." It allows you to create your own document markups. Where HTML does a very good job of marking documents for browsers, XML allows you to define any kind of document markup, for example a document that describes a "to do" list for an organizer application. XML is a very structured and convenient format. All those random file formats created to store application data can all be replaced with XML. One parser for everything.
There are different ways to access and interact with XML data. TinyXML uses a Document Object Model (DOM), meaning the XML data is parsed into a C++ objects that can be browsed and manipulated, and then written to disk or another output stream. You can also construct an XML document from scratch with C++ objects and write this to disk or another output stream.
TinyXML is designed to be easy and fast to learn. It is two headers and four cpp files. Simply add these to your project and off you go. There is an example file - xmltest.cpp - to get you started.
TinyXML is released under the ZLib license, so you can use it in open source or commercial code. The details of the license are at the top of every source file.
TinyXML attempts to be a flexible parser, but with truly correct and compliant XML output. TinyXML should compile on any reasonably C++ compliant system. It does not rely on exceptions or RTTI. It can be compiled with or without STL support. TinyXML fully supports the UTF-8 encoding, and the first 64k character entities.
-TinyXML doesn't parse or use DTDs (Document Type Definitions) or XSLs (eXtensible Stylesheet Language.) There are other parsers out there (check out www.sourceforge.org, search for XML) that are much more fully featured. But they are also much bigger, take longer to set up in your project, have a higher learning curve, and often have a more restrictive license. If you are working with browsers or have more complete XML needs, TinyXML is not the parser for you.
because TinyXML sees this as a !DOCTYPE node with an illegally embedded !ELEMENT node. This may be addressed in the future.
-For the impatient, here is a tutorial to get you going. A great way to get started, but it is worth your time to read this (very short) manual completely.
For the impatient, here is a tutorial to get you going. A great way to get started, but it is worth your time to read this (very short) manual completely.
-TinyXML is mature, tested code. It is very stable. If you find bugs, please file a bug report on the sourceforge web site (www.sourceforge.net/projects/tinyxml). We'll get them straightened out as soon as possible.
-There are some areas of improvement; please check sourceforge if you are interested in working on TinyXML.
TinyXML is mature, tested code. It is very stable. If you find bugs, please file a bug report on the sourceforge web site (www.sourceforge.net/projects/tinyxml). We'll get them straightened out as soon as possible.
There are some areas of improvement; please check sourceforge if you are interested in working on TinyXML.
-TinyXML can be compiled to use or not use STL. When using STL, TinyXML uses the std::string class, and fully supports std::istream, std::ostream, operator<<, and operator>>. Many API methods have both 'const char*' and 'const std::string&' forms.
-When STL support is compiled out, no STL files are included whatsoever. All the string classes are implemented by TinyXML itself. API methods all use the 'const char*' form for input.
-to compile one version or the other. This can be passed by the compiler, or set as the first line of "tinyxml.h".
-Note: If compiling the test code in Linux, setting the environment variable TINYXML_USE_STL=YES/NO will control STL compilation. In the Windows project file, STL and non STL targets are provided. In your project, It's probably easiest to add the line "#define TIXML_USE_STL" as the first line of tinyxml.h .
TinyXML can be compiled to use or not use STL. When using STL, TinyXML uses the std::string class, and fully supports std::istream, std::ostream, operator<<, and operator>>. Many API methods have both 'const char*' and 'const std::string&' forms.
When STL support is compiled out, no STL files are included whatsoever. All the string classes are implemented by TinyXML itself. API methods all use the 'const char*' form for input.
to compile one version or the other. This can be passed by the compiler, or set as the first line of "tinyxml.h".
Note: If compiling the test code in Linux, setting the environment variable TINYXML_USE_STL=YES/NO will control STL compilation. In the Windows project file, STL and non STL targets are provided. In your project, It's probably easiest to add the line "#define TIXML_USE_STL" as the first line of tinyxml.h .
-TinyXML supports UTF-8 allowing to manipulate XML files in any language. TinyXML also supports "legacy mode" - the encoding used before UTF-8 support and probably best described as "extended ascii".
-Normally, TinyXML will try to detect the correct encoding and use it. However, by setting the value of TIXML_DEFAULT_ENCODING in the header file, TinyXML can be forced to always use one encoding.
+TinyXML supports UTF-8 allowing to manipulate XML files in any language. TinyXML also supports "legacy mode" - the encoding used before UTF-8 support and probably best described as "extended ascii".
+Normally, TinyXML will try to detect the correct encoding and use it. However, by setting the value of TIXML_DEFAULT_ENCODING in the header file, TinyXML can be forced to always use one encoding.
+TinyXML will assume Legacy Mode until one of the following occurs:
+
If the non-standard but common "UTF-8 lead bytes" (0xef 0xbb 0xbf) begin the file or data stream, TinyXML will read it as UTF-8.
@@ -81,75 +77,86 @@ If the declaration tag is read, and it has an encoding="something else", then Ti
Until one of the above criteria is met, TinyXML runs in Legacy Mode.
-
-What happens if the encoding is incorrectly set or detected? TinyXML will try to read and pass through text seen as improperly encoded. You may get some strange results or mangled characters. You may want to force TinyXML to the correct mode.
-You may force TinyXML to Legacy Mode by using LoadFile( TIXML_ENCODING_LEGACY ) or LoadFile( filename, TIXML_ENCODING_LEGACY ). You may force it to use legacy mode all the time by setting TIXML_DEFAULT_ENCODING = TIXML_ENCODING_LEGACY. Likewise, you may force it to TIXML_ENCODING_UTF8 with the same technique.
-For English users, using English XML, UTF-8 is the same as low-ASCII. You don't need to be aware of UTF-8 or change your code in any way. You can think of UTF-8 as a "superset" of ASCII.
-UTF-8 is not a double byte format - but it is a standard encoding of Unicode! TinyXML does not use or directly support wchar, TCHAR, or Microsoft's _UNICODE at this time. It is common to see the term "Unicode" improperly refer to UTF-16, a wide byte encoding of unicode. This is a source of confusion.
-For "high-ascii" languages - everything not English, pretty much - TinyXML can handle all languages, at the same time, as long as the XML is encoded in UTF-8. That can be a little tricky, older programs and operating systems tend to use the "default" or "traditional" code page. Many apps (and almost all modern ones) can output UTF-8, but older or stubborn (or just broken) ones still output text in the default code page.
-For example, Japanese systems traditionally use SHIFT-JIS encoding. Text encoded as SHIFT-JIS can not be read by TinyXML. A good text editor can import SHIFT-JIS and then save as UTF-8.
-The Skew.org link does a great job covering the encoding issue.
-The test file "utf8test.xml" is an XML containing English, Spanish, Russian, and Simplified Chinese. (Hopefully they are translated correctly). The file "utf8test.gif" is a screen capture of the XML file, rendered in IE. Note that if you don't have the correct fonts (Simplified Chinese or Russian) on your system, you won't see output that matches the GIF file even if you can parse it correctly. Also note that (at least on my Windows machine) console output is in a Western code page, so that Print() or printf() cannot correctly display the file. This is not a bug in TinyXML - just an OS issue. No data is lost or destroyed by TinyXML. The console just doesn't render UTF-8.
+
What happens if the encoding is incorrectly set or detected? TinyXML will try to read and pass through text seen as improperly encoded. You may get some strange results or mangled characters. You may want to force TinyXML to the correct mode.
+You may force TinyXML to Legacy Mode by using LoadFile( TIXML_ENCODING_LEGACY ) or LoadFile( filename, TIXML_ENCODING_LEGACY ). You may force it to use legacy mode all the time by setting TIXML_DEFAULT_ENCODING = TIXML_ENCODING_LEGACY. Likewise, you may force it to TIXML_ENCODING_UTF8 with the same technique.
+For English users, using English XML, UTF-8 is the same as low-ASCII. You don't need to be aware of UTF-8 or change your code in any way. You can think of UTF-8 as a "superset" of ASCII.
+UTF-8 is not a double byte format - but it is a standard encoding of Unicode! TinyXML does not use or directly support wchar, TCHAR, or Microsoft's _UNICODE at this time. It is common to see the term "Unicode" improperly refer to UTF-16, a wide byte encoding of unicode. This is a source of confusion.
+For "high-ascii" languages - everything not English, pretty much - TinyXML can handle all languages, at the same time, as long as the XML is encoded in UTF-8. That can be a little tricky, older programs and operating systems tend to use the "default" or "traditional" code page. Many apps (and almost all modern ones) can output UTF-8, but older or stubborn (or just broken) ones still output text in the default code page.
+For example, Japanese systems traditionally use SHIFT-JIS encoding. Text encoded as SHIFT-JIS can not be read by TinyXML. A good text editor can import SHIFT-JIS and then save as UTF-8.
+The Skew.org link does a great job covering the encoding issue.
+The test file "utf8test.xml" is an XML containing English, Spanish, Russian, and Simplified Chinese. (Hopefully they are translated correctly). The file "utf8test.gif" is a screen capture of the XML file, rendered in IE. Note that if you don't have the correct fonts (Simplified Chinese or Russian) on your system, you won't see output that matches the GIF file even if you can parse it correctly. Also note that (at least on my Windows machine) console output is in a Western code page, so that Print() or printf() cannot correctly display the file. This is not a bug in TinyXML - just an OS issue. No data is lost or destroyed by TinyXML. The console just doesn't render UTF-8.
Entities
-
-TinyXML recognizes the pre-defined "character entities", meaning special characters. Namely:
-
& &
+TinyXML recognizes the pre-defined "character entities", meaning special characters. Namely:
+
+ & &
< <
> >
" "
' '
-
-These are recognized when the XML document is read, and translated to there UTF-8 equivalents. For instance, text with the XML of:
-
-will have the Value() of "Far & Away" when queried from the TiXmlText object, and will be written back to the XML stream/file as an ampersand. Older versions of TinyXML "preserved" character entities, but the newer versions will translate them into characters.
-Additionally, any character can be specified by its Unicode code point: The syntax " " or " " are both to the non-breaking space characher.
+
These are recognized when the XML document is read, and translated to there UTF-8 equivalents. For instance, text with the XML of:
+will have the Value() of "Far & Away" when queried from the TiXmlText object, and will be written back to the XML stream/file as an ampersand. Older versions of TinyXML "preserved" character entities, but the newer versions will translate them into characters.
+Additionally, any character can be specified by its Unicode code point: The syntax " " or " " are both to the non-breaking space characher.
Printing
-
-TinyXML can print output in several different ways that all have strengths and limitations.
+
TinyXML can print output in several different ways that all have strengths and limitations.
Print( FILE* ). Output to a std-C stream, which includes all C files as well as stdout.
-"Pretty prints", but you don't have control over printing options. The output is streamed directly to the FILE object, so there is no memory overhead in the TinyXML code. used by Print() and SaveFile()
-
-
+
"Pretty prints", but you don't have control over printing options.
+The output is streamed directly to the FILE object, so there is no memory overhead in the TinyXML code.
+used by Print() and SaveFile()
+
+
+
operator<<. Output to a c++ stream.
-Integrates with standart C++ iostreams. Outputs in "network printing" mode without line breaks. Good for network transmission and moving XML between C++ objects, but hard for a human to read.
-
-
+
Integrates with standart C++ iostreams.
+Outputs in "network printing" mode without line breaks. Good for network transmission and moving XML between C++ objects, but hard for a human to read.
+
+
+
-TiXmlPrinter . Output to a std::string or memory buffer.
-API is less concise Future printing options will be put here. Printing may change slightly in future versions as it is refined and expanded.
-
-
+
TiXmlPrinter . Output to a std::string or memory buffer.
+API is less concise
+Future printing options will be put here.
+Printing may change slightly in future versions as it is refined and expanded.
+
+Streams
-
-With TIXML_USE_STL on TinyXML supports C++ streams (operator <<,>>) streams as well as C (FILE*) streams. There are some differences that you may need to be aware of.
-C style output:
-based on FILE* the Print() and SaveFile() methods
-
-Generates formatted output, with plenty of white space, intended to be as human-readable as possible. They are very fast, and tolerant of ill formed XML documents. For example, an XML document that contains 2 root elements and 2 declarations, will still print.
-C style input:
-based on FILE* the Parse() and LoadFile() methods
-
-A fast, tolerant read. Use whenever you don't need the C++ streams.
-C++ style output:
-based on std::ostream operator<<
-
-Generates condensed output, intended for network transmission rather than readability. Depending on your system's implementation of the ostream class, these may be somewhat slower. (Or may not.) Not tolerant of ill formed XML: a document should contain the correct one root element. Additional root level elements will not be streamed out.
-C++ style input:
-based on std::istream operator>>
-
-Reads XML from a stream, making it useful for network transmission. The tricky part is knowing when the XML document is complete, since there will almost certainly be other data in the stream. TinyXML will assume the XML data is complete after it reads the root element. Put another way, documents that are ill-constructed with more than one root element will not read correctly. Also note that operator>> is somewhat slower than Parse, due to both implementation of the STL and limitations of TinyXML.
+
With TIXML_USE_STL on TinyXML supports C++ streams (operator <<,>>) streams as well as C (FILE*) streams. There are some differences that you may need to be aware of.
+C style output:
+
+based on FILE*
+the Print() and SaveFile() methods
+
+Generates formatted output, with plenty of white space, intended to be as human-readable as possible. They are very fast, and tolerant of ill formed XML documents. For example, an XML document that contains 2 root elements and 2 declarations, will still print.
+C style input:
+
+based on FILE*
+the Parse() and LoadFile() methods
+
+A fast, tolerant read. Use whenever you don't need the C++ streams.
+C++ style output:
+
+based on std::ostream
+operator<<
+
+Generates condensed output, intended for network transmission rather than readability. Depending on your system's implementation of the ostream class, these may be somewhat slower. (Or may not.) Not tolerant of ill formed XML: a document should contain the correct one root element. Additional root level elements will not be streamed out.
+C++ style input:
+
+based on std::istream
+operator>>
+
+Reads XML from a stream, making it useful for network transmission. The tricky part is knowing when the XML document is complete, since there will almost certainly be other data in the stream. TinyXML will assume the XML data is complete after it reads the root element. Put another way, documents that are ill-constructed with more than one root element will not read correctly. Also note that operator>> is somewhat slower than Parse, due to both implementation of the STL and limitations of TinyXML.
White space
-
-The world simply does not agree on whether white space should be kept, or condensed. For example, pretend the '_' is a space, and look at "Hello____world". HTML, and at least some XML parsers, will interpret this as "Hello_world". They condense white space. Some XML parsers do not, and will leave it as "Hello____world". (Remember to keep pretending the _ is a space.) Others suggest that __Hello___world__ should become Hello___world.
-It's an issue that hasn't been resolved to my satisfaction. TinyXML supports the first 2 approaches. Call TiXmlBase::SetCondenseWhiteSpace( bool ) to set the desired behavior. The default is to condense white space.
-If you change the default, you should call TiXmlBase::SetCondenseWhiteSpace( bool ) before making any calls to Parse XML data, and I don't recommend changing it after it has been set.
+
The world simply does not agree on whether white space should be kept, or condensed. For example, pretend the '_' is a space, and look at "Hello____world". HTML, and at least some XML parsers, will interpret this as "Hello_world". They condense white space. Some XML parsers do not, and will leave it as "Hello____world". (Remember to keep pretending the _ is a space.) Others suggest that __Hello___world__ should become Hello___world.
+It's an issue that hasn't been resolved to my satisfaction. TinyXML supports the first 2 approaches. Call TiXmlBase::SetCondenseWhiteSpace( bool ) to set the desired behavior. The default is to condense white space.
+If you change the default, you should call TiXmlBase::SetCondenseWhiteSpace( bool ) before making any calls to Parse XML data, and I don't recommend changing it after it has been set.
Handles
-
-Where browsing an XML document in a robust way, it is important to check for null returns from method calls. An error safe implementation can generate a lot of code like:
-
TiXmlElement* root = document.FirstChildElement( "Document" );
+Where browsing an XML document in a robust way, it is important to check for null returns from method calls. An error safe implementation can generate a lot of code like:
+
+TiXmlElement* root = document.FirstChildElement( "Document" );
if ( root )
{
TiXmlElement* element = root->FirstChildElement( "Element" );
@@ -162,26 +169,22 @@ if ( root )
if ( child2 )
{
// Finally do something useful.
-
-Handles have been introduced to clean this up. Using the TiXmlHandle class, the previous code reduces to:
-
TiXmlHandle docHandle( &document );
+ Handles have been introduced to clean this up. Using the TiXmlHandle class, the previous code reduces to:
+
+TiXmlHandle docHandle( &document );
TiXmlElement* child2 = docHandle.FirstChild( "Document" ).FirstChild( "Element" ).Child( "Child", 1 ).ToElement();
if ( child2 )
{
// do something useful
-
-Which is much easier to deal with. See TiXmlHandle for more information.
+
Which is much easier to deal with. See TiXmlHandle for more information.
Row and Column tracking
-
-Being able to track nodes and attributes back to their origin location in source files can be very important for some applications. Additionally, knowing where parsing errors occured in the original source can be very time saving.
-TinyXML can tracks the row and column origin of all nodes and attributes in a text file. The TiXmlBase::Row() and TiXmlBase::Column() methods return the origin of the node in the source text. The correct tabs can be configured in TiXmlDocument::SetTabSize() .
+
Being able to track nodes and attributes back to their origin location in source files can be very important for some applications. Additionally, knowing where parsing errors occured in the original source can be very time saving.
+TinyXML can tracks the row and column origin of all nodes and attributes in a text file. The TiXmlBase::Row() and TiXmlBase::Column() methods return the origin of the node in the source text. The correct tabs can be configured in TiXmlDocument::SetTabSize() .
Using and Installing
-
-To Compile and Run xmltest:
-A Linux Makefile and a Windows Visual C++ .dsw file is provided. Simply compile and run. It will write the file demotest.xml to your disk and generate output on the screen. It also tests walking the DOM by printing out the number of nodes found using different techniques.
-The Linux makefile is very generic and runs on many systems - it is currently tested on mingw and MacOSX. You do not need to run 'make depend'. The dependecies have been hard coded.
+
To Compile and Run xmltest:
+A Linux Makefile and a Windows Visual C++ .dsw file is provided. Simply compile and run. It will write the file demotest.xml to your disk and generate output on the screen. It also tests walking the DOM by printing out the number of nodes found using different techniques.
+The Linux makefile is very generic and runs on many systems - it is currently tested on mingw and MacOSX. You do not need to run 'make depend'. The dependecies have been hard coded.
Windows project file for VC6
-
tinyxml: tinyxml library, non-STL
@@ -192,49 +195,49 @@ tinyXmlTest: test app, non-STL
tinyXmlTestSTL: test app, STL
-
Makefile
-
-At the top of the makefile you can set:
-PROFILE, DEBUG, and TINYXML_USE_STL. Details (such that they are) are in the makefile.
-In the tinyxml directory, type "make clean" then "make". The executable file 'xmltest' will be created.
+
At the top of the makefile you can set:
+PROFILE, DEBUG, and TINYXML_USE_STL. Details (such that they are) are in the makefile.
+In the tinyxml directory, type "make clean" then "make". The executable file 'xmltest' will be created.
To Use in an Application:
-
-Add tinyxml.cpp, tinyxml.h , tinyxmlerror.cpp, tinyxmlparser.cpp, tinystr.cpp, and tinystr.h to your project or make file. That's it! It should compile on any reasonably compliant C++ system. You do not need to enable exceptions or RTTI for TinyXML.
+
Add tinyxml.cpp, tinyxml.h , tinyxmlerror.cpp, tinyxmlparser.cpp, tinystr.cpp, and tinystr.h to your project or make file. That's it! It should compile on any reasonably compliant C++ system. You do not need to enable exceptions or RTTI for TinyXML.
How TinyXML works.
-
-An example is probably the best way to go. Take:
<?xml version="1.0" standalone=no>
+An example is probably the best way to go. Take:
+
+ <?xml version="1.0" standalone=no>
<!-- Our to do list data -->
<ToDo>
<Item priority="1"> Go to the <bold>Toy store!</bold></Item>
<Item priority="2"> Do bills</Item>
</ToDo>
-
-Its not much of a To Do list, but it will do. To read this file (say "demo.xml") you would create a document, and parse it in:
TiXmlDocument doc( "demo.xml" );
+ Its not much of a To Do list, but it will do. To read this file (say "demo.xml") you would create a document, and parse it in:
+
+ TiXmlDocument doc( "demo.xml" );
doc.LoadFile();
-
-And its ready to go. Now lets look at some lines and how they relate to the DOM.
-
<?xml version="1.0" standalone=no>
-
-The first line is a declaration, and gets turned into the TiXmlDeclaration class. It will be the first child of the document node.
-This is the only directive/special tag parsed by by TinyXML. Generally directive tags are stored in TiXmlUnknown so the commands wont be lost when it is saved back to disk.
-
<!-- Our to do list data -->
-
-A comment. Will become a TiXmlComment object.
-
-The "ToDo" tag defines a TiXmlElement object. This one does not have any attributes, but does contain 2 other elements.
-
-Creates another TiXmlElement which is a child of the "ToDo" element. This element has 1 attribute, with the name "priority" and the value "1".
-
-A TiXmlText . This is a leaf node and cannot contain other nodes. It is a child of the "Item" TiXmlElement .
-
-Another TiXmlElement , this one a child of the "Item" element.
-Etc.
-Looking at the entire object tree, you end up with:
TiXmlDocument "demo.xml"
+ And its ready to go. Now lets look at some lines and how they relate to the DOM.
+
+<?xml version="1.0" standalone=no>
+ The first line is a declaration, and gets turned into the TiXmlDeclaration class. It will be the first child of the document node.
+This is the only directive/special tag parsed by TinyXML. Generally directive tags are stored in TiXmlUnknown so the commands wont be lost when it is saved back to disk.
+
+<!-- Our to do list data -->
+ A comment. Will become a TiXmlComment object.
+The "ToDo" tag defines a TiXmlElement object. This one does not have any attributes, but does contain 2 other elements.
+Creates another TiXmlElement which is a child of the "ToDo" element. This element has 1 attribute, with the name "priority" and the value "1".
+A TiXmlText . This is a leaf node and cannot contain other nodes. It is a child of the "Item" TiXmlElement .
+Another TiXmlElement , this one a child of the "Item" element.
+Etc.
+Looking at the entire object tree, you end up with:
+
+TiXmlDocument "demo.xml"
TiXmlDeclaration "version='1.0'" "standalone=no"
TiXmlComment " Our to do list data"
TiXmlElement "ToDo"
@@ -244,32 +247,29 @@ Looking at the entire object tree, you end up with:
-
Documentation
-
-The documentation is build with Doxygen, using the 'dox' configuration file.
+
Documentation
+The documentation is build with Doxygen, using the 'dox' configuration file.
License
-
-TinyXML is released under the zlib license:
-This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software.
-Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions:
-1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
-2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
-3. This notice may not be removed or altered from any source distribution.
+
TinyXML is released under the zlib license:
+This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions:
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
References
-
-The World Wide Web Consortium is the definitive standard body for XML, and there web pages contain huge amounts of information.
-The definitive spec: http://www.w3.org/TR/2004/REC-xml-20040204/
-I also recommend "XML Pocket Reference" by Robert Eckstein and published by OReilly...the book that got the whole thing started.
+
The World Wide Web Consortium is the definitive standard body for XML, and their web pages contain huge amounts of information.
+The definitive spec: http://www.w3.org/TR/2004/REC-xml-20040204/
+I also recommend "XML Pocket Reference" by Robert Eckstein and published by OReilly...the book that got the whole thing started.
Contributors, Contacts, and a Brief History
-
-Thanks very much to everyone who sends suggestions, bugs, ideas, and encouragement. It all helps, and makes this project fun. A special thanks to the contributors on the web pages that keep it lively.
-So many people have sent in bugs and ideas, that rather than list here we try to give credit due in the "changes.txt" file.
-TinyXML was originally written by Lee Thomason. (Often the "I" still in the documentation.) Lee reviews changes and releases new versions, with the help of Yves Berquin, Andrew Ellerton, and the tinyXml community.
-We appreciate your suggestions, and would love to know if you use TinyXML. Hopefully you will enjoy it and find it useful. Please post questions, comments, file bugs, or contact us at:
-www.sourceforge.net/projects/tinyxml
-Lee Thomason, Yves Berquin, Andrew Ellerton
Generated on Sun May 6 15:41:22 2007 for TinyXml by
+ Thanks very much to everyone who sends suggestions, bugs, ideas, and encouragement. It all helps, and makes this project fun. A special thanks to the contributors on the web pages that keep it lively.
+So many people have sent in bugs and ideas, that rather than list here we try to give credit due in the "changes.txt" file.
+TinyXML was originally written by Lee Thomason. (Often the "I" still in the documentation.) Lee reviews changes and releases new versions, with the help of Yves Berquin, Andrew Ellerton, and the tinyXml community.
+We appreciate your suggestions, and would love to know if you use TinyXML. Hopefully you will enjoy it and find it useful. Please post questions, comments, file bugs, or contact us at:
+www.sourceforge.net/projects/tinyxml
+Lee Thomason, Yves Berquin, Andrew Ellerton
+ Generated by
- 1.4.7 TinyXml: Page Index
-TinyXml Related Pages Here is a list of all related documentation pages:Generated by
- 1.4.7 TinyXml: tinystr.h Source File
-tinystr.h #ifndef TIXML_USE_STL
-#ifndef TIXML_STRING_INCLUDED
-#define TIXML_STRING_INCLUDED
-#include <assert.h>
-#include <string.h>
-#if defined(_MSC_VER) && (_MSC_VER >= 1200 )
- #define TIXML_EXPLICIT explicit
-#elif defined(__GNUC__) && (__GNUC__ >= 3 )
- #define TIXML_EXPLICIT explicit
-#else
- #define TIXML_EXPLICIT
-#endif
-class TiXmlString
-public :
-typedef size_t size_type;
-static const size_type npos;
-const TiXmlString & copy) : rep_(0)
-const char * copy) : rep_(0)
-const char * str, size_type len) : rep_(0)
-const char * copy)
-return assign( copy, (size_type)strlen(copy));
-const TiXmlString & copy)
-return assign(copy.start(), copy.length());
-const char * suffix)
-return append(suffix, static_cast<size_type>( strlen(suffix) ));
-char single)
-return append(&single, 1);
-const TiXmlString & suffix)
-return append(suffix.data(), suffix.length());
-const char * c_str () const { return rep_->str; }
-const char * data () const { return rep_->str; }
- const { return rep_->size; }
- const { return rep_->size; }
-bool empty () const { return rep_->size == 0; }
- const { return rep_->capacity; }
-const char & at (size_type index) const
- {
-return rep_->str[ index ];
-char & operator [] (size_type index) const
- {
-return rep_->str[ index ];
-char lookup) const
- {
-return find(lookup, 0);
-char tofind, size_type offset) const
- {
-if (offset >= length()) return npos;
-for (const char * p = c_str() + offset; *p != '\0' ; ++p)
-if (*p == tofind) return static_cast< size_type >( p - c_str() );
-return npos;
-void clear ()
-void reserve (size_type cap);
-const char * str, size_type len);
-const char * str, size_type len);
-void swap (TiXmlString& other)
-private :
-void init(size_type sz) { init(sz, sz); }
-void set_size(size_type sz) { rep_->str[ rep_->size = sz ] = '\0' ; }
-char * start() const { return rep_->str; }
-char * finish() const { return rep_->str + rep_->size; }
-struct Rep
-char str[1];
-void init(size_type sz, size_type cap)
-if (cap)
-const size_type bytesNeeded = sizeof (Rep) + cap;
-const size_type intsNeeded = ( bytesNeeded + sizeof (int) - 1 ) / sizeof ( int );
-new int [ intsNeeded ] );
-'\0' ;
-else
-void quit()
-if (rep_ != &nullrep_)
-delete [] ( reinterpret_cast<int*>( rep_ ) );
-static Rep nullrep_;
-inline bool operator == (const TiXmlString & a, const TiXmlString & b)
-return ( a.length() == b.length() )
-inline bool operator < (const TiXmlString & a, const TiXmlString & b)
-return strcmp(a.c_str(), b.c_str()) < 0;
-inline bool operator != (const TiXmlString & a, const TiXmlString & b) { return !(a == b); }
-inline bool operator > (const TiXmlString & a, const TiXmlString & b) { return b < a; }
-inline bool operator <= (const TiXmlString & a, const TiXmlString & b) { return !(b < a); }
-inline bool operator >= (const TiXmlString & a, const TiXmlString & b) { return !(a < b); }
-inline bool operator == (const TiXmlString & a, const char * b) { return strcmp(a.c_str(), b) == 0; }
-inline bool operator == (const char * a, const TiXmlString & b) { return b == a; }
-inline bool operator != (const TiXmlString & a, const char * b) { return !(a == b); }
-inline bool operator != (const char * a, const TiXmlString & b) { return !(b == a); }
-const TiXmlString & a, const TiXmlString & b);
-const TiXmlString & a, const char * b);
-const char * a, const TiXmlString & b);
-class TiXmlOutStream : public TiXmlString
-public :
-const TiXmlString & in)
-this += in;
-return *this ;
-const char * in)
-this += in;
-return *this ;
-#endif // TIXML_STRING_INCLUDED
-#endif // TIXML_USE_STL
-Generated on Sun May 6 15:41:22 2007 for TinyXml by
-
- 1.4.7 TinyXml: tinystr.h Source File
+
+
+
+
tinystr.h #ifndef TIXML_USE_STL
+#ifndef TIXML_STRING_INCLUDED
+#define TIXML_STRING_INCLUDED
+#include <assert.h>
+#include <string.h>
+#if defined(_MSC_VER) && (_MSC_VER >= 1200 )
+ #define TIXML_EXPLICIT explicit
+#elif defined(__GNUC__) && (__GNUC__ >= 3 )
+ #define TIXML_EXPLICIT explicit
+#else
+ #define TIXML_EXPLICIT
+#endif
+class TiXmlString
+public :
+typedef size_t size_type;
+static const size_type npos;
+const TiXmlString & copy) : rep_(0)
+const char * copy) : rep_(0)
+const char * str, size_type len) : rep_(0)
+const char * copy)
+return assign( copy, (size_type)strlen(copy));
+const TiXmlString & copy)
+return assign(copy.start(), copy.length());
+const char * suffix)
+return append(suffix, static_cast<size_type>( strlen(suffix) ));
+char single)
+return append(&single, 1);
+const TiXmlString & suffix)
+return append(suffix.data(), suffix.length());
+const char * c_str () const { return rep_->str; }
+const char * data () const { return rep_->str; }
+ const { return rep_->size; }
+ const { return rep_->size; }
+bool empty () const { return rep_->size == 0; }
+ const { return rep_->capacity; }
+const char & at (size_type index) const
+ {
+return rep_->str[ index ];
+char & operator [] (size_type index) const
+ {
+return rep_->str[ index ];
+char lookup) const
+ {
+return find(lookup, 0);
+char tofind, size_type offset) const
+ {
+if (offset >= length()) return npos;
+for (const char * p = c_str() + offset; *p != '\0' ; ++p)
+if (*p == tofind) return static_cast< size_type > ( p - c_str() );
+return npos;
+void clear ()
+void reserve (size_type cap);
+const char * str, size_type len);
+const char * str, size_type len);
+void swap (TiXmlString& other)
+private :
+void init(size_type sz) { init(sz, sz); }
+void set_size(size_type sz) { rep_->str[ rep_->size = sz ] = '\0' ; }
+char * start() const { return rep_->str; }
+char * finish() const { return rep_->str + rep_->size; }
+struct Rep
+char str[1];
+void init(size_type sz, size_type cap)
+if (cap)
+const size_type bytesNeeded = sizeof (Rep) + cap;
+const size_type intsNeeded = ( bytesNeeded + sizeof (int) - 1 ) / sizeof ( int );
+reinterpret_cast< Rep*> ( new int [ intsNeeded ] );
+'\0' ;
+else
+void quit()
+if (rep_ != &nullrep_)
+delete [] ( reinterpret_cast< int *> ( rep_ ) );
+static Rep nullrep_;
+inline bool operator == (const TiXmlString & a, const TiXmlString & b)
+return ( a.length() == b.length() )
+inline bool operator < (const TiXmlString & a, const TiXmlString & b)
+return strcmp(a.c_str(), b.c_str()) < 0;
+inline bool operator != (const TiXmlString & a, const TiXmlString & b) { return !(a == b); }
+inline bool operator > (const TiXmlString & a, const TiXmlString & b) { return b < a; }
+inline bool operator <= (const TiXmlString & a, const TiXmlString & b) { return !(b < a); }
+inline bool operator >= (const TiXmlString & a, const TiXmlString & b) { return !(a < b); }
+inline bool operator == (const TiXmlString & a, const char * b) { return strcmp(a.c_str(), b) == 0; }
+inline bool operator == (const char * a, const TiXmlString & b) { return b == a; }
+inline bool operator != (const TiXmlString & a, const char * b) { return !(a == b); }
+inline bool operator != (const char * a, const TiXmlString & b) { return !(b == a); }
+const TiXmlString & a, const TiXmlString & b);
+const TiXmlString & a, const char * b);
+const char * a, const TiXmlString & b);
+class TiXmlOutStream : public TiXmlString
+public :
+const TiXmlString & in)
+this += in;
+return *this ;
+const char * in)
+this += in;
+return *this ;
+#endif // TIXML_STRING_INCLUDED
+#endif // TIXML_USE_STL
+Generated by
+
+ 1.6.2 TinyXml: tinyxml.h Source File
-tinyxml.h #ifndef TINYXML_INCLUDED
-#define TINYXML_INCLUDED
-#ifdef _MSC_VER
-#pragma warning( push )
-#pragma warning( disable : 4530 )
-#pragma warning( disable : 4786 )
-#endif
-#include <ctype.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <assert.h>
-#if defined( _DEBUG ) && !defined( DEBUG )
-#define DEBUG
-#endif
-#ifdef TIXML_USE_STL
- #include <string>
- #include <iostream>
- #include <sstream>
- #define TIXML_STRING std::string
-#else
- #include "tinystr.h"
- #define TIXML_STRING TiXmlString
-#endif
-#define TIXML_SAFE
-#ifdef TIXML_SAFE
- #if defined(_MSC_VER) && (_MSC_VER >= 1400 )
- #define TIXML_SNPRINTF _snprintf_s
- #define TIXML_SNSCANF _snscanf_s
- #define TIXML_SSCANF sscanf_s
- #elif defined(_MSC_VER) && (_MSC_VER >= 1200 )
- #define TIXML_SNPRINTF _snprintf
- #define TIXML_SNSCANF _snscanf
- #define TIXML_SSCANF sscanf
- #elif defined(__GNUC__) && (__GNUC__ >= 3 )
- #define TIXML_SNPRINTF snprintf
- #define TIXML_SNSCANF snscanf
- #define TIXML_SSCANF sscanf
- #else
- #define TIXML_SSCANF sscanf
- #endif
-#endif
-class TiXmlDocument ;
-class TiXmlElement ;
-class TiXmlComment ;
-class TiXmlUnknown ;
-class TiXmlAttribute ;
-class TiXmlText ;
-class TiXmlDeclaration ;
-class TiXmlParsingData;
-const int TIXML_MAJOR_VERSION = 2;
-const int TIXML_MINOR_VERSION = 5;
-const int TIXML_PATCH_VERSION = 3;
-struct TiXmlCursor
-void Clear() { row = col = -1; }
-int row;
-int col;
-00129 class TiXmlVisitor
-public :
-virtual ~TiXmlVisitor () {}
-00135 virtual bool VisitEnter ( const TiXmlDocument & ) { return true ; }
-00137 virtual bool VisitExit ( const TiXmlDocument & ) { return true ; }
-00140 virtual bool VisitEnter ( const TiXmlElement & , const TiXmlAttribute * ) { return true ; }
-00142 virtual bool VisitExit ( const TiXmlElement & ) { return true ; }
-00145 virtual bool Visit ( const TiXmlDeclaration & ) { return true ; }
-00147 virtual bool Visit ( const TiXmlText & ) { return true ; }
-00149 virtual bool Visit ( const TiXmlComment & ) { return true ; }
-00151 virtual bool Visit ( const TiXmlUnknown & ) { return true ; }
-enum
-enum TiXmlEncoding
-const TiXmlEncoding TIXML_DEFAULT_ENCODING = TIXML_ENCODING_UNKNOWN;
-00195 class TiXmlBase
-friend class TiXmlNode ;
-friend class TiXmlElement ;
-friend class TiXmlDocument ;
-public :
-TiXmlBase () : userData (0) {}
-virtual ~TiXmlBase () {}
-virtual void Print ( FILE* cfile, int depth ) const = 0;
-00222 static void SetCondenseWhiteSpace ( bool condense ) { condenseWhiteSpace = condense; }
-00225 static bool IsWhiteSpaceCondensed () { return condenseWhiteSpace; }
-00245 int Row () const { return location.row + 1; }
-00246 int Column () const { return location.col + 1; }
-00248 void SetUserData ( void * user ) { userData = user; }
-00249 void * GetUserData () { return userData ; }
-00250 const void * GetUserData () const { return userData ; }
-static const int utf8ByteTable[256];
-virtual const char * Parse ( const char * p,
-static void EncodeString ( const TIXML_STRING& str, TIXML_STRING* out );
-enum
-protected :
-static const char * SkipWhiteSpace( const char *, TiXmlEncoding encoding );
-inline static bool IsWhiteSpace( char c )
-return ( isspace( (unsigned char ) c ) || c == '\n' || c == '\r' );
-inline static bool IsWhiteSpace( int c )
-if ( c < 256 )
-return IsWhiteSpace( (char ) c );
-return false ;
- #ifdef TIXML_USE_STL
-static bool StreamWhiteSpace( std::istream * in, TIXML_STRING * tag );
-static bool StreamTo( std::istream * in, int character, TIXML_STRING * tag );
- #endif
-static const char * ReadName( const char * p, TIXML_STRING* name, TiXmlEncoding encoding );
-static const char * ReadText( const char * in,
-bool ignoreWhiteSpace,
-const char * endTag,
-bool ignoreCase,
-static const char * GetEntity( const char * in, char * value, int * length, TiXmlEncoding encoding );
-inline static const char * GetChar( const char * p, char * _value, int * length, TiXmlEncoding encoding )
-if ( encoding == TIXML_ENCODING_UTF8 )
-const unsigned char *)p) ];
-else
-if ( *length == 1 )
-if ( *p == '&' )
-return GetEntity( p, _value, length, encoding );
-return p+1;
-else if ( *length )
-for ( int i=0; p[i] && i<*length; ++i ) {
-return p + (*length);
-else
-return 0;
-static bool StringEqual( const char * p,
-const char * endTag,
-bool ignoreCase,
-static const char * errorString[ TIXML_ERROR_STRING_COUNT ];
-00377 void * userData ;
-static int IsAlpha( unsigned char anyByte, TiXmlEncoding encoding );
-static int IsAlphaNum( unsigned char anyByte, TiXmlEncoding encoding );
-inline static int ToLower( int v, TiXmlEncoding encoding )
-if ( encoding == TIXML_ENCODING_UTF8 )
-if ( v < 128 ) return tolower( v );
-return v;
-else
-return tolower( v );
-static void ConvertUTF32ToUTF8( unsigned long input, char * output, int * length );
-private :
-TiXmlBase ( const TiXmlBase & );
-void operator=( const TiXmlBase & base );
-struct Entity
-const char * str;
-unsigned int strLength;
-char chr;
-enum
-static Entity entity[ NUM_ENTITY ];
-static bool condenseWhiteSpace;
-00424 class TiXmlNode : public TiXmlBase
-friend class TiXmlDocument ;
-friend class TiXmlElement ;
-public :
- #ifdef TIXML_USE_STL
-friend std::istream& operator >> (std::istream& in, TiXmlNode & base);
-friend std::ostream& operator<< (std::ostream& out, const TiXmlNode & base);
-friend std::string& operator<< (std::string& out, const TiXmlNode & base );
- #endif
-00463 enum NodeType
-virtual ~TiXmlNode ();
-00488 const char *Value () const { return value.c_str (); }
- #ifdef TIXML_USE_STL
-00495 const std::string& ValueStr () const { return value; }
- #endif
-const TIXML_STRING& ValueTStr() const { return value; }
-00509 void SetValue (const char * _value) { value = _value;}
- #ifdef TIXML_USE_STL
-00513 void SetValue( const std::string& _value ) { value = _value; }
- #endif
-void Clear ();
-00520 TiXmlNode * Parent () { return parent; }
-const TiXmlNode * Parent () const { return parent; }
-00523 const TiXmlNode * FirstChild () const { return firstChild; }
-TiXmlNode * FirstChild () { return firstChild; }
-const TiXmlNode * FirstChild ( const char * value ) const ;
-00527 TiXmlNode * FirstChild ( const char * _value ) {
-return const_cast< TiXmlNode* > ((const_cast< const TiXmlNode* >(this ))->FirstChild( _value ));
-const TiXmlNode * LastChild() const { return lastChild; }
-00533 TiXmlNode * LastChild() { return lastChild; }
-const TiXmlNode * LastChild( const char * value ) const ;
-00536 TiXmlNode * LastChild( const char * _value ) {
-return const_cast< TiXmlNode* > ((const_cast< const TiXmlNode* >(this ))->LastChild( _value ));
- #ifdef TIXML_USE_STL
-00541 const TiXmlNode * FirstChild ( const std::string& _value ) const { return FirstChild (_value.c_str ()); }
-00542 TiXmlNode * FirstChild ( const std::string& _value ) { return FirstChild (_value.c_str ()); }
-00543 const TiXmlNode * LastChild( const std::string& _value ) const { return LastChild (_value.c_str ()); }
-00544 TiXmlNode * LastChild( const std::string& _value ) { return LastChild (_value.c_str ()); }
- #endif
-const TiXmlNode * IterateChildren ( const TiXmlNode * previous ) const ;
-TiXmlNode * IterateChildren ( const TiXmlNode * previous ) {
-return const_cast< TiXmlNode* >( (const_cast< const TiXmlNode* >(this ))->IterateChildren( previous ) );
-const TiXmlNode * IterateChildren ( const char * value, const TiXmlNode * previous ) const ;
-TiXmlNode * IterateChildren ( const char * _value, const TiXmlNode * previous ) {
-return const_cast< TiXmlNode* >( (const_cast< const TiXmlNode* >(this ))->IterateChildren( _value, previous ) );
- #ifdef TIXML_USE_STL
-00575 const TiXmlNode * IterateChildren ( const std::string& _value, const TiXmlNode * previous ) const { return IterateChildren (_value.c_str (), previous); }
-00576 TiXmlNode * IterateChildren ( const std::string& _value, const TiXmlNode * previous ) { return IterateChildren (_value.c_str (), previous); }
- #endif
-TiXmlNode * InsertEndChild ( const TiXmlNode & addThis );
-TiXmlNode * LinkEndChild ( TiXmlNode * addThis );
-TiXmlNode * InsertBeforeChild ( TiXmlNode * beforeThis, const TiXmlNode & addThis );
-TiXmlNode * InsertAfterChild ( TiXmlNode * afterThis, const TiXmlNode & addThis );
-TiXmlNode * ReplaceChild ( TiXmlNode * replaceThis, const TiXmlNode & withThis );
-bool RemoveChild ( TiXmlNode * removeThis );
-00615 const TiXmlNode * PreviousSibling () const { return prev; }
-TiXmlNode * PreviousSibling () { return prev; }
-const TiXmlNode * PreviousSibling ( const char * ) const ;
-TiXmlNode * PreviousSibling ( const char *_prev ) {
-return const_cast< TiXmlNode* >( (const_cast< const TiXmlNode* >(this ))->PreviousSibling( _prev ) );
- #ifdef TIXML_USE_STL
-00625 const TiXmlNode * PreviousSibling ( const std::string& _value ) const { return PreviousSibling (_value.c_str ()); }
-00626 TiXmlNode * PreviousSibling ( const std::string& _value ) { return PreviousSibling (_value.c_str ()); }
-00627 const TiXmlNode * NextSibling ( const std::string& _value) const { return NextSibling (_value.c_str ()); }
-00628 TiXmlNode * NextSibling ( const std::string& _value) { return NextSibling (_value.c_str ()); }
- #endif
-00632 const TiXmlNode * NextSibling () const { return next; }
-TiXmlNode * NextSibling () { return next; }
-const TiXmlNode * NextSibling ( const char * ) const ;
-TiXmlNode * NextSibling ( const char * _next ) {
-return const_cast< TiXmlNode* >( (const_cast< const TiXmlNode* >(this ))->NextSibling( _next ) );
-const TiXmlElement * NextSiblingElement () const ;
-TiXmlElement * NextSiblingElement () {
-return const_cast< TiXmlElement* >( (const_cast< const TiXmlNode* >(this ))->NextSiblingElement() );
-const TiXmlElement * NextSiblingElement ( const char * ) const ;
-TiXmlElement * NextSiblingElement ( const char *_next ) {
-return const_cast< TiXmlElement* >( (const_cast< const TiXmlNode* >(this ))->NextSiblingElement( _next ) );
- #ifdef TIXML_USE_STL
-00660 const TiXmlElement * NextSiblingElement ( const std::string& _value) const { return NextSiblingElement (_value.c_str ()); }
-00661 TiXmlElement * NextSiblingElement ( const std::string& _value) { return NextSiblingElement (_value.c_str ()); }
- #endif
-const TiXmlElement * FirstChildElement () const ;
-TiXmlElement * FirstChildElement () {
-return const_cast< TiXmlElement* >( (const_cast< const TiXmlNode* >(this ))->FirstChildElement() );
-const TiXmlElement * FirstChildElement ( const char * _value ) const ;
-TiXmlElement * FirstChildElement ( const char * _value ) {
-return const_cast< TiXmlElement* >( (const_cast< const TiXmlNode* >(this ))->FirstChildElement( _value ) );
- #ifdef TIXML_USE_STL
-00677 const TiXmlElement * FirstChildElement ( const std::string& _value ) const { return FirstChildElement (_value.c_str ()); }
-00678 TiXmlElement * FirstChildElement ( const std::string& _value ) { return FirstChildElement (_value.c_str ()); }
- #endif
-00685 int Type () const { return type; }
-const TiXmlDocument * GetDocument () const ;
-TiXmlDocument * GetDocument () {
-return const_cast< TiXmlDocument* >( (const_cast< const TiXmlNode* >(this ))->GetDocument() );
-00696 bool NoChildren () const { return !firstChild; }
-00698 virtual const TiXmlDocument * ToDocument () const { return 0; }
-00699 virtual const TiXmlElement * ToElement () const { return 0; }
-00700 virtual const TiXmlComment * ToComment () const { return 0; }
-00701 virtual const TiXmlUnknown * ToUnknown () const { return 0; }
-00702 virtual const TiXmlText * ToText () const { return 0; }
-00703 virtual const TiXmlDeclaration * ToDeclaration () const { return 0; }
-00705 virtual TiXmlDocument * ToDocument () { return 0; }
-00706 virtual TiXmlElement * ToElement () { return 0; }
-00707 virtual TiXmlComment * ToComment () { return 0; }
-00708 virtual TiXmlUnknown * ToUnknown () { return 0; }
-00709 virtual TiXmlText * ToText () { return 0; }
-00710 virtual TiXmlDeclaration * ToDeclaration () { return 0; }
-virtual TiXmlNode * Clone () const = 0;
-virtual bool Accept ( TiXmlVisitor * visitor ) const = 0;
-protected :
-TiXmlNode ( NodeType _type );
-void CopyTo( TiXmlNode * target ) const ;
- #ifdef TIXML_USE_STL
-virtual void StreamIn( std::istream* in, TIXML_STRING* tag ) = 0;
- #endif
-TiXmlNode * Identify( const char * start, TiXmlEncoding encoding );
-TiXmlNode * parent;
-NodeType type;
-TiXmlNode * firstChild;
-TiXmlNode * lastChild;
-TiXmlNode * prev;
-TiXmlNode * next;
-private :
-TiXmlNode ( const TiXmlNode & );
-void operator=( const TiXmlNode & base );
-00780 class TiXmlAttribute : public TiXmlBase
-friend class TiXmlAttributeSet;
-public :
-00786 TiXmlAttribute () : TiXmlBase ()
- #ifdef TIXML_USE_STL
-00794 TiXmlAttribute( const std::string& _name, const std::string& _value )
- #endif
-00804 TiXmlAttribute ( const char * _name, const char * _value )
-00812 const char * Name () const { return name.c_str(); }
-00813 const char * Value () const { return value.c_str(); }
- #ifdef TIXML_USE_STL
-00815 const std::string& ValueStr () const { return value; }
- #endif
-int IntValue () const ;
-double DoubleValue () const ;
-const TIXML_STRING& NameTStr() const { return name; }
-int QueryIntValue ( int * _value ) const ;
-int QueryDoubleValue ( double * _value ) const ;
-00836 void SetName ( const char * _name ) { name = _name; }
-00837 void SetValue ( const char * _value ) { value = _value; }
-void SetIntValue ( int _value );
-void SetDoubleValue ( double _value );
- #ifdef TIXML_USE_STL
-00844 void SetName( const std::string& _name ) { name = _name; }
-00846 void SetValue( const std::string& _value ) { value = _value; }
- #endif
-const TiXmlAttribute * Next () const ;
-TiXmlAttribute * Next () {
-return const_cast< TiXmlAttribute* >( (const_cast< const TiXmlAttribute* >(this ))->Next() );
-const TiXmlAttribute * Previous () const ;
-TiXmlAttribute * Previous () {
-return const_cast< TiXmlAttribute* >( (const_cast< const TiXmlAttribute* >(this ))->Previous() );
-bool operator==( const TiXmlAttribute & rhs ) const { return rhs.name == name; }
-bool operator<( const TiXmlAttribute & rhs ) const { return name < rhs.name ; }
-bool operator>( const TiXmlAttribute & rhs ) const { return name > rhs.name ; }
-virtual const char * Parse( const char * p, TiXmlParsingData* data, TiXmlEncoding encoding );
-00871 virtual void Print ( FILE* cfile, int depth ) const {
-Print ( cfile, depth, 0 );
-void Print ( FILE* cfile, int depth, TIXML_STRING* str ) const ;
-void SetDocument( TiXmlDocument * doc ) { document = doc; }
-private :
-TiXmlAttribute ( const TiXmlAttribute & );
-void operator=( const TiXmlAttribute & base );
-TiXmlDocument * document;
-TiXmlAttribute * prev;
-TiXmlAttribute * next;
-class TiXmlAttributeSet
-public :
-void Add( TiXmlAttribute * attribute );
-void Remove( TiXmlAttribute * attribute );
-const TiXmlAttribute * First() const { return ( sentinel.next == &sentinel ) ? 0 : sentinel.next; }
-TiXmlAttribute * First() { return ( sentinel.next == &sentinel ) ? 0 : sentinel.next; }
-const TiXmlAttribute * Last() const { return ( sentinel.prev == &sentinel ) ? 0 : sentinel.prev; }
-TiXmlAttribute * Last() { return ( sentinel.prev == &sentinel ) ? 0 : sentinel.prev; }
-const TiXmlAttribute * Find( const char * _name ) const ;
-TiXmlAttribute * Find( const char * _name ) {
-return const_cast< TiXmlAttribute* >( (const_cast< const TiXmlAttributeSet* >(this ))->Find( _name ) );
- #ifdef TIXML_USE_STL
-const TiXmlAttribute * Find( const std::string& _name ) const ;
-TiXmlAttribute * Find( const std::string& _name ) {
-return const_cast< TiXmlAttribute* >( (const_cast< const TiXmlAttributeSet* >(this ))->Find( _name ) );
- #endif
-private :
-const TiXmlAttributeSet& );
-void operator=( const TiXmlAttributeSet& );
-TiXmlAttribute sentinel;
-00944 class TiXmlElement : public TiXmlNode
-public :
-TiXmlElement (const char * in_value);
- #ifdef TIXML_USE_STL
- TiXmlElement( const std::string& _value );
- #endif
-TiXmlElement ( const TiXmlElement & );
-void operator=( const TiXmlElement & base );
-virtual ~TiXmlElement ();
-const char * Attribute ( const char * name ) const ;
-const char * Attribute ( const char * name, int * i ) const ;
-const char * Attribute ( const char * name, double * d ) const ;
-int QueryIntAttribute ( const char * name, int * _value ) const ;
-int QueryDoubleAttribute ( const char * name, double * _value ) const ;
-00993 int QueryFloatAttribute ( const char * name, float * _value ) const {
-double d;
-int result = QueryDoubleAttribute ( name, &d );
-if ( result == TIXML_SUCCESS ) {
-return result;
- #ifdef TIXML_USE_STL
-01011 template < typename T > int QueryValueAttribute ( const std::string& name, T* outValue ) const
- {
-const TiXmlAttribute * node = attributeSet.Find( name );
-if ( !node )
-return TIXML_NO_ATTRIBUTE;
-ValueStr () );
-if ( !sstream.fail() )
-return TIXML_SUCCESS;
-return TIXML_WRONG_TYPE;
- #endif
-void SetAttribute ( const char * name, const char * _value );
- #ifdef TIXML_USE_STL
-const std::string* Attribute ( const std::string& name ) const ;
-const std::string* Attribute ( const std::string& name, int * i ) const ;
-const std::string* Attribute ( const std::string& name, double * d ) const ;
-int QueryIntAttribute ( const std::string& name, int * _value ) const ;
-int QueryDoubleAttribute ( const std::string& name, double * _value ) const ;
-void SetAttribute ( const std::string& name, const std::string& _value );
-void SetAttribute ( const std::string& name, int _value );
- #endif
-void SetAttribute ( const char * name, int value );
-void SetDoubleAttribute ( const char * name, double value );
-void RemoveAttribute ( const char * name );
- #ifdef TIXML_USE_STL
-01072 void RemoveAttribute ( const std::string& name ) { RemoveAttribute (name.c_str ()); }
- #endif
-01075 const TiXmlAttribute * FirstAttribute () const { return attributeSet.First(); }
-TiXmlAttribute * FirstAttribute () { return attributeSet.First(); }
-01077 const TiXmlAttribute * LastAttribute () const { return attributeSet.Last(); }
-TiXmlAttribute * LastAttribute () { return attributeSet.Last(); }
-const char * GetText () const ;
-virtual TiXmlNode * Clone () const ;
-virtual void Print ( FILE* cfile, int depth ) const ;
-virtual const char * Parse( const char * p, TiXmlParsingData* data, TiXmlEncoding encoding );
-01124 virtual const TiXmlElement * ToElement () const { return this ; }
-01125 virtual TiXmlElement * ToElement () { return this ; }
-virtual bool Accept ( TiXmlVisitor * visitor ) const ;
-protected :
-void CopyTo( TiXmlElement * target ) const ;
-void ClearThis();
- #ifdef TIXML_USE_STL
-virtual void StreamIn( std::istream * in, TIXML_STRING * tag );
- #endif
-const char * ReadValue( const char * in, TiXmlParsingData* prevData, TiXmlEncoding encoding );
-private :
-01154 class TiXmlComment : public TiXmlNode
-public :
-01158 TiXmlComment () : TiXmlNode ( TiXmlNode ::COMMENT ) {}
-01160 TiXmlComment ( const char * _value ) : TiXmlNode ( TiXmlNode ::COMMENT ) {
-SetValue ( _value );
-TiXmlComment ( const TiXmlComment & );
-void operator=( const TiXmlComment & base );
-virtual ~TiXmlComment () {}
-virtual TiXmlNode * Clone () const ;
-virtual void Print ( FILE* cfile, int depth ) const ;
-virtual const char * Parse( const char * p, TiXmlParsingData* data, TiXmlEncoding encoding );
-01178 virtual const TiXmlComment * ToComment () const { return this ; }
-01179 virtual TiXmlComment * ToComment () { return this ; }
-virtual bool Accept ( TiXmlVisitor * visitor ) const ;
-protected :
-void CopyTo( TiXmlComment * target ) const ;
- #ifdef TIXML_USE_STL
-virtual void StreamIn( std::istream * in, TIXML_STRING * tag );
- #endif
-private :
-01204 class TiXmlText : public TiXmlNode
-friend class TiXmlElement ;
-public :
-01212 TiXmlText (const char * initValue ) : TiXmlNode (TiXmlNode ::TEXT)
-SetValue ( initValue );
-false ;
-virtual ~TiXmlText () {}
- #ifdef TIXML_USE_STL
-01221 TiXmlText( const std::string& initValue ) : TiXmlNode (TiXmlNode::TEXT)
-SetValue ( initValue );
-false ;
- #endif
-TiXmlText ( const TiXmlText & copy ) : TiXmlNode ( TiXmlNode ::TEXT ) { copy.CopyTo ( this ); }
-void operator=( const TiXmlText & base ) { base.CopyTo ( this ); }
-virtual void Print ( FILE* cfile, int depth ) const ;
-01235 bool CDATA () const { return cdata; }
-01237 void SetCDATA ( bool _cdata ) { cdata = _cdata; }
-virtual const char * Parse( const char * p, TiXmlParsingData* data, TiXmlEncoding encoding );
-01241 virtual const TiXmlText * ToText () const { return this ; }
-01242 virtual TiXmlText * ToText () { return this ; }
-virtual bool Accept ( TiXmlVisitor * content ) const ;
-protected :
-virtual TiXmlNode * Clone () const ;
-void CopyTo( TiXmlText * target ) const ;
-bool Blank() const ;
- #ifdef TIXML_USE_STL
-virtual void StreamIn( std::istream * in, TIXML_STRING * tag );
- #endif
-private :
-bool cdata;
-01277 class TiXmlDeclaration : public TiXmlNode
-public :
-01281 TiXmlDeclaration () : TiXmlNode ( TiXmlNode ::DECLARATION ) {}
-#ifdef TIXML_USE_STL
- TiXmlDeclaration( const std::string& _version,
-const std::string& _encoding,
-const std::string& _standalone );
-#endif
-TiXmlDeclaration ( const char * _version,
-const char * _encoding,
-const char * _standalone );
-TiXmlDeclaration ( const TiXmlDeclaration & copy );
-void operator=( const TiXmlDeclaration & copy );
-virtual ~TiXmlDeclaration () {}
-01301 const char *Version () const { return version.c_str (); }
-01303 const char *Encoding () const { return encoding.c_str (); }
-01305 const char *Standalone () const { return standalone.c_str (); }
-virtual TiXmlNode * Clone () const ;
-virtual void Print( FILE* cfile, int depth, TIXML_STRING* str ) const ;
-01311 virtual void Print( FILE* cfile, int depth ) const {
-virtual const char * Parse( const char * p, TiXmlParsingData* data, TiXmlEncoding encoding );
-01317 virtual const TiXmlDeclaration * ToDeclaration () const { return this ; }
-01318 virtual TiXmlDeclaration * ToDeclaration () { return this ; }
-virtual bool Accept ( TiXmlVisitor * visitor ) const ;
-protected :
-void CopyTo( TiXmlDeclaration * target ) const ;
- #ifdef TIXML_USE_STL
-virtual void StreamIn( std::istream * in, TIXML_STRING * tag );
- #endif
-private :
-01346 class TiXmlUnknown : public TiXmlNode
-public :
-TiXmlUnknown () : TiXmlNode ( TiXmlNode::UNKNOWN ) {}
-virtual ~TiXmlUnknown () {}
-TiXmlUnknown ( const TiXmlUnknown & copy ) : TiXmlNode ( TiXmlNode::UNKNOWN ) { copy.CopyTo ( this ); }
-void operator=( const TiXmlUnknown & copy ) { copy.CopyTo ( this ); }
-virtual TiXmlNode * Clone () const ;
-virtual void Print ( FILE* cfile, int depth ) const ;
-virtual const char * Parse( const char * p, TiXmlParsingData* data, TiXmlEncoding encoding );
-01362 virtual const TiXmlUnknown * ToUnknown () const { return this ; }
-01363 virtual TiXmlUnknown * ToUnknown () { return this ; }
-virtual bool Accept ( TiXmlVisitor * content ) const ;
-protected :
-void CopyTo( TiXmlUnknown * target ) const ;
- #ifdef TIXML_USE_STL
-virtual void StreamIn( std::istream * in, TIXML_STRING * tag );
- #endif
-private :
-01385 class TiXmlDocument : public TiXmlNode
-public :
-TiXmlDocument ();
-TiXmlDocument ( const char * documentName );
- #ifdef TIXML_USE_STL
- TiXmlDocument( const std::string& documentName );
- #endif
-TiXmlDocument ( const TiXmlDocument & copy );
-void operator=( const TiXmlDocument & copy );
-virtual ~TiXmlDocument () {}
-bool LoadFile ( TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING );
-bool SaveFile () const ;
-bool LoadFile ( const char * filename, TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING );
-bool SaveFile ( const char * filename ) const ;
-bool LoadFile ( FILE*, TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING );
-bool SaveFile ( FILE* ) const ;
- #ifdef TIXML_USE_STL
-01424 bool LoadFile ( const std::string& filename, TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING )
-return LoadFile ( filename.c_str(), encoding );
-01430 bool SaveFile ( const std::string& filename ) const
-return SaveFile ( filename.c_str() );
- #endif
-virtual const char * Parse ( const char * p, TiXmlParsingData* data = 0, TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING );
-01448 const TiXmlElement * RootElement () const { return FirstChildElement (); }
-TiXmlElement * RootElement () { return FirstChildElement (); }
-01456 bool Error () const { return error; }
-01459 const char * ErrorDesc () const { return errorDesc.c_str (); }
-01464 int ErrorId () const { return errorId; }
-01473 int ErrorRow () const { return errorLocation.row+1; }
-01474 int ErrorCol () const { return errorLocation.col+1; }
-01500 void SetTabSize ( int _tabsize ) { tabsize = _tabsize; }
-int TabSize() const { return tabsize; }
-01507 void ClearError () { error = false ;
-"" ;
-01515 void Print () const { Print ( stdout, 0 ); }
-virtual void Print ( FILE* cfile, int depth = 0 ) const ;
-void SetError( int err, const char * errorLocation, TiXmlParsingData* prevData, TiXmlEncoding encoding );
-01528 virtual const TiXmlDocument * ToDocument () const { return this ; }
-01529 virtual TiXmlDocument * ToDocument () { return this ; }
-virtual bool Accept ( TiXmlVisitor * content ) const ;
-protected :
-virtual TiXmlNode * Clone () const ;
- #ifdef TIXML_USE_STL
-virtual void StreamIn( std::istream * in, TIXML_STRING * tag );
- #endif
-private :
-void CopyTo( TiXmlDocument * target ) const ;
-bool error;
-int errorId;
-int tabsize;
-bool useMicrosoftBOM;
-01634 class TiXmlHandle
-public :
-01638 TiXmlHandle ( TiXmlNode * _node ) { this->node = _node; }
-01640 TiXmlHandle ( const TiXmlHandle & ref ) { this->node = ref.node ; }
-TiXmlHandle operator=( const TiXmlHandle & ref ) { this->node = ref.node ; return *this ; }
-TiXmlHandle FirstChild () const ;
-TiXmlHandle FirstChild ( const char * value ) const ;
-TiXmlHandle FirstChildElement () const ;
-TiXmlHandle FirstChildElement ( const char * value ) const ;
-TiXmlHandle Child ( const char * value, int index ) const ;
-TiXmlHandle Child ( int index ) const ;
-TiXmlHandle ChildElement ( const char * value, int index ) const ;
-TiXmlHandle ChildElement ( int index ) const ;
- #ifdef TIXML_USE_STL
-TiXmlHandle FirstChild ( const std::string& _value ) const { return FirstChild ( _value.c_str() ); }
-TiXmlHandle FirstChildElement ( const std::string& _value ) const { return FirstChildElement ( _value.c_str() ); }
-TiXmlHandle Child ( const std::string& _value, int index ) const { return Child ( _value.c_str(), index ); }
-TiXmlHandle ChildElement ( const std::string& _value, int index ) const { return ChildElement ( _value.c_str(), index ); }
- #endif
-01681 TiXmlNode * ToNode () const { return node; }
-01684 TiXmlElement * ToElement () const { return ( ( node && node->ToElement () ) ? node->ToElement () : 0 ); }
-01687 TiXmlText * ToText () const { return ( ( node && node->ToText () ) ? node->ToText () : 0 ); }
-01690 TiXmlUnknown * ToUnknown () const { return ( ( node && node->ToUnknown () ) ? node->ToUnknown () : 0 ); }
-01695 TiXmlNode * Node () const { return ToNode (); }
-01699 TiXmlElement * Element () const { return ToElement (); }
-01703 TiXmlText * Text () const { return ToText (); }
-01707 TiXmlUnknown * Unknown () const { return ToUnknown (); }
-private :
-TiXmlNode * node;
-01733 class TiXmlPrinter : public TiXmlVisitor
-public :
-TiXmlPrinter () : depth( 0 ), simpleTextPrint( false ),
-" " ), lineBreak( "\n" ) {}
-virtual bool VisitEnter ( const TiXmlDocument & doc );
-virtual bool VisitExit ( const TiXmlDocument & doc );
-virtual bool VisitEnter ( const TiXmlElement & element, const TiXmlAttribute * firstAttribute );
-virtual bool VisitExit ( const TiXmlElement & element );
-virtual bool Visit ( const TiXmlDeclaration & declaration );
-virtual bool Visit ( const TiXmlText & text );
-virtual bool Visit ( const TiXmlComment & comment );
-virtual bool Visit ( const TiXmlUnknown & unknown );
-01753 void SetIndent ( const char * _indent ) { indent = _indent ? _indent : "" ; }
-01755 const char * Indent () { return indent.c_str(); }
-01760 void SetLineBreak ( const char * _lineBreak ) { lineBreak = _lineBreak ? _lineBreak : "" ; }
-01762 const char * LineBreak () { return lineBreak.c_str(); }
-01767 void SetStreamPrinting () { indent = "" ;
-"" ;
-01771 const char * CStr () { return buffer.c_str(); }
-01773 size_t Size () { return buffer.size(); }
- #ifdef TIXML_USE_STL
-01777 const std::string& Str() { return buffer; }
- #endif
-private :
-void DoIndent() {
-for ( int i=0; i<depth; ++i )
-void DoLineBreak() {
-int depth;
-bool simpleTextPrint;
-#ifdef _MSC_VER
-#pragma warning( pop )
-#endif
-#endif
-Generated on Sun May 6 15:41:23 2007 for TinyXml by
-
- 1.4.7 TinyXml: tinyxml.h Source File
+
+
+
+
tinyxml.h #ifndef TINYXML_INCLUDED
+#define TINYXML_INCLUDED
+#ifdef _MSC_VER
+#pragma warning( push )
+#pragma warning( disable : 4530 )
+#pragma warning( disable : 4786 )
+#endif
+#include <ctype.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#if defined( _DEBUG ) && !defined( DEBUG )
+#define DEBUG
+#endif
+#ifdef TIXML_USE_STL
+ #include <string>
+ #include <iostream>
+ #include <sstream>
+ #define TIXML_STRING std::string
+#else
+ #include "tinystr.h"
+ #define TIXML_STRING TiXmlString
+#endif
+#define TIXML_SAFE
+#ifdef TIXML_SAFE
+ #if defined(_MSC_VER) && (_MSC_VER >= 1400 )
+ #define TIXML_SNPRINTF _snprintf_s
+ #define TIXML_SSCANF sscanf_s
+ #elif defined(_MSC_VER) && (_MSC_VER >= 1200 )
+ #define TIXML_SNPRINTF _snprintf
+ #define TIXML_SSCANF sscanf
+ #elif defined(__GNUC__) && (__GNUC__ >= 3 )
+ #define TIXML_SNPRINTF snprintf
+ #define TIXML_SSCANF sscanf
+ #else
+ #define TIXML_SNPRINTF snprintf
+ #define TIXML_SSCANF sscanf
+ #endif
+#endif
+class TiXmlDocument ;
+class TiXmlElement ;
+class TiXmlComment ;
+class TiXmlUnknown ;
+class TiXmlAttribute ;
+class TiXmlText ;
+class TiXmlDeclaration ;
+class TiXmlParsingData;
+const int TIXML_MAJOR_VERSION = 2;
+const int TIXML_MINOR_VERSION = 6;
+const int TIXML_PATCH_VERSION = 2;
+struct TiXmlCursor
+void Clear() { row = col = -1; }
+int row;
+int col;
+00128 class TiXmlVisitor
+public :
+virtual ~TiXmlVisitor () {}
+00134 virtual bool VisitEnter ( const TiXmlDocument & ) { return true ; }
+00136 virtual bool VisitExit ( const TiXmlDocument & ) { return true ; }
+00139 virtual bool VisitEnter ( const TiXmlElement & , const TiXmlAttribute * ) { return true ; }
+00141 virtual bool VisitExit ( const TiXmlElement & ) { return true ; }
+00144 virtual bool Visit ( const TiXmlDeclaration & ) { return true ; }
+00146 virtual bool Visit ( const TiXmlText & ) { return true ; }
+00148 virtual bool Visit ( const TiXmlComment & ) { return true ; }
+00150 virtual bool Visit ( const TiXmlUnknown & ) { return true ; }
+enum
+enum TiXmlEncoding
+const TiXmlEncoding TIXML_DEFAULT_ENCODING = TIXML_ENCODING_UNKNOWN;
+00194 class TiXmlBase
+friend class TiXmlNode ;
+friend class TiXmlElement ;
+friend class TiXmlDocument ;
+public :
+TiXmlBase () : userData (0) {}
+virtual ~TiXmlBase () {}
+virtual void Print ( FILE* cfile, int depth ) const = 0;
+00221 static void SetCondenseWhiteSpace ( bool condense ) { condenseWhiteSpace = condense; }
+00224 static bool IsWhiteSpaceCondensed () { return condenseWhiteSpace; }
+00244 int Row () const { return location.row + 1; }
+00245 int Column () const { return location.col + 1; }
+00247 void SetUserData ( void * user ) { userData = user; }
+00248 void * GetUserData () { return userData ; }
+00249 const void * GetUserData () const { return userData ; }
+static const int utf8ByteTable[256];
+virtual const char * Parse ( const char * p,
+static void EncodeString ( const TIXML_STRING& str, TIXML_STRING* out );
+enum
+protected :
+static const char * SkipWhiteSpace( const char *, TiXmlEncoding encoding );
+inline static bool IsWhiteSpace( char c )
+return ( isspace( (unsigned char ) c ) || c == '\n' || c == '\r' );
+inline static bool IsWhiteSpace( int c )
+if ( c < 256 )
+return IsWhiteSpace( (char ) c );
+return false ;
+ #ifdef TIXML_USE_STL
+static bool StreamWhiteSpace( std::istream * in, TIXML_STRING * tag );
+static bool StreamTo( std::istream * in, int character, TIXML_STRING * tag );
+ #endif
+static const char * ReadName( const char * p, TIXML_STRING* name, TiXmlEncoding encoding );
+static const char * ReadText( const char * in,
+bool ignoreWhiteSpace,
+const char * endTag,
+bool ignoreCase,
+static const char * GetEntity( const char * in, char * value, int * length, TiXmlEncoding encoding );
+inline static const char * GetChar( const char * p, char * _value, int * length, TiXmlEncoding encoding )
+if ( encoding == TIXML_ENCODING_UTF8 )
+const unsigned char *)p) ];
+else
+if ( *length == 1 )
+if ( *p == '&' )
+return GetEntity( p, _value, length, encoding );
+return p+1;
+else if ( *length )
+for ( int i=0; p[i] && i<*length; ++i ) {
+return p + (*length);
+else
+return 0;
+static bool StringEqual( const char * p,
+const char * endTag,
+bool ignoreCase,
+static const char * errorString[ TIXML_ERROR_STRING_COUNT ];
+00376 void * userData ;
+static int IsAlpha( unsigned char anyByte, TiXmlEncoding encoding );
+static int IsAlphaNum( unsigned char anyByte, TiXmlEncoding encoding );
+inline static int ToLower( int v, TiXmlEncoding encoding )
+if ( encoding == TIXML_ENCODING_UTF8 )
+if ( v < 128 ) return tolower( v );
+return v;
+else
+return tolower( v );
+static void ConvertUTF32ToUTF8( unsigned long input, char * output, int * length );
+private :
+TiXmlBase ( const TiXmlBase & );
+void operator=( const TiXmlBase & base );
+struct Entity
+const char * str;
+unsigned int strLength;
+char chr;
+enum
+static Entity entity[ NUM_ENTITY ];
+static bool condenseWhiteSpace;
+00423 class TiXmlNode : public TiXmlBase
+friend class TiXmlDocument ;
+friend class TiXmlElement ;
+public :
+ #ifdef TIXML_USE_STL
+friend std::istream& operator >> (std::istream& in, TiXmlNode & base);
+friend std::ostream& operator<< (std::ostream& out, const TiXmlNode & base);
+friend std::string& operator<< (std::string& out, const TiXmlNode & base );
+ #endif
+00462 enum NodeType
+virtual ~TiXmlNode ();
+00487 const char *Value () const { return value.c_str (); }
+ #ifdef TIXML_USE_STL
+00494 const std::string& ValueStr () const { return value; }
+ #endif
+const TIXML_STRING& ValueTStr() const { return value; }
+00508 void SetValue (const char * _value) { value = _value;}
+ #ifdef TIXML_USE_STL
+00512 void SetValue( const std::string& _value ) { value = _value; }
+ #endif
+void Clear ();
+00519 TiXmlNode * Parent () { return parent; }
+const TiXmlNode * Parent () const { return parent; }
+00522 const TiXmlNode * FirstChild () const { return firstChild; }
+TiXmlNode * FirstChild () { return firstChild; }
+const TiXmlNode * FirstChild ( const char * value ) const ;
+00526 TiXmlNode * FirstChild ( const char * _value ) {
+return const_cast< TiXmlNode * > ((const_cast< const TiXmlNode * > (this ))->FirstChild( _value ));
+const TiXmlNode * LastChild() const { return lastChild; }
+00532 TiXmlNode * LastChild () { return lastChild; }
+const TiXmlNode * LastChild( const char * value ) const ;
+00535 TiXmlNode * LastChild ( const char * _value ) {
+return const_cast< TiXmlNode * > ((const_cast< const TiXmlNode * > (this ))->LastChild( _value ));
+ #ifdef TIXML_USE_STL
+00540 const TiXmlNode * FirstChild ( const std::string& _value ) const { return FirstChild (_value.c_str ()); }
+00541 TiXmlNode * FirstChild ( const std::string& _value ) { return FirstChild (_value.c_str ()); }
+00542 const TiXmlNode * LastChild ( const std::string& _value ) const { return LastChild (_value.c_str ()); }
+00543 TiXmlNode * LastChild ( const std::string& _value ) { return LastChild (_value.c_str ()); }
+ #endif
+const TiXmlNode * IterateChildren ( const TiXmlNode * previous ) const ;
+TiXmlNode * IterateChildren ( const TiXmlNode * previous ) {
+return const_cast< TiXmlNode * > ( (const_cast< const TiXmlNode * > (this ))->IterateChildren( previous ) );
+const TiXmlNode * IterateChildren ( const char * value, const TiXmlNode * previous ) const ;
+TiXmlNode * IterateChildren ( const char * _value, const TiXmlNode * previous ) {
+return const_cast< TiXmlNode * > ( (const_cast< const TiXmlNode * > (this ))->IterateChildren( _value, previous ) );
+ #ifdef TIXML_USE_STL
+00574 const TiXmlNode * IterateChildren ( const std::string& _value, const TiXmlNode * previous ) const { return IterateChildren (_value.c_str (), previous); }
+00575 TiXmlNode * IterateChildren ( const std::string& _value, const TiXmlNode * previous ) { return IterateChildren (_value.c_str (), previous); }
+ #endif
+TiXmlNode * InsertEndChild ( const TiXmlNode & addThis );
+TiXmlNode * LinkEndChild ( TiXmlNode * addThis );
+TiXmlNode * InsertBeforeChild ( TiXmlNode * beforeThis, const TiXmlNode & addThis );
+TiXmlNode * InsertAfterChild ( TiXmlNode * afterThis, const TiXmlNode & addThis );
+TiXmlNode * ReplaceChild ( TiXmlNode * replaceThis, const TiXmlNode & withThis );
+bool RemoveChild ( TiXmlNode * removeThis );
+00614 const TiXmlNode * PreviousSibling () const { return prev; }
+TiXmlNode * PreviousSibling () { return prev; }
+const TiXmlNode * PreviousSibling ( const char * ) const ;
+TiXmlNode * PreviousSibling ( const char *_prev ) {
+return const_cast< TiXmlNode * > ( (const_cast< const TiXmlNode * > (this ))->PreviousSibling( _prev ) );
+ #ifdef TIXML_USE_STL
+00624 const TiXmlNode * PreviousSibling ( const std::string& _value ) const { return PreviousSibling (_value.c_str ()); }
+00625 TiXmlNode * PreviousSibling ( const std::string& _value ) { return PreviousSibling (_value.c_str ()); }
+00626 const TiXmlNode * NextSibling ( const std::string& _value) const { return NextSibling (_value.c_str ()); }
+00627 TiXmlNode * NextSibling ( const std::string& _value) { return NextSibling (_value.c_str ()); }
+ #endif
+00631 const TiXmlNode * NextSibling () const { return next; }
+TiXmlNode * NextSibling () { return next; }
+const TiXmlNode * NextSibling ( const char * ) const ;
+TiXmlNode * NextSibling ( const char * _next ) {
+return const_cast< TiXmlNode * > ( (const_cast< const TiXmlNode * > (this ))->NextSibling( _next ) );
+const TiXmlElement * NextSiblingElement () const ;
+TiXmlElement * NextSiblingElement () {
+return const_cast< TiXmlElement * > ( (const_cast< const TiXmlNode * > (this ))->NextSiblingElement() );
+const TiXmlElement * NextSiblingElement ( const char * ) const ;
+TiXmlElement * NextSiblingElement ( const char *_next ) {
+return const_cast< TiXmlElement * > ( (const_cast< const TiXmlNode * > (this ))->NextSiblingElement( _next ) );
+ #ifdef TIXML_USE_STL
+00659 const TiXmlElement * NextSiblingElement ( const std::string& _value) const { return NextSiblingElement (_value.c_str ()); }
+00660 TiXmlElement * NextSiblingElement ( const std::string& _value) { return NextSiblingElement (_value.c_str ()); }
+ #endif
+const TiXmlElement * FirstChildElement () const ;
+TiXmlElement * FirstChildElement () {
+return const_cast< TiXmlElement * > ( (const_cast< const TiXmlNode * > (this ))->FirstChildElement() );
+const TiXmlElement * FirstChildElement ( const char * _value ) const ;
+TiXmlElement * FirstChildElement ( const char * _value ) {
+return const_cast< TiXmlElement * > ( (const_cast< const TiXmlNode * > (this ))->FirstChildElement( _value ) );
+ #ifdef TIXML_USE_STL
+00676 const TiXmlElement * FirstChildElement ( const std::string& _value ) const { return FirstChildElement (_value.c_str ()); }
+00677 TiXmlElement * FirstChildElement ( const std::string& _value ) { return FirstChildElement (_value.c_str ()); }
+ #endif
+00684 int Type () const { return type; }
+const TiXmlDocument * GetDocument () const ;
+TiXmlDocument * GetDocument () {
+return const_cast< TiXmlDocument * > ( (const_cast< const TiXmlNode * > (this ))->GetDocument() );
+00695 bool NoChildren () const { return !firstChild; }
+00697 virtual const TiXmlDocument * ToDocument () const { return 0; }
+00698 virtual const TiXmlElement * ToElement () const { return 0; }
+00699 virtual const TiXmlComment * ToComment () const { return 0; }
+00700 virtual const TiXmlUnknown * ToUnknown () const { return 0; }
+00701 virtual const TiXmlText * ToText () const { return 0; }
+00702 virtual const TiXmlDeclaration * ToDeclaration () const { return 0; }
+00704 virtual TiXmlDocument * ToDocument () { return 0; }
+00705 virtual TiXmlElement * ToElement () { return 0; }
+00706 virtual TiXmlComment * ToComment () { return 0; }
+00707 virtual TiXmlUnknown * ToUnknown () { return 0; }
+00708 virtual TiXmlText * ToText () { return 0; }
+00709 virtual TiXmlDeclaration * ToDeclaration () { return 0; }
+virtual TiXmlNode * Clone () const = 0;
+virtual bool Accept ( TiXmlVisitor * visitor ) const = 0;
+protected :
+TiXmlNode ( NodeType _type );
+void CopyTo( TiXmlNode * target ) const ;
+ #ifdef TIXML_USE_STL
+virtual void StreamIn( std::istream* in, TIXML_STRING* tag ) = 0;
+ #endif
+TiXmlNode * Identify( const char * start, TiXmlEncoding encoding );
+TiXmlNode * parent;
+NodeType type;
+TiXmlNode * firstChild;
+TiXmlNode * lastChild;
+TiXmlNode * prev;
+TiXmlNode * next;
+private :
+TiXmlNode ( const TiXmlNode & );
+void operator=( const TiXmlNode & base );
+00779 class TiXmlAttribute : public TiXmlBase
+friend class TiXmlAttributeSet;
+public :
+00785 TiXmlAttribute () : TiXmlBase ()
+ #ifdef TIXML_USE_STL
+00793 TiXmlAttribute( const std::string& _name, const std::string& _value )
+ #endif
+00803 TiXmlAttribute ( const char * _name, const char * _value )
+00811 const char * Name () const { return name.c_str(); }
+00812 const char * Value () const { return value.c_str(); }
+ #ifdef TIXML_USE_STL
+00814 const std::string& ValueStr () const { return value; }
+ #endif
+int IntValue () const ;
+double DoubleValue () const ;
+const TIXML_STRING& NameTStr() const { return name; }
+int QueryIntValue ( int * _value ) const ;
+int QueryDoubleValue ( double * _value ) const ;
+00835 void SetName ( const char * _name ) { name = _name; }
+00836 void SetValue ( const char * _value ) { value = _value; }
+void SetIntValue ( int _value );
+void SetDoubleValue ( double _value );
+ #ifdef TIXML_USE_STL
+00843 void SetName( const std::string& _name ) { name = _name; }
+00845 void SetValue( const std::string& _value ) { value = _value; }
+ #endif
+const TiXmlAttribute * Next () const ;
+TiXmlAttribute * Next () {
+return const_cast< TiXmlAttribute * > ( (const_cast< const TiXmlAttribute * > (this ))->Next() );
+const TiXmlAttribute * Previous () const ;
+TiXmlAttribute * Previous () {
+return const_cast< TiXmlAttribute * > ( (const_cast< const TiXmlAttribute * > (this ))->Previous() );
+bool operator==( const TiXmlAttribute & rhs ) const { return rhs.name == name; }
+bool operator<( const TiXmlAttribute & rhs ) const { return name < rhs.name; }
+bool operator>( const TiXmlAttribute & rhs ) const { return name > rhs.name; }
+virtual const char * Parse( const char * p, TiXmlParsingData* data, TiXmlEncoding encoding );
+00870 virtual void Print ( FILE* cfile, int depth ) const {
+Print ( cfile, depth, 0 );
+void Print ( FILE* cfile, int depth, TIXML_STRING* str ) const ;
+void SetDocument( TiXmlDocument * doc ) { document = doc; }
+private :
+TiXmlAttribute ( const TiXmlAttribute & );
+void operator=( const TiXmlAttribute & base );
+TiXmlDocument * document;
+TiXmlAttribute * prev;
+TiXmlAttribute * next;
+class TiXmlAttributeSet
+public :
+void Add( TiXmlAttribute * attribute );
+void Remove( TiXmlAttribute * attribute );
+const TiXmlAttribute * First() const { return ( sentinel.next == &sentinel ) ? 0 : sentinel.next; }
+TiXmlAttribute * First() { return ( sentinel.next == &sentinel ) ? 0 : sentinel.next; }
+const TiXmlAttribute * Last() const { return ( sentinel.prev == &sentinel ) ? 0 : sentinel.prev; }
+TiXmlAttribute * Last() { return ( sentinel.prev == &sentinel ) ? 0 : sentinel.prev; }
+TiXmlAttribute * Find( const char * _name ) const ;
+TiXmlAttribute * FindOrCreate( const char * _name );
+# ifdef TIXML_USE_STL
+TiXmlAttribute * Find( const std::string& _name ) const ;
+TiXmlAttribute * FindOrCreate( const std::string& _name );
+# endif
+private :
+const TiXmlAttributeSet& );
+void operator=( const TiXmlAttributeSet& );
+TiXmlAttribute sentinel;
+00940 class TiXmlElement : public TiXmlNode
+public :
+TiXmlElement (const char * in_value);
+ #ifdef TIXML_USE_STL
+ TiXmlElement( const std::string& _value );
+ #endif
+TiXmlElement ( const TiXmlElement & );
+TiXmlElement & operator=( const TiXmlElement & base );
+virtual ~TiXmlElement ();
+const char * Attribute ( const char * name ) const ;
+const char * Attribute ( const char * name, int * i ) const ;
+const char * Attribute ( const char * name, double * d ) const ;
+int QueryIntAttribute ( const char * name, int * _value ) const ;
+int QueryUnsignedAttribute ( const char * name, unsigned * _value ) const ;
+int QueryBoolAttribute ( const char * name, bool * _value ) const ;
+int QueryDoubleAttribute ( const char * name, double * _value ) const ;
+00996 int QueryFloatAttribute ( const char * name, float * _value ) const {
+double d;
+int result = QueryDoubleAttribute ( name, &d );
+if ( result == TIXML_SUCCESS ) {
+return result;
+ #ifdef TIXML_USE_STL
+01007 int QueryStringAttribute( const char* name, std::string* _value ) const {
+const char * cstr = Attribute ( name );
+if ( cstr ) {
+return TIXML_SUCCESS;
+return TIXML_NO_ATTRIBUTE;
+01024 template < typename T > int QueryValueAttribute( const std::string& name, T* outValue ) const
+ {
+const TiXmlAttribute * node = attributeSet.Find( name );
+if ( !node )
+return TIXML_NO_ATTRIBUTE;
+ValueStr () );
+if ( !sstream.fail() )
+return TIXML_SUCCESS;
+return TIXML_WRONG_TYPE;
+int QueryValueAttribute( const std::string& name, std::string* outValue ) const
+ {
+const TiXmlAttribute * node = attributeSet.Find( name );
+if ( !node )
+return TIXML_NO_ATTRIBUTE;
+ValueStr ();
+return TIXML_SUCCESS;
+ #endif
+void SetAttribute( const char * name, const char * _value );
+ #ifdef TIXML_USE_STL
+const std::string* Attribute( const std::string& name ) const ;
+const std::string* Attribute( const std::string& name, int * i ) const ;
+const std::string* Attribute( const std::string& name, double * d ) const ;
+int QueryIntAttribute( const std::string& name, int * _value ) const ;
+int QueryDoubleAttribute( const std::string& name, double * _value ) const ;
+void SetAttribute( const std::string& name, const std::string& _value );
+void SetAttribute( const std::string& name, int _value );
+void SetDoubleAttribute( const std::string& name, double value );
+ #endif
+void SetAttribute( const char * name, int value );
+void SetDoubleAttribute( const char * name, double value );
+void RemoveAttribute( const char * name );
+ #ifdef TIXML_USE_STL
+01081 void RemoveAttribute ( const std::string& name ) { RemoveAttribute (name.c_str ()); }
+ #endif
+01084 const TiXmlAttribute * FirstAttribute () const { return attributeSet.First(); }
+TiXmlAttribute * FirstAttribute() { return attributeSet.First(); }
+01086 const TiXmlAttribute * LastAttribute () const { return attributeSet.Last(); }
+TiXmlAttribute * LastAttribute() { return attributeSet.Last(); }
+const char * GetText() const ;
+virtual TiXmlNode * Clone() const ;
+virtual void Print( FILE* cfile, int depth ) const ;
+virtual const char * Parse( const char * p, TiXmlParsingData* data, TiXmlEncoding encoding );
+01133 virtual const TiXmlElement * ToElement () const { return this ; }
+01134 virtual TiXmlElement * ToElement () { return this ; }
+virtual bool Accept( TiXmlVisitor * visitor ) const ;
+protected :
+void CopyTo( TiXmlElement * target ) const ;
+void ClearThis();
+ #ifdef TIXML_USE_STL
+virtual void StreamIn( std::istream * in, TIXML_STRING * tag );
+ #endif
+const char * ReadValue( const char * in, TiXmlParsingData* prevData, TiXmlEncoding encoding );
+private :
+01162 class TiXmlComment : public TiXmlNode
+public :
+01166 TiXmlComment () : TiXmlNode ( TiXmlNode ::TINYXML_COMMENT ) {}
+01168 TiXmlComment ( const char * _value ) : TiXmlNode ( TiXmlNode ::TINYXML_COMMENT ) {
+SetValue ( _value );
+TiXmlComment ( const TiXmlComment & );
+TiXmlComment & operator=( const TiXmlComment & base );
+virtual ~TiXmlComment () {}
+virtual TiXmlNode * Clone () const ;
+virtual void Print ( FILE* cfile, int depth ) const ;
+virtual const char * Parse( const char * p, TiXmlParsingData* data, TiXmlEncoding encoding );
+01186 virtual const TiXmlComment * ToComment () const { return this ; }
+01187 virtual TiXmlComment * ToComment () { return this ; }
+virtual bool Accept ( TiXmlVisitor * visitor ) const ;
+protected :
+void CopyTo( TiXmlComment * target ) const ;
+ #ifdef TIXML_USE_STL
+virtual void StreamIn( std::istream * in, TIXML_STRING * tag );
+ #endif
+private :
+01212 class TiXmlText : public TiXmlNode
+friend class TiXmlElement ;
+public :
+01220 TiXmlText (const char * initValue ) : TiXmlNode (TiXmlNode ::TINYXML_TEXT)
+SetValue ( initValue );
+false ;
+virtual ~TiXmlText () {}
+ #ifdef TIXML_USE_STL
+01229 TiXmlText( const std::string& initValue ) : TiXmlNode (TiXmlNode::TINYXML_TEXT)
+SetValue ( initValue );
+false ;
+ #endif
+TiXmlText ( const TiXmlText & copy ) : TiXmlNode ( TiXmlNode ::TINYXML_TEXT ) { copy.CopyTo( this ); }
+TiXmlText & operator=( const TiXmlText & base ) { base.CopyTo( this ); return *this ; }
+virtual void Print ( FILE* cfile, int depth ) const ;
+01243 bool CDATA () const { return cdata; }
+01245 void SetCDATA ( bool _cdata ) { cdata = _cdata; }
+virtual const char * Parse( const char * p, TiXmlParsingData* data, TiXmlEncoding encoding );
+01249 virtual const TiXmlText * ToText () const { return this ; }
+01250 virtual TiXmlText * ToText () { return this ; }
+virtual bool Accept ( TiXmlVisitor * content ) const ;
+protected :
+virtual TiXmlNode * Clone () const ;
+void CopyTo( TiXmlText * target ) const ;
+bool Blank() const ;
+ #ifdef TIXML_USE_STL
+virtual void StreamIn( std::istream * in, TIXML_STRING * tag );
+ #endif
+private :
+bool cdata;
+01285 class TiXmlDeclaration : public TiXmlNode
+public :
+01289 TiXmlDeclaration () : TiXmlNode ( TiXmlNode ::TINYXML_DECLARATION ) {}
+#ifdef TIXML_USE_STL
+ TiXmlDeclaration( const std::string& _version,
+const std::string& _encoding,
+const std::string& _standalone );
+#endif
+TiXmlDeclaration ( const char * _version,
+const char * _encoding,
+const char * _standalone );
+TiXmlDeclaration ( const TiXmlDeclaration & copy );
+TiXmlDeclaration & operator=( const TiXmlDeclaration & copy );
+virtual ~TiXmlDeclaration () {}
+01309 const char *Version () const { return version.c_str (); }
+01311 const char *Encoding () const { return encoding.c_str (); }
+01313 const char *Standalone () const { return standalone.c_str (); }
+virtual TiXmlNode * Clone () const ;
+virtual void Print( FILE* cfile, int depth, TIXML_STRING* str ) const ;
+01319 virtual void Print ( FILE* cfile, int depth ) const {
+virtual const char * Parse( const char * p, TiXmlParsingData* data, TiXmlEncoding encoding );
+01325 virtual const TiXmlDeclaration * ToDeclaration () const { return this ; }
+01326 virtual TiXmlDeclaration * ToDeclaration () { return this ; }
+virtual bool Accept ( TiXmlVisitor * visitor ) const ;
+protected :
+void CopyTo( TiXmlDeclaration * target ) const ;
+ #ifdef TIXML_USE_STL
+virtual void StreamIn( std::istream * in, TIXML_STRING * tag );
+ #endif
+private :
+01354 class TiXmlUnknown : public TiXmlNode
+public :
+TiXmlUnknown () : TiXmlNode ( TiXmlNode::TINYXML_UNKNOWN ) {}
+virtual ~TiXmlUnknown () {}
+TiXmlUnknown ( const TiXmlUnknown & copy ) : TiXmlNode ( TiXmlNode::TINYXML_UNKNOWN ) { copy.CopyTo( this ); }
+TiXmlUnknown & operator=( const TiXmlUnknown & copy ) { copy.CopyTo( this ); return *this ; }
+virtual TiXmlNode * Clone () const ;
+virtual void Print ( FILE* cfile, int depth ) const ;
+virtual const char * Parse( const char * p, TiXmlParsingData* data, TiXmlEncoding encoding );
+01370 virtual const TiXmlUnknown * ToUnknown () const { return this ; }
+01371 virtual TiXmlUnknown * ToUnknown () { return this ; }
+virtual bool Accept ( TiXmlVisitor * content ) const ;
+protected :
+void CopyTo( TiXmlUnknown * target ) const ;
+ #ifdef TIXML_USE_STL
+virtual void StreamIn( std::istream * in, TIXML_STRING * tag );
+ #endif
+private :
+01393 class TiXmlDocument : public TiXmlNode
+public :
+TiXmlDocument ();
+TiXmlDocument ( const char * documentName );
+ #ifdef TIXML_USE_STL
+ TiXmlDocument( const std::string& documentName );
+ #endif
+TiXmlDocument ( const TiXmlDocument & copy );
+TiXmlDocument & operator=( const TiXmlDocument & copy );
+virtual ~TiXmlDocument () {}
+bool LoadFile ( TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING );
+bool SaveFile () const ;
+bool LoadFile ( const char * filename, TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING );
+bool SaveFile ( const char * filename ) const ;
+bool LoadFile ( FILE*, TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING );
+bool SaveFile ( FILE* ) const ;
+ #ifdef TIXML_USE_STL
+01432 bool LoadFile ( const std::string& filename, TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING )
+return LoadFile ( filename.c_str(), encoding );
+01436 bool SaveFile ( const std::string& filename ) const
+return SaveFile ( filename.c_str() );
+ #endif
+virtual const char * Parse ( const char * p, TiXmlParsingData* data = 0, TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING );
+01452 const TiXmlElement * RootElement () const { return FirstChildElement (); }
+TiXmlElement * RootElement () { return FirstChildElement (); }
+01460 bool Error () const { return error; }
+01463 const char * ErrorDesc () const { return errorDesc.c_str (); }
+01468 int ErrorId () const { return errorId; }
+01477 int ErrorRow () const { return errorLocation.row+1; }
+01478 int ErrorCol () const { return errorLocation.col+1; }
+01504 void SetTabSize ( int _tabsize ) { tabsize = _tabsize; }
+int TabSize() const { return tabsize; }
+01511 void ClearError () { error = false ;
+"" ;
+01519 void Print () const { Print ( stdout, 0 ); }
+virtual void Print ( FILE* cfile, int depth = 0 ) const ;
+void SetError( int err, const char * errorLocation, TiXmlParsingData* prevData, TiXmlEncoding encoding );
+01532 virtual const TiXmlDocument * ToDocument () const { return this ; }
+01533 virtual TiXmlDocument * ToDocument () { return this ; }
+virtual bool Accept ( TiXmlVisitor * content ) const ;
+protected :
+virtual TiXmlNode * Clone () const ;
+ #ifdef TIXML_USE_STL
+virtual void StreamIn( std::istream * in, TIXML_STRING * tag );
+ #endif
+private :
+void CopyTo( TiXmlDocument * target ) const ;
+bool error;
+int errorId;
+int tabsize;
+bool useMicrosoftBOM;
+01638 class TiXmlHandle
+public :
+01642 TiXmlHandle ( TiXmlNode * _node ) { this->node = _node; }
+01644 TiXmlHandle ( const TiXmlHandle & ref ) { this->node = ref.node; }
+TiXmlHandle operator=( const TiXmlHandle & ref ) { if ( &ref != this ) this->node = ref.node; return *this ; }
+TiXmlHandle FirstChild () const ;
+TiXmlHandle FirstChild ( const char * value ) const ;
+TiXmlHandle FirstChildElement () const ;
+TiXmlHandle FirstChildElement ( const char * value ) const ;
+TiXmlHandle Child ( const char * value, int index ) const ;
+TiXmlHandle Child ( int index ) const ;
+TiXmlHandle ChildElement ( const char * value, int index ) const ;
+TiXmlHandle ChildElement ( int index ) const ;
+ #ifdef TIXML_USE_STL
+TiXmlHandle FirstChild ( const std::string& _value ) const { return FirstChild ( _value.c_str() ); }
+TiXmlHandle FirstChildElement ( const std::string& _value ) const { return FirstChildElement ( _value.c_str() ); }
+TiXmlHandle Child ( const std::string& _value, int index ) const { return Child ( _value.c_str(), index ); }
+TiXmlHandle ChildElement ( const std::string& _value, int index ) const { return ChildElement ( _value.c_str(), index ); }
+ #endif
+01685 TiXmlNode * ToNode () const { return node; }
+01688 TiXmlElement * ToElement () const { return ( ( node && node->ToElement() ) ? node->ToElement() : 0 ); }
+01691 TiXmlText * ToText () const { return ( ( node && node->ToText() ) ? node->ToText() : 0 ); }
+01694 TiXmlUnknown * ToUnknown () const { return ( ( node && node->ToUnknown() ) ? node->ToUnknown() : 0 ); }
+01699 TiXmlNode * Node () const { return ToNode (); }
+01703 TiXmlElement * Element () const { return ToElement (); }
+01707 TiXmlText * Text () const { return ToText (); }
+01711 TiXmlUnknown * Unknown () const { return ToUnknown (); }
+private :
+TiXmlNode * node;
+01737 class TiXmlPrinter : public TiXmlVisitor
+public :
+TiXmlPrinter () : depth( 0 ), simpleTextPrint( false ),
+" " ), lineBreak( "\n" ) {}
+virtual bool VisitEnter ( const TiXmlDocument & doc );
+virtual bool VisitExit ( const TiXmlDocument & doc );
+virtual bool VisitEnter ( const TiXmlElement & element, const TiXmlAttribute * firstAttribute );
+virtual bool VisitExit ( const TiXmlElement & element );
+virtual bool Visit ( const TiXmlDeclaration & declaration );
+virtual bool Visit ( const TiXmlText & text );
+virtual bool Visit ( const TiXmlComment & comment );
+virtual bool Visit ( const TiXmlUnknown & unknown );
+01757 void SetIndent ( const char * _indent ) { indent = _indent ? _indent : "" ; }
+01759 const char * Indent () { return indent.c_str(); }
+01764 void SetLineBreak ( const char * _lineBreak ) { lineBreak = _lineBreak ? _lineBreak : "" ; }
+01766 const char * LineBreak () { return lineBreak.c_str(); }
+01771 void SetStreamPrinting () { indent = "" ;
+"" ;
+01775 const char * CStr () { return buffer.c_str(); }
+01777 size_t Size () { return buffer.size(); }
+ #ifdef TIXML_USE_STL
+01781 const std::string& Str() { return buffer; }
+ #endif
+private :
+void DoIndent() {
+for ( int i=0; i<depth; ++i )
+void DoLineBreak() {
+int depth;
+bool simpleTextPrint;
+#ifdef _MSC_VER
+#pragma warning( pop )
+#endif
+#endif
+Generated by
+
+ 1.6.2 TinyXml: TinyXML Tutorial
-What is this?
-
-This tutorial has a few tips and suggestions on how to use TinyXML effectively.
-I've also tried to include some C++ tips like how to convert strings to integers and vice versa. This isn't anything to do with TinyXML itself, but it may helpful for your project so I've put it in anyway.
-If you don't know basic C++ concepts this tutorial won't be useful. Likewise if you don't know what a DOM is, look elsewhere first.
+
+
+
+
+
+
+
What is this?
+
This tutorial has a few tips and suggestions on how to use TinyXML effectively.
+
I've also tried to include some C++ tips like how to convert strings to integers and vice versa. This isn't anything to do with TinyXML itself, but it may helpful for your project so I've put it in anyway.
+
If you don't know basic C++ concepts this tutorial won't be useful. Likewise if you don't know what a DOM is, look elsewhere first.
Before we start
-
-Some example XML datasets/files will be used.
-example1.xml:
-
<?xml version="1.0" ?>
+Some example XML datasets/files will be used.
+example1.xml:
+
+<?xml version="1.0" ?>
<Hello>World</Hello>
-
-example2.xml:
-
example2.xml:
+
+<?xml version="1.0" ?>
<poetry>
<verse>
Alas
@@ -35,16 +43,16 @@ example2.xml:
Alas (again)
</verse>
</poetry>
-
-example3.xml:
-
example3.xml:
+
+<?xml version="1.0" ?>
<shapes>
<circle name="int-based" x="20" y="30" r="50" />
<point name="float-based" x="3.5" y="52.1" />
</shapes>
-
-example4.xml
-
example4.xml
+
+<?xml version="1.0" ?>
<MyApp>
<!-- Settings for MyApp -->
<Messages>
@@ -56,17 +64,15 @@ example4.xml
</Windows>
<Connection ip="192.168.0.1" timeout="123.456000" />
</MyApp>
-
-
Getting Started
-
+
Getting Started
Load XML from a file
-
-The simplest way to load a file into a TinyXML DOM is:
-
TiXmlDocument doc( "demo.xml" );
+The simplest way to load a file into a TinyXML DOM is:
+
+TiXmlDocument doc( "demo.xml" );
doc.LoadFile();
-
-A more real-world usage is shown below. This will load the file and display the contents to STDOUT:
-
// load the named file and dump its structure to STDOUT
+ A more real-world usage is shown below. This will load the file and display the contents to STDOUT:
+
+// load the named file and dump its structure to STDOUT
void dump_to_stdout(const char* pFilename)
{
TiXmlDocument doc(pFilename);
@@ -81,29 +87,28 @@ void dump_to_stdout(const char* pFilename)
printf("Failed to load file \"%s\"\n", pFilename);
}
}
-
-A simple demonstration of this function is to use a main like this:
-
A simple demonstration of this function is to use a main like this:
+
+int main(void)
{
dump_to_stdout("example1.xml");
return 0;
}
-
-Recall that Example 1 XML is:
-
Recall that Example 1 XML is:
+
+<?xml version="1.0" ?>
<Hello>World</Hello>
-
-Running the program with this XML will display this in the console/DOS window:
-
Running the program with this XML will display this in the console/DOS window:
+
+DOCUMENT
+ DECLARATION
+ ELEMENT Hello
+ TEXT[World]
-
-The ``dump_to_stdout`` function is defined later in this tutorial and is useful if you want to understand recursive traversal of a DOM.
+
The ``dump_to_stdout`` function is defined later in this tutorial and is useful if you want to understand recursive traversal of a DOM.
Building Documents Programatically
-
-This is how to build Example 1 pragmatically:
-
void build_simple_doc( )
+This is how to build Example 1 pragmatically:
+
+void build_simple_doc( )
{
// Make xml: <?xml ..><Hello>World</Hello>
TiXmlDocument doc;
@@ -115,19 +120,19 @@ This is how to build Example 1 pragmatically:
doc.LinkEndChild( element );
doc.SaveFile( "madeByHand.xml" );
}
-
-This can be loaded and displayed on the console with:
-
dump_to_stdout("madeByHand.xml"); // this func defined later in the tutorial
-
-and you'll see it is identical to Example 1:
-
This can be loaded and displayed on the console with:
+
+dump_to_stdout("madeByHand.xml"); // this func defined later in the tutorial
+ and you'll see it is identical to Example 1:
+
+madeByHand.xml:
Document
+ Declaration
+ Element [Hello]
+ Text: [World]
-
-This code produces exactly the same XML DOM but it shows a different ordering to node creation and linking:
-
void write_simple_doc2( )
+ This code produces exactly the same XML DOM but it shows a different ordering to node creation and linking:
+
+void write_simple_doc2( )
{
// same as write_simple_doc1 but add each node
// as early as possible into the tree.
@@ -144,29 +149,28 @@ This code produces exactly the same XML DOM but it shows a different ordering to
doc.SaveFile( "madeByHand2.xml" );
}
-
-Both of these produce the same XML, namely:
-
Both of these produce the same XML, namely:
+
+<?xml version="1.0" ?>
<Hello>World</Hello>
-
-Or in structure form:
-
Or in structure form:
+
+DOCUMENT
+ DECLARATION
+ ELEMENT Hello
+ TEXT[World]
-
-
Attributes
-
-Given an existing node, settings attributes is easy:
-
window = new TiXmlElement( "Demo" );
+ Attributes
+Given an existing node, settings attributes is easy:
+
+window = new TiXmlElement( "Demo" );
window->SetAttribute("name", "Circle");
window->SetAttribute("x", 5);
window->SetAttribute("y", 15);
window->SetDoubleAttribute("radius", 3.14159);
-
-You can it also work with the TiXmlAttribute objects if you want.
-The following code shows one way (not the only way) to get all attributes of an element, print the name and string value, and if the value can be converted to an integer or double, print that value too:
-
// print all attributes of pElement.
+ You can it also work with the TiXmlAttribute objects if you want.
+The following code shows one way (not the only way) to get all attributes of an element, print the name and string value, and if the value can be converted to an integer or double, print that value too:
+
+// print all attributes of pElement.
// returns the number of attributes printed
int dump_attribs_to_stdout(TiXmlElement* pElement, unsigned int indent)
{
@@ -190,14 +194,13 @@ int dump_attribs_to_stdout(TiXmlElement* pElement, unsigned int indent)
}
return i;
}
-
-
Writing a document to a file
-
-Writing a pre-built DOM to a file is trivial:
-
doc.SaveFile( saveFilename );
-
-Recall, for example, example 4:
-
Writing a document to a file
+Writing a pre-built DOM to a file is trivial:
+
+doc.SaveFile( saveFilename );
+ Recall, for example, example 4:
+
+<?xml version="1.0" ?>
<MyApp>
<!-- Settings for MyApp -->
<Messages>
@@ -209,9 +212,9 @@ Recall, for example, example 4:
</Windows>
<Connection ip="192.168.0.1" timeout="123.456000" />
</MyApp>
-
-The following function builds this DOM and writes the file "appsettings.xml":
-
void write_app_settings_doc( )
+ The following function builds this DOM and writes the file "appsettings.xml":
+
+void write_app_settings_doc( )
{
TiXmlDocument doc;
TiXmlElement* msg;
@@ -256,9 +259,9 @@ The following function builds this DOM and writes the file "appsettings.xml":
dump_to_stdout( &doc );
doc.SaveFile( "appsettings.xml" );
}
-
-The dump_to_stdout function will show this structure:
-
The dump_to_stdout function will show this structure:
+
+Document
+ Declaration
+ Element [MyApp]
(No attributes)
@@ -284,21 +287,18 @@ The dump_to_stdout function will show this structure:
+ ip: value=[192.168.0.1] int=192 d=192.2
+ timeout: value=[123.456000] int=123 d=123.5
2 attributes
-
-I was surprised that TinyXml, by default, writes the XML in what other APIs call a "pretty" format - it modifies the whitespace of text of elements that contain other nodes so that writing the tree includes an indication of nesting level.
-I haven't looked yet to see if there is a way to turn off indenting when writing a file - its bound to be easy.
-[Lee: It's easy in STL mode, just use cout << myDoc. Non-STL mode is always in "pretty" format. Adding a switch would be a nice feature and has been requested.]
+
I was surprised that TinyXml, by default, writes the XML in what other APIs call a "pretty" format - it modifies the whitespace of text of elements that contain other nodes so that writing the tree includes an indication of nesting level.
+
I haven't looked yet to see if there is a way to turn off indenting when writing a file - its bound to be easy.
+
[Lee: It's easy in STL mode, just use cout << myDoc. Non-STL mode is always in "pretty" format. Adding a switch would be a nice feature and has been requested.]
XML to/from C++ objects
-
Intro
-
-This example assumes you're loading and saving your app settings in an XML file, e.g. something like example4.xml.
-There are a number of ways to do this. For example, look into the TinyBind project at http://sourceforge.net/projects/tinybind
-This section shows a plain-old approach to loading and saving a basic object structure using XML.
+
This example assumes you're loading and saving your app settings in an XML file, e.g. something like example4.xml.
+
There are a number of ways to do this. For example, look into the TinyBind project at http://sourceforge.net/projects/tinybind
+
This section shows a plain-old approach to loading and saving a basic object structure using XML.
Set up your object classes
-
-Start off with some basic classes like these:
-
#include <string>
+Start off with some basic classes like these:
+
+#include <string>
#include <map>
using namespace std;
@@ -359,9 +359,9 @@ public:
m_connection.timeout=123.456;
}
};
-
-This is a basic main() that shows how to create a default settings object tree, save it and load it again:
-
This is a basic main() that shows how to create a default settings object tree, save it and load it again:
+
+int main(void)
{
AppSettings settings;
@@ -369,9 +369,9 @@ This is a basic main() that shows how to create a default settings object tree,
settings.load("appsettings2.xml");
return 0;
}
-
-The following main() shows creation, modification, saving and then loading of a settings structure:
-
The following main() shows creation, modification, saving and then loading of a settings structure:
+
+int main(void)
{
// block: customise and save settings
{
@@ -399,16 +399,15 @@ The following main() shows creation, modification, saving and then loading of a
}
return 0;
}
-
-When the save() and load() are completed (see below), running this main() displays on the console:
-
HitchHikerApp: Don't Panic
+ When the save() and load() are completed (see below), running this main() displays on the console:
+
+HitchHikerApp: Don't Panic
HitchHikerApp: Show window 'BookFrame' at 15,25 (300 x 100)
HitchHikerApp: Thanks for all the fish
-
-
Encode C++ state as XML
-
-There are lots of different ways to approach saving this to a file. Here's one:
-
void AppSettings::save(const char* pFilename)
+ Encode C++ state as XML
+There are lots of different ways to approach saving this to a file. Here's one:
+
+void AppSettings::save(const char* pFilename)
{
TiXmlDocument doc;
TiXmlElement* msg;
@@ -474,9 +473,9 @@ There are lots of different ways to approach saving this to a file. Here's one:<
doc.SaveFile(pFilename);
}
-
-Running this with the modified main produces this file:
-
Running this with the modified main produces this file:
+
+<?xml version="1.0" ?>
<HitchHikerApp>
<!-- Settings for HitchHikerApp -->
<Messages>
@@ -488,11 +487,10 @@ Running this with the modified main produces this file:
</Windows>
<Connection ip="192.168.0.77" timeout="42.000000" />
</HitchHikerApp>
-
-
Decoding state from XML
-
-As with encoding objects, there are a number of approaches to decoding XML into your own C++ object structure. The following approach uses TiXmlHandles.
-
void AppSettings::load(const char* pFilename)
+ Decoding state from XML
+As with encoding objects, there are a number of approaches to decoding XML into your own C++ object structure. The following approach uses TiXmlHandles.
+
+void AppSettings::load(const char* pFilename)
{
TiXmlDocument doc(pFilename);
if (!doc.LoadFile()) return;
@@ -558,11 +556,10 @@ As with encoding objects, there are a number of approaches to decoding XML into
}
}
}
-
-
Full listing for dump_to_stdout
-
-Below is a copy-and-paste demo program for loading arbitrary XML files and dumping the structure to STDOUT using the recursive traversal listed above.
-
// tutorial demo program
+ Full listing for dump_to_stdout
+Below is a copy-and-paste demo program for loading arbitrary XML files and dumping the structure to STDOUT using the recursive traversal listed above.
+
+// tutorial demo program
#include "stdafx.h"
#include "tinyxml.h"
@@ -627,11 +624,11 @@ void dump_to_stdout( TiXmlNode* pParent, unsigned int indent = 0 )
switch ( t )
{
- case TiXmlNode::DOCUMENT:
+ case TiXmlNode::TINYXML_DOCUMENT:
printf( "Document" );
break;
- case TiXmlNode::ELEMENT:
+ case TiXmlNode::TINYXML_ELEMENT:
printf( "Element [%s]", pParent->Value() );
num=dump_attribs_to_stdout(pParent->ToElement(), indent+1);
switch(num)
@@ -642,20 +639,20 @@ void dump_to_stdout( TiXmlNode* pParent, unsigned int indent = 0 )
}
break;
- case TiXmlNode::COMMENT:
+ case TiXmlNode::TINYXML_COMMENT:
printf( "Comment: [%s]", pParent->Value());
break;
- case TiXmlNode::UNKNOWN:
+ case TiXmlNode::TINYXML_UNKNOWN:
printf( "Unknown" );
break;
- case TiXmlNode::TEXT:
+ case TiXmlNode::TINYXML_TEXT:
pText = pParent->ToText();
printf( "Text: [%s]", pText->Value() );
break;
- case TiXmlNode::DECLARATION:
+ case TiXmlNode::TINYXML_DECLARATION:
printf( "Declaration" );
break;
default:
@@ -695,9 +692,9 @@ int main(int argc, char* argv[])
}
return 0;
}
-
-Run this from the command line or a DOS window, e.g.:
-
C:\dev\tinyxml> Debug\tinyxml_1.exe example1.xml
+ Run this from the command line or a DOS window, e.g.:
+
+C:\dev\tinyxml> Debug\tinyxml_1.exe example1.xml
example1.xml:
Document
@@ -705,8 +702,8 @@ Document
+ Element [Hello]
(No attributes)
+ Text: [World]
-
- Authors and Changes
Authors and Changes
+
Written by Ellers, April, May, June 2005
@@ -714,8 +711,10 @@ Minor edits and integration into doc system, Lee Thomason September 2005
Updated by Ellers, October 2005
-
Generated on Sun May 6 15:41:23 2007 for TinyXml by
+
+Generated by
- 1.4.7 References
The World Wide Web Consortium is the definitive standard body for
-XML, and there web pages contain huge amounts of information.
+XML, and their web pages contain huge amounts of information.
The definitive spec:
http://www.w3.org/TR/2004/REC-xml-20040204/
diff --git a/Engine/lib/tinyxml/tinystr.cpp b/Engine/lib/tinyxml/tinystr.cpp
index 681250714..066576820 100644
--- a/Engine/lib/tinyxml/tinystr.cpp
+++ b/Engine/lib/tinyxml/tinystr.cpp
@@ -1,6 +1,5 @@
/*
www.sourceforge.net/projects/tinyxml
-Original file by Yves Berquin.
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any
@@ -22,10 +21,6 @@ must not be misrepresented as being the original software.
distribution.
*/
-/*
- * THIS FILE WAS ALTERED BY Tyge Løvset, 7. April 2005.
- */
-
#ifndef TIXML_USE_STL
diff --git a/Engine/lib/tinyxml/tinystr.h b/Engine/lib/tinyxml/tinystr.h
index 3c2aa9d54..89cca3341 100644
--- a/Engine/lib/tinyxml/tinystr.h
+++ b/Engine/lib/tinyxml/tinystr.h
@@ -1,6 +1,5 @@
/*
www.sourceforge.net/projects/tinyxml
-Original file by Yves Berquin.
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any
@@ -22,17 +21,6 @@ must not be misrepresented as being the original software.
distribution.
*/
-/*
- * THIS FILE WAS ALTERED BY Tyge Lovset, 7. April 2005.
- *
- * - completely rewritten. compact, clean, and fast implementation.
- * - sizeof(TiXmlString) = pointer size (4 bytes on 32-bit systems)
- * - fixed reserve() to work as per specification.
- * - fixed buggy compares operator==(), operator<(), and operator>()
- * - fixed operator+=() to take a const ref argument, following spec.
- * - added "copy" constructor with length, and most compare operators.
- * - added swap(), clear(), size(), capacity(), operator+().
- */
#ifndef TIXML_USE_STL
@@ -106,13 +94,11 @@ class TiXmlString
quit();
}
- // = operator
TiXmlString& operator = (const char * copy)
{
return assign( copy, (size_type)strlen(copy));
}
- // = operator
TiXmlString& operator = (const TiXmlString & copy)
{
return assign(copy.start(), copy.length());
diff --git a/Engine/lib/tinyxml/tinyxml.cpp b/Engine/lib/tinyxml/tinyxml.cpp
index 9fea74ccf..9c161dfcb 100644
--- a/Engine/lib/tinyxml/tinyxml.cpp
+++ b/Engine/lib/tinyxml/tinyxml.cpp
@@ -1,6 +1,6 @@
/*
www.sourceforge.net/projects/tinyxml
-Original code (2.0 and earlier )copyright (c) 2000-2006 Lee Thomason (www.grinninglizard.com)
+Original code by Lee Thomason (www.grinninglizard.com)
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any
@@ -31,6 +31,7 @@ distribution.
#include "tinyxml.h"
+FILE* TiXmlFOpen( const char* filename, const char* mode );
bool TiXmlBase::condenseWhiteSpace = true;
@@ -161,6 +162,7 @@ void TiXmlNode::CopyTo( TiXmlNode* target ) const
{
target->SetValue (value.c_str() );
target->userData = userData;
+ target->location = location;
}
@@ -186,10 +188,11 @@ TiXmlNode* TiXmlNode::LinkEndChild( TiXmlNode* node )
assert( node->parent == 0 || node->parent == this );
assert( node->GetDocument() == 0 || node->GetDocument() == this->GetDocument() );
- if ( node->Type() == TiXmlNode::DOCUMENT )
+ if ( node->Type() == TiXmlNode::TINYXML_DOCUMENT )
{
delete node;
- if ( GetDocument() ) GetDocument()->SetError( TIXML_ERROR_DOCUMENT_TOP_ONLY, 0, 0, TIXML_ENCODING_UNKNOWN );
+ if ( GetDocument() )
+ GetDocument()->SetError( TIXML_ERROR_DOCUMENT_TOP_ONLY, 0, 0, TIXML_ENCODING_UNKNOWN );
return 0;
}
@@ -210,9 +213,10 @@ TiXmlNode* TiXmlNode::LinkEndChild( TiXmlNode* node )
TiXmlNode* TiXmlNode::InsertEndChild( const TiXmlNode& addThis )
{
- if ( addThis.Type() == TiXmlNode::DOCUMENT )
+ if ( addThis.Type() == TiXmlNode::TINYXML_DOCUMENT )
{
- if ( GetDocument() ) GetDocument()->SetError( TIXML_ERROR_DOCUMENT_TOP_ONLY, 0, 0, TIXML_ENCODING_UNKNOWN );
+ if ( GetDocument() )
+ GetDocument()->SetError( TIXML_ERROR_DOCUMENT_TOP_ONLY, 0, 0, TIXML_ENCODING_UNKNOWN );
return 0;
}
TiXmlNode* node = addThis.Clone();
@@ -228,9 +232,10 @@ TiXmlNode* TiXmlNode::InsertBeforeChild( TiXmlNode* beforeThis, const TiXmlNode&
if ( !beforeThis || beforeThis->parent != this ) {
return 0;
}
- if ( addThis.Type() == TiXmlNode::DOCUMENT )
+ if ( addThis.Type() == TiXmlNode::TINYXML_DOCUMENT )
{
- if ( GetDocument() ) GetDocument()->SetError( TIXML_ERROR_DOCUMENT_TOP_ONLY, 0, 0, TIXML_ENCODING_UNKNOWN );
+ if ( GetDocument() )
+ GetDocument()->SetError( TIXML_ERROR_DOCUMENT_TOP_ONLY, 0, 0, TIXML_ENCODING_UNKNOWN );
return 0;
}
@@ -260,9 +265,10 @@ TiXmlNode* TiXmlNode::InsertAfterChild( TiXmlNode* afterThis, const TiXmlNode& a
if ( !afterThis || afterThis->parent != this ) {
return 0;
}
- if ( addThis.Type() == TiXmlNode::DOCUMENT )
+ if ( addThis.Type() == TiXmlNode::TINYXML_DOCUMENT )
{
- if ( GetDocument() ) GetDocument()->SetError( TIXML_ERROR_DOCUMENT_TOP_ONLY, 0, 0, TIXML_ENCODING_UNKNOWN );
+ if ( GetDocument() )
+ GetDocument()->SetError( TIXML_ERROR_DOCUMENT_TOP_ONLY, 0, 0, TIXML_ENCODING_UNKNOWN );
return 0;
}
@@ -289,9 +295,20 @@ TiXmlNode* TiXmlNode::InsertAfterChild( TiXmlNode* afterThis, const TiXmlNode& a
TiXmlNode* TiXmlNode::ReplaceChild( TiXmlNode* replaceThis, const TiXmlNode& withThis )
{
+ if ( !replaceThis )
+ return 0;
+
if ( replaceThis->parent != this )
return 0;
+ if ( withThis.ToDocument() ) {
+ // A document can never be a child. Thanks to Noam.
+ TiXmlDocument* document = GetDocument();
+ if ( document )
+ document->SetError( TIXML_ERROR_DOCUMENT_TOP_ONLY, 0, 0, TIXML_ENCODING_UNKNOWN );
+ return 0;
+ }
+
TiXmlNode* node = withThis.Clone();
if ( !node )
return 0;
@@ -317,6 +334,10 @@ TiXmlNode* TiXmlNode::ReplaceChild( TiXmlNode* replaceThis, const TiXmlNode& wit
bool TiXmlNode::RemoveChild( TiXmlNode* removeThis )
{
+ if ( !removeThis ) {
+ return false;
+ }
+
if ( removeThis->parent != this )
{
assert( 0 );
@@ -502,7 +523,7 @@ const TiXmlDocument* TiXmlNode::GetDocument() const
TiXmlElement::TiXmlElement (const char * _value)
- : TiXmlNode( TiXmlNode::ELEMENT )
+ : TiXmlNode( TiXmlNode::TINYXML_ELEMENT )
{
firstChild = lastChild = 0;
value = _value;
@@ -511,7 +532,7 @@ TiXmlElement::TiXmlElement (const char * _value)
#ifdef TIXML_USE_STL
TiXmlElement::TiXmlElement( const std::string& _value )
- : TiXmlNode( TiXmlNode::ELEMENT )
+ : TiXmlNode( TiXmlNode::TINYXML_ELEMENT )
{
firstChild = lastChild = 0;
value = _value;
@@ -520,17 +541,18 @@ TiXmlElement::TiXmlElement( const std::string& _value )
TiXmlElement::TiXmlElement( const TiXmlElement& copy)
- : TiXmlNode( TiXmlNode::ELEMENT )
+ : TiXmlNode( TiXmlNode::TINYXML_ELEMENT )
{
firstChild = lastChild = 0;
copy.CopyTo( this );
}
-void TiXmlElement::operator=( const TiXmlElement& base )
+TiXmlElement& TiXmlElement::operator=( const TiXmlElement& base )
{
ClearThis();
base.CopyTo( this );
+ return *this;
}
@@ -564,9 +586,9 @@ const char* TiXmlElement::Attribute( const char* name ) const
#ifdef TIXML_USE_STL
const std::string* TiXmlElement::Attribute( const std::string& name ) const
{
- const TiXmlAttribute* node = attributeSet.Find( name );
- if ( node )
- return &node->ValueStr();
+ const TiXmlAttribute* attrib = attributeSet.Find( name );
+ if ( attrib )
+ return &attrib->ValueStr();
return 0;
}
#endif
@@ -574,195 +596,202 @@ const std::string* TiXmlElement::Attribute( const std::string& name ) const
const char* TiXmlElement::Attribute( const char* name, int* i ) const
{
- const char* s = Attribute( name );
- if ( i )
- {
- if ( s ) {
- *i = atoi( s );
- }
- else {
- *i = 0;
+ const TiXmlAttribute* attrib = attributeSet.Find( name );
+ const char* result = 0;
+
+ if ( attrib ) {
+ result = attrib->Value();
+ if ( i ) {
+ attrib->QueryIntValue( i );
}
}
- return s;
+ return result;
}
#ifdef TIXML_USE_STL
const std::string* TiXmlElement::Attribute( const std::string& name, int* i ) const
{
- const std::string* s = Attribute( name );
- if ( i )
- {
- if ( s ) {
- *i = atoi( s->c_str() );
- }
- else {
- *i = 0;
+ const TiXmlAttribute* attrib = attributeSet.Find( name );
+ const std::string* result = 0;
+
+ if ( attrib ) {
+ result = &attrib->ValueStr();
+ if ( i ) {
+ attrib->QueryIntValue( i );
}
}
- return s;
+ return result;
}
#endif
const char* TiXmlElement::Attribute( const char* name, double* d ) const
{
- const char* s = Attribute( name );
- if ( d )
- {
- if ( s ) {
- *d = atof( s );
- }
- else {
- *d = 0;
+ const TiXmlAttribute* attrib = attributeSet.Find( name );
+ const char* result = 0;
+
+ if ( attrib ) {
+ result = attrib->Value();
+ if ( d ) {
+ attrib->QueryDoubleValue( d );
}
}
- return s;
+ return result;
}
#ifdef TIXML_USE_STL
const std::string* TiXmlElement::Attribute( const std::string& name, double* d ) const
{
- const std::string* s = Attribute( name );
- if ( d )
- {
- if ( s ) {
- *d = atof( s->c_str() );
- }
- else {
- *d = 0;
+ const TiXmlAttribute* attrib = attributeSet.Find( name );
+ const std::string* result = 0;
+
+ if ( attrib ) {
+ result = &attrib->ValueStr();
+ if ( d ) {
+ attrib->QueryDoubleValue( d );
}
}
- return s;
+ return result;
}
#endif
int TiXmlElement::QueryIntAttribute( const char* name, int* ival ) const
+{
+ const TiXmlAttribute* attrib = attributeSet.Find( name );
+ if ( !attrib )
+ return TIXML_NO_ATTRIBUTE;
+ return attrib->QueryIntValue( ival );
+}
+
+
+int TiXmlElement::QueryUnsignedAttribute( const char* name, unsigned* value ) const
{
const TiXmlAttribute* node = attributeSet.Find( name );
if ( !node )
return TIXML_NO_ATTRIBUTE;
- return node->QueryIntValue( ival );
+
+ int ival = 0;
+ int result = node->QueryIntValue( &ival );
+ *value = (unsigned)ival;
+ return result;
}
+int TiXmlElement::QueryBoolAttribute( const char* name, bool* bval ) const
+{
+ const TiXmlAttribute* node = attributeSet.Find( name );
+ if ( !node )
+ return TIXML_NO_ATTRIBUTE;
+
+ int result = TIXML_WRONG_TYPE;
+ if ( StringEqual( node->Value(), "true", true, TIXML_ENCODING_UNKNOWN )
+ || StringEqual( node->Value(), "yes", true, TIXML_ENCODING_UNKNOWN )
+ || StringEqual( node->Value(), "1", true, TIXML_ENCODING_UNKNOWN ) )
+ {
+ *bval = true;
+ result = TIXML_SUCCESS;
+ }
+ else if ( StringEqual( node->Value(), "false", true, TIXML_ENCODING_UNKNOWN )
+ || StringEqual( node->Value(), "no", true, TIXML_ENCODING_UNKNOWN )
+ || StringEqual( node->Value(), "0", true, TIXML_ENCODING_UNKNOWN ) )
+ {
+ *bval = false;
+ result = TIXML_SUCCESS;
+ }
+ return result;
+}
+
+
+
#ifdef TIXML_USE_STL
int TiXmlElement::QueryIntAttribute( const std::string& name, int* ival ) const
{
- const TiXmlAttribute* node = attributeSet.Find( name );
- if ( !node )
+ const TiXmlAttribute* attrib = attributeSet.Find( name );
+ if ( !attrib )
return TIXML_NO_ATTRIBUTE;
- return node->QueryIntValue( ival );
+ return attrib->QueryIntValue( ival );
}
#endif
int TiXmlElement::QueryDoubleAttribute( const char* name, double* dval ) const
{
- const TiXmlAttribute* node = attributeSet.Find( name );
- if ( !node )
+ const TiXmlAttribute* attrib = attributeSet.Find( name );
+ if ( !attrib )
return TIXML_NO_ATTRIBUTE;
- return node->QueryDoubleValue( dval );
+ return attrib->QueryDoubleValue( dval );
}
#ifdef TIXML_USE_STL
int TiXmlElement::QueryDoubleAttribute( const std::string& name, double* dval ) const
{
- const TiXmlAttribute* node = attributeSet.Find( name );
- if ( !node )
+ const TiXmlAttribute* attrib = attributeSet.Find( name );
+ if ( !attrib )
return TIXML_NO_ATTRIBUTE;
- return node->QueryDoubleValue( dval );
+ return attrib->QueryDoubleValue( dval );
}
#endif
void TiXmlElement::SetAttribute( const char * name, int val )
{
- char buf[64];
- #if defined(TIXML_SNPRINTF)
- TIXML_SNPRINTF( buf, sizeof(buf), "%d", val );
- #else
- sprintf( buf, "%d", val );
- #endif
- SetAttribute( name, buf );
+ TiXmlAttribute* attrib = attributeSet.FindOrCreate( name );
+ if ( attrib ) {
+ attrib->SetIntValue( val );
+ }
}
#ifdef TIXML_USE_STL
void TiXmlElement::SetAttribute( const std::string& name, int val )
{
- std::ostringstream oss;
- oss << val;
- SetAttribute( name, oss.str() );
+ TiXmlAttribute* attrib = attributeSet.FindOrCreate( name );
+ if ( attrib ) {
+ attrib->SetIntValue( val );
+ }
}
#endif
void TiXmlElement::SetDoubleAttribute( const char * name, double val )
{
- char buf[256];
- #if defined(TIXML_SNPRINTF)
- TIXML_SNPRINTF( buf, sizeof(buf), "%f", val );
- #else
- sprintf( buf, "%f", val );
- #endif
- SetAttribute( name, buf );
-}
-
-
-void TiXmlElement::SetAttribute( const char * cname, const char * cvalue )
-{
- #ifdef TIXML_USE_STL
- TIXML_STRING _name( cname );
- TIXML_STRING _value( cvalue );
- #else
- const char* _name = cname;
- const char* _value = cvalue;
- #endif
-
- TiXmlAttribute* node = attributeSet.Find( _name );
- if ( node )
- {
- node->SetValue( _value );
- return;
- }
-
- TiXmlAttribute* attrib = new TiXmlAttribute( cname, cvalue );
- if ( attrib )
- {
- attributeSet.Add( attrib );
- }
- else
- {
- TiXmlDocument* document = GetDocument();
- if ( document ) document->SetError( TIXML_ERROR_OUT_OF_MEMORY, 0, 0, TIXML_ENCODING_UNKNOWN );
+ TiXmlAttribute* attrib = attributeSet.FindOrCreate( name );
+ if ( attrib ) {
+ attrib->SetDoubleValue( val );
}
}
#ifdef TIXML_USE_STL
-void TiXmlElement::SetAttribute( const std::string& name, const std::string& _value )
-{
- TiXmlAttribute* node = attributeSet.Find( name );
- if ( node )
- {
- node->SetValue( _value );
- return;
+void TiXmlElement::SetDoubleAttribute( const std::string& name, double val )
+{
+ TiXmlAttribute* attrib = attributeSet.FindOrCreate( name );
+ if ( attrib ) {
+ attrib->SetDoubleValue( val );
}
+}
+#endif
- TiXmlAttribute* attrib = new TiXmlAttribute( name, _value );
- if ( attrib )
- {
- attributeSet.Add( attrib );
+
+void TiXmlElement::SetAttribute( const char * cname, const char * cvalue )
+{
+ TiXmlAttribute* attrib = attributeSet.FindOrCreate( cname );
+ if ( attrib ) {
+ attrib->SetValue( cvalue );
}
- else
- {
- TiXmlDocument* document = GetDocument();
- if ( document ) document->SetError( TIXML_ERROR_OUT_OF_MEMORY, 0, 0, TIXML_ENCODING_UNKNOWN );
+}
+
+
+#ifdef TIXML_USE_STL
+void TiXmlElement::SetAttribute( const std::string& _name, const std::string& _value )
+{
+ TiXmlAttribute* attrib = attributeSet.FindOrCreate( _name );
+ if ( attrib ) {
+ attrib->SetValue( _value );
}
}
#endif
@@ -806,15 +835,10 @@ void TiXmlElement::Print( FILE* cfile, int depth ) const
for ( node = firstChild; node; node=node->NextSibling() )
{
- fprintf( cfile, "\n" );
-
- if ( node->ToText() )
+ if ( !node->ToText() )
{
- for( i=0; iPrint( cfile, depth+1 );
}
fprintf( cfile, "\n" );
@@ -886,14 +910,14 @@ const char* TiXmlElement::GetText() const
}
-TiXmlDocument::TiXmlDocument() : TiXmlNode( TiXmlNode::DOCUMENT )
+TiXmlDocument::TiXmlDocument() : TiXmlNode( TiXmlNode::TINYXML_DOCUMENT )
{
tabsize = 4;
useMicrosoftBOM = false;
ClearError();
}
-TiXmlDocument::TiXmlDocument( const char * documentName ) : TiXmlNode( TiXmlNode::DOCUMENT )
+TiXmlDocument::TiXmlDocument( const char * documentName ) : TiXmlNode( TiXmlNode::TINYXML_DOCUMENT )
{
tabsize = 4;
useMicrosoftBOM = false;
@@ -903,7 +927,7 @@ TiXmlDocument::TiXmlDocument( const char * documentName ) : TiXmlNode( TiXmlNode
#ifdef TIXML_USE_STL
-TiXmlDocument::TiXmlDocument( const std::string& documentName ) : TiXmlNode( TiXmlNode::DOCUMENT )
+TiXmlDocument::TiXmlDocument( const std::string& documentName ) : TiXmlNode( TiXmlNode::TINYXML_DOCUMENT )
{
tabsize = 4;
useMicrosoftBOM = false;
@@ -913,49 +937,33 @@ TiXmlDocument::TiXmlDocument( const std::string& documentName ) : TiXmlNode( TiX
#endif
-TiXmlDocument::TiXmlDocument( const TiXmlDocument& copy ) : TiXmlNode( TiXmlNode::DOCUMENT )
+TiXmlDocument::TiXmlDocument( const TiXmlDocument& copy ) : TiXmlNode( TiXmlNode::TINYXML_DOCUMENT )
{
copy.CopyTo( this );
}
-void TiXmlDocument::operator=( const TiXmlDocument& copy )
+TiXmlDocument& TiXmlDocument::operator=( const TiXmlDocument& copy )
{
Clear();
copy.CopyTo( this );
+ return *this;
}
bool TiXmlDocument::LoadFile( TiXmlEncoding encoding )
{
- // See STL_STRING_BUG below.
- //StringToBuffer buf( value );
-
return LoadFile( Value(), encoding );
}
bool TiXmlDocument::SaveFile() const
{
- // See STL_STRING_BUG below.
-// StringToBuffer buf( value );
-//
-// if ( buf.buffer && SaveFile( buf.buffer ) )
-// return true;
-//
-// return false;
return SaveFile( Value() );
}
bool TiXmlDocument::LoadFile( const char* _filename, TiXmlEncoding encoding )
{
- // There was a really terrifying little bug here. The code:
- // value = filename
- // in the STL case, cause the assignment method of the std::string to
- // be called. What is strange, is that the std::string had the same
- // address as it's c_str() method, and so bad things happen. Looks
- // like a bug in the Microsoft STL implementation.
- // Add an extra string to avoid the crash.
TIXML_STRING filename( _filename );
value = filename;
@@ -1000,11 +1008,6 @@ bool TiXmlDocument::LoadFile( FILE* file, TiXmlEncoding encoding )
return false;
}
- // If we have a file, assume it is all one big XML file, and read it in.
- // The document parser may decide the document ends sooner than the entire file, however.
- TIXML_STRING data;
- data.reserve( length );
-
// Subtle bug here. TinyXml did use fgets. But from the XML spec:
// 2.11 End-of-Line Handling
//
@@ -1035,58 +1038,46 @@ bool TiXmlDocument::LoadFile( FILE* file, TiXmlEncoding encoding )
return false;
}
- const char* lastPos = buf;
- const char* p = buf;
+ // Process the buffer in place to normalize new lines. (See comment above.)
+ // Copies from the 'p' to 'q' pointer, where p can advance faster if
+ // a newline-carriage return is hit.
+ //
+ // Wikipedia:
+ // Systems based on ASCII or a compatible character set use either LF (Line feed, '\n', 0x0A, 10 in decimal) or
+ // CR (Carriage return, '\r', 0x0D, 13 in decimal) individually, or CR followed by LF (CR+LF, 0x0D 0x0A)...
+ // * LF: Multics, Unix and Unix-like systems (GNU/Linux, AIX, Xenix, Mac OS X, FreeBSD, etc.), BeOS, Amiga, RISC OS, and others
+ // * CR+LF: DEC RT-11 and most other early non-Unix, non-IBM OSes, CP/M, MP/M, DOS, OS/2, Microsoft Windows, Symbian OS
+ // * CR: Commodore 8-bit machines, Apple II family, Mac OS up to version 9 and OS-9
+
+ const char* p = buf; // the read head
+ char* q = buf; // the write head
+ const char CR = 0x0d;
+ const char LF = 0x0a;
buf[length] = 0;
while( *p ) {
assert( p < (buf+length) );
- if ( *p == 0xa ) {
- // Newline character. No special rules for this. Append all the characters
- // since the last string, and include the newline.
- data.append( lastPos, (p-lastPos+1) ); // append, include the newline
- ++p; // move past the newline
- lastPos = p; // and point to the new buffer (may be 0)
- assert( p <= (buf+length) );
- }
- else if ( *p == 0xd ) {
- // Carriage return. Append what we have so far, then
- // handle moving forward in the buffer.
- if ( (p-lastPos) > 0 ) {
- data.append( lastPos, p-lastPos ); // do not add the CR
- }
- data += (char)0xa; // a proper newline
+ assert( q <= (buf+length) );
+ assert( q <= p );
- if ( *(p+1) == 0xa ) {
- // Carriage return - new line sequence
- p += 2;
- lastPos = p;
- assert( p <= (buf+length) );
- }
- else {
- // it was followed by something else...that is presumably characters again.
- ++p;
- lastPos = p;
- assert( p <= (buf+length) );
+ if ( *p == CR ) {
+ *q++ = LF;
+ p++;
+ if ( *p == LF ) { // check for CR+LF (and skip LF)
+ p++;
}
}
else {
- ++p;
+ *q++ = *p++;
}
}
- // Handle any left over characters.
- if ( p-lastPos ) {
- data.append( lastPos, p-lastPos );
- }
+ assert( q <= (buf+length) );
+ *q = 0;
+
+ Parse( buf, 0, encoding );
+
delete [] buf;
- buf = 0;
-
- Parse( data.c_str(), 0, encoding );
-
- if ( Error() )
- return false;
- else
- return true;
+ return !Error();
}
@@ -1225,7 +1216,7 @@ void TiXmlAttribute::Print( FILE* cfile, int /*depth*/, TIXML_STRING* str ) cons
if (value.find ('\"') == TIXML_STRING::npos) {
if ( cfile ) {
- fprintf (cfile, "%s=\"%s\"", n.c_str(), v.c_str() );
+ fprintf (cfile, "%s=\"%s\"", n.c_str(), v.c_str() );
}
if ( str ) {
(*str) += n; (*str) += "=\""; (*str) += v; (*str) += "\"";
@@ -1233,7 +1224,7 @@ void TiXmlAttribute::Print( FILE* cfile, int /*depth*/, TIXML_STRING* str ) cons
}
else {
if ( cfile ) {
- fprintf (cfile, "%s='%s'", n.c_str(), v.c_str() );
+ fprintf (cfile, "%s='%s'", n.c_str(), v.c_str() );
}
if ( str ) {
(*str) += n; (*str) += "='"; (*str) += v; (*str) += "'";
@@ -1271,9 +1262,9 @@ void TiXmlAttribute::SetDoubleValue( double _value )
{
char buf [256];
#if defined(TIXML_SNPRINTF)
- TIXML_SNPRINTF( buf, sizeof(buf), "%lf", _value);
+ TIXML_SNPRINTF( buf, sizeof(buf), "%g", _value);
#else
- sprintf (buf, "%lf", _value);
+ sprintf (buf, "%g", _value);
#endif
SetValue (buf);
}
@@ -1289,16 +1280,17 @@ double TiXmlAttribute::DoubleValue() const
}
-TiXmlComment::TiXmlComment( const TiXmlComment& copy ) : TiXmlNode( TiXmlNode::COMMENT )
+TiXmlComment::TiXmlComment( const TiXmlComment& copy ) : TiXmlNode( TiXmlNode::TINYXML_COMMENT )
{
copy.CopyTo( this );
}
-void TiXmlComment::operator=( const TiXmlComment& base )
+TiXmlComment& TiXmlComment::operator=( const TiXmlComment& base )
{
Clear();
base.CopyTo( this );
+ return *this;
}
@@ -1387,7 +1379,7 @@ TiXmlNode* TiXmlText::Clone() const
TiXmlDeclaration::TiXmlDeclaration( const char * _version,
const char * _encoding,
const char * _standalone )
- : TiXmlNode( TiXmlNode::DECLARATION )
+ : TiXmlNode( TiXmlNode::TINYXML_DECLARATION )
{
version = _version;
encoding = _encoding;
@@ -1399,7 +1391,7 @@ TiXmlDeclaration::TiXmlDeclaration( const char * _version,
TiXmlDeclaration::TiXmlDeclaration( const std::string& _version,
const std::string& _encoding,
const std::string& _standalone )
- : TiXmlNode( TiXmlNode::DECLARATION )
+ : TiXmlNode( TiXmlNode::TINYXML_DECLARATION )
{
version = _version;
encoding = _encoding;
@@ -1409,16 +1401,17 @@ TiXmlDeclaration::TiXmlDeclaration( const std::string& _version,
TiXmlDeclaration::TiXmlDeclaration( const TiXmlDeclaration& copy )
- : TiXmlNode( TiXmlNode::DECLARATION )
+ : TiXmlNode( TiXmlNode::TINYXML_DECLARATION )
{
copy.CopyTo( this );
}
-void TiXmlDeclaration::operator=( const TiXmlDeclaration& copy )
+TiXmlDeclaration& TiXmlDeclaration::operator=( const TiXmlDeclaration& copy )
{
Clear();
copy.CopyTo( this );
+ return *this;
}
@@ -1553,18 +1546,7 @@ void TiXmlAttributeSet::Remove( TiXmlAttribute* removeMe )
#ifdef TIXML_USE_STL
-const TiXmlAttribute* TiXmlAttributeSet::Find( const std::string& name ) const
-{
- for( const TiXmlAttribute* node = sentinel.next; node != &sentinel; node = node->next )
- {
- if ( node->name == name )
- return node;
- }
- return 0;
-}
-
-/*
-TiXmlAttribute* TiXmlAttributeSet::Find( const std::string& name )
+TiXmlAttribute* TiXmlAttributeSet::Find( const std::string& name ) const
{
for( TiXmlAttribute* node = sentinel.next; node != &sentinel; node = node->next )
{
@@ -1573,22 +1555,21 @@ TiXmlAttribute* TiXmlAttributeSet::Find( const std::string& name )
}
return 0;
}
-*/
+
+TiXmlAttribute* TiXmlAttributeSet::FindOrCreate( const std::string& _name )
+{
+ TiXmlAttribute* attrib = Find( _name );
+ if ( !attrib ) {
+ attrib = new TiXmlAttribute();
+ Add( attrib );
+ attrib->SetName( _name );
+ }
+ return attrib;
+}
#endif
-const TiXmlAttribute* TiXmlAttributeSet::Find( const char* name ) const
-{
- for( const TiXmlAttribute* node = sentinel.next; node != &sentinel; node = node->next )
- {
- if ( strcmp( node->name.c_str(), name ) == 0 )
- return node;
- }
- return 0;
-}
-
-/*
-TiXmlAttribute* TiXmlAttributeSet::Find( const char* name )
+TiXmlAttribute* TiXmlAttributeSet::Find( const char* name ) const
{
for( TiXmlAttribute* node = sentinel.next; node != &sentinel; node = node->next )
{
@@ -1597,7 +1578,19 @@ TiXmlAttribute* TiXmlAttributeSet::Find( const char* name )
}
return 0;
}
-*/
+
+
+TiXmlAttribute* TiXmlAttributeSet::FindOrCreate( const char* _name )
+{
+ TiXmlAttribute* attrib = Find( _name );
+ if ( !attrib ) {
+ attrib = new TiXmlAttribute();
+ Add( attrib );
+ attrib->SetName( _name );
+ }
+ return attrib;
+}
+
#ifdef TIXML_USE_STL
std::istream& operator>> (std::istream & in, TiXmlNode & base)
diff --git a/Engine/lib/tinyxml/tinyxml.h b/Engine/lib/tinyxml/tinyxml.h
index c6f40cc27..a3589e5b2 100644
--- a/Engine/lib/tinyxml/tinyxml.h
+++ b/Engine/lib/tinyxml/tinyxml.h
@@ -1,6 +1,6 @@
/*
www.sourceforge.net/projects/tinyxml
-Original code (2.0 and earlier )copyright (c) 2000-2006 Lee Thomason (www.grinninglizard.com)
+Original code by Lee Thomason (www.grinninglizard.com)
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any
@@ -63,21 +63,19 @@ distribution.
#if defined(_MSC_VER) && (_MSC_VER >= 1400 )
// Microsoft visual studio, version 2005 and higher.
#define TIXML_SNPRINTF _snprintf_s
- #define TIXML_SNSCANF _snscanf_s
#define TIXML_SSCANF sscanf_s
#elif defined(_MSC_VER) && (_MSC_VER >= 1200 )
// Microsoft visual studio, version 6 and higher.
//#pragma message( "Using _sn* functions." )
#define TIXML_SNPRINTF _snprintf
- #define TIXML_SNSCANF _snscanf
#define TIXML_SSCANF sscanf
#elif defined(__GNUC__) && (__GNUC__ >= 3 )
// GCC version 3 and higher.s
//#warning( "Using sn* functions." )
#define TIXML_SNPRINTF snprintf
- #define TIXML_SNSCANF snscanf
#define TIXML_SSCANF sscanf
#else
+ #define TIXML_SNPRINTF snprintf
#define TIXML_SSCANF sscanf
#endif
#endif
@@ -92,8 +90,8 @@ class TiXmlDeclaration;
class TiXmlParsingData;
const int TIXML_MAJOR_VERSION = 2;
-const int TIXML_MINOR_VERSION = 5;
-const int TIXML_PATCH_VERSION = 3;
+const int TIXML_MINOR_VERSION = 6;
+const int TIXML_PATCH_VERSION = 2;
/* Internal structure for tracking location of items
in the XML file.
@@ -109,10 +107,11 @@ struct TiXmlCursor
/**
+ Implements the interface to the "Visitor pattern" (see the Accept() method.)
If you call the Accept() method, it requires being passed a TiXmlVisitor
class to handle callbacks. For nodes that contain other nodes (Document, Element)
you will get called with a VisitEnter/VisitExit pair. Nodes that are always leaves
- are simple called with Visit().
+ are simply called with Visit().
If you return 'true' from a Visit method, recursive parsing will continue. If you return
false, no children of this node or its sibilings will be Visited.
@@ -147,7 +146,7 @@ public:
virtual bool Visit( const TiXmlText& /*text*/ ) { return true; }
/// Visit a comment node
virtual bool Visit( const TiXmlComment& /*comment*/ ) { return true; }
- /// Visit an unknow node
+ /// Visit an unknown node
virtual bool Visit( const TiXmlUnknown& /*unknown*/ ) { return true; }
};
@@ -267,7 +266,6 @@ public:
TIXML_NO_ERROR = 0,
TIXML_ERROR,
TIXML_ERROR_OPENING_FILE,
- TIXML_ERROR_OUT_OF_MEMORY,
TIXML_ERROR_PARSING_ELEMENT,
TIXML_ERROR_FAILED_TO_READ_ELEMENT_NAME,
TIXML_ERROR_READING_ELEMENT_VALUE,
@@ -288,6 +286,7 @@ public:
protected:
static const char* SkipWhiteSpace( const char*, TiXmlEncoding encoding );
+
inline static bool IsWhiteSpace( char c )
{
return ( isspace( (unsigned char) c ) || c == '\n' || c == '\r' );
@@ -462,13 +461,13 @@ public:
*/
enum NodeType
{
- DOCUMENT,
- ELEMENT,
- COMMENT,
- UNKNOWN,
- TEXT,
- DECLARATION,
- TYPECOUNT
+ TINYXML_DOCUMENT,
+ TINYXML_ELEMENT,
+ TINYXML_COMMENT,
+ TINYXML_UNKNOWN,
+ TINYXML_TEXT,
+ TINYXML_DECLARATION,
+ TINYXML_TYPECOUNT
};
virtual ~TiXmlNode();
@@ -679,8 +678,8 @@ public:
#endif
/** Query the type (as an enumerated value, above) of this node.
- The possible types are: DOCUMENT, ELEMENT, COMMENT,
- UNKNOWN, TEXT, and DECLARATION.
+ The possible types are: TINYXML_DOCUMENT, TINYXML_ELEMENT, TINYXML_COMMENT,
+ TINYXML_UNKNOWN, TINYXML_TEXT, and TINYXML_DECLARATION.
*/
int Type() const { return type; }
@@ -915,17 +914,14 @@ public:
const TiXmlAttribute* Last() const { return ( sentinel.prev == &sentinel ) ? 0 : sentinel.prev; }
TiXmlAttribute* Last() { return ( sentinel.prev == &sentinel ) ? 0 : sentinel.prev; }
- const TiXmlAttribute* Find( const char* _name ) const;
- TiXmlAttribute* Find( const char* _name ) {
- return const_cast< TiXmlAttribute* >( (const_cast< const TiXmlAttributeSet* >(this))->Find( _name ) );
- }
- #ifdef TIXML_USE_STL
- const TiXmlAttribute* Find( const std::string& _name ) const;
- TiXmlAttribute* Find( const std::string& _name ) {
- return const_cast< TiXmlAttribute* >( (const_cast< const TiXmlAttributeSet* >(this))->Find( _name ) );
- }
+ TiXmlAttribute* Find( const char* _name ) const;
+ TiXmlAttribute* FindOrCreate( const char* _name );
+
+# ifdef TIXML_USE_STL
+ TiXmlAttribute* Find( const std::string& _name ) const;
+ TiXmlAttribute* FindOrCreate( const std::string& _name );
+# endif
- #endif
private:
//*ME: Because of hidden/disabled copy-construktor in TiXmlAttribute (sentinel-element),
@@ -954,7 +950,7 @@ public:
TiXmlElement( const TiXmlElement& );
- void operator=( const TiXmlElement& base );
+ TiXmlElement& operator=( const TiXmlElement& base );
virtual ~TiXmlElement();
@@ -987,6 +983,13 @@ public:
does not exist, then TIXML_NO_ATTRIBUTE is returned.
*/
int QueryIntAttribute( const char* name, int* _value ) const;
+ /// QueryUnsignedAttribute examines the attribute - see QueryIntAttribute().
+ int QueryUnsignedAttribute( const char* name, unsigned* _value ) const;
+ /** QueryBoolAttribute examines the attribute - see QueryIntAttribute().
+ Note that '1', 'true', or 'yes' are considered true, while '0', 'false'
+ and 'no' are considered false.
+ */
+ int QueryBoolAttribute( const char* name, bool* _value ) const;
/// QueryDoubleAttribute examines the attribute - see QueryIntAttribute().
int QueryDoubleAttribute( const char* name, double* _value ) const;
/// QueryFloatAttribute examines the attribute - see QueryIntAttribute().
@@ -1000,11 +1003,21 @@ public:
}
#ifdef TIXML_USE_STL
+ /// QueryStringAttribute examines the attribute - see QueryIntAttribute().
+ int QueryStringAttribute( const char* name, std::string* _value ) const {
+ const char* cstr = Attribute( name );
+ if ( cstr ) {
+ *_value = std::string( cstr );
+ return TIXML_SUCCESS;
+ }
+ return TIXML_NO_ATTRIBUTE;
+ }
+
/** Template form of the attribute query which will try to read the
attribute into the specified type. Very easy, very powerful, but
be careful to make sure to call this with the correct type.
- NOTE: This method doesn't work correctly for 'string' types.
+ NOTE: This method doesn't work correctly for 'string' types that contain spaces.
@return TIXML_SUCCESS, TIXML_WRONG_TYPE, or TIXML_NO_ATTRIBUTE
*/
@@ -1020,13 +1033,8 @@ public:
return TIXML_SUCCESS;
return TIXML_WRONG_TYPE;
}
- /*
- This is - in theory - a bug fix for "QueryValueAtribute returns truncated std::string"
- but template specialization is hard to get working cross-compiler. Leaving the bug for now.
-
- // The above will fail for std::string because the space character is used as a seperator.
- // Specialize for strings. Bug [ 1695429 ] QueryValueAtribute returns truncated std::string
- template<> int QueryValueAttribute( const std::string& name, std::string* outValue ) const
+
+ int QueryValueAttribute( const std::string& name, std::string* outValue ) const
{
const TiXmlAttribute* node = attributeSet.Find( name );
if ( !node )
@@ -1034,7 +1042,6 @@ public:
*outValue = node->ValueStr();
return TIXML_SUCCESS;
}
- */
#endif
/** Sets an attribute of name to a given value. The attribute
@@ -1053,6 +1060,8 @@ public:
void SetAttribute( const std::string& name, const std::string& _value );
///< STL std::string form.
void SetAttribute( const std::string& name, int _value );
+ ///< STL std::string form.
+ void SetDoubleAttribute( const std::string& name, double value );
#endif
/** Sets an attribute of name to a given value. The attribute
@@ -1144,7 +1153,6 @@ protected:
const char* ReadValue( const char* in, TiXmlParsingData* prevData, TiXmlEncoding encoding );
private:
-
TiXmlAttributeSet attributeSet;
};
@@ -1155,13 +1163,13 @@ class TiXmlComment : public TiXmlNode
{
public:
/// Constructs an empty comment.
- TiXmlComment() : TiXmlNode( TiXmlNode::COMMENT ) {}
+ TiXmlComment() : TiXmlNode( TiXmlNode::TINYXML_COMMENT ) {}
/// Construct a comment from text.
- TiXmlComment( const char* _value ) : TiXmlNode( TiXmlNode::COMMENT ) {
+ TiXmlComment( const char* _value ) : TiXmlNode( TiXmlNode::TINYXML_COMMENT ) {
SetValue( _value );
}
TiXmlComment( const TiXmlComment& );
- void operator=( const TiXmlComment& base );
+ TiXmlComment& operator=( const TiXmlComment& base );
virtual ~TiXmlComment() {}
@@ -1175,8 +1183,8 @@ public:
*/
virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding );
- virtual const TiXmlComment* ToComment() const { return this; } ///< Cast to a more defined type. Will return null not of the requested type.
- virtual TiXmlComment* ToComment() { return this; } ///< Cast to a more defined type. Will return null not of the requested type.
+ virtual const TiXmlComment* ToComment() const { return this; } ///< Cast to a more defined type. Will return null not of the requested type.
+ virtual TiXmlComment* ToComment() { return this; } ///< Cast to a more defined type. Will return null not of the requested type.
/** Walk the XML tree visiting this node and all of its children.
*/
@@ -1209,7 +1217,7 @@ public:
normal, encoded text. If you want it be output as a CDATA text
element, set the parameter _cdata to 'true'
*/
- TiXmlText (const char * initValue ) : TiXmlNode (TiXmlNode::TEXT)
+ TiXmlText (const char * initValue ) : TiXmlNode (TiXmlNode::TINYXML_TEXT)
{
SetValue( initValue );
cdata = false;
@@ -1218,15 +1226,15 @@ public:
#ifdef TIXML_USE_STL
/// Constructor.
- TiXmlText( const std::string& initValue ) : TiXmlNode (TiXmlNode::TEXT)
+ TiXmlText( const std::string& initValue ) : TiXmlNode (TiXmlNode::TINYXML_TEXT)
{
SetValue( initValue );
cdata = false;
}
#endif
- TiXmlText( const TiXmlText& copy ) : TiXmlNode( TiXmlNode::TEXT ) { copy.CopyTo( this ); }
- void operator=( const TiXmlText& base ) { base.CopyTo( this ); }
+ TiXmlText( const TiXmlText& copy ) : TiXmlNode( TiXmlNode::TINYXML_TEXT ) { copy.CopyTo( this ); }
+ TiXmlText& operator=( const TiXmlText& base ) { base.CopyTo( this ); return *this; }
// Write this text object to a FILE stream.
virtual void Print( FILE* cfile, int depth ) const;
@@ -1278,7 +1286,7 @@ class TiXmlDeclaration : public TiXmlNode
{
public:
/// Construct an empty declaration.
- TiXmlDeclaration() : TiXmlNode( TiXmlNode::DECLARATION ) {}
+ TiXmlDeclaration() : TiXmlNode( TiXmlNode::TINYXML_DECLARATION ) {}
#ifdef TIXML_USE_STL
/// Constructor.
@@ -1293,7 +1301,7 @@ public:
const char* _standalone );
TiXmlDeclaration( const TiXmlDeclaration& copy );
- void operator=( const TiXmlDeclaration& copy );
+ TiXmlDeclaration& operator=( const TiXmlDeclaration& copy );
virtual ~TiXmlDeclaration() {}
@@ -1346,11 +1354,11 @@ private:
class TiXmlUnknown : public TiXmlNode
{
public:
- TiXmlUnknown() : TiXmlNode( TiXmlNode::UNKNOWN ) {}
+ TiXmlUnknown() : TiXmlNode( TiXmlNode::TINYXML_UNKNOWN ) {}
virtual ~TiXmlUnknown() {}
- TiXmlUnknown( const TiXmlUnknown& copy ) : TiXmlNode( TiXmlNode::UNKNOWN ) { copy.CopyTo( this ); }
- void operator=( const TiXmlUnknown& copy ) { copy.CopyTo( this ); }
+ TiXmlUnknown( const TiXmlUnknown& copy ) : TiXmlNode( TiXmlNode::TINYXML_UNKNOWN ) { copy.CopyTo( this ); }
+ TiXmlUnknown& operator=( const TiXmlUnknown& copy ) { copy.CopyTo( this ); return *this; }
/// Creates a copy of this Unknown and returns it.
virtual TiXmlNode* Clone() const;
@@ -1359,8 +1367,8 @@ public:
virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding );
- virtual const TiXmlUnknown* ToUnknown() const { return this; } ///< Cast to a more defined type. Will return null not of the requested type.
- virtual TiXmlUnknown* ToUnknown() { return this; } ///< Cast to a more defined type. Will return null not of the requested type.
+ virtual const TiXmlUnknown* ToUnknown() const { return this; } ///< Cast to a more defined type. Will return null not of the requested type.
+ virtual TiXmlUnknown* ToUnknown() { return this; } ///< Cast to a more defined type. Will return null not of the requested type.
/** Walk the XML tree visiting this node and all of its children.
*/
@@ -1396,7 +1404,7 @@ public:
#endif
TiXmlDocument( const TiXmlDocument& copy );
- void operator=( const TiXmlDocument& copy );
+ TiXmlDocument& operator=( const TiXmlDocument& copy );
virtual ~TiXmlDocument() {}
@@ -1423,14 +1431,10 @@ public:
#ifdef TIXML_USE_STL
bool LoadFile( const std::string& filename, TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING ) ///< STL std::string version.
{
-// StringToBuffer f( filename );
-// return ( f.buffer && LoadFile( f.buffer, encoding ));
return LoadFile( filename.c_str(), encoding );
}
bool SaveFile( const std::string& filename ) const ///< STL std::string version.
{
-// StringToBuffer f( filename );
-// return ( f.buffer && SaveFile( f.buffer ));
return SaveFile( filename.c_str() );
}
#endif
@@ -1638,7 +1642,7 @@ public:
TiXmlHandle( TiXmlNode* _node ) { this->node = _node; }
/// Copy constructor
TiXmlHandle( const TiXmlHandle& ref ) { this->node = ref.node; }
- TiXmlHandle operator=( const TiXmlHandle& ref ) { this->node = ref.node; return *this; }
+ TiXmlHandle operator=( const TiXmlHandle& ref ) { if ( &ref != this ) this->node = ref.node; return *this; }
/// Return a handle to the first child node.
TiXmlHandle FirstChild() const;
@@ -1799,4 +1803,3 @@ private:
#endif
#endif
-
diff --git a/Engine/lib/tinyxml/tinyxmlerror.cpp b/Engine/lib/tinyxml/tinyxmlerror.cpp
index d24f63b2e..538c21d0b 100644
--- a/Engine/lib/tinyxml/tinyxmlerror.cpp
+++ b/Engine/lib/tinyxml/tinyxmlerror.cpp
@@ -31,12 +31,11 @@ distribution.
// It also cleans up the code a bit.
//
-const char* TiXmlBase::errorString[ TIXML_ERROR_STRING_COUNT ] =
+const char* TiXmlBase::errorString[ TiXmlBase::TIXML_ERROR_STRING_COUNT ] =
{
"No error",
"Error",
"Failed to open file",
- "Memory allocation failed.",
"Error parsing Element.",
"Failed to read Element name",
"Error reading Element value.",
diff --git a/Engine/lib/tinyxml/tinyxmlparser.cpp b/Engine/lib/tinyxml/tinyxmlparser.cpp
index 2e8f56739..81b7eae96 100644
--- a/Engine/lib/tinyxml/tinyxmlparser.cpp
+++ b/Engine/lib/tinyxml/tinyxmlparser.cpp
@@ -1,6 +1,6 @@
/*
www.sourceforge.net/projects/tinyxml
-Original code (2.0 and earlier )copyright (c) 2000-2002 Lee Thomason (www.grinninglizard.com)
+Original code by Lee Thomason (www.grinninglizard.com)
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any
@@ -40,7 +40,7 @@ distribution.
// Note tha "PutString" hardcodes the same list. This
// is less flexible than it appears. Changing the entries
// or order will break putstring.
-TiXmlBase::Entity TiXmlBase::entity[ NUM_ENTITY ] =
+TiXmlBase::Entity TiXmlBase::entity[ TiXmlBase::NUM_ENTITY ] =
{
{ "&", 5, '&' },
{ "<", 4, '<' },
@@ -174,7 +174,7 @@ class TiXmlParsingData
public:
void Stamp( const char* now, TiXmlEncoding encoding );
- const TiXmlCursor& Cursor() { return cursor; }
+ const TiXmlCursor& Cursor() const { return cursor; }
private:
// Only used by the document!
@@ -346,7 +346,7 @@ const char* TiXmlBase::SkipWhiteSpace( const char* p, TiXmlEncoding encoding )
continue;
}
- if ( IsWhiteSpace( *p ) || *p == '\n' || *p =='\r' ) // Still using old rules for white space.
+ if ( IsWhiteSpace( *p ) ) // Still using old rules for white space.
++p;
else
break;
@@ -354,7 +354,7 @@ const char* TiXmlBase::SkipWhiteSpace( const char* p, TiXmlEncoding encoding )
}
else
{
- while ( *p && IsWhiteSpace( *p ) || *p == '\n' || *p =='\r' )
+ while ( *p && IsWhiteSpace( *p ) )
++p;
}
@@ -631,9 +631,9 @@ const char* TiXmlBase::ReadText( const char* p,
}
}
}
- if ( p )
+ if ( p && *p )
p += strlen( endTag );
- return p;
+ return ( p && *p ) ? p : 0;
}
#ifdef TIXML_USE_STL
@@ -825,7 +825,6 @@ TiXmlNode* TiXmlNode::Identify( const char* p, TiXmlEncoding encoding )
return 0;
}
- TiXmlDocument* doc = GetDocument();
p = SkipWhiteSpace( p, encoding );
if ( !p || !*p )
@@ -896,11 +895,6 @@ TiXmlNode* TiXmlNode::Identify( const char* p, TiXmlEncoding encoding )
// Set the parent, so it can report errors
returnNode->parent = this;
}
- else
- {
- if ( doc )
- doc->SetError( TIXML_ERROR_OUT_OF_MEMORY, 0, 0, TIXML_ENCODING_UNKNOWN );
- }
return returnNode;
}
@@ -1121,18 +1115,20 @@ const char* TiXmlElement::Parse( const char* p, TiXmlParsingData* data, TiXmlEnc
}
// We should find the end tag now
+ // note that:
+ // and
+ //
+ // are both valid end tags.
if ( StringEqual( p, endTag.c_str(), false, encoding ) )
{
- // Handle whitespace between end tag name and '>' character
p += endTag.length();
p = SkipWhiteSpace( p, encoding );
- if (*p == '>')
- return ++p;
- else
- {
- if ( document ) document->SetError( TIXML_ERROR_READING_END_TAG, p, data, encoding );
- return 0;
+ if ( p && *p && *p == '>' ) {
+ ++p;
+ return p;
}
+ if ( document ) document->SetError( TIXML_ERROR_READING_END_TAG, p, data, encoding );
+ return 0;
}
else
{
@@ -1146,7 +1142,6 @@ const char* TiXmlElement::Parse( const char* p, TiXmlParsingData* data, TiXmlEnc
TiXmlAttribute* attrib = new TiXmlAttribute();
if ( !attrib )
{
- if ( document ) document->SetError( TIXML_ERROR_OUT_OF_MEMORY, pErr, data, encoding );
return 0;
}
@@ -1169,7 +1164,7 @@ const char* TiXmlElement::Parse( const char* p, TiXmlParsingData* data, TiXmlEnc
#endif
if ( node )
{
- node->SetValue( attrib->Value() );
+ if ( document ) document->SetError( TIXML_ERROR_PARSING_ELEMENT, pErr, data, encoding );
delete attrib;
return 0;
}
@@ -1198,8 +1193,7 @@ const char* TiXmlElement::ReadValue( const char* p, TiXmlParsingData* data, TiXm
if ( !textNode )
{
- if ( document ) document->SetError( TIXML_ERROR_OUT_OF_MEMORY, 0, 0, encoding );
- return 0;
+ return 0;
}
if ( TiXmlBase::IsWhiteSpaceCondensed() )
@@ -1304,9 +1298,10 @@ const char* TiXmlUnknown::Parse( const char* p, TiXmlParsingData* data, TiXmlEnc
if ( !p )
{
- if ( document ) document->SetError( TIXML_ERROR_PARSING_UNKNOWN, 0, 0, encoding );
+ if ( document )
+ document->SetError( TIXML_ERROR_PARSING_UNKNOWN, 0, 0, encoding );
}
- if ( *p == '>' )
+ if ( p && *p == '>' )
return p+1;
return p;
}
@@ -1356,7 +1351,8 @@ const char* TiXmlComment::Parse( const char* p, TiXmlParsingData* data, TiXmlEnc
if ( !StringEqual( p, startTag, false, encoding ) )
{
- document->SetError( TIXML_ERROR_PARSING_COMMENT, p, data, encoding );
+ if ( document )
+ document->SetError( TIXML_ERROR_PARSING_COMMENT, p, data, encoding );
return 0;
}
p += strlen( startTag );
@@ -1386,7 +1382,7 @@ const char* TiXmlComment::Parse( const char* p, TiXmlParsingData* data, TiXmlEnc
value.append( p, 1 );
++p;
}
- if ( p )
+ if ( p && *p )
p += strlen( endTag );
return p;
@@ -1398,10 +1394,6 @@ const char* TiXmlAttribute::Parse( const char* p, TiXmlParsingData* data, TiXmlE
p = SkipWhiteSpace( p, encoding );
if ( !p || !*p ) return 0;
-// int tabsize = 4;
-// if ( document )
-// tabsize = document->TabSize();
-
if ( data )
{
data->Stamp( p, encoding );
@@ -1453,7 +1445,7 @@ const char* TiXmlAttribute::Parse( const char* p, TiXmlParsingData* data, TiXmlE
// its best, even without them.
value = "";
while ( p && *p // existence
- && !IsWhiteSpace( *p ) && *p != '\n' && *p != '\r' // whitespace
+ && !IsWhiteSpace( *p ) // whitespace
&& *p != '/' && *p != '>' ) // tag end
{
if ( *p == SINGLE_QUOTE || *p == DOUBLE_QUOTE ) {
@@ -1522,7 +1514,8 @@ const char* TiXmlText::Parse( const char* p, TiXmlParsingData* data, TiXmlEncodi
if ( !StringEqual( p, startTag, false, encoding ) )
{
- document->SetError( TIXML_ERROR_PARSING_CDATA, p, data, encoding );
+ if ( document )
+ document->SetError( TIXML_ERROR_PARSING_CDATA, p, data, encoding );
return 0;
}
p += strlen( startTag );
@@ -1546,7 +1539,7 @@ const char* TiXmlText::Parse( const char* p, TiXmlParsingData* data, TiXmlEncodi
const char* end = "<";
p = ReadText( p, &value, ignoreWhite, end, false, encoding );
- if ( p )
+ if ( p && *p )
return p-1; // don't truncate the '<'
return 0;
}
1.4.7
+