#ifndef SOURCE_PUGIXML_CPP

#define SOURCE_PUGIXML_CPP

#include "pugixml.hpp"

#include <tmxlite/detail/Android.hpp>

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

#include <assert.h>

#include <limits.h>

#ifndef LLONG_MIN

#define LLONG_MIN (-9223372036854775807LL - 1)

#define LLONG_MAX 9223372036854775807LL

#define ULLONG_MAX 18446744073709551615ULL

#endif

#ifdef PUGIXML_WCHAR_MODE

# include <wchar.h>

#endif

#ifndef PUGIXML_NO_XPATH

# include <math.h>

# include <float.h>

# ifdef PUGIXML_NO_EXCEPTIONS

# include <setjmp.h>

# endif

#endif

#ifndef PUGIXML_NO_STL

# include <istream>

# include <ostream>

# include <string>

#endif

#include <new>

#ifdef _MSC_VER

# pragma warning(push)

# pragma warning(disable: 4127) // conditional expression is constant

# pragma warning(disable: 4324) // structure was padded due to __declspec(align())

# pragma warning(disable: 4611) // interaction between '_setjmp' and C++ object destruction is non-portable

# pragma warning(disable: 4702) // unreachable code

# pragma warning(disable: 4996) // this function or variable may be unsafe

# pragma warning(disable: 4793) // function compiled as native: presence of '_setjmp' makes a function unmanaged

#endif

#ifdef __INTEL_COMPILER

# pragma warning(disable: 177) // function was declared but never referenced

# pragma warning(disable: 279) // controlling expression is constant

# pragma warning(disable: 1478 1786) // function was declared "deprecated"

# pragma warning(disable: 1684) // conversion from pointer to same-sized integral type

#endif

#if defined(__BORLANDC__) && defined(PUGIXML_HEADER_ONLY)

# pragma warn -8080 // symbol is declared but never used; disabling this inside push/pop bracket does not make the warning go away

#endif

#ifdef __BORLANDC__

# pragma option push

# pragma warn -8008 // condition is always false

# pragma warn -8066 // unreachable code

#endif

#ifdef __SNC__

# pragma diag_suppress=178 // function was declared but never referenced

# pragma diag_suppress=237 // controlling expression is constant

#endif

#if defined(_MSC_VER) && _MSC_VER >= 1300

# define PUGI__NO_INLINE __declspec(noinline)

#elif defined(__GNUC__)

# define PUGI__NO_INLINE __attribute__((noinline))

#else

# define PUGI__NO_INLINE

#endif

#if defined(__GNUC__)

# define PUGI__UNLIKELY(cond) __builtin_expect(cond, 0)

#else

# define PUGI__UNLIKELY(cond) (cond)

#endif

#define PUGI__STATIC_ASSERT(cond) { static const char condition_failed[(cond) ? 1 : -1] = {0}; (void)condition_failed[0]; }

#ifdef __DMC__

# define PUGI__DMC_VOLATILE volatile

#else

# define PUGI__DMC_VOLATILE

#endif

#if defined(__BORLANDC__) && !defined(__MEM_H_USING_LIST)

using std::memcpy;

using std::memmove;

#endif

#if defined(_MSC_VER) && !defined(__S3E__)

# define PUGI__MSVC_CRT_VERSION _MSC_VER

#endif

#ifdef PUGIXML_HEADER_ONLY

# define PUGI__NS_BEGIN namespace pugi { namespace impl {

# define PUGI__NS_END } }

# define PUGI__FN inline

# define PUGI__FN_NO_INLINE inline

#else

# if defined(_MSC_VER) && _MSC_VER < 1300 // MSVC6 seems to have an amusing bug with anonymous namespaces inside namespaces

# define PUGI__NS_BEGIN namespace pugi { namespace impl {

# define PUGI__NS_END } }

# else

# define PUGI__NS_BEGIN namespace pugi { namespace impl { namespace {

# define PUGI__NS_END } } }

# endif

# define PUGI__FN

# define PUGI__FN_NO_INLINE PUGI__NO_INLINE

#endif

#if !defined(_MSC_VER) || _MSC_VER >= 1600

# include <stdint.h>

#else

namespace pugi

{

# ifndef _UINTPTR_T_DEFINED

typedef size_t uintptr_t;

# endif

typedef unsigned __int8 uint8_t;

typedef unsigned __int16 uint16_t;

typedef unsigned __int32 uint32_t;

}

#endif

PUGI__FN void* default_allocate(size_t size)

{

return malloc(size);

}

PUGI__FN void default_deallocate(void* ptr)

{

free(ptr);

}

template <typename T>

struct xml_memory_management_function_storage

};

// Global allocation functions are stored in class statics so that in header mode linker deduplicates them

// Without a template<> we'll get multiple definitions of the same static

template <typename T> allocation_function xml_memory_management_function_storage<T>::allocate = default_allocate;

template <typename T> deallocation_function xml_memory_management_function_storage<T>::deallocate = default_deallocate;

typedef xml_memory_management_function_storage<int> xml_memory;

// Get string length

PUGI__FN size_t strlength(const char_t* s)

}

// Compare two strings

PUGI__FN bool strequal(const char_t* src, const char_t* dst)

}

// Compare lhs with [rhs_begin, rhs_end)

PUGI__FN bool strequalrange(const char_t* lhs, const char_t* rhs, size_t count)

}

// Get length of wide string, even if CRT lacks wide character support

PUGI__FN size_t strlength_wide(const wchar_t* s)

}

template <typename T, typename D = void(*)(T*)> struct auto_deleter

