{

va_list va;

va_start( va, format );

int result = vsnprintf_s( buffer, size, _TRUNCATE, format, va );

va_end( va );

return result;

{

enum {

NEEDS_ENTITY_PROCESSING = 0x01,

NEEDS_NEWLINE_NORMALIZATION = 0x02,

COLLAPSE_WHITESPACE = 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

};

StrPair() : _flags( 0 ), _start( 0 ), _end( 0 ) {}

~StrPair();

void Set( char* start, char* end, int flags ) {

Reset();

_start = start;

_end = end;

_flags = flags | NEEDS_FLUSH;

}

const char* GetStr();

bool Empty() const {

return _start == _end;

}

void SetInternedStr( const char* str ) {

Reset();

_start = const_cast<char*>(str);

}

void SetStr( const char* str, int flags=0 );

char* ParseText( char* in, const char* endTag, int strFlags );

char* ParseName( char* in );

void TransferTo( StrPair* other );

void Reset();

void CollapseWhitespace();

enum {

NEEDS_FLUSH = 0x100,

NEEDS_DELETE = 0x200

};

// After parsing, if *_end != 0, it can be set to zero.

int _flags;

char* _start;

char* _end;

StrPair( const StrPair& other ); // not supported

void operator=( StrPair& other ); // not supported, use TransferTo()

{

DynArray< T, INIT >() {

_mem = _pool;

_allocated = INIT;

_size = 0;

}

~DynArray() {

if ( _mem != _pool ) {

delete [] _mem;

}

}

void Clear() {

_size = 0;

}

void Push( T t ) {

EnsureCapacity( _size+1 );

_mem[_size++] = t;

}

T* PushArr( int count ) {

EnsureCapacity( _size+count );

T* ret = &_mem[_size];

_size += count;

return ret;

}

T Pop() {

return _mem[--_size];

}

void PopArr( int count ) {

TIXMLASSERT( _size >= count );

_size -= count;

}

bool Empty() const {

return _size == 0;

}

T& operator[](int i) {

TIXMLASSERT( i>= 0 && i < _size );

return _mem[i];

}

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

TIXMLASSERT( i>= 0 && i < _size );

return _mem[i];

}

const T& PeekTop() const {

TIXMLASSERT( _size > 0 );

return _mem[ _size - 1];

}

int Size() const {

return _size;

}

int Capacity() const {

return _allocated;

}

const T* Mem() const {

return _mem;

}

T* Mem() {

return _mem;

}

void EnsureCapacity( int cap ) {

if ( cap > _allocated ) {

int newAllocated = cap * 2;

T* newMem = new T[newAllocated];

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[INIT];

int _allocated; // objects allocated

int _size; // number objects in use

{

MemPool() {}

virtual ~MemPool() {}

virtual int ItemSize() const = 0;

virtual void* Alloc() = 0;

virtual void Free( void* ) = 0;

virtual void SetTracked() = 0;

virtual void Clear() = 0;

{

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

~MemPoolT() {

Clear();

}

void Clear() {

// Delete the blocks.

while( !_blockPtrs.Empty()) {

Block* b = _blockPtrs.Pop();

delete b;

}

_root = 0;

_currentAllocs = 0;

_nAllocs = 0;

_maxAllocs = 0;

_nUntracked = 0;

}

virtual int ItemSize() const {

return SIZE;

}

int CurrentAllocs() const {

return _currentAllocs;

}

virtual void* Alloc() {

if ( !_root ) {

// Need a new block.

Block* block = new Block();

_blockPtrs.Push( block );

for( int i=0; i<COUNT-1; ++i ) {

block->chunk[i].next = &block->chunk[i+1];

}

block->chunk[COUNT-1].next = 0;

_root = block->chunk;

}

void* result = _root;

_root = _root->next;

++_currentAllocs;

if ( _currentAllocs > _maxAllocs ) {

_maxAllocs = _currentAllocs;

}

_nAllocs++;

_nUntracked++;

return result;

}

virtual void Free( void* mem ) {

if ( !mem ) {

return;

}

--_currentAllocs;

Chunk* chunk = static_cast<Chunk*>( mem );

#ifdef DEBUG

memset( chunk, 0xfe, sizeof(Chunk) );

#endif

chunk->next = _root;

_root = chunk;

}

void Trace( const char* name ) {

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

name, _maxAllocs, _maxAllocs*SIZE/1024, _currentAllocs, SIZE, _nAllocs, _blockPtrs.Size() );

}

void SetTracked() {

_nUntracked--;

}

int 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

enum { COUNT = (4*1024)/SIZE }; // Some compilers do not accept to use COUNT in private part if COUNT is private

union Chunk {

Chunk* next;

char mem[SIZE];

};

struct Block {

Chunk chunk[COUNT];

};

DynArray< Block*, 10 > _blockPtrs;

Chunk* _root;

int _currentAllocs;

int _nAllocs;

int _maxAllocs;

int _nUntracked;

XML_SUCCESS = 0,

XML_NO_ERROR = 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_ELEMENT_MISMATCH,

XML_ERROR_PARSING_ELEMENT,

XML_ERROR_PARSING_ATTRIBUTE,

XML_ERROR_IDENTIFYING_TAG,

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_ERROR_COUNT

{

static const char* SkipWhiteSpace( const char* p ) {

while( IsWhiteSpace(*p) ) {

++p;

}

return p;

}

static char* SkipWhiteSpace( char* p ) {

return const_cast<char*>( SkipWhiteSpace( const_cast<const char*>(p) ) );

}

// Anything in the high order range of UTF-8 is assumed to not be whitespace. This isn't

// correct, but simple, and usually works.

static bool IsWhiteSpace( char p ) {

return !IsUTF8Continuation(p) && isspace( static_cast<unsigned char>(p) );

}

inline static bool IsNameStartChar( unsigned char ch ) {

return ( ( ch < 128 ) ? isalpha( ch ) : 1 )

|| ch == ':'

|| ch == '_';

}

inline static bool IsNameChar( unsigned char ch ) {

return IsNameStartChar( ch )

|| isdigit( ch )

|| ch == '.'

|| ch == '-';

}

inline static bool StringEqual( const char* p, const char* q, int nChar=INT_MAX ) {

int n = 0;

if ( p == q ) {

return true;

}

while( *p && *q && *p == *q && n<nChar ) {

++p;

++q;

++n;

}

if ( (n == nChar) || ( *p == 0 && *q == 0 ) ) {

return true;

}

return false;

}

inline static bool IsUTF8Continuation( const char p ) {

return ( p & 0x80 ) != 0;

}

static const char* ReadBOM( const char* p, bool* hasBOM );

// p is the starting location,

// the UTF-8 value of the entity will be placed in value, and length filled in.

static const char* GetCharacterRef( const char* p, char* value, int* length );

static void ConvertUTF32ToUTF8( unsigned long input, char* output, int* length );

// converts primitive types to strings

static void ToStr( int v, char* buffer, int bufferSize );

static void ToStr( unsigned v, char* buffer, int bufferSize );

static void ToStr( bool v, char* buffer, int bufferSize );

static void ToStr( float v, char* buffer, int bufferSize );

static void ToStr( double v, char* buffer, int bufferSize );

// converts strings to primitive types

static bool ToInt( const char* str, int* value );

static bool ToUnsigned( const char* str, unsigned* value );

static bool ToBool( const char* str, bool* value );

static bool ToFloat( const char* str, float* value );

static bool ToDouble( const char* str, double* value );