mirror of https://github.com/AxioDL/tinyxml2.git
Merge remote-tracking branch 'origin/master' into build-tests-option
This commit is contained in:
commit
105f32f64d
|
@ -29,25 +29,6 @@ set(GENERIC_LIB_SOVERSION "4")
|
|||
|
||||
include_directories("${CMAKE_CURRENT_SOURCE_DIR}/.")
|
||||
|
||||
################################
|
||||
# Add custom target to copy all data
|
||||
|
||||
set(TARGET_DATA_COPY DATA_COPY)
|
||||
set(DATA_COPY_FILES)
|
||||
if(NOT ${CMAKE_CURRENT_SOURCE_DIR} STREQUAL ${CMAKE_CURRENT_BINARY_DIR})
|
||||
foreach(data dream.xml empty.xml utf8test.xml utf8testverify.xml)
|
||||
set(DATA_COPY_SRC ${CMAKE_CURRENT_SOURCE_DIR}/resources/${data})
|
||||
set(DATA_COPY_DEST ${CMAKE_CURRENT_BINARY_DIR}/resources/${data})
|
||||
add_custom_command(
|
||||
OUTPUT ${DATA_COPY_DEST}
|
||||
COMMAND ${CMAKE_COMMAND}
|
||||
ARGS -E copy ${DATA_COPY_SRC} ${DATA_COPY_DEST}
|
||||
DEPENDS ${DATA_COPY_SRC})
|
||||
list(APPEND DATA_COPY_FILES ${DATA_COPY_DEST})
|
||||
endforeach(data)
|
||||
endif(NOT ${CMAKE_CURRENT_SOURCE_DIR} STREQUAL ${CMAKE_CURRENT_BINARY_DIR})
|
||||
add_custom_target(${TARGET_DATA_COPY} DEPENDS ${DATA_COPY_FILES})
|
||||
|
||||
################################
|
||||
# Add definitions
|
||||
|
||||
|
@ -61,7 +42,7 @@ set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -DDEBUG")
|
|||
# Add targets
|
||||
# By Default shared libray is being built
|
||||
# To build static libs also - Do cmake . -DBUILD_STATIC_LIBS:BOOL=ON
|
||||
# User can choose not to build shared library by using cmake -BUILD_SHARED_LIBS:BOOL:OFF
|
||||
# User can choose not to build shared library by using cmake -DBUILD_SHARED_LIBS:BOOL=OFF
|
||||
# To build only static libs use cmake . -DBUILD_SHARED_LIBS:BOOL=OFF -DBUILD_STATIC_LIBS:BOOL=ON
|
||||
# To build the tests, use cmake . -DBUILD_TESTS:BOOL=ON
|
||||
# To disable the building of the tests, use cmake . -DBUILD_TESTS:BOOL=OFF
|
||||
|
@ -113,19 +94,20 @@ if(BUILD_TESTS)
|
|||
add_executable(xmltest xmltest.cpp)
|
||||
if(BUILD_SHARED_LIBS)
|
||||
add_dependencies(xmltest tinyxml2)
|
||||
add_dependencies(xmltest ${TARGET_DATA_COPY})
|
||||
target_link_libraries(xmltest tinyxml2)
|
||||
else(BUILD_STATIC_LIBS)
|
||||
add_dependencies(xmltest tinyxml2_static)
|
||||
add_dependencies(xmltest ${TARGET_DATA_COPY})
|
||||
target_link_libraries(xmltest tinyxml2_static)
|
||||
endif()
|
||||
|
||||
#add_test(xmltest ${SAMPLE_NAME} COMMAND $<TARGET_FILE:${SAMPLE_NAME}>)
|
||||
# Copy test resources and create test output directory
|
||||
add_custom_command(TARGET xmltest POST_BUILD
|
||||
COMMAND ${CMAKE_COMMAND} -E copy_directory ${CMAKE_SOURCE_DIR}/resources $<TARGET_FILE_DIR:xmltest>/resources
|
||||
COMMAND ${CMAKE_COMMAND} -E make_directory $<TARGET_FILE_DIR:xmltest>/resources/out
|
||||
COMMENT "Configuring xmltest resources directory: ${CMAKE_BINARY_DIR}/resources"
|
||||
)
|
||||
endif()
|
||||
|
||||
install(TARGETS DESTINATION ${CMAKE_INSTALL_BINDIR})
|
||||
|
||||
install(FILES tinyxml2.h DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
|
||||
|
||||
foreach(p LIB INCLUDE)
|
||||
|
|
|
@ -3,5 +3,5 @@ before_build:
|
|||
|
||||
build_script:
|
||||
- msbuild tinyxml2.sln /m /p:Configuration=Release /t:ALL_BUILD
|
||||
- copy Release\xmltest.exe .\ && copy Release\tinyxml2.dll .\
|
||||
- cd Release
|
||||
- xmltest.exe
|
||||
|
|
79
tinyxml2.cpp
79
tinyxml2.cpp
|
@ -368,6 +368,19 @@ const char* StrPair::GetStr()
|
|||
|
||||
// --------- XMLUtil ----------- //
|
||||
|
||||
const char* XMLUtil::writeBoolTrue = "true";
|
||||
const char* XMLUtil::writeBoolFalse = "false";
|
||||
|
||||
void XMLUtil::SetBoolSerialization(const char* writeTrue, const char* writeFalse)
|
||||
{
|
||||
static const char* defTrue = "true";
|
||||
static const char* defFalse = "false";
|
||||
|
||||
writeBoolTrue = (writeTrue) ? writeTrue : defTrue;
|
||||
writeBoolFalse = (writeFalse) ? writeFalse : defFalse;
|
||||
}
|
||||
|
||||
|
||||
const char* XMLUtil::ReadBOM( const char* p, bool* bom )
|
||||
{
|
||||
TIXMLASSERT( p );
|
||||
|
@ -545,7 +558,7 @@ void XMLUtil::ToStr( unsigned v, char* buffer, int bufferSize )
|
|||
|
||||
void XMLUtil::ToStr( bool v, char* buffer, int bufferSize )
|
||||
{
|
||||
TIXML_SNPRINTF( buffer, bufferSize, "%s", v ? "true" : "false" );
|
||||
TIXML_SNPRINTF( buffer, bufferSize, "%s", v ? writeBoolTrue : writeBoolFalse);
|
||||
}
|
||||
|
||||
/*
|
||||
|
@ -665,46 +678,34 @@ char* XMLDocument::Identify( char* p, XMLNode** node )
|
|||
TIXMLASSERT( sizeof( XMLComment ) == sizeof( XMLDeclaration ) ); // use same memory pool
|
||||
XMLNode* returnNode = 0;
|
||||
if ( XMLUtil::StringEqual( p, xmlHeader, xmlHeaderLen ) ) {
|
||||
TIXMLASSERT( sizeof( XMLDeclaration ) == _commentPool.ItemSize() );
|
||||
returnNode = new (_commentPool.Alloc()) XMLDeclaration( this );
|
||||
returnNode = CreateUnlinkedNode<XMLDeclaration>( _commentPool );
|
||||
returnNode->_parseLineNum = _parseCurLineNum;
|
||||
returnNode->_memPool = &_commentPool;
|
||||
p += xmlHeaderLen;
|
||||
}
|
||||
else if ( XMLUtil::StringEqual( p, commentHeader, commentHeaderLen ) ) {
|
||||
TIXMLASSERT( sizeof( XMLComment ) == _commentPool.ItemSize() );
|
||||
returnNode = new (_commentPool.Alloc()) XMLComment( this );
|
||||
returnNode = CreateUnlinkedNode<XMLComment>( _commentPool );
|
||||
returnNode->_parseLineNum = _parseCurLineNum;
|
||||
returnNode->_memPool = &_commentPool;
|
||||
p += commentHeaderLen;
|
||||
}
|
||||
else if ( XMLUtil::StringEqual( p, cdataHeader, cdataHeaderLen ) ) {
|
||||
TIXMLASSERT( sizeof( XMLText ) == _textPool.ItemSize() );
|
||||
XMLText* text = new (_textPool.Alloc()) XMLText( this );
|
||||
XMLText* text = CreateUnlinkedNode<XMLText>( _textPool );
|
||||
returnNode = text;
|
||||
returnNode->_parseLineNum = _parseCurLineNum;
|
||||
returnNode->_memPool = &_textPool;
|
||||
p += cdataHeaderLen;
|
||||
text->SetCData( true );
|
||||
}
|
||||
else if ( XMLUtil::StringEqual( p, dtdHeader, dtdHeaderLen ) ) {
|
||||
TIXMLASSERT( sizeof( XMLUnknown ) == _commentPool.ItemSize() );
|
||||
returnNode = new (_commentPool.Alloc()) XMLUnknown( this );
|
||||
returnNode = CreateUnlinkedNode<XMLUnknown>( _commentPool );
|
||||
returnNode->_parseLineNum = _parseCurLineNum;
|
||||
returnNode->_memPool = &_commentPool;
|
||||
p += dtdHeaderLen;
|
||||
}
|
||||
else if ( XMLUtil::StringEqual( p, elementHeader, elementHeaderLen ) ) {
|
||||
TIXMLASSERT( sizeof( XMLElement ) == _elementPool.ItemSize() );
|
||||
returnNode = new (_elementPool.Alloc()) XMLElement( this );
|
||||
returnNode = CreateUnlinkedNode<XMLElement>( _elementPool );
|
||||
returnNode->_parseLineNum = _parseCurLineNum;
|
||||
returnNode->_memPool = &_elementPool;
|
||||
p += elementHeaderLen;
|
||||
}
|
||||
else {
|
||||
TIXMLASSERT( sizeof( XMLText ) == _textPool.ItemSize() );
|
||||
returnNode = new (_textPool.Alloc()) XMLText( this );
|
||||
returnNode->_memPool = &_textPool;
|
||||
returnNode = CreateUnlinkedNode<XMLText>( _textPool );
|
||||
returnNode->_parseLineNum = _parseCurLineNum; // Report line of first non-whitespace character
|
||||
p = start; // Back it up, all the text counts.
|
||||
_parseCurLineNum = startLine;
|
||||
|
@ -954,7 +955,7 @@ const XMLElement* XMLNode::PreviousSiblingElement( const char* name ) const
|
|||
}
|
||||
|
||||
|
||||
char* XMLNode::ParseDeep( char* p, StrPair* parentEnd, int* curLineNumPtr )
|
||||
char* XMLNode::ParseDeep( char* p, StrPair* parentEndTag, int* curLineNumPtr )
|
||||
{
|
||||
// This is a recursive method, but thinking about it "at the current level"
|
||||
// it is a pretty simple flat list:
|
||||
|
@ -1019,8 +1020,8 @@ char* XMLNode::ParseDeep( char* p, StrPair* parentEnd, int* curLineNumPtr )
|
|||
if ( ele ) {
|
||||
// We read the end tag. Return it to the parent.
|
||||
if ( ele->ClosingType() == XMLElement::CLOSING ) {
|
||||
if ( parentEnd ) {
|
||||
ele->_value.TransferTo( parentEnd );
|
||||
if ( parentEndTag ) {
|
||||
ele->_value.TransferTo( parentEndTag );
|
||||
}
|
||||
node->_memPool->SetTracked(); // created and then immediately deleted.
|
||||
DeleteNode( node );
|
||||
|
@ -1132,6 +1133,7 @@ XMLNode* XMLText::ShallowClone( XMLDocument* doc ) const
|
|||
|
||||
bool XMLText::ShallowEqual( const XMLNode* compare ) const
|
||||
{
|
||||
TIXMLASSERT( compare );
|
||||
const XMLText* text = compare->ToText();
|
||||
return ( text && XMLUtil::StringEqual( text->Value(), Value() ) );
|
||||
}
|
||||
|
@ -1447,7 +1449,7 @@ void XMLAttribute::SetAttribute( float v )
|
|||
|
||||
// --------- XMLElement ---------- //
|
||||
XMLElement::XMLElement( XMLDocument* doc ) : XMLNode( doc ),
|
||||
_closingType( 0 ),
|
||||
_closingType( OPEN ),
|
||||
_rootAttribute( 0 )
|
||||
{
|
||||
}
|
||||
|
@ -1837,6 +1839,7 @@ XMLAttribute* XMLElement::CreateAttribute()
|
|||
{
|
||||
TIXMLASSERT( sizeof( XMLAttribute ) == _document->_attributePool.ItemSize() );
|
||||
XMLAttribute* attrib = new (_document->_attributePool.Alloc() ) XMLAttribute();
|
||||
TIXMLASSERT( attrib );
|
||||
attrib->_memPool = &_document->_attributePool;
|
||||
attrib->_memPool->SetTracked();
|
||||
return attrib;
|
||||
|
@ -1846,7 +1849,7 @@ XMLAttribute* XMLElement::CreateAttribute()
|
|||
// <ele></ele>
|
||||
// <ele>foo<b>bar</b></ele>
|
||||
//
|
||||
char* XMLElement::ParseDeep( char* p, StrPair* strPair, int* curLineNumPtr )
|
||||
char* XMLElement::ParseDeep( char* p, StrPair* parentEndTag, int* curLineNumPtr )
|
||||
{
|
||||
// Read the element name.
|
||||
p = XMLUtil::SkipWhiteSpace( p, curLineNumPtr );
|
||||
|
@ -1865,11 +1868,11 @@ char* XMLElement::ParseDeep( char* p, StrPair* strPair, int* curLineNumPtr )
|
|||
}
|
||||
|
||||
p = ParseAttributes( p, curLineNumPtr );
|
||||
if ( !p || !*p || _closingType ) {
|
||||
if ( !p || !*p || _closingType != OPEN ) {
|
||||
return p;
|
||||
}
|
||||
|
||||
p = XMLNode::ParseDeep( p, strPair, curLineNumPtr );
|
||||
p = XMLNode::ParseDeep( p, parentEndTag, curLineNumPtr );
|
||||
return p;
|
||||
}
|
||||
|
||||
|
@ -1955,12 +1958,12 @@ const char* XMLDocument::_errorNames[XML_ERROR_COUNT] = {
|
|||
};
|
||||
|
||||
|
||||
XMLDocument::XMLDocument( bool processEntities, Whitespace whitespace ) :
|
||||
XMLDocument::XMLDocument( bool processEntities, Whitespace whitespaceMode ) :
|
||||
XMLNode( 0 ),
|
||||
_writeBOM( false ),
|
||||
_processEntities( processEntities ),
|
||||
_errorID(XML_SUCCESS),
|
||||
_whitespace( whitespace ),
|
||||
_whitespaceMode( whitespaceMode ),
|
||||
_errorLineNum( 0 ),
|
||||
_charBuffer( 0 ),
|
||||
_parseCurLineNum( 0 )
|
||||
|
@ -2008,9 +2011,7 @@ void XMLDocument::Clear()
|
|||
|
||||
XMLElement* XMLDocument::NewElement( const char* name )
|
||||
{
|
||||
TIXMLASSERT( sizeof( XMLElement ) == _elementPool.ItemSize() );
|
||||
XMLElement* ele = new (_elementPool.Alloc()) XMLElement( this );
|
||||
ele->_memPool = &_elementPool;
|
||||
XMLElement* ele = CreateUnlinkedNode<XMLElement>( _elementPool );
|
||||
ele->SetName( name );
|
||||
return ele;
|
||||
}
|
||||
|
@ -2018,9 +2019,7 @@ XMLElement* XMLDocument::NewElement( const char* name )
|
|||
|
||||
XMLComment* XMLDocument::NewComment( const char* str )
|
||||
{
|
||||
TIXMLASSERT( sizeof( XMLComment ) == _commentPool.ItemSize() );
|
||||
XMLComment* comment = new (_commentPool.Alloc()) XMLComment( this );
|
||||
comment->_memPool = &_commentPool;
|
||||
XMLComment* comment = CreateUnlinkedNode<XMLComment>( _commentPool );
|
||||
comment->SetValue( str );
|
||||
return comment;
|
||||
}
|
||||
|
@ -2028,9 +2027,7 @@ XMLComment* XMLDocument::NewComment( const char* str )
|
|||
|
||||
XMLText* XMLDocument::NewText( const char* str )
|
||||
{
|
||||
TIXMLASSERT( sizeof( XMLText ) == _textPool.ItemSize() );
|
||||
XMLText* text = new (_textPool.Alloc()) XMLText( this );
|
||||
text->_memPool = &_textPool;
|
||||
XMLText* text = CreateUnlinkedNode<XMLText>( _textPool );
|
||||
text->SetValue( str );
|
||||
return text;
|
||||
}
|
||||
|
@ -2038,9 +2035,7 @@ XMLText* XMLDocument::NewText( const char* str )
|
|||
|
||||
XMLDeclaration* XMLDocument::NewDeclaration( const char* str )
|
||||
{
|
||||
TIXMLASSERT( sizeof( XMLDeclaration ) == _commentPool.ItemSize() );
|
||||
XMLDeclaration* dec = new (_commentPool.Alloc()) XMLDeclaration( this );
|
||||
dec->_memPool = &_commentPool;
|
||||
XMLDeclaration* dec = CreateUnlinkedNode<XMLDeclaration>( _commentPool );
|
||||
dec->SetValue( str ? str : "xml version=\"1.0\" encoding=\"UTF-8\"" );
|
||||
return dec;
|
||||
}
|
||||
|
@ -2048,9 +2043,7 @@ XMLDeclaration* XMLDocument::NewDeclaration( const char* str )
|
|||
|
||||
XMLUnknown* XMLDocument::NewUnknown( const char* str )
|
||||
{
|
||||
TIXMLASSERT( sizeof( XMLUnknown ) == _commentPool.ItemSize() );
|
||||
XMLUnknown* unk = new (_commentPool.Alloc()) XMLUnknown( this );
|
||||
unk->_memPool = &_commentPool;
|
||||
XMLUnknown* unk = CreateUnlinkedNode<XMLUnknown>( _commentPool );
|
||||
unk->SetValue( str );
|
||||
return unk;
|
||||
}
|
||||
|
|
50
tinyxml2.h
50
tinyxml2.h
|
@ -527,7 +527,7 @@ enum XMLError {
|
|||
/*
|
||||
Utility functionality.
|
||||
*/
|
||||
class XMLUtil
|
||||
class TINYXML2_LIB XMLUtil
|
||||
{
|
||||
public:
|
||||
static const char* SkipWhiteSpace( const char* p, int* curLineNumPtr ) {
|
||||
|
@ -605,6 +605,17 @@ public:
|
|||
static bool ToFloat( const char* str, float* value );
|
||||
static bool ToDouble( const char* str, double* value );
|
||||
static bool ToInt64(const char* str, int64_t* value);
|
||||
|
||||
// Changes what is serialized for a boolean value.
|
||||
// Default to "true" and "false". Shouldn't be changed
|
||||
// unless you have a special testing or compatibility need.
|
||||
// Be careful: static, global, & not thread safe.
|
||||
// Be sure to set static const memory as parameters.
|
||||
static void SetBoolSerialization(const char* writeTrue, const char* writeFalse);
|
||||
|
||||
private:
|
||||
static const char* writeBoolTrue;
|
||||
static const char* writeBoolFalse;
|
||||
};
|
||||
|
||||
|
||||
|
@ -896,7 +907,7 @@ protected:
|
|||
XMLNode( XMLDocument* );
|
||||
virtual ~XMLNode();
|
||||
|
||||
virtual char* ParseDeep( char*, StrPair*, int* );
|
||||
virtual char* ParseDeep( char* p, StrPair* parentEndTag, int* curLineNumPtr);
|
||||
|
||||
XMLDocument* _document;
|
||||
XMLNode* _parent;
|
||||
|
@ -964,7 +975,7 @@ protected:
|
|||
XMLText( XMLDocument* doc ) : XMLNode( doc ), _isCData( false ) {}
|
||||
virtual ~XMLText() {}
|
||||
|
||||
char* ParseDeep( char*, StrPair* endTag, int* curLineNumPtr );
|
||||
char* ParseDeep( char* p, StrPair* parentEndTag, int* curLineNumPtr );
|
||||
|
||||
private:
|
||||
bool _isCData;
|
||||
|
@ -995,7 +1006,7 @@ protected:
|
|||
XMLComment( XMLDocument* doc );
|
||||
virtual ~XMLComment();
|
||||
|
||||
char* ParseDeep( char*, StrPair* endTag, int* curLineNumPtr);
|
||||
char* ParseDeep( char* p, StrPair* parentEndTag, int* curLineNumPtr);
|
||||
|
||||
private:
|
||||
XMLComment( const XMLComment& ); // not supported
|
||||
|
@ -1034,7 +1045,7 @@ protected:
|
|||
XMLDeclaration( XMLDocument* doc );
|
||||
virtual ~XMLDeclaration();
|
||||
|
||||
char* ParseDeep( char*, StrPair* endTag, int* curLineNumPtr );
|
||||
char* ParseDeep( char* p, StrPair* parentEndTag, int* curLineNumPtr );
|
||||
|
||||
private:
|
||||
XMLDeclaration( const XMLDeclaration& ); // not supported
|
||||
|
@ -1069,7 +1080,7 @@ protected:
|
|||
XMLUnknown( XMLDocument* doc );
|
||||
virtual ~XMLUnknown();
|
||||
|
||||
char* ParseDeep( char*, StrPair* endTag, int* curLineNumPtr );
|
||||
char* ParseDeep( char* p, StrPair* parentEndTag, int* curLineNumPtr );
|
||||
|
||||
private:
|
||||
XMLUnknown( const XMLUnknown& ); // not supported
|
||||
|
@ -1548,19 +1559,19 @@ public:
|
|||
float FloatText(float defaultValue = 0) const;
|
||||
|
||||
// internal:
|
||||
enum {
|
||||
enum ElementClosingType {
|
||||
OPEN, // <foo>
|
||||
CLOSED, // <foo/>
|
||||
CLOSING // </foo>
|
||||
};
|
||||
int ClosingType() const {
|
||||
ElementClosingType ClosingType() const {
|
||||
return _closingType;
|
||||
}
|
||||
virtual XMLNode* ShallowClone( XMLDocument* document ) const;
|
||||
virtual bool ShallowEqual( const XMLNode* compare ) const;
|
||||
|
||||
protected:
|
||||
char* ParseDeep( char* p, StrPair* endTag, int* curLineNumPtr );
|
||||
char* ParseDeep( char* p, StrPair* parentEndTag, int* curLineNumPtr );
|
||||
|
||||
private:
|
||||
XMLElement( XMLDocument* doc );
|
||||
|
@ -1578,7 +1589,7 @@ private:
|
|||
XMLAttribute* CreateAttribute();
|
||||
|
||||
enum { BUF_SIZE = 200 };
|
||||
int _closingType;
|
||||
ElementClosingType _closingType;
|
||||
// The attribute list is ordered; there is no 'lastAttribute'
|
||||
// because the list needs to be scanned for dupes before adding
|
||||
// a new attribute.
|
||||
|
@ -1602,7 +1613,7 @@ class TINYXML2_LIB XMLDocument : public XMLNode
|
|||
friend class XMLElement;
|
||||
public:
|
||||
/// constructor
|
||||
XMLDocument( bool processEntities = true, Whitespace = PRESERVE_WHITESPACE );
|
||||
XMLDocument( bool processEntities = true, Whitespace whitespaceMode = PRESERVE_WHITESPACE );
|
||||
~XMLDocument();
|
||||
|
||||
virtual XMLDocument* ToDocument() {
|
||||
|
@ -1666,7 +1677,7 @@ public:
|
|||
return _processEntities;
|
||||
}
|
||||
Whitespace WhitespaceMode() const {
|
||||
return _whitespace;
|
||||
return _whitespaceMode;
|
||||
}
|
||||
|
||||
/**
|
||||
|
@ -1804,7 +1815,7 @@ private:
|
|||
bool _writeBOM;
|
||||
bool _processEntities;
|
||||
XMLError _errorID;
|
||||
Whitespace _whitespace;
|
||||
Whitespace _whitespaceMode;
|
||||
mutable StrPair _errorStr1;
|
||||
mutable StrPair _errorStr2;
|
||||
int _errorLineNum;
|
||||
|
@ -1819,8 +1830,21 @@ private:
|
|||
static const char* _errorNames[XML_ERROR_COUNT];
|
||||
|
||||
void Parse();
|
||||
|
||||
template<class NodeType, int PoolElementSize>
|
||||
NodeType* CreateUnlinkedNode( MemPoolT<PoolElementSize>& pool );
|
||||
};
|
||||
|
||||
template<class NodeType, int PoolElementSize>
|
||||
inline NodeType* XMLDocument::CreateUnlinkedNode( MemPoolT<PoolElementSize>& pool )
|
||||
{
|
||||
TIXMLASSERT( sizeof( NodeType ) == PoolElementSize );
|
||||
TIXMLASSERT( sizeof( NodeType ) == pool.ItemSize() );
|
||||
NodeType* returnNode = new (pool.Alloc()) NodeType( this );
|
||||
TIXMLASSERT( returnNode );
|
||||
returnNode->_memPool = &pool;
|
||||
return returnNode;
|
||||
}
|
||||
|
||||
/**
|
||||
A XMLHandle is a class that wraps a node pointer with null checks; this is
|
||||
|
|
29
xmltest.cpp
29
xmltest.cpp
|
@ -10,16 +10,10 @@
|
|||
#include <ctime>
|
||||
|
||||
#if defined( _MSC_VER )
|
||||
#include <direct.h> // _mkdir
|
||||
#include <crtdbg.h>
|
||||
#define WIN32_LEAN_AND_MEAN
|
||||
#include <windows.h>
|
||||
_CrtMemState startMemState;
|
||||
_CrtMemState endMemState;
|
||||
#elif defined(MINGW32) || defined(__MINGW32__)
|
||||
#include <io.h> // mkdir
|
||||
#else
|
||||
#include <sys/stat.h> // mkdir
|
||||
#endif
|
||||
|
||||
using namespace tinyxml2;
|
||||
|
@ -299,17 +293,6 @@ int main( int argc, const char ** argv )
|
|||
_CrtSetDbgFlag(_CrtSetDbgFlag(_CRTDBG_REPORT_FLAG) | _CRTDBG_LEAK_CHECK_DF);
|
||||
#endif
|
||||
|
||||
#if defined(_MSC_VER) || defined(MINGW32) || defined(__MINGW32__)
|
||||
#if defined __MINGW64_VERSION_MAJOR && defined __MINGW64_VERSION_MINOR
|
||||
//MINGW64: both 32 and 64-bit
|
||||
mkdir( "resources/out/" );
|
||||
#else
|
||||
_mkdir( "resources/out/" );
|
||||
#endif
|
||||
#else
|
||||
mkdir( "resources/out/", S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);
|
||||
#endif
|
||||
|
||||
{
|
||||
TIXMLASSERT( true );
|
||||
}
|
||||
|
@ -752,6 +735,18 @@ int main( int argc, const char ** argv )
|
|||
XMLTest("Attribute: bool", true, v, true);
|
||||
XMLTest("Attribute: bool", true, element->BoolAttribute("attrib"), true);
|
||||
}
|
||||
{
|
||||
element->SetAttribute("attrib", true);
|
||||
const char* result = element->Attribute("attrib");
|
||||
XMLTest("Bool true is 'true'", "true", result);
|
||||
|
||||
XMLUtil::SetBoolSerialization("1", "0");
|
||||
element->SetAttribute("attrib", true);
|
||||
result = element->Attribute("attrib");
|
||||
XMLTest("Bool true is '1'", "1", result);
|
||||
|
||||
XMLUtil::SetBoolSerialization(0, 0);
|
||||
}
|
||||
{
|
||||
element->SetAttribute("attrib", 100.0);
|
||||
double v = 0;
|
||||
|
|
Loading…
Reference in New Issue