NEEDS_ENTITY_PROCESSING = 0x01,

NEEDS_NEWLINE_NORMALIZATION = 0x02,

NEEDS_WHITESPACE_COLLAPSING = 0x04,

TEXT_ELEMENT = NEEDS_ENTITY_PROCESSING | NEEDS_NEWLINE_NORMALIZATION,

TEXT_ELEMENT_LEAVE_ENTITIES = NEEDS_NEWLINE_NORMALIZATION,

ATTRIBUTE_NAME = 0,

ATTRIBUTE_VALUE = NEEDS_ENTITY_PROCESSING | NEEDS_NEWLINE_NORMALIZATION,

ATTRIBUTE_VALUE_LEAVE_ENTITIES = NEEDS_NEWLINE_NORMALIZATION,

COMMENT = NEEDS_NEWLINE_NORMALIZATION

TIXMLASSERT( start );

TIXMLASSERT( end );

Reset();

_start = start;

_end = end;

_flags = flags | NEEDS_FLUSH;

{

DynArray() :

_mem( _pool ),

_allocated( INITIAL_SIZE ),

_size( 0 )

{

}

~DynArray() {

if ( _mem != _pool ) {

delete [] _mem;

}

}

void Clear() {

_size = 0;

}

void Push( T t ) {

TIXMLASSERT( _size < INT_MAX );

EnsureCapacity( _size+1 );

_mem[_size] = t;

++_size;

}

T* PushArr( size_t count ) {

TIXMLASSERT( _size <= SIZE_MAX - count );

EnsureCapacity( _size+count );

T* ret = &_mem[_size];

_size += count;

return ret;

}

T Pop() {

TIXMLASSERT( _size > 0 );

--_size;

return _mem[_size];

}

void PopArr( size_t count ) {

TIXMLASSERT( _size >= count );

_size -= count;

}

bool Empty() const {

return _size == 0;

}

T& operator[](size_t i) {

TIXMLASSERT( i < _size );

return _mem[i];

}

const T& operator[](size_t i) const {

TIXMLASSERT( i < _size );

return _mem[i];

}

const T& PeekTop() const {

TIXMLASSERT( _size > 0 );

return _mem[ _size - 1];

}

size_t Size() const {

TIXMLASSERT( _size >= 0 );

return _size;

}

size_t Capacity() const {

TIXMLASSERT( _allocated >= INITIAL_SIZE );

return _allocated;

}

void SwapRemove(size_t i) {

TIXMLASSERT(i < _size);

TIXMLASSERT(_size > 0);

_mem[i] = _mem[_size - 1];

--_size;

}

const T* Mem() const {

TIXMLASSERT( _mem );

return _mem;

}

T* Mem() {

TIXMLASSERT( _mem );

return _mem;

}

DynArray( const DynArray& ); // not supported

void operator=( const DynArray& ); // not supported

void EnsureCapacity( size_t cap ) {

TIXMLASSERT( cap > 0 );

if ( cap > _allocated ) {

TIXMLASSERT( cap <= SIZE_MAX / 2 / sizeof(T));

const size_t newAllocated = cap * 2;

T* newMem = new T[newAllocated];

TIXMLASSERT( newAllocated >= _size );

memcpy( newMem, _mem, sizeof(T) * _size ); // warning: not using constructors, only works for PODs

if ( _mem != _pool ) {

delete [] _mem;

}

_mem = newMem;

_allocated = newAllocated;

}

}

T* _mem;

T _pool[INITIAL_SIZE];

size_t _allocated; // objects allocated

size_t _size; // number objects in use

{

MemPool() {}

virtual ~MemPool() {}

virtual size_t ItemSize() const = 0;

virtual void* Alloc() = 0;

virtual void Free( void* ) = 0;

virtual void SetTracked() = 0;

{

MemPoolT() : _blockPtrs(), _root(0), _currentAllocs(0), _nAllocs(0), _maxAllocs(0), _nUntracked(0) {}

~MemPoolT() {

MemPoolT< ITEM_SIZE >::Clear();

}

void Clear() {

// Delete the blocks.

while( !_blockPtrs.Empty()) {

Block* lastBlock = _blockPtrs.Pop();

delete lastBlock;

}

_root = 0;

_currentAllocs = 0;

_nAllocs = 0;

_maxAllocs = 0;

_nUntracked = 0;

}

virtual size_t ItemSize() const override {

return ITEM_SIZE;

}

size_t CurrentAllocs() const {

return _currentAllocs;

}

virtual void* Alloc() override{

if ( !_root ) {

// Need a new block.

Block* block = new Block;

_blockPtrs.Push( block );

Item* blockItems = block->items;

for( size_t i = 0; i < ITEMS_PER_BLOCK - 1; ++i ) {

blockItems[i].next = &(blockItems[i + 1]);

}

blockItems[ITEMS_PER_BLOCK - 1].next = 0;

_root = blockItems;

}

Item* const result = _root;

TIXMLASSERT( result != 0 );

_root = _root->next;

++_currentAllocs;

if ( _currentAllocs > _maxAllocs ) {

_maxAllocs = _currentAllocs;

}

++_nAllocs;

++_nUntracked;

return result;

}

virtual void Free( void* mem ) override {

if ( !mem ) {

return;

}

--_currentAllocs;

Item* item = static_cast<Item*>( mem );

#ifdef TINYXML2_DEBUG

memset( item, 0xfe, sizeof( *item ) );

#endif

item->next = _root;

_root = item;

}

void Trace( const char* name ) {

printf( "Mempool %s watermark=%d [%dk] current=%d size=%d nAlloc=%d blocks=%d\n",

name, _maxAllocs, _maxAllocs * ITEM_SIZE / 1024, _currentAllocs,

ITEM_SIZE, _nAllocs, _blockPtrs.Size() );

}

void SetTracked() override {

--_nUntracked;

}

size_t Untracked() const {

return _nUntracked;

}

// This number is perf sensitive. 4k seems like a good tradeoff on my machine.

// The test file is large, 170k.

// Release: VS2010 gcc(no opt)

// 1k: 4000

// 2k: 4000

// 4k: 3900 21000

// 16k: 5200

// 32k: 4300

// 64k: 4000 21000

// Declared public because some compilers do not accept to use ITEMS_PER_BLOCK

// in private part if ITEMS_PER_BLOCK is private

enum { ITEMS_PER_BLOCK = (4 * 1024) / ITEM_SIZE };

MemPoolT( const MemPoolT& ); // not supported

void operator=( const MemPoolT& ); // not supported

union Item {

Item* next;

char itemData[static_cast<size_t>(ITEM_SIZE)];

};

struct Block {

Item items[ITEMS_PER_BLOCK];

};

DynArray< Block*, 10 > _blockPtrs;

Item* _root;

size_t _currentAllocs;

size_t _nAllocs;

size_t _maxAllocs;

size_t _nUntracked;

XML_SUCCESS = 0,

XML_NO_ATTRIBUTE,

XML_WRONG_ATTRIBUTE_TYPE,

XML_ERROR_FILE_NOT_FOUND,

XML_ERROR_FILE_COULD_NOT_BE_OPENED,

XML_ERROR_FILE_READ_ERROR,

XML_ERROR_PARSING_ELEMENT,

XML_ERROR_PARSING_ATTRIBUTE,

XML_ERROR_PARSING_TEXT,

XML_ERROR_PARSING_CDATA,

XML_ERROR_PARSING_COMMENT,

XML_ERROR_PARSING_DECLARATION,

XML_ERROR_PARSING_UNKNOWN,

XML_ERROR_EMPTY_DOCUMENT,

XML_ERROR_MISMATCHED_ELEMENT,

XML_ERROR_PARSING,

XML_CAN_NOT_CONVERT_TEXT,

XML_NO_TEXT_NODE,

XML_ELEMENT_DEPTH_EXCEEDED,

XML_ERROR_COUNT

if ( ch >= 128 ) {

// This is a heuristic guess in attempt to not implement Unicode-aware isalpha()

return true;

}

if ( isalpha( ch ) ) {

return true;

}

return ch == ':' || ch == '_';

return IsNameStartChar( ch )

|| isdigit( ch )

|| ch == '.'

|| ch == '-';

if ( p == q ) {

return true;

}

TIXMLASSERT( p );

TIXMLASSERT( q );

TIXMLASSERT( nChar >= 0 );

return strncmp( p, q, static_cast<size_t>(nChar) ) == 0;