{

T* data;

D deleter;

auto_deleter(T* data_, D deleter_): data(data_), deleter(deleter_)

{

}

~auto_deleter()

{

if (data) deleter(data);

}

T* release()

{

T* result = data;

data = 0;

return result;

}

};

#ifdef PUGIXML_COMPACT

class compact_hash_table

{

public:

compact_hash_table(): _items(0), _capacity(0), _count(0)

{

}

void clear()

}

void** find(const void* key)

{

assert(key);

if (_capacity == 0) return 0;

size_t hashmod = _capacity - 1;

size_t bucket = hash(key) & hashmod;

for (size_t probe = 0; probe <= hashmod; ++probe)

{

item_t& probe_item = _items[bucket];

if (probe_item.key == key)

return &probe_item.value;

if (probe_item.key == 0)

return 0;

// hash collision, quadratic probing

bucket = (bucket + probe + 1) & hashmod;

}

assert(!"Hash table is full");

return 0;

}

void** insert(const void* key)

{

assert(key);

assert(_count < _capacity * 3 / 4);

size_t hashmod = _capacity - 1;

size_t bucket = hash(key) & hashmod;

for (size_t probe = 0; probe <= hashmod; ++probe)

{

item_t& probe_item = _items[bucket];

if (probe_item.key == 0)

{

probe_item.key = key;

_count++;

return &probe_item.value;

}

if (probe_item.key == key)

return &probe_item.value;

// hash collision, quadratic probing

bucket = (bucket + probe + 1) & hashmod;

}

assert(!"Hash table is full");

return 0;

}

bool reserve()

}

private:

struct item_t

};

item_t* _items;

size_t _capacity;

size_t _count;

bool rehash();

static unsigned int hash(const void* key)

}

};

PUGI__FN_NO_INLINE bool compact_hash_table::rehash()

}

#endif

static const size_t xml_memory_page_size =

#ifdef PUGIXML_MEMORY_PAGE_SIZE

PUGIXML_MEMORY_PAGE_SIZE

#else

32768

#endif

;

#ifdef PUGIXML_COMPACT

static const uintptr_t xml_memory_block_alignment = 4;

static const uintptr_t xml_memory_page_alignment = sizeof(void*);

#else

static const uintptr_t xml_memory_block_alignment = sizeof(void*);

static const uintptr_t xml_memory_page_alignment = 64;

static const uintptr_t xml_memory_page_pointer_mask = ~(xml_memory_page_alignment - 1);

#endif

// extra metadata bits

static const uintptr_t xml_memory_page_contents_shared_mask = 32;

static const uintptr_t xml_memory_page_name_allocated_mask = 16;

static const uintptr_t xml_memory_page_value_allocated_mask = 8;

static const uintptr_t xml_memory_page_type_mask = 7;

// combined masks for string uniqueness

static const uintptr_t xml_memory_page_name_allocated_or_shared_mask = xml_memory_page_name_allocated_mask | xml_memory_page_contents_shared_mask;

static const uintptr_t xml_memory_page_value_allocated_or_shared_mask = xml_memory_page_value_allocated_mask | xml_memory_page_contents_shared_mask;

#ifdef PUGIXML_COMPACT

#define PUGI__GETPAGE_IMPL(header) (header).get_page()

#else

#define PUGI__GETPAGE_IMPL(header) reinterpret_cast<impl::xml_memory_page*>((header) & impl::xml_memory_page_pointer_mask)

#endif

#define PUGI__GETPAGE(n) PUGI__GETPAGE_IMPL((n)->header)

#define PUGI__NODETYPE(n) static_cast<xml_node_type>(((n)->header & impl::xml_memory_page_type_mask) + 1)

struct xml_allocator;

struct xml_memory_page

};

struct xml_memory_string_header

};

struct xml_allocator

};

PUGI__FN_NO_INLINE void* xml_allocator::allocate_memory_oob(size_t size, xml_memory_page*& out_page)

{

const size_t large_allocation_threshold = xml_memory_page_size / 4;

xml_memory_page* page = allocate_page(size <= large_allocation_threshold ? xml_memory_page_size : size);

out_page = page;

if (!page) return 0;

if (size <= large_allocation_threshold)

{

_root->busy_size = _busy_size;

// insert page at the end of linked list

page->prev = _root;

_root->next = page;

_root = page;

_busy_size = size;

}

else

{

// insert page before the end of linked list, so that it is deleted as soon as possible

// the last page is not deleted even if it's empty (see deallocate_memory)

assert(_root->prev);

page->prev = _root->prev;

page->next = _root;

_root->prev->next = page;

_root->prev = page;

page->busy_size = size;

}

return reinterpret_cast<char*>(page) + sizeof(xml_memory_page);

}

#ifdef PUGIXML_COMPACT

static const uintptr_t compact_alignment_log2 = 2;

static const uintptr_t compact_alignment = 1 << compact_alignment_log2;

class compact_header

};

PUGI__FN xml_memory_page* compact_get_page(const void* object, int header_offset)

{

const compact_header* header = reinterpret_cast<const compact_header*>(static_cast<const char*>(object) - header_offset);

return header->get_page();

}

template <int header_offset, typename T> PUGI__FN_NO_INLINE T* compact_get_value(const void* object)

{

return static_cast<T*>(*compact_get_page(object, header_offset)->allocator->_hash->find(object));

}

template <int header_offset, typename T> PUGI__FN_NO_INLINE void compact_set_value(const void* object, T* value)

{

*compact_get_page(object, header_offset)->allocator->_hash->insert(object) = value;

}

template <typename T, int header_offset, int start = -126> class compact_pointer

};

template <typename T, int header_offset> class compact_pointer_parent

};

template <int header_offset, int base_offset> class compact_